Hướng dẫn how do you edit a json object in python? - làm thế nào để bạn chỉnh sửa một đối tượng json trong python?

Một từ vựng nhỏ

Quá trình mã hóa JSON thường được gọi là tuần tự hóa. Thuật ngữ này đề cập đến việc chuyển đổi dữ liệu thành một loạt byte (do đó nối tiếp) được lưu trữ hoặc truyền qua một mạng. Bạn cũng có thể nghe thấy thuật ngữ sắp xếp, nhưng đó là một cuộc thảo luận hoàn toàn khác. Đương nhiên, việc giải phóng hóa là quá trình đối ứng của việc giải mã dữ liệu đã được lưu trữ hoặc phân phối theo tiêu chuẩn JSON.serialization. This term refers to the transformation of data into a series of bytes (hence serial) to be stored or transmitted across a network. You may also hear the term marshaling, but that’s a whole other discussion. Naturally, deserialization is the reciprocal process of decoding data that has been stored or delivered in the JSON standard.

Yike! Nghe có vẻ khá kỹ thuật. Chắc chắn. Nhưng trong thực tế, tất cả những gì chúng tôi nói về ở đây là đọc và viết. Hãy nghĩ về nó như thế này: Mã hóa là để ghi dữ liệu vào đĩa, trong khi giải mã là để đọc dữ liệu vào bộ nhớ. Definitely. But in reality, all we’re talking about here is reading and writing. Think of it like this: encoding is for writing data to disk, while decoding is for reading data into memory.

Nối tiếp json

Điều gì xảy ra sau khi một máy tính xử lý rất nhiều thông tin? Nó cần phải lấy một kết xuất dữ liệu. Theo đó, thư viện

{
    "id":134,
    "name":"myname"
}

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Các đối tượng Python đơn giản được dịch sang JSON theo một chuyển đổi khá trực quan.

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

Một ví dụ tuần tự hóa đơn giản

Hãy tưởng tượng bạn làm việc với một đối tượng Python trong bộ nhớ trông hơi giống như thế này:

data = {
    "president": {
        "name": "Zaphod Beeblebrox",
        "species": "Betelgeusian"
    }
}

Điều quan trọng là bạn lưu thông tin này vào đĩa, vì vậy nhiệm vụ của bạn là viết nó vào một tệp.

Sử dụng trình quản lý bối cảnh Python, bạn có thể tạo một tệp có tên

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

import json
  
# Read Existing JSON File
with open('data.json') as f:
    data = json.load(f)
  
# Append new object to list data
data.append({
        "ID": 4,
        "Name": "Paresh Patel",
        "email": ""
    })
  
# Append new object to list data
data.append({
        "ID": 5,
        "Name": "Rakesh Patel",
        "email": ""
    })
    
# Create new JSON file
with open('data.json', 'w') as f:
    json.dump(data, f, indent=2)
  
# Closing file
f.close()

{
    "name":"mynamme",
    "id":134
}

Lưu ý rằng

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Hoặc, nếu bạn có khuynh hướng tiếp tục sử dụng dữ liệu JSON được nối tiếp này trong chương trình của mình, bạn có thể viết nó vào một đối tượng Python

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

{
    "name":"mynamme",
    "id":134
}

Lưu ý rằng đối tượng giống như tệp không có vì bạn không thực sự viết vào đĩa. Ngoài ra,

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Hoan hô! Bạn đã sinh ra một số em bé JSON, và bạn đã sẵn sàng phát hành nó ra tự nhiên để phát triển lớn và mạnh mẽ.

Một số đối số từ khóa hữu ích

Hãy nhớ rằng, JSON có nghĩa là dễ dàng đọc được bởi con người, nhưng cú pháp có thể đọc được là đủ nếu tất cả đều bị vắt cùng nhau. Ngoài ra, bạn có thể có một phong cách lập trình khác với tôi và bạn có thể dễ dàng đọc mã hơn khi nó được định dạng theo ý thích của bạn.

Lưu ý: Cả hai phương thức

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

0 và

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

1 đều sử dụng cùng một đối số từ khóa. Both the

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

0 and

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

1 methods use the same keyword arguments.

Tùy chọn đầu tiên mà hầu hết mọi người muốn thay đổi là khoảng trắng. Bạn có thể sử dụng đối số từ khóa

import json
  
# Read Existing JSON File
with open('data.json') as f:
    data = json.load(f)
  
