Tuple trong Python là một chuỗi các phần tử có thứ tự giống như list. Sự khác biệt giữa list và tuple là chúng ta không thể thay đổi các phần tử trong tuple khi đã gán, nhưng trong list thì các phần tử có thể thay đổi.
Tuple thường được sử dụng cho các dữ liệu không cho phép sửa đổi và nhanh hơn list vì nó không thể thay đổi tự động. Một tuple được định nghĩa bằng dấu ngoặc đơn (), các phần tử trong tuple cách nhau bằng dấu phẩy (,).
Ví dụ:
t = (10, "quan tri mang", 2j)
Bạn có thể sử dụng toán tử cắt [] để trích xuất phần tử trong tuple nhưng không thể thay đổi giá trị của nó.
t = (10, "quan tri mang", 2j)
#t[0:2] = (10, 'quan tri mang')
print("t[0:2] = ", t[0:2])
Chạy code trên ta được kết quả:
t[0:2] = (10, 'quan tri mang')
Vì tuple và list khá giống nhau, nên chúng thường được sử dụng trong những tình huống tương tự nhau. Tuy nhiên, tuple vẫn có những lợi thế nhất định so với list, như:
Tuple được tạo bằng cách đặt tất cả các phần tử của nó trong dấu ngoặc đơn (), phân tách bằng dấu phẩy. Bạn có thể bỏ dấu ngoặc đơn nếu muốn, nhưng nên thêm nó vào cho code rõ ràng hơn.
Tuple không bị giới hạn số lượng phần tử và có thể có nhiều kiểu dữ liệu khác nhau như số nguyên, số thập phân, list, string,...
# Tuple rỗng
# Output: ()
my_tuple = ()
print(my_tuple)
# tuple số nguyên
# Output: (2, 4, 16, 256)
my_tuple = (2, 4, 16, 256)
print(my_tuple)
# tuple có nhiều kiểu dữ liệu
# Output: (10, "Quantrimang.com", 3.5)
my_tuple = (10, "Quantrimang.com", 3.5)
print(my_tuple)
# tuple lồng nhau
# Output: ("QTM", [2, 4, 6], (3, 5, 7))
my_tuple = ("QTM", [2, 4, 6], (3, 5, 7))
print(my_tuple)
# tuple có thể được tạo mà không cần dấu ()
# còn gọi là đóng gói tuple
# Output: (10, "Quantrimang.com", 3.5)
my_tuple = 10, "Quantrimang.com", 3.5
print(my_tuple)
# mở gói (unpacking) tuple cũng có thể làm được
# Output:
# 10
# Quantrimang.com
# 3.5
a, b, c = my_tuple
print(a)
print(b)
print(c)
Tạo tuple chỉ có một phần tử hơi phức tạp chút, nếu bạn tạo theo cách thông thường là cho phần tử đó vào trong cặp dấu () là chưa đủ, cần phải thêm dấu phẩy để chỉ ra rằng, đây là tuple.
# tạo tuple chỉ với ()
# Output: <class 'str'>
my_tuple = ("Quantrimang.com")
print(type(my_tuple))
# khi thêm dấu phẩy vào cuối
# Output: <class 'tuple'>
my_tuple = ("Quantrimang.com",)
print(type(my_tuple))
# dấu () là tùy chọn, bạn có thể bỏ nếu thích
# Output: <class 'tuple'>
my_tuple = "Quantrimang.com",
print(type(my_tuple))
Có nhiều cách khác nhau để truy cập vào các phần tử của một tuple, khá giống với list, nên mình không lấy ví dụ cụ thể, các bạn có thể xem lại phần list nha.
Index: Sử dụng toán tử index [] để truy cập vào phần tử trong tuple với index bắt đầu bằng 0. Nghĩa là nếu tuple có 6 phần tử thì index của nó sẽ bắt đầu từ 0 đến 5. Nếu cố gắn truy cập đến index 6, 7 thì sẽ tạo lỗi IndexError. Index bắt buộc phải là số nguyên, mà không thể là số thập phân hay bất kỳ kiểu dữ liệu nào khác, nếu không sẽ tạo lỗi TypeError. Những tuple lồng nhau được truy cập bằng cách sử dụng index lồng nhau:
# tuple lồng nhau
n_tuple = ("Quantrimang.com", [2, 6, 8], (1, 2, 3))
# index lồng nhau
# Output: 'r'
print(n_tuple[0][5])
# index lồng nhau
# Output: 8
print(n_tuple[1][2])
Index âm: Python cho phép lập chỉ mục âm cho các đối tượng dạng chuỗi. Index -1 tham chiếu đến phần tử cuối cùng, -2 là thứ 2 tính từ cuối tính lên.
Cắt lát: Có thể truy cập đến một loạt phần tử trong tuple bằng cách sử dụng toán tử cắt lát : (dấu 2 chấm).
Không giống như list, tuple không thể thay đổi. Điều này có nghĩa là các phần tử của một tuple không thể thay đổi một khi đã được gán. Nhưng, nếu bản thân phần tử đó là một kiểu dữ liệu có thể thay đổi (như list chẳng hạn) thì các phần tử lồng nhau có thể được thay đổi. Chúng ta cũng có thể gán giá trị khác cho tuple (gọi là gán lại - reassignment).
my_tuple = (1, 3, 5, [7, 9])
# không thể thay đổi phần tử của tuple
# Nếu bạn bỏ dấu # ở dòng 8
# Bạn sẽ nhận được lỗi:
# TypeError: 'tuple' object does not support item assignment
#my_tuple[1] = 9
# Nhưng phần tử có index 3 trong tuple là list
# list có thể thay đổi, nên phần tử đó có thể thay đổi
# Output: (1, 3, 5, [8, 9])
my_tuple[3][0] = 8
print(my_tuple)
# Nếu cần thay đổi tuple hãy gán lại giá trị cho nó
# Output: ('q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g')
my_tuple = ('q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g')
print(my_tuple)
Bạn có thể dùng toán tử + để nối 2 tuple, toán tử * để lặp lại tuple theo số lần đã cho. Cả + và * đều cho kết quả là một tuple mới.
# Nối 2 tuple
# Output: (2, 4, 6, 3, 5, 7)
print((2, 4, 6) + (3, 5, 7))
# Lặp lại tuple
# Output: ('Quantrimang.com', 'Quantrimang.com', 'Quantrimang.com')
print(("Quantrimang.com",) * 3)
Các phần tử trong tuple không thể thay đổi nên chúng ta cũng không thể xóa, loại bỏ phần tử khỏi tuple. Nhưng việc xóa hoàn toàn một tuple có thể thực hiện được với từ khóa del như dưới đây:
QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']
# Không thể xóa phần tử của tuple
# Nếu bạn bỏ dấu # ở dòng 8,
# sẽ tạo ra lỗi:
# TypeError: 'tuple' object doesn't support item deletion
#del QTM[3]
# Có thể xóa toàn bộ tuple
# Kết quả chạy code sẽ hiện ra lỗi:
# NameError: name 'my_tuple' is not defined
del QTM
QTM
Phương thức thêm phần tử và xóa phần tử không thể sử dụng với tuple, chỉ có 2 phương thức sau là dùng được:
QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']
# Count
# Output: 2
print(QTM.count('m'))
# Index
# Output: 3
print(QTM.index('n'))
Các hàm dùng trong tuple khá giống với list, gồm có:
Bạn có thể kiểm tra xem một phần tử đã tồn tại trong tuple hay chưa với từ khóa in.
QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']
# Kiểm tra phần tử
# Output: True
print('a' in QTM)
# Output: False
print('b' in QTM)
# Not in operation
# Output: False
print('g' not in QTM)
Sử dụng vòng lặp for để lặp qua các phần tử trong tuple.
for ngon_ngu in ('Python','C++','Web'):
print("Tôi thích lập trình",ngon_ngu)
Kết quả trả về sẽ như sau:
Tôi thích lập trình Python
Tôi thích lập trình C++
Tôi thích lập trình Web
Set trong Python là tập hợp các phần tử duy nhất, không có thứ tự. Các phần tử trong set phân cách nhau bằng dấu phẩy và nằm trong dấu ngoặc nhọn {}. Nhớ kỹ rằng các phần tử trong set không có thứ tự. Nhưng các phần tử trong set có thể thay đổi, có thể thêm hoặc xóa phần tử của set. Set có thể được sử dụng để thực hiện các phép toán như tập hợp, giao,...
Set được tạo bằng cách đặt tất cả các phần tử trong dấu ngoặc nhọn, phân tách bằng dấu phẩy hoặc sử dụng hàm set(). Set không giới hạn số lượng phần tử, nó có thể chứa nhiều kiểu biến khác nhau, nhưng không thể chứa phần tử có thể thay đổi được như list, set hay dictionary.
Ví dụ về set:
a = {5,2,3,1,4}
Nếu thực hiện lệnh in như sau:
print("a=", a)
Bạn sẽ nhận được kết quả:
a = {1, 2, 3, 4, 5}
Set với nhiều kiểu dữ liệu hỗn hợp như sau:
my_set = {1.0, "Xin chào", (1, 2, 3)}
#Output: QTM_Set= {'Xin chào', 1.0, (1, 2, 3)}
print("QTM_Set=",my_set)
Tạo set rỗng có chút khó khăn. Cặp dấu {} sẽ tạo một dictionary trong Python. Để tạo set không có phần tử nào, ta sử dụng hàm set() mà không có đối số nào.
# initialize a with {}
qtm = {}
# Kiểm tra kiểu dữ liệu của qtm
# Output: <class 'dict'>
print(type(qtm))
# Khởi tạo qtm với set()
qtm = set()
# Kiểm tra kiểu dữ liệu của qtm
# Output: <class 'set'>
print(type(qtm))
Vì set là tập hợp các phần tử không có thứ tự nên chỉ mục chả có ý nghĩa gì với set. Do đó toán tử cắt [] sẽ không làm việc trên set. Nếu cố tình dùng, bạn sẽ nhận được thông báo lỗi như dưới đây:
>>> a[1]
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
a[1]
TypeError: 'set' object does not support indexing
Để thêm một phần tử vào set, bạn sử dụng add() và để thêm nhiều phần tử dùng update(). Update() có thể nhận tuple, list, strring và set làm đối số. Trong mọi trường hợp, Set có giá trị duy nhất, các bản sao sẽ tự động bị loại bỏ.
# Khởi tạo my_set
my_set = {1,3}
print(my_set)
# Nếu bỏ dấu # ở dòng 9,
# Bạn sẽ nhận được lỗi
# TypeError: 'set' object does not support indexing
#my_set[0]
# Thêm phần tử
# Output: {1, 2, 3}
my_set.add(2)
print(my_set)
# Thêm nhiều phần tử vào set
# Output: {1, 2, 3, 4}
my_set.update([2,3,4])
print(my_set)
# Thêm list và set
# Output: {1, 2, 3, 4, 5, 6, 8}
my_set.update([4,5], {1,6,8})
print(my_set)
Bạn dùng discard() và remove() để xóa phần tử cụ thể khỏi set. Khi phần tử cần xóa không tồn tại trong set thì discard() không làm gì cả, còn remove() sẽ báo lỗi.
# Khởi tạo my_set
my_set = {1, 3, 4, 5, 6}
print(my_set)
# Xóa phần tử bằng discard()
# Output: {1, 3, 5, 6}
my_set.discard(4)
print(my_set)
# Xóa bằng remove()
# Output: {1, 3, 5}
my_set.remove(6)
print(my_set)
# Xóa phần tử không có
# trong set bằng discard()
# Output: {1, 3, 5}
my_set.discard(2)
print(my_set)
# Xóa phần tử không có
# trong set bằng remove()
# Nếu bạn bỏ dấu # ở dòng 27,
# bạn sẽ nhận được lỗi.
# Output: KeyError: 2
#my_set.remove(2)
Bạn có thể xóa và trả lại một mục bằng phương thức pop(). Set không có thứ tự, không có cách nào để xác định phần tử nào sẽ bị xóa, điều này diễn ra hoàn toàn ngẫu hứng. Việc xóa hoàn toàn set được thực hiện bằng cách dùng clear().
# Khởi tạo my_set
# Output: set of unique elements
my_set = set("Quantrimang.com")
print(my_set)
# xóa phần tử bằng pop()
# Output: phần tử bị xóa ngẫu nhiên
print(my_set.pop())
# xóa phần tử khác bằng pop()
# Output: phần tử bị xóa ngẫu nhiên
my_set.pop()
print(my_set)
# clear my_set
#Output: set()
my_set.clear()
print(my_set)
Set thường được sử dụng để chứa các toán tử tập hợp như hợp, giao, hiệu, bù. Có cả phương thức và toán tử để thực hiện những phép toán tập hợp này.
Ta sẽ sử dụng 2 tập hợp dưới đây:
>>> A = {1, 2, 3, 4, 5}
>>> B = {4, 5, 6, 7, 8}
Hợp của A và B là tập hợp tất cả các phần tử của A và B. Hợp được biểu diễn bằng cách sử dụng toán tử | hoặc sử dụng phương thức union().
# Khởi tạo A và B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# sử dụng toán tử |
# Output: {1, 2, 3, 4, 5, 6, 7, 8}
print(A | B)
# sử dụng hàm union()
# Output: Như trên
print(A.union(B))
print(B.union(A))
Giao của A và B là tập hợp những phần tử chung của A và B. Để tìm giao của A và B ta có thể dùng toán tử & hoặc hàm intersection().
# khởi tạo A và B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# sử dụng &
# Output: {4, 5}
print(A & B)
# sử dụng intersection()
# Output: {4, 5}
print(A.intersection(B))
print(B.intersection(A))
Hiệu của A và B (A-B) là tập hợp phần tử chỉ có trong A, không có trong B. Hiệu của B và A (B-A) là tập hợp phần tử chỉ có trong B không có trong A. Có thể sử dụng toán tử - hoặc hàm difference() để thực hiện phép toán tập hợp này.
# Khởi tạo A và B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# Sử dụng toán tử - trên A
# Output: {1, 2, 3}
print(A - B)
# Sử dụng hàm difference() trên A
# Output: {1, 2, 3}
print(A.difference(B))
# Sử dụng toán tử - trên B
# Output: {8, 6, 7}
print(B - A)
# Sử dụng difference() trên B
# Output: {8, 6, 7}
print(B.difference(A))
Bù của A và B là tập hợp những phần tử có trong A và B nhưng không phải phần tử chung của hai tập hợp này. Bạn có thể dùng toán tử ^ hoặc hàm symmetric_difference() để thực hiện phép bù.
# Khởi tạo A và B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# Sử dụng toán tử ^
# Output: {1, 2, 3, 6, 7, 8}
print(A ^ B)
# Sử dụng symmetric_difference() trên A
# Output: {1, 2, 3, 6, 7, 8}
print(A.symmetric_difference(B))
Phương thức | Mô tả |
add() | Thêm một phần tử vào set. |
clear() | Xóa tất cả phần tử của set. |
copy() | Trả về bản sao chép của set. |
difference() | Trả về set mới chứa những phần tử khác nhau của 2 hay nhiều set. |
difference_update() | Xóa tất cả các phần tử của set khác từ set này. |
discard() | Xóa phần tử nếu nó có mặt trong set. |
intersection() | Trả về set mới chứa phần tử chung của 2 set. |
intersection_update() | Cập nhật set với phần tử chung của chính nó và set khác. |
isdisjoint() | Trả về True nếu 2 set không có phần tử chung. |
issubset() | Trả về True nếu set khác chứa set này. |
issuperset() | Trả về True nếu set này chưa set khác. |
pop() | Xóa và trả về phần tử ngẫu nhiên, báo lỗi KeyError nếu set rỗng. |
remove() | Xóa phần tử từ set. Nếu phần tử đó không có trong set sẽ báo lỗi KeyError. |
symmetric_difference() | Trả về set mới chứa những phần tử không phải là phần tử chung của 2 set. |
symmetric_difference_update() | Cập nhật set với những phần tử khác nhau của chính nó và set khác. |
union() | Trả về set mới là hợp của 2 set. |
update() | Cập nhật set với hợp của chính nó và set khác. |
Bạn có thể kiểm tra một đối tượng xem nó có nằm trong set không, sử dụng từ khóa in.
# Khởi tạo my_set
my_set = set("Quantrimang.com")
# Kiểm tra xem Q có trong my_set không
# Output: True
print('Q' in my_set)
# Kiểm tra xem q có trong my_set không
# Output: False
print('q' in my_set)
Sử dụng vòng lặp for để lặp qua các phần tử của set.
for letter in set("Python"):
print(letter)
Chạy code trên bạn nhận được kết quả như sau:
t
y
P
h
o
n
Các hàm thường dùng trên set bao gồm all(), any(), enumerate(), len(), max(), min(), sorted(), sum(). Chức năng của những hàm này khá giống với khi bạn sử dụng trên list, tuple, bạn có thể tham khảo thêm nếu chưa rõ nha.
Frozenset là một lớp mới, có đặc điểm của một set, nhưng phần tử của nó không thể thay đổi được sau khi gán. Để dễ hình dung thì tuple là list bất biến còn frozenset là set bất biến.
Các set có thể thay đổi được nhưng không thể băm (hash) được, do đó không thể sử dụng set để làm key cho dictionary. Nhưng frozenset có thể băm được nên có thể dùng như các key cho dictionary.
Frozenset có thể tạo bằng hàm frozenset(). Kiểu dữ liệu này hỗ trợ các phương thức như copy(), difference(), intersection(), isdisjoint(), issubset(), issuperset(), symmetric_difference() và union(). Vì không thể thay đổi nên phương thức add() hay remove() không sử dụng được trên frozenset.
Dictionary là tập hợp các cặp khóa giá trị không có thứ tự. Nó thường được sử dụng khi chúng ta có một số lượng lớn dữ liệu. Các dictionary được tối ưu hóa để trích xuất dữ liệu với điều kiện bạn phải biết được khóa để lấy giá trị.
Trong Python, dictionary được định nghĩa trong dấu ngoặc nhọn {} với mỗi phần tử là một cặp theo dạng key:value. Key và value này có thể là bất kỳ kiểu dữ liệu nào. Bạn cũng có thể tạo dictionary bằng cách sử dụng hàm dict() được tích hợp sẵn.
Ví dụ:
dict1 = {} #dictionary rỗng
#dict2 là dictionary với các khóa nguyên
dict2 = {1: 'Quantrimang.com',2: 'Công nghệ'}
#Tạo dictionary với khóa hỗn hợp
dict3 = {'tên': 'QTM', 1: [1, 3, 5]}
#Tạo dictionary bằng dict()
dict4 = dict({1:'apple', 2:'ball'})
#Tạo dictionary từ chuỗi với mỗi mục là một cặp
dict5 = dict([(1,'QTM'), (2,'CN')])
Khi thực hiện kiểm tra kiểu dữ liệu của d ta được kết quả:
>>> type(dict2)
<class 'dict'>
Các kiểu dữ liệu lưu trữ khác sử dụng index để truy cập vào các giá trị thì dictionary sử dụng các key. Key có thể được sử dụng trong cặp dấu ngoặc vuông hoặc sử dụng get().
Sử dụng khóa để trích xuất dữ liệu:
#khai báo và gán giá trị dict2
dict2 = {1: 'Quantrimang.com','quantrimang': 'Công nghệ'}
print(type(dict2)) #in kiểu dữ liệu của dict2
#trích xuất dữ liệu bằng khóa rồi in
print("dict2[1] = ", dict2[1])
print("dict2[quantrimang] = ",dict2['quantrimang'])
Chạy đoạn code trên ta sẽ được kết quả:
<class 'dict'>
dict2[1] = Quantrimang.com
dict2[quantrimang] = Công nghệ
Dictionary có thể thay đổi, nên có thể thêm phần tử mới hoặc thay đổi giá trị của các phần tử hiện có bằng cách sử dụng toán tử gán. Nếu key đã có, giá trị sẽ được cập nhật, nếu là một cặp key: value mới thì sẽ được thêm thành phần tử mới.
dict2 = {1: 'Quantrimang.com','quantrimang': 'Công nghệ'}
#cập nhật giá trị
dict2['quantrimang'] = 'Quản trị mạng'
#output: {1: 'Quantrimang.com', 'quantrimang': 'Quản trị mạng'}
print(dict2)
#thêm phần tử mới
dict2[2] = 'Python'
#output: {1: 'Quantrimang.com', 'quantrimang': 'Quản trị mạng', 2: 'Python'}
print(dict2)
Bạn có thể xóa phần tử cụ thể của dictionary bằng cách sử dụng pop(), nó sẽ phần tử có key đã cho và trả về giá trị của phần tử. popitem() có thể xóa và trả về một phần tử tùy ý dưới dạng (key, value). Tất cả các phần tử trong dictionary có thể bị xóa cùng lúc bằng cách dùng clear(). Ngoài ra, từ khóa del cũng có thể dùng để xóa một phần tử hoặc toàn bộ dictionary.
# tạo dictionary
binh_phuong = {1:1, 2:4, 3:9, 4:16, 5:25}
# xóa phần tử số 4
# Output: 16
print(binh_phuong.pop(4))
# Output: {1: 1, 2: 4, 3: 9, 5: 25}
print(binh_phuong)
# xóa phần tử cụ thể
del binh_phuong[2]
# output: {1: 1, 3: 9, 5: 25}
print(binh_phuong)
# xóa phần tử bất kỳ
# Output: (5, 25)
print(binh_phuong.popitem())
# Output: {1: 1, 3: 9}
print(binh_phuong)
# xóa tất cả phần tử
binh_phuong.clear()
# output: {}
print(binh_phuong)
# xóa dictionary binh_phuong
del binh_phuong
# tạo lỗi nếu bỏ # ở lệnh sau
# print(squares)
Đây là những phương thức thường dùng với dictionary:
Method | Mô tả |
---|---|
clear() | Xóa tất cả phần tử của dictionary. |
copy() | Trả về một bản sao shollow copy của dictionary. |
fromkeys(seq[,v]) | Trả về dictionary mới với key từ seq và value bằng v (default là None ). |
get(key[,d]) | Trả về giá trị của key, nếu key không tồn tại, trả về d. (default là None ). |
items() | Trả lại kiểu xem mới của các phần tử trong dictionary (key, value). |
keys() | Trả về kiểu xem mới của các key trong dictionary. |
pop(key[,d]) | Xóa phần tử bằng key và trả về giá trị hoặc d nếu key không tìm thấy. Nếu d không được cấp, key không tồn tại thì sẽ tạo lỗi KeyError . |
popitem() | Xóa và trả về phần tử bất kỳ ở dạng (key, value). Tạo lỗi KeyError nếu dictionary rỗng. |
setdefault(key,[,d]) | Nếy key tồn tại trả về value của nó, nếu không thêm key với value là d và trả về d (default là None ). |
update([other]) | Cập nhật dictionary với cặp key/value từ other, ghi đè lên các key đã có. |
values() | Trả về kiểu view mới của value trong dictionary. |
Các hàm tích hợp như all(), any(), len(), cmp(), sorted(),... thường được sử dụng với dictionary để thực hiện những nhiệm vụ khác nhau.
Dictionary comprehension là cách đơn giản, rút gọn để tạo dictionary mới từ một vòng lặp trong Python. Câu lệnh sẽ bao gồm một cặp biểu thức (key:value) cùng câu lệnh for, tất cả đặt trong dấu {}. Dưới đây là ví dụ tạo dictionary với mỗi pahàn tử là một cặp số và lập phương của nó.
lap_phuong = {x: x*x*x for x in range(6)}
# Output: {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
print(lap_phuong)
Chương trình trên tương đương với
lap_phuong = {}
for x in range(6):
lap_phuong[x] = x*x*x
print(lap_phuong)
Bạn cũng có thể sử dụng lệnh if trong dictionary comprehension. Lệnh if có thể lọc những phần tử trong dictionary hiện có để tạo thành dictionary mới như ví dụ dưới đây:
lap_phuong_chan = {x: x*x*x for x in range (10) if x%2==0}
# output: {0: 0, 2: 8, 4: 64, 6: 216, 8: 512}
print(lap_phuong_chan)
Bạn chỉ có thể kiểm tra key của phần tử đã có trong dictionary hay chưa bằng cách dùng in, và không thể làm điều đó với value.
lap_phuong = {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
#output: True
print (2 in lap_phuong)
#output: False
print (9 in lap_phuong)
#output: False
print (5 not in lap_phuong)
Bạn có thể sử dụng vòng lặp for để lặp qua key của các phần tử trong dictionary.
lap_phuong = {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
for i in lap_phuong
print(lap_phuong[i])
Chạy code trên, các giá trị tương ứng với từng key sẽ được in ra màn hình theo thứ tự của key.
Chúng ta có thể chuyển đổi giữa các kiểu dữ liệu khác nhau bằng cách sử dụng hàm chuyển đổi kiểu khác nhau như int() (kiểu số nguyên), float() số thập phân, str() chuỗi,...
Ví dụ:
>>> float(11)
11.0
Chuyển đổi từ kiểu float sang kiểu int sẽ bị giảm giá trị (làm cho nó gần với số không hơn).
Ví dụ:
int(18.6)
18
Chuyển đổi từ string sang hoặc ngược lại phải có các giá trị tương thích.
Bạn có thể thực hiện chuyển đổi chuỗi này sang chuỗi khác:
>>> set([2,4,6])
{2,4,6}
>>> tuple({3,5,7})
(3,5,7)
>>> list('quantrimang')
['q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g']
Để chuyển đổi sang dictionary, mỗi phần tử phải là một cặp như ví dụ dưới đây:
>>> dict([[2,4],[1,3]])
{2: 4, 1: 3}
>>> dict([(3,9),(4,16)])
{3: 9, 4: 16}
Tất nhiên, chúng ta có thể sử dụng Python cho những tác vụ phức tạp hơn là thêm vài phần tử vào chuỗi. Ví dụ, có thể viết một chuỗi con của dãy Fibonacci (dãy vô hạn các số tự nhiên bắt đầu bằng hai phần tử 0 và 1 hoặc 1 và 1, các phần tử sau đó được thiết lập bằng cách cộng hai phần tử trước nó lại) như sau:
>>> # Dãy Fibonacci:
... # tổng của hai phần tử tạo nên phần tử tiếp theo
... a, b = 0, 1
>>> while b < 10:
... print(b)
... a, b = b, a+b
...
1
1
2
3
5
8
Ví dụ này giới thiệu một số tính năng mới:
>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536
Có thể sử dụng thêm đối số end cho hàm print() để tránh thêm dòng mới trong kết quả đầu ra hoặc kết thúc kết quả với một chuỗi khác:
>>> a, b = 0, 1
>>> while b < 1000:
... print(b, end=',')
... a, b = b, a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
Đến đây các bạn đã bắt đầu hình dung được phần nào về Python rồi đúng không? Hãy cùng chờ đón những bài học tiếp theo về các câu lệnh, cấu trúc dữ liệu trong Python nhé.
Phần sau:
Phần trước: [Python Cơ Bản] Phần 6: Các kiểu dữ liệu trong Python
Tác giả bài viết: Thanh Sơn
Nguồn tin: quantrimang.com
Ý kiến bạn đọc
Những tin mới hơn
Những tin cũ hơn