Dictionary trong Python là một tập hợp các giá trị khóa, được sử dụng để lưu trữ các giá trị dữ liệu như map, không giống như các loại dữ liệu khác chỉ chứa một giá trị duy nhất dưới dạng phần tử.
Các bài viết liên quan:
Ví dụ về dictionary trong Python
Dictionary giữ cặp key: value. Khóa-Giá trị được cung cấp trong dictionary để làm cho nó được tối ưu hóa hơn.
Dict = {1: 'test1', 2: 'test2', 3: 'test3'}
print(Dict)
Tạo dictionary
Trong Python, một dictionary có thể được tạo bằng cách đặt một chuỗi các phần tử trong dấu ngoặc nhọn {}, được phân tách bằng ‘dấu phẩy’. dictionary chứa các cặp giá trị, một là Khóa và phần tử cặp tương ứng còn lại là key-value của nó. Các value trong dictionary có thể thuộc bất kỳ loại dữ liệu nào và có thể được sao chép, trong khi các khóa không thể lặp lại và phải không thay đổi.
Lưu ý – Các khóa dictionary có phân biệt chữ hoa chữ thường, cùng tên nhưng khác chữ hoa chữ thường của Khóa sẽ được xử lý khác biệt.
# tạo một Dictionary
# với key số nguyên
Dict = {1: 'test1', 2: 'test2', 3: 'test3'}
print("\nDictionary sử dụng số nguyên làm key: ")
print(Dict)
# tạo Dictionary với keys hỗn hợp
Dict = {'Name': 'test1', 1: [1, 2, 3, 4]}
print("\nDictionary sử dụng Mixed Keys: ")
print(Dict)
Dictionary cũng có thể được tạo bằng chức năng tích hợp sẵn dict(). Một dictionary trống có thể được tạo bằng cách chỉ cần đặt vào dấu ngoặc nhọn{}.
# tạo Dictionary rỗng
Dict = {}
print(" Dictionary rỗng: ")
print(Dict)
# Tạo Dictionary với dict()
Dict = dict({1: 'test1', 2: 'test2', 3: 'test3'})
print("\nDictionary với phương thức dict(): ")
# xuất ra Dict
print(Dict)
# Tạo Dictionary với mỗi item là 1 cặp
Dict = dict([(1, 'test1'), (2, 'test2')])
print("\nDictionary với mỗi cặp: ")
print(Dict)
Sự phức tạp để tạo một dictionary:
- Độ phức tạp về thời gian: O(len(dict))
- Độ phức tạp không gian: O(n)
Dictionary lồng nhau
# Tạo Dictionary lồng
Dict = {1: 'test1', 2: 'test2',
3: {'A': 'Welcome', 'B': 'To', 'C': 'test3'}}
print(Dict)
{1: 'test1', 2: 'test2', 3: {'A': 'Welcome', 'B': 'To', 'C': 'test3'}}Thêm các phần tử vào Dictionary
Việc bổ sung các phần tử có thể được thực hiện theo nhiều cách. Mỗi lần có thể thêm một giá trị vào dictionary bằng cách xác định giá trị cùng với khóa, ví dụ: Dict[Key] = ‘Giá trị’. Việc cập nhật một giá trị hiện có trong dictionary có thể được thực hiện bằng cách sử dụng phương thức update() tích hợp sẵn. Các giá trị khóa lồng nhau cũng có thể được thêm vào dictionary hiện có.
Lưu ý- Trong khi thêm một giá trị, nếu khóa-giá trị đã tồn tại, thì giá trị đó sẽ được cập nhật, nếu không, một Khóa mới có giá trị sẽ được thêm vào dictionary.
# Tạo một Dictionary rỗng
Dict = {}
print("Dictionary rỗng: ")
print(Dict)
# thêm element
Dict[0] = 'test1'
Dict[2] = 'test2'
Dict[3] = 'test2'
print("\nDictionary sau khi thêm: ")
print(Dict)
# thêm tập giá trị vào Key
Dict['mix1'] = 2, 3, 4
print("\nDictionary sau khi thêm: ")
print(Dict)
# Cập nhật Key's giá trị
Dict[2] = 'test4'
print("\nUpdated key value: ")
print(Dict)
# thêm giá trị lồng Key value to Dictionary
Dict[5] = {'Nested': {'1': 'test5', '2': 'test6'}}
print("\nAdding khóa lồng: ")
print(Dict)
Dictionary rỗng:
{}
Dictionary sau khi thêm:
{0: 'test1', 2: 'test2', 3: 'test2'}
Dictionary sau khi thêm:
{0: 'test1', 2: 'test2', 3: 'test2', 'mix1': (2, 3, 4)}
Updated key value:
{0: 'test1', 2: 'test4', 3: 'test2', 'mix1': (2, 3, 4)}
Adding khóa lồng:
{0: 'test1', 2: 'test4', 3: 'test2', 'mix1': (2, 3, 4), 5: {'Nested': {'1': 'test5', '2': 'test6'}}}
> Sự phức tạp khi thêm các phần tử trong dictionary:
- Độ phức tạp về thời gian: O(1)/O(n)
- Độ phức tạp không gian: O(1)
Truy cập các phần tử của dictionary
Để truy cập các index của dictionary, hãy tham khảo tên khóa của nó. Key có thể được sử dụng bên trong dấu ngoặc vuông.
# Tạo một Dictionary
Dict = {1: 'test1', 'name': 'test2', 3: 'test1'}
# Truy cập vào element sử dụng key
print("truy cập vào element vào key:")
print(Dict['name'])
# accessing a element using key
print("Accessing a element using key:")
print(Dict[1])
Đầu ra:
truy cập vào element vào key: test2 Accessing a element using key: test1 >
Ngoài ra còn có một phương thức gọi là get() cũng sẽ giúp truy cập phần tử từ một dictionary. Phương thức này chấp nhận khóa làm đối số và trả về giá trị.
Sự phức tạp khi truy cập các phần tử trong dictionary:
- Độ phức tạp thời gian: O(1)
- Độ phức tạp không gian: O(1)
# Tạo một Dictionary
Dict = {1: 'test1', 'name': 'test2', 3: 'test3'}
# truy cập sử dụng get()
print("truy cập vào sử dụng get():")
print(Dict.get(3))
Truy cập một phần tử của dictionary lồng nhau
Để truy cập giá trị của bất kỳ khóa nào trong dictionary lồng nhau, hãy sử dụng cú pháp lập chỉ mục [].
# tạo một Dictionary
Dict = {'Dict1': {1: 'test1'},
'Dict2': {'Name': 'test2'}}
# truy cập vào element sử dụng []
print(Dict['Dict1'])
print(Dict['Dict1'][1])
print(Dict['Dict2']['Name'])
Phương thức dictionary
- clear() – Xóa tất cả các phần tử khỏi dictionary
- copy() – Trả về một bản sao của dictionary
- get() – Trả về giá trị của key được chỉ định
- items() – Trả về một danh sách chứa một bộ cho mỗi cặp giá trị khóa
- keys() – Trả về danh sách chứa các khóa của dictionary
- pop() – Xóa phần tử bằng khóa được chỉ định
- popitem() – Xóa cặp khóa-giá trị được chèn cuối cùng
- update() – Cập nhật dictionary với các cặp khóa-giá trị được chỉ định
- values() – Trả về danh sách tất cả các giá trị của dictionary
# khởi tạo một dictionary
dict1 = {1: "Java", 2: "c++", 3: "python", 4: "Rust"}
# phương thức copy
dict2 = dict1.copy()
print(dict2)
#phương thức clear()
dict1.clear()
print(dict1)
#phương thức get()
print(dict2.get(1))
#phương thức items()
print(dict2.items())
#phương thức keys()
print(dict2.keys())
#phương thức pop()
dict2.pop(4)
print(dict2)
#phương thức popitem()
dict2.popitem()
print(dict2)
#phương thức update()
dict2.update({3: "Scala"})
print(dict2)
#phương thức values()
print(dict2.values())
{1: 'Java', 2: 'c++', 3: 'python', 4: 'Rust'}
{}
Java
dict_items([(1, 'Java'), (2, 'c++'), (3, 'python'), (4, 'Rust')])
dict_keys([1, 2, 3, 4])
{1: 'Java', 2: 'c++', 3: 'python'}
{1: 'Java', 2: 'c++'}
{1: 'Java', 2: 'c++', 3: 'Scala'}
dict_values(['Java', 'c++', 'Scala'])
> 