# Append new object to list data
data.append({
        "ID": 4,
        "Name": "Paresh Patel",
        "email": ""
    })
  
# Append new object to list data
data.append({
        "ID": 5,
        "Name": "Rakesh Patel",
        "email": ""
    })
    
# Create new JSON file
with open('data.json', 'w') as f:
    json.dump(data, f, indent=2)
  
# Closing file
f.close()

import json
  
# Read Existing JSON File
with open('data.json') as f:
    data = json.load(f)
  
# Append new object to list data
data.append({
        "ID": 4,
        "Name": "Paresh Patel",
        "email": ""
    })
  
# Append new object to list data
data.append({
        "ID": 5,
        "Name": "Rakesh Patel",
        "email": ""
    })
    
# Create new JSON file
with open('data.json', 'w') as f:
    json.dump(data, f, indent=2)
  
# Closing file
f.close()

>>>

{
    "name":"mynamme",
    "id":134
}

Một tùy chọn định dạng khác là đối số từ khóa

import json
  
# Read Existing JSON File
with open('data.json') as f:
    data = json.load(f)
  
# Append new object to list data
data.append({
        "ID": 4,
        "Name": "Paresh Patel",
        "email": ""
    })
  
# Append new object to list data
data.append({
        "ID": 5,
        "Name": "Rakesh Patel",
        "email": ""
    })
    
# Create new JSON file
with open('data.json', 'w') as f:
    json.dump(data, f, indent=2)
  
# Closing file
f.close()

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  },
  {
    "ID": 4,
    "Name": "Paresh Patel",
    "email": ""
  },
  {
    "ID": 5,
    "Name": "Rakesh Patel",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  },
  {
    "ID": 4,
    "Name": "Paresh Patel",
    "email": ""
  },
  {
    "ID": 5,
    "Name": "Rakesh Patel",
    "email": ""
  }
]

Có những người khác, như

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  },
  {
    "ID": 4,
    "Name": "Paresh Patel",
    "email": ""
  },
  {
    "ID": 5,
    "Name": "Rakesh Patel",
    "email": ""
  }
]

Deserializing json

Tuyệt vời, có vẻ như bạn đã bắt giữ mình một số Json hoang dã! Bây giờ nó thời gian để đánh nó thành hình dạng. Trong thư viện

{
    "id":134,
    "name":"myname"
}

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  },
  {
    "ID": 4,
    "Name": "Paresh Patel",
    "email": ""
  },
  {
    "ID": 5,
    "Name": "Rakesh Patel",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  },
  {
    "ID": 4,
    "Name": "Paresh Patel",
    "email": ""
  },
  {
    "ID": 5,
    "Name": "Rakesh Patel",
    "email": ""
  }
]

Giống như tuần tự hóa, có một bảng chuyển đổi đơn giản để giải phóng, mặc dù bạn có thể đoán được nó trông như thế nào.

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

Về mặt kỹ thuật, chuyển đổi này không phải là một nghịch đảo hoàn hảo với bảng tuần tự hóa. Điều đó về cơ bản có nghĩa là nếu bạn mã hóa một đối tượng ngay bây giờ và sau đó giải mã lại sau, bạn có thể không nhận được chính xác cùng một đối tượng. Tôi tưởng tượng nó có một chút giống như dịch chuyển tức thời: phá vỡ các phân tử của tôi ở đây và đặt chúng trở lại với nhau ở đó. Tôi vẫn là cùng một người?

Trong thực tế, nó có lẽ giống như một người bạn dịch một cái gì đó sang tiếng Nhật và một người bạn khác để dịch nó sang tiếng Anh. Bất kể, ví dụ đơn giản nhất sẽ là mã hóa

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

>>>

{
    "name":"mynamme",
    "id":134
}

Một ví dụ về sự thoái hóa đơn giản

Lần này, hãy tưởng tượng bạn đã có một số dữ liệu được lưu trữ trên đĩa mà bạn muốn thao tác trong bộ nhớ. Bạn vẫn sẽ sử dụng trình quản lý ngữ cảnh, nhưng lần này bạn sẽ mở

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  }
]

{
    "name":"mynamme",
    "id":134
}

Mọi thứ khá đơn giản ở đây, nhưng hãy nhớ rằng kết quả của phương pháp này có thể trả về bất kỳ loại dữ liệu nào được phép từ bảng chuyển đổi. Điều này chỉ quan trọng nếu bạn đang tải dữ liệu mà bạn đã thấy trước đây. Trong hầu hết các trường hợp, đối tượng gốc sẽ là

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Nếu bạn đã rút dữ liệu JSON từ một chương trình khác hoặc đã thu được một chuỗi dữ liệu được định dạng JSON trong Python, bạn có thể dễ dàng giải phóng điều đó với

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  },
  {
    "ID": 4,
    "Name": "Paresh Patel",
    "email": ""
  },
  {
    "ID": 5,
    "Name": "Rakesh Patel",
    "email": ""
  }
]

{
    "name":"mynamme",
    "id":134
}

Voilà! Bạn đã thuần hóa JSON hoang dã, và bây giờ nó nằm dưới sự kiểm soát của bạn. Nhưng những gì bạn làm với sức mạnh đó là tùy thuộc vào bạn. Bạn có thể cho nó ăn, nuôi dưỡng nó, và thậm chí dạy nó các thủ thuật. Nó không phải là tôi không tin tưởng bạn, nhưng hãy giữ nó trên dây xích, được chứ?

Đơn giản hóa cấu trúc dữ liệu

Bây giờ, câu hỏi là làm thế nào để đối phó với các cấu trúc dữ liệu phức tạp hơn. Chà, bạn có thể cố gắng mã hóa và giải mã JSON bằng tay, nhưng có một giải pháp thông minh hơn một chút mà sẽ giúp bạn tiết kiệm một số công việc. Thay vì đi thẳng từ kiểu dữ liệu tùy chỉnh đến JSON, bạn có thể ném vào một bước trung gian.

Tất cả những gì bạn cần làm là đại diện cho dữ liệu của bạn theo các loại tích hợp

{
    "id":134,
    "name":"myname"
}

{
    "id":134,
    "name":"myname"
}

Để hiểu được điều này, bạn sẽ cần một đối tượng phức tạp để chơi. Bạn có thể sử dụng bất kỳ lớp tùy chỉnh nào bạn thích, nhưng Python có loại tích hợp có tên

{
    "name":"mynamme",
    "id":134
}

{
    "name":"mynamme",
    "id":134
}

>>>

index_add = 0
with open("data.json") as f:
    data = json.load(f)
    data_li = [[k, v] for k, v in data.items()]
    data_li.insert(index_add, ["id", 134])
    data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Mặc dù mô-đun

{
    "id":134,
    "name":"myname"
}

8 có thể xử lý hầu hết các loại Python tích hợp, nhưng nó không hiểu cách mã hóa các loại dữ liệu tùy chỉnh theo mặc định. Nó giống như cố gắng lắp một cái chốt vuông trong một lỗ tròn mà bạn cần một người giám sát Buzzsaw và cha mẹ. You see, when a real number and an imaginary number love each other very much, they add together to produce a number which is (justifiably) called complex.

Đơn giản hóa cấu trúc dữ liệuWhat is the minimum amount of information necessary to recreate this object? In the case of complex numbers, you only need to know the real and imaginary parts, both of which you can access as attributes on the

{
    "name":"mynamme",
    "id":134
}

>>>

index_add = 0
with open("data.json") as f:
    data = json.load(f)
    data_li = [[k, v] for k, v in data.items()]
    data_li.insert(index_add, ["id", 134])
    data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Mặc dù mô-đun

{
    "id":134,
    "name":"myname"
}

>>>

index_add = 0
with open("data.json") as f:
    data = json.load(f)
    data_li = [[k, v] for k, v in data.items()]
    data_li.insert(index_add, ["id", 134])
    data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Mặc dù mô-đun

{
    "id":134,
    "name":"myname"
}

Đơn giản hóa cấu trúc dữ liệu

Bây giờ, câu hỏi là làm thế nào để đối phó với các cấu trúc dữ liệu phức tạp hơn. Chà, bạn có thể cố gắng mã hóa và giải mã JSON bằng tay, nhưng có một giải pháp thông minh hơn một chút mà sẽ giúp bạn tiết kiệm một số công việc. Thay vì đi thẳng từ kiểu dữ liệu tùy chỉnh đến JSON, bạn có thể ném vào một bước trung gian.

index_add = 0
with open("data.json") as f:
    data = json.load(f)
    data_li = [[k, v] for k, v in data.items()]
    data_li.insert(index_add, ["id", 134])
    data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Tất cả những gì bạn cần làm là đại diện cho dữ liệu của bạn theo các loại tích hợp

{
    "id":134,
    "name":"myname"
}

{
    "id":134,
    "name":"myname"
}

>>>

index_add = 0
with open("data.json") as f:
    data = json.load(f)
    data_li = [[k, v] for k, v in data.items()]
    data_li.insert(index_add, ["id", 134])
    data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Mặc dù mô-đun

{
    "id":134,
    "name":"myname"
}

8 có thể xử lý hầu hết các loại Python tích hợp, nhưng nó không hiểu cách mã hóa các loại dữ liệu tùy chỉnh theo mặc định. Nó giống như cố gắng lắp một cái chốt vuông trong một lỗ tròn mà bạn cần một người giám sát Buzzsaw và cha mẹ. Great question! That certainly wasn’t the only choice, nor is it necessarily the best choice. In fact, this wouldn’t be a very good representation if you ever wanted to decode the object later, as you’ll see shortly.

Đơn giản hóa cấu trúc dữ liệu

{
    "id":134,
    "name":"myname"
}

Bây giờ, câu hỏi là làm thế nào để đối phó với các cấu trúc dữ liệu phức tạp hơn. Chà, bạn có thể cố gắng mã hóa và giải mã JSON bằng tay, nhưng có một giải pháp thông minh hơn một chút mà sẽ giúp bạn tiết kiệm một số công việc. Thay vì đi thẳng từ kiểu dữ liệu tùy chỉnh đến JSON, bạn có thể ném vào một bước trung gian.

>>>

{
    "id":134,
    "name":"myname"
}

Mặc dù mô-đun { "id":134, "name":"myname" } 8 có thể xử lý hầu hết các loại Python tích hợp, nhưng nó không hiểu cách mã hóa các loại dữ liệu tùy chỉnh theo mặc định. Nó giống như cố gắng lắp một cái chốt vuông trong một lỗ tròn mà bạn cần một người giám sát Buzzsaw và cha mẹ.

Đơn giản hóa cấu trúc dữ liệu

>>>

{
    "id":134,
    "name":"myname"
}

Mặc dù mô-đun

{
    "id":134,
    "name":"myname"
}

Đơn giản hóa cấu trúc dữ liệuWhat is the minimum amount of information that is both necessary and sufficient to recreate this object?

Mô -đun

{
    "id":134,
    "name":"myname"
}

{
    "name":"mynamme",
    "id":134
}

{
    "name":"mynamme",
    "id":134
}

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

{
    "id":134,
    "name":"myname"
}

Xem bit thông minh? Chìa khóa

{
    "name":"mynamme",
    "id":134
}

{
    "id":134,
    "name":"myname"
}

Nếu

{
    "name":"mynamme",
    "id":134
}

Mỗi khi phương thức

[
  {
    "ID": 1,
    "Name": "Hardik Savani",
    "email": ""
  },
  {
    "ID": 2,
    "Name": "Vimal Kashiyani",
    "email": ""
  },
  {
    "ID": 3,
    "Name": "Harshad Pathak",
    "email": ""
  },
  {
    "ID": 4,
    "Name": "Paresh Patel",
    "email": ""
  },
  {
    "ID": 5,
    "Name": "Rakesh Patel",
    "email": ""
  }
]

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

{
    "name":"mynamme",
    "id":134
}

Bây giờ chơi cùng một loại trò chơi như trước:

>>>

{
    "id":134,
    "name":"myname"
}

Trong khi

{
    "name":"mynamme",
    "id":134
}

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)

Điều này cũng không chỉ hoạt động với một đối tượng. Hãy thử đặt danh sách các số phức tạp này vào

{
    "name":"mynamme",
    "id":134
}

{
    "id":134,
    "name":"myname"
}

Nếu mọi việc suôn sẻ, bạn sẽ nhận được một danh sách các đối tượng

{
    "name":"mynamme",
    "id":134
}

>>>

{
    "id":134,
    "name":"myname"
}

Trong khi

{
    "name":"mynamme",
    "id":134
}

index_add = 0
n_k = "id"
n_v = 134
with open("data.json") as f:
    data = json.load(f)
    if n_k in data:
        data[n_k] = n_v
    else:
       data_li = [[k, v] for k, v in data.items()]
       data_li.insert(index_add, [n_k, n_v])
       data = {data_li[i][0]:data_li[i][1] for i in range(0, len(data_li))}
    json.dump(data, open("data.json", "w"), indent = 4)