Kiểu dữ liệu trong Python: chuỗi, số, list, tuple, set và dictionary

Trong phần trước, tất cả chúng ta đã làm quen với chương trình Python trước hết là thêm hai số và in tổng của chúng ra ngoài màn hình. Phần này, bạn sẽ học cách dùng Python như một cái máy tính, học về số, chuỗi, danh sách và đi bước trước hết nhắm tới lập trình Python.

Vì nội dung sẽ liệt kê những bài viết trọng yếu nhất của toàn bộ các kiểu dữ liệu trong Python nên sẽ khá dài. Mỗi kiểu dữ liệu đều đi kèm với chẳng hạn rõ ràng để bạn dễ hình dung.

Hãy chắc rằng bạn đã lưu giữ trang Tài liệu Python này để update những bài tiên tiến nhất nhé. Đừng quên làm bài tập Python để củng cố học thức nữa nhé.

1. Biến trong Python

Biến là một địa điểm trong bộ nhớ lưu trữ được sử dụng để lưu trữ dữ liệu (giá trị). Biến được đặt tên duy nhất để phân biệt giữa các địa điểm bộ nhớ lưu trữ khác nhau. Các nguyên tắc để viết tên một biến giống như nguyên tắc viết các định danh trong Python.

Trong Python, bạn không cần khai báo biến trước khi sử dụng, chỉ cần gán cho biến một giá trị và nó sẽ tồn tại. Cũng không cần phải khai báo kiểu biến, kiểu biến sẽ được nhận auto dựa theo giá trị mà bạn đã gán cho biến.

Gán giá trị cho biến:

Để gán giá trị cho biến ta sử dụng toán tử =. Bất kỳ loại giá trị nào cũng có thể gán cho biến hợp lệ.

Chẳng hạn:

hoa = "Hồng"
la = 3
canh = 5.5

Phía trên là 3 câu lệnh gán, “Hồng” là một chuỗi ký tự, được gán cho biến hoa, 3 là số nguyên và được gán cho la, 5.5 là số thập phân và gán cho canh.

Gán nhiều giá trị:

Trong Python bạn có thể thực hiện gán nhiều giá trị trong một lệnh như sau:

hoa, la, canh = "Hồng", 3, 5.5

Nếu mong muốn gán giá trị giống nhau cho nhiều biến thì có thể viết lệnh như sau:

hoa, la, canh = 3

Lệnh trên sẽ gán giá trị 3 cho cả 3 biến là hoa, la và canh.

2. Kiểu dữ liệu số trong Python

Các kiểu dữ liệu số trong Python

Python phụ trợ số nguyên, số thập phân và số phức, chúng lần lượt được khái niệm là các lớp int, float, complex trong Python. Số nguyên và số thập phân được phân biệt bằng sự có mặt hoặc vắng mặt của dấu thập phân. Chẳng hạn: 5 là số nguyên, 5.0 là số thập phân. Python cũng phụ trợ số phức và sử dụng hậu tố j hoặc J để chỉ phần ảo. Chẳng hạn: 3+5j. Ngoài intfloat, Python phụ trợ thêm 2 loại số nữa là DecimalFraction.

Ta sẽ dùng hàm type() để kiểm soát xem biến hoặc giá trị thuộc lớp số nào và hàm isinstance() để kiểm soát xem chúng có thuộc về một class rõ ràng nào không.

a = 9

# Output: <class 'int'>
print(type(a))

# Output: <class 'float'>
print(type(5.0))

# Output: (10+2j)
b = 8 + 2j
print(b + 2)

# Kiểm soát xem b có phải là số phức không
# Output: True
print(isinstance(b, complex)) 

Số nguyên trong Python không bị hạn chế độ dài, số thập phân bị hạn chế đến 16 số sau dấu thập phân.

Những con số chúng là làm việc mỗi ngày thường là hệ số 10, nhưng lập trình viên laptop (thường là lập trình viên nhúng) cần làm việc với hệ thống số nhị phân, thập lục phân và bát phân. Để trình diễn những hệ số này trong Python, ta đặt một tiền tố phù hợp trước số đó.

Tiền tố hệ số cho các số Python:

Hệ thống sốTiền tốHệ nhị phân’0b’ hoặc ‘0B’Hệ bát phân’0o’ hoặc ‘0O’Hệ thập lục phân’0x’ hoặc ‘0X’

(Bạn đặt tiền tố nhưng không có dấu ‘ ‘ nhé).

Đây là chẳng hạn về việc sử dụng các tiền tố hệ số trong Python, và khi dùng hàm print() để in giá trị của chúng ra màn hình, ta sẽ thu được số tương ứng trong hệ số 10.

# Output: 187
print(0b10111011)

# Output: 257 (250 + 7)
print(0xFA + 0b111)

# Output: 15
print(0o17)

Chuyển hóa giữa các kiểu số trong Python

Tất cả chúng ta có thể chuyển hóa kiểu số này sang kiểu số khác. Điều này có cách gọi khác là cưỡng chế (coercion). Các phép toán như cộng, trừ sẽ ngầm chuyển hóa số nguyên thành số thập phân (một cách auto) nếu có một toán tử trong phép toán là số thập phân.

Chẳng hạn: Nếu bạn thực hiện phép cộng giữa số nguyên là 2 và số thập phân là 3.0, thì 2 sẽ bị cưỡng chế chuyển thành số thập phân 2.0 và kết quả trả về sẽ là số thập phân 5.0.

>>> 2 + 3.0
5.0

Ta có thể sử dụng các hàm Python tích hợp sẵn như int(), float() và complex() để chuyển hóa giữa các kiểu số một cách rõ ràng và cụ thể. Những hàm này thậm chí có thể chuyển hóa từ các chuỗi.

>>> int(3.6)
3
>>> int(-1.2)
-1
>>> float(7)
7.0
>>> complex('2+8j')
(2+8j)

Khi chuyển hóa từ số thập phân sang số nguyên, số sẽ bị bỏ bớt, chỉ lấy phần nguyên.

Mô-đun Decimal trong Python

Class float được tích hợp trong Python có thể khiến tất cả chúng ta bất ngờ đôi chút. Thông thường nếu tính tổng 1.1 và 2.2 ta nghĩ kết quả sẽ là 3.3, nhưng có lẽ không phải vậy. Nếu bạn kiểm soát tính đúng sai của phép toán này trong Python, sẽ thu được kết quả là False.

>>> (1.1 + 2.2) == 3.3
False

Chuyện gì xảy ra vậy?

Điều đó là do, các số thập phân được thực hiện trong Hartware laptop dưới dạng phân số nhị phân, vì laptop chỉ hiểu các số nhị phân (0 và 1) nên đa phần các phân số thập phân mà tất cả chúng ta biết, chẳng thể được lưu trữ chuẩn xác trong laptop.

Chẳng hạn, ta chẳng thể trình diễn phân số 1/3 dưới dạng số thập phân, vì nó là một số thập phân vô hạn tuần hoàn, với các số sau dấu thập phân dài vô hạn, nên ta chỉ có thể ước tính nó.

Khi chuyển hóa phần thập phân 0.1, sẽ kéo theo phần nhị phân dài vô hạn của 0.000110011001100110011… và laptop chỉ lưu trữ một phần số hữu hạn sau dấu . của nó thôi. Cho nên, số được lưu trữ chỉ xấp xỉ 0.1 chứ không lúc nào bằng 0.1. Này là nguyên nhân tại sao, phép cộng tất cả chúng ta kể tới ở trên không đề ra kết quả như tất cả chúng ta trông mong. Này là hạn chế của Hartware laptop chứ không phải lỗi của Python.

Giờ bạn thử gõ phép cộng trên vào Python xem kết quả trả về là bao nhiêu nhé:

>>> 1.1+2.2
3.3000000000000003

Để giải quyết vấn đề này, tất cả chúng ta có thể sử dụng mô-đun Decimal trong Python. Trong lúc số float chỉ lấy 16 số sau dấu thập phân thì mô-đun Decimal cho phép tùy chỉnh độ dài của số.

import decimal

# Output: 0.1
print(0.1)

# Output: 0.1000000000000000055511151231257827021181583404541015625
print(decimal.Decimal(0.1))

Mô-đun này được sử dụng khi tất cả chúng ta mong muốn thực hiện các phép toán ở hệ số thập phân để có kết quả như đã học ở trường.

Điều này cũng tương đối trọng yếu, chẳng hạn như 25.50kg sẽ chuẩn xác hơn 25.5kg, vì 2 chữ số thập phân vẫn chuẩn xác hơn 1 chữ số.

from decimal import Decimal
# Output: 3.3
print(Decimal('1.1') + Decimal('2.2'))

# Output: 10.000
print(Decimal('4.0') * Decimal('2.50'))

Nếu mong muốn code ngắn gọn hơn, bạn có thể nhập mô-đun Decimal và sửa tên mô-đun thành D.

from decimal import Decimal as D
# Output: 3.3
print(D('1.1') + D('2.2'))

# Output: 10.000
print(D('4.0') * D('2.50'))

Trong code này ta nhập mô-đun Decimal và sửa tên nó thành D, kết quả không đổi đối với code trên.

Bạn có thể khúc mắc trong phần phép nhân, vì sao không sử dụng số Decimal để nhân lại phải thêm số 0 vào sau 4 và cả 2.5. Câu giải đáp là tính hiệu quả, các phép toán với số float được hiện mau hơn các phép toán Decimal.

Lúc nào nên sử dụng Decimal thay cho float?

Ta thường sử dụng Decimal trong các trường hợp sau:

  • Khi tạo áp dụng tài chính, cần trình diễn phần thập phân chuẩn xác.
  • Khi mong muốn kiểm tra mức độ chuẩn xác của số.
  • Khi mong muốn thực hiện các phép toán giống như đã học ở trường.

Phân số trong Python

Python phân phối các phép toán liên quan đến phân số thông qua mô-đun fractions. Một phân số có tử số và mẫu số, cả hai đều là số nguyên. Ta có thể tạo đối tượng phân số (Fraction) theo nhiều cách khác nhau:

import fractions

# Tạo phân số từ số thập phân
print(fractions.Fraction(4.5))
# Output: 9/2

# Tạo phân số từ số nguyên
# Code by Quantrimang.com
print(fractions.Fraction(9))
# Output: 9

# Tạo phân số bằng cách khai báo tử, mẫu số
print(fractions.Fraction(2,5))
# Output: 2/5

Khi tạo phân số từ float, ta có thể thu được những kết quả không bình bình, điều đó là do giới hạn của Hartware laptop như đã luận bàn trong phần mô-đun decimal.

Đặc biệt, bạn có thể khởi tạo một phân số từ string. Đây là cách khởi tạo được ưa chuộng khi sử dụng số thập phân.

import fractions

# Khởi tạo phân số từ float
print(fractions.Fraction(0.1))
# Output: 3602879701896397/36028797018963968

# Khởi tạo phân số từ string
# Code by Quantrimang.com
print(fractions.Fraction('0.1'))
# Output: 1/10

Kiểu dữ liệu phân số phụ trợ đầy đủ các phép toán căn bản như cộng, trừ, nhân, chia, logic:

# Output: 1
print(F(2,5) + F(3,5))
# Output: 3/5
print(F(2,5) + F(1,5))
# Output: 7/1
print(1 / F(3,7))
# Output: False
print(F(-2,9) > 0)
# Output: True
print(F(-2,9) < 0)

Toán học trong Python

Python phân phối các mô-đun math và random để khắc phục các vấn đề toán học khác như lượng giác, logarit, xác suất và tổng hợp, v.v… Vì mô-đun math có hơi nhiều hàm và tính chất, nên mình tính sẽ làm một bài riêng để liệt kê chúng. Dưới đây là chẳng hạn về math trong Python.

from fractions import Fraction as F
import math

# Output: 3.141592653589793
print(math.pi)
# Output: -1.0
print(math.cos(math.pi))
# Output: 22026.465794806718
print(math.exp(10))
# Output: 2.0
print(math.log2(4))
# Output: 1.1752011936438014
print(math.sinh(1))
# Output: 40320
print(math.factorial(8))

Sử dụng trình thông dịch như laptop bỏ túi

Trình thông dịch hoạt động như một laptop dễ dàng: Bạn có thể nhập vào một phép tính và nó sẽ viết ra giá trị. Cú pháp biểu thức khá dễ dàng: các toán tử như +, -, * và / làm việc giống như trong đa phần các từ ngữ lập trình khác (Pascal, C), dấu ngoặc đơn () có thể được sử dụng để nhóm. Chẳng hạn:

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # phép chia luôn trả về một số dạng thập phân với dấu chấm
1.6

Số nguyên (chẳng hạn như 2, 4, 20) có kiểu int, số dạng thập phân (như 5.0, 1.6) có kiểu float.

Phép chia (/) luôn luôn trả về kiểu float. Để thực hiện phép chia lấy phần nguyên (loại bỏ các số sau dấu thập phân) bạn có thể sử dụng toán tử //; để tính phần dư thì sử dụng % như chẳng hạn dưới đây:

>>> 17 / 3 # phép chia thường trả về số thập phân
5.666666666666667
>>>
>>> 17 // 3 # phép chia lấy số nguyên, loại bỏ phần sau dấu thập phân
5
>>> 17 % 3 # toán tử % trả về số dư của phép chia
2
>>> 5 * 3 + 2 # thương * số chia + số dư
17

Với Python, bạn có thể sử dụng toán tử ** để tính số mũ:

>>> 5 ** 2 # 5 bình phương
25
>>> 2 ** 7 # 2 mũ 7
128

Dấu bằng = được sử dụng để gán giá trị cho 1 biến. Sau đó, không có kết quả nào được hiển thị trước dấu nhắc lệnh kế đến:

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

Nếu một biến không được khái niệm (gán giá trị), nỗ lực sử dụng biến đó, bạn sẽ thu được lỗi sau:

>>> n # bạn đang cố truy cập vào biến n chưa được gán giá trị
Traceback (most recent call last):
File "<stdin>", line 1, in <modulevàgt;
NameError: name 'n' is not defined

Python phụ trợ đầy đủ cho dấu chấm động, phép tính có cả số nguyên và số thập phân thì kết quả sẽ trả về số dưới dạng thập phân (nguyên văn: toán tử với toán hạng kiểu hỗn hợp chuyển hóa toán hạng số nguyên sang số thập phân):

>>> 4 * 3.75 - 1
14.0

Trong cơ chế tương tác, biểu thức được in ra cuối cùng sẽ được gán cho biến _, giúp đơn giản thực hiện các phép tính kế đến hơn. Chẳng hạn:

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

Chúng ta nên coi biến đó là read-only, đừng gán giá trị cho nó – vì nếu tạo thành một biến cùng tên nó sẽ chiếm mất biến mặc định này và không còn giúp được những thứ hay ho như trên nữa.

3. Chuỗi (string)

String trong Python là một dãy các ký tự. Laptop không giải quyết các ký tự, chúng chỉ làm việc với số nhị phân. Dù bạn có thể chứng kiến các ký tự trên màn hình, nhưng chúng được lưu trữ và giải quyết nội bộ dưới dạng phối hợp của số 0 và 1. Việc chuyển hóa ký tự thành số được gọi là mã hóa và tiến trình trái lại được gọi là giải mã. ASCII và Unicode là 2 trong số những mã hóa thông dụng hay được dùng.

Trong Python, string là một dãy các ký tự Unicode. Unicode bao gồm mọi ký tự trong toàn bộ các từ ngữ và đem lại tính đồng nhất trong mã hóa.

Cách tạo string trong Python

Bên cạnh số, Python cũng có thể thao tác với chuỗi, được trình diễn bằng nhiều cách. Chúng có thể được để trong dấu nháy đơn ('...') hoặc kép ("...") với cùng một kết quả. được sử dụng để “trốn (escape)” 2 dấu nháy này.

>>> 'gửi tin rác eggs' # dấu nháy đơn
'gửi tin rác eggs'
>>> 'doesn't' # sử dụng ' để viết dấu nháy đơn...
"doesn't"
>>> "doesn't" # ...hoặc sử dụng dấu nháy kép
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> ""Yes," he said."
'"Yes," he said.'
>>> '"Isn't," she said.'
'"Isn't," she said.'

Trong trình thông dịch tương tác, chuỗi kết quả bao gồm phần trong dấu ngoặc kép và các ký tự đặc biệt “trốn” được nhờ sử dụng . Dù đầu ra trông có lẽ hơi khác với đầu vào (dấu nháy kèm theo có thể biến đổi) nhưng hai chuỗi đó là tương tự. Chuỗi được viết trong dấu ngoặc kép khi chuỗi chứa dấu nháy đơn và không có dấu nháy kép), trái lại nó sẽ được viết trong dấu nháy đơn. Hàm print() tạo chuỗi đầu ra dễ đọc hơn, bằng cách bỏ qua dấu nháy kèm theo và in các ký tự đặc biệt, đã “trốn” được dấu nháy:

>>> '"Isn't," she said.'
'"Isn't," she said.'
>>> print('"Isn't," she said.')
"Isn't," she said.
>>> s = 'First line.nSecond line.' # n nghĩa là dòng mới
>>> s # không có print(), n sẽ được viết trong kết quả đầu ra
'First line.nSecond line.'
>>> print(s) # có print(), n sẽ tạo thành dòng mới
First line.
Second line.

Nếu như không mong muốn các ký tự được thêm vào bởi được trình thông dịch hiểu là ký tự đặc biệt thì sử dụng chuỗi raw bằng cách thêm r vào trước dấu nháy trước hết:

>>> print('C:somename') # ở giai đoạn này n là dòng mới!
C:some
ame
>>> print(r'C:somename') # thêm r trước dấu nháy
C:somename

Chuỗi ký tự dạng chuỗi có thể viết trên nhiều dòng bằng cách dùng 3 dấu nháy: """...""" hoặc '''...'''. Chấm dứt dòng auto bao gồm trong chuỗi, nhưng có thể ngăn chặn điều này bằng cách thêm vào cuối dòng. Chẳng hạn:

print("""
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to kết nối to
""")

Đây là kết quả (dòng mới ban đầu không được tính):

Xem Thêm  Cách chuyển đổi ngày thành chuỗi trong JavaScript - javascript chuyển đổi ngày tháng sang định dạng chuỗi

Đây là danh sách tất cả các ký tự thoát (escape sequence) được Python hỗ trợ:

Escape SequenceMô tảnewlineDấu gạch chéo ngược và dòng mới bị bỏ quaDấu gạch chéo ngược’Dấu nháy đơn”Dấu nháy képa

ASCII Bell

bASCII BackspacefASCII FormfeednASCII LinefeedrASCII Carriage ReturntASCII Horizontal TabvASCII Vertical TaboooKý tự có giá trị bát phân là oooxHHKý tự có giá trị thập lục phân là HH

Chẳng hạn: Hãy chạy từng lệnh riêng rẽ ngay trong trình biên dịch để thấy kết quả bạn nhé.

>>> print("C:Python32Quantrimang.com")
C:Python32Quantrimang.com
>>> print("In dòng nàynthành 2 dòng")
In dòng này
thành 2 dòng
>>> print("In giá trị x48x45x58")
In giá trị HEX
>>> 

Cách truy cập vào phần tử của chuỗi

Các chuỗi có thể được lập chỉ mục với ký tự trước hết được đánh số 0. Không có kiểu ký tự biệt lập, mỗi ký tự dễ dàng là một con số:

>>> word = 'Python'
>>> word[0] # ký tự ở địa điểm số 0
'P'
>>> word[5] # ký tự ở địa điểm số 5
'n' 

Chỉ số cũng có thể là số âm, khởi đầu đếm từ bên phải:

>>> word[-1] # last character
'n'
>>> word[-2] # second-last character
'o'
>>> word[-6]
'P'

Chú ý rằng vì -0 cũng giống với 0, nên các chỉ số âm khởi nguồn từ -1.

Ngoài việc đánh số, thì xắt lát cũng được phụ trợ. Trong lúc index được sử dụng để lấy các ký tự riêng rẽ thì xắt lát sẽ cho phép bạn lấy chuỗi con:

>>> word[0:2] # các ký tự từ địa điểm 0 (bao gồm) đến 2 (ngoại trừ)
'Py'
>>> word[2:5] # các ký tự từ địa điểm 2 (bao gồm) đến 5 (ngoại trừ)
'tho'

Hãy chú tâm đến cách các ký tự được giữ lại và ngoại trừ. Nó luôn bảo đảm rằng s[:i] + s[i:] bằng s:

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

Các chỉ số trong cắt chuỗi có cài đặt mặc định khá hữu hiệu, có 2 chỉ số bị bỏ qua theo mặc định, là 0 và kích cỡ của chuỗi được cắt.

>>> word[:2] # các ký tự từ đầu đến địa điểm thứ 2 (loại bỏ)
'Py'
>>> word[4:] # các ký tự từ địa điểm thứ 4(lấy) đến hết
'on'
>>> word[-2:] # các ký tự thứ hai tính từ cuối lên (lấy) đến hết
'on'

Một cách khác để ghi nhớ phương thức cắt chuỗi làm việc là hình dung các chỉ số như là vách ngăn giữa các ký tự, với ký tự ngoài cùng bên trái được đánh số 0. Khi đó, ký tự cuối cùng bên phải, trong chuỗi n ký tự sẽ có chỉ số n, chẳng hạn:

+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1

Vị trí thứ nhất tiên của số đem đến địa điểm của chỉ số từ 0 đến 6 trong chuỗi. Hàng thứ hai là các chỉ số âm tương ứng. Khi cắt từ i đến j sẽ bao gồm toàn bộ các ký tự nằm giữa i và j, tương ứng.

So với các chỉ số không âm, bề dài của một lát cắt là sự chênh lệch của các chỉ số, nếu cả hai đều nằm trong hạn chế. Chẳng hạn, bề dài của word[1:3] là 2.

Phấn đấu sử dụng một chỉ mục quá lớn sẽ trả về kết quả lỗi:

>>> word[42] # từ chỉ có 6 ký tự
Traceback (most recent call last):
File "<stdin>", line 1, in <modulevàgt;
IndexError: string index out of range

Không những thế, các chỉ mục bên ngoài phạm vi lát cắt vẫn được giải quyết ngăn nắp khi được sử dụng để cắt:

>>> word[4:42] # cắt ký tự từ địa điểm thứ 4 đến 42
'on'
>>> word[42:] # cắt ký tự sau địa điểm 42
''

Biến đổi hoặc xóa chuỗi

Các chuỗi Python chẳng thể biến đổi – chúng là cố định. Chính vì như vậy, nếu cứ cố ý gán một ký tự nào đó cho địa điểm đã được lập chỉ mục thì bạn sẽ thu được cảnh báo lỗi:

>>> word[0] = 'J'
...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
...
TypeError: 'str' object does not support item assignment

Nếu cần một chuỗi khác, cách hiệu quả nhất là tạo mới:

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

Bạn chẳng thể xóa hay loại bỏ ký tự khỏi chuỗi, nhưng giống như tuple, bạn có thể xóa toàn thể chuỗi, bằng cách dùng keyword del:

qtm_string = 'quantrimang.com'
del qtm_string
# Output: NameError: name 'qtm_string' is not defined
qtm_string

Nối chuỗi

Các chuỗi có thể được nối với nhau bằng toán tử + và thay thế bằng *:

>>> # thêm 3 'un' vào sau 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

Hai hoặc nhiều ký tự dạng chuỗi (tức là ký tự trong dấu nháy) cạnh nhau được nối auto.

>>> 'Py' 'thon'
'Python'

Chức năng trên chỉ làm việc với chuỗi dạng chuỗi (literal), không ứng dụng với biến hay biểu thức:

>>> prefix = 'Py'
>>> prefix 'thon' # chẳng thể nối một biến với một chuỗi
...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
...
SyntaxError: invalid syntax

Nếu mong muốn ghép nối các biến với nhau hoặc biến với chuỗi hãy sử dụng dấu +:

>>> prefix + 'thon'
'Python'

Chức năng này đặc biệt hữu hiệu khi mong muốn bẻ các chuỗi dài thành chuỗi ngắn hơn:

>>> text = ('Put several strings within parentheses '
... 'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

Nếu mong muốn nối các chuỗi trong nhiều dòng khác nhau, hãy sử dụng dấu ngoặc đơn:

>>> # sử dụng ()
>>> s = ('Xin '
... 'chào!')
>>> s
'Xin chào!'

Lặp và kiểm soát phần tử của chuỗi

Giống danh sách và tuple, bạn cũng sử dụng vòng lặp for khi cần lặp qua một chuỗi, như chẳng hạn đếm số ký tự “i” trong chuỗi dưới đây:

count = 0
for letter in 'Quantrimang.com':
if(letter == 'i'):
count += 1
# Output: Có 1 chữ i được tìm ra
print('Có', count,'chữ i được tìm ra')

Để kiểm soát một chuỗi con có trong chuỗi hay chưa, hãy dùng keyword in, như sau:

>>> 'quantrimang' in 'quantrimang.com'
True
>>> 'python' in 'quantrimang.com'
False
>>> 

Hàm Python tích hợp sẵn để làm việc với chuỗi

Có 2 hàm thường dùng nhất khi làm việc với string trong Python là enumerate() và len().

Hàm len() được tích hợp trong Python, sẽ trả về độ dài của chuỗi:

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

Hàm enumerate() trả về đối tượng liệt kê, chứa cặp giá trị và index của phần tử trong string, khá hữu hiệu trong khi lặp.

qtm_str = 'Python'

# enumerate()
qtm_enum = danh sách(enumerate(qtm_str))

# Output: danh sách(enumerate(qtm_str) = [(0, 'P'), (1, 'y'), (2, 't'), (3, 'h'), (4, 'o'), (5, 'n')]
print('danh sách(enumerate(qtm_str) = ', qtm_enum)

Phương pháp format() để định dạng chuỗi

Phương pháp format() rất linh động và đầy sức mạnh khi dùng để định dạng chuỗi. Định dạng chuỗi chứa dấu {} làm trình giữ chỗ hoặc trường thay thế để nhận giá trị thay thế. Bạn cũng có thể sử dụng đối số địa điểm hoặc keyword để chỉ định thứ tự.

# default(implicit) order
thu_tu_mac_dinh = "{}, {} và {}".format('Quản','Trị','Mạng')
print('n--- Thứ tự mặc định ---')
print(thu_tu_mac_dinh)

# sử dụng đối số địa điểm để xếp đặt thứ tự
vi_tri_thu_tu= "{1}, {0} và {2}".format('Quản','Trị','Mạng')
print('n--- Thứ tự theo địa điểm ---')
print(vi_tri_thu_tu)

# sử dụng keyword để xếp đặt thứ tự
tu_khoa_thu_tu = "{s}, {b} và {j}".format(j='Quản',b='Trị',s='Mạng')
print('n--- Thứ tự theo keyword ---')
print(tu_khoa_thu_tu)

Ta có kết quả khi chạy code trên như sau:

--- Thứ tự mặc định ---
Quản, Trị và Mạng

--- Thứ tự theo địa điểm ---
Trị, Quản và Mạng

--- Thứ tự theo keyword ---
Mạng, Trị và Quản

Phương pháp format() có thể có những đặc tả định dạng tùy chọn. Chúng được tách khỏi tên trường bằng dấu :. Chẳng hạn, có thể căn trái <, căn phải > hoặc căn giữa ^ một chuỗi trong không gian đã cho. Có thể định dạng số nguyên như số nhị phân, thập lục phân; số thập phân có thể được làm tròn hoặc hiển thị dưới dạng số mũ. Có rất là nhiều định dạng bạn có thể sử dụng.

>>> # Định dạng số nguyên
>>> "Khi chuyển {0} sang nhị phân sẽ là {0:b}".format(12)
'Khi chuyển 12 sang nhị phân sẽ là 1100'

>>> # Định dạng số thập phân
>>> "Số thập phân {0} ở dạng mũ sẽ là {0:e}".format(1566.345)
'Số thập phân 1566.345 ở dạng mũ sẽ là 1.566345e+03'

>>> # Làm tròn số thập phân
>>> "1 phần 3 là: {0:.3f}".format(1/3)
'1 phần 3 là: 0.333'

>>> # cân chỉnh chuỗi
>>> "|{:<10}|{:^10}|{:>10}|".format('Quản','Trị','Mạng')
'|Quản | Trị | Mạng|'

Định dạng chuỗi kiểu cũ:

Bạn có thể định dạng chuỗi trong Python về phong thái sprintf() được sử dụng trong từ ngữ lập trình C bằng toán tử %.

>>> x = 15.1236789
>>> print('Giá trị của x là %3.2f' %x)
Giá trị của x là 15.12
>>> print('Giá trị của x là %3.4f' %x)
Giá trị của x là 15.123712.3457

Phương pháp hay được dùng trong string

Có rất là nhiều mẹo được tích hợp sẵn trong Python để làm việc với string. Ngoài format() được đề cập bên trên còn tồn tại lower(), upper(), join(), split(), find(), replace(), v.v….

>>> "QuanTriMang.Com".lower()
'quantrimang.com'
>>> "QuanTriMang.Com".upper()
'QUANTRIMANG.COM'
>>> "Quan Tri Mang Chấm Com".split()
['Quan', 'Tri', 'Mang', 'Chấm', 'Com']
>>> ' '.join(['Quan', 'Tri', 'Mang', 'Chấm', 'Com'])
'Quan Tri Đưa Chấm Com''
>>> 'Quan Tri Đưa Chấm Com'.find('Qua')
0
>>> 'Quan Tri Đưa Chấm Com'.replace('Chấm','.')
'Quan Tri Đưa . Com'

4. Danh mục (danh sách)

Python phân phối một loạt các dữ liệu phức hợp, thường được gọi là các chuỗi (sequence), sử dụng để nhóm các giá trị khác nhau. Đa chức năng đặc biệt là danh mục (danh sách).

Cách tạo danh sách trong Python

Trong Python, danh sách được trình diễn bằng dãy các giá trị, được phân chia nhau bằng dấu phẩy, nằm trong dấu []. Các danh mục có thể chứa nhiều mục với kiểu khác nhau, nhưng thông thường là các mục có cùng kiểu.

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

Menu không hạn chế số lượng mục, bạn có thể có nhiều kiểu dữ liệu khác nhau trong cùng một danh sách, như chuỗi, số nguyên, số thập phân,…

list1 = [] # danh sách rỗng
list2 = [1, 2, 3] # danh sách số nguyên
list3 = [1, "Hello", 3.4] # danh sách với kiểu dữ liệu hỗn hợp

Bạn cũng có thể tạo các danh sách lồng nhau (danh mục chứa trong danh mục), chẳng hạn:

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]

print (x) # Output: [['a', 'b', 'c'], [1, 2, 3]]
print (x[0]) # Output: ['a', 'b', 'c']
print(x[0][1]) # Output: b

Hoặc khai báo danh sách lồng nhau từ đầu:

list4 = [mouse", [8, 4, 6], ['a']]

Truy cập vào phần tử của list

Có nhiều cách khác nhau để truy cập vào phần tử của một danh sách:

Index (chỉ mục) của list:

Sử dụng toán tử index [] để truy cập vào một phần tử của list. Index bắt đầu từ 0, nên một list có 5 phần tử sẽ có index từ 0 đến 4. Truy cập vào phần tử có index khác index của list sẽ làm phát sinh lỗi IndexError. Index phải là một số nguyên, không thể sử dụng float, hay kiểu dữ liệu khác, sẽ tạo lỗi TypeError.

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']

# TypeError: danh sách indices must be integers or slices, not float
# TypeError: index của danh sách phải là số nguyên hoặc slice, không phải số thập phân
qtm_list[2.0]

Menu lồng nhau có thể truy cập bằng index lồng nhau:

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']
# Output: q
print(qtm_list[0])

# Output: a
print(qtm_list[2])

# Output: t
print(qtm_list[4])

# Menu lồng nhau
ln_list = ["Happy", [1,3,5,9]]

# Index lồng nhau

# Output: a
print(ln_list[0][1])

# Output: 9
print(ln_list[1][3])

Index âm:

Python cho phép lập chỉ mục âm cho các chuỗi. Index -1 là phần tử cuối cùng, -2 là phần tử thứ 2 từ cuối cùng lên. Nói dễ dàng là index âm dùng khi bạn đếm phần tử của chuỗi ngược từ cuối lên đầu.

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']

# Code by Quantrimang.com
# Output: m
print(qtm_list[-1])
# Output: i
print(qtm_list[-9])

Xắt lát (slice) danh sách trong Python

Python cho phép truy cập vào một dải phần tử của danh sách bằng cách dùng toán tử xắt lát : (dấu hai chấm). Mọi hành động cắt danh sách đều trả về danh sách mới chứa những yếu tố được yêu cầu.

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']
# Code by Quantrimang.com
# Output: ['u', 'a', 'n', 't']
print(qtm_list[1:5])
# Output: ['q', 'u', 'a', 'n', 't', 'r', 'i']
print(qtm_list[:-8])
# Output: ['n', 'g', '.', 'c', 'o', 'm']
print(qtm_list[9:])

Để xắt lát danh sách, bạn chỉ cần sử dụng dấu : giữa 2 index cần lấy các phần tử. [1:5] sẽ lấy phần tử 1 đến 5, [:-8] lấy từ 0 đến phần tử -8,…

Nếu thực hiện hành động cắt sau thì nó sẽ trả về một danh sách mới là bản sao của danh sách ban đầu:

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']

# Output: ['q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g', '.', 'c', 'o', 'm']
print(qtm_list[:])

Biến đổi hoặc thêm phần tử vào danh sách

Menu cũng phụ trợ các hoạt động như nối danh sách:

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Không giống như chuỗi, bị gán cố định, danh sách là kiểu dữ liệu có thể biến đổi. Chẳng hạn, bạn có thể biến đổi các mục trong danh sách:

>>> cubes = [1, 8, 27, 65, 125] # có lẽ sai sai
>>> 4 ** 3 # lập phương của 4 là 64, không phải 65!
64
>>> cubes[3] = 64 # thay thế giá trị sai
>>> cubes
[1, 8, 27, 64, 125]

Bạn cũng có thể cho thêm mục mới vào cuối danh sách bằng cách dùng các mẹo, ví dụ như append():

>>> cubes.append(216) # thêm lập phương của 6
>>> cubes.append(7 ** 3) # và lập phương của 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

Việc gán cho lát cũng có thể thực hiện và thậm chí có thể biến đổi cả kích cỡ của danh sách hay xóa nó hoàn toàn:

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # thay thế vài giá trị
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # giờ thì xóa chúng
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # xóa danh sách bằng cách thay toàn bộ các phần tử bằng một danh sách rỗng
>>> letters[:] = []
>>> letters
[]

Hàm len() cũng có thể ứng dụng với danh sách:

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

Xóa hoặc loại bỏ phần tử khỏi danh sách trong Python

Bạn có thể xóa một hoặc nhiều phần tử khỏi danh sách sử dụng keyword del, có thể xóa hoàn toàn cả danh sách.

my_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']

# xóa phần tử có index là 2
del my_list[2]

# Output: ['q', 'u', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g', '.', 'c', 'o', 'm'] 
print(my_list)

# xóa phần tử có index từ 1 đến 7
del my_list[1:7]

# Output: ['q', 'a', 'n', 'g', '.', 'c', 'o', 'm']
print(my_list)

# xóa toàn thể danh sách my_list
del my_list

# Error: NameError: name 'my_list' is not defined
print(my_list)

Bạn cũng có thể sử dụng remove() để loại bỏ những phần tử đã cho hoặc pop() để loại bỏ phần tử tại một index khẳng định. pop() loại bỏ phần tử và trả về phần tử cuối cùng nếu index không được chỉ định. Điều này giúp triển khai danh sách dưới dạng stack (ngăn xếp) (kết cấu dữ liệu first in last out – vào trước hết, ra cuối cùng).

không dừng lại ở đó, mẹo clear() cũng được dùng để làm rỗng một danh sách (xóa toàn bộ các phần tử trong danh sách).

my_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']
my_list.remove('.')

# Output: ['q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g', 'c', 'o', 'm'] 
print(my_list)

# Output: n
print(my_list.pop(3))

# Output: ['q', 'u', 'a', 't', 'r', 'i', 'm', 'a', 'n', 'g', 'c', 'o', 'm']
print(my_list)

# Output: m
print(my_list.pop())

# Output: ['q', 'u', 'a', 't', 'r', 'i', 'm', 'a', 'n', 'g', 'c', 'o']
print(my_list)

my_list.clear()

# Output: [] (danh sách rỗng)
print(my_list)

Cách cuối cùng để xóa các phần tử trong một danh sách là gán một danh sách rỗng cho các lát phần tử.

>>> my_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']
>>> my_list[11:15]=[]
>>> my_list
['q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g']

Phương pháp danh sách trong Python

Những mẹo có sẵn cho danh sách trong Python gồm:

  • append(): Thêm phần tử vào cuối danh sách.
  • extend(): Thêm toàn bộ phần tử của danh sách giờ đây vào danh sách khác.
  • insert(): Chèn một phần tử vào index cho trước.
  • remove(): Xóa phần tử khỏi danh sách.
  • pop(): Xóa phần tử khỏi danh sách và trả về phần tử tại index đã cho.
  • clear(): Xóa toàn bộ phần tử của danh sách.
  • index(): Trả về index của phần tử thích hợp trước hết.
  • count(): Trả về số lượng phần tử đã đếm được trong danh sách như một đối số.
  • sort(): Sắp đặt các phần tử trong danh sách theo thứ tự tăng dần.
  • reverse(): Đảo ngược thứ tự các phần tử trong danh sách.
  • sao chép(): Trả về bản sao của danh sách.
Xem Thêm  Các kiểu dữ liệu SQL cho MySQL, SQL Server và MS Access - cơ sở dữ liệu sql kiểu dữ liệu

Chẳng hạn:

QTM = [9,8,7,6,8,5,8]

# Output: 2
print(QTM.index(7))

# Output: 3
print(QTM.count(8))

QTM.sort()

# Output: [5, 6, 7, 8, 8, 8, 9]
print(QTM)

QTM.reverse()

# Output: [9, 8, 8, 8, 7, 6, 5]
print(QTM)

Chẳng hạn 2:

QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']

# Output: 3
print(QTM.index('n'))

# Output: 2
print(QTM.count('a'))

QTM.sort()

# Output: ['.', 'a', 'a', 'c', 'g', 'i', 'm', 'm', 'n', 'n', 'o', 'q', 'r', 't', 'u']
print(QTM)

QTM.reverse()

# Output: ['u', 't', 'r', 'q', 'o', 'n', 'n', 'm', 'm', 'i', 'g', 'c', 'a', 'a', '.']
print(QTM)

Menu comprehension: Cách tạo danh sách mới ngắn gọn

Menu comprehension là một biểu thức đi kèm với lệnh for được đặt trong cặp dấu ngoặc vuông [].

Chẳng hạn:

cub3 = [3 ** x for x in range(9)]

# Output: [1, 3, 9, 27, 81, 243, 729, 2187, 6561]
print(cub3)

Code trên tương tự với:

cub3 = []
for x in range (9):
cub3.append(3**x)
print(cub3)

Ngoài for, if cũng có thể được sử dụng trong một danh sách comprehension của Python. Lệnh if có thể lọc các phần tử trong danh sách giờ đây để tạo nên danh sách mới. Dưới đây là chẳng hạn:

cub3 = [3 ** x for x in range(9) if x > 4]

# Output: [243, 729, 2187, 6561]
print(cub3)

so_le = [x for x in range (18) if x % 2 == 1]

# Output: [1, 3, 5, 7, 9, 11, 13, 15, 17]
print(so_le)

noi_list = [x+y for x in ['Ngôn ngữ ','Lập trình '] for y in ['Python','C++']]

# Output: ['Ngôn ngữ Python', 'Ngôn ngữ C++', 'Lập trình Python', 'Lập trình C++']
print(noi_list)

Kiểm soát phần tử có trong danh sách không

Sử dụng từ khóa in để kiểm soát xem một phần tử đã có trong danh sách hay chưa. Nếu phần tử đã tồn tại, kết quả trả về là True, và trái lại sẽ trả về False.

QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']

# Output: True
print('q' in QTM)

# Output: True
print('.' in QTM)

# Output: False
print('z' in QTM)

Vòng lặp for trong danh sách

Sử dụng vòng lặp for để lặp qua các phần tử trong danh sách như chẳng hạn dưới đây:

for ngon_ngu in ['Python','Java','C']:
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 Java
Tôi thích lập trình C

Các hàm Python tích phù hợp với danh sách

Các hàm Python tích hợp sẵn như all(), any(), enumerate(), len(), max(), min(), danh sách(), sorted(),… hay được dùng với danh sách để thực hiện những bổ phận khác nhau.

  • all(): Trả về giá trị True nếu toàn bộ các phần tử của danh sách đều là true hoặc danh sách rỗng.
  • any(): Trả về True khi bất kỳ phần tử nào trong danh sách là true. Nếu danh sách rỗng hàm trả về giá trị False.
  • enumerate(): Trả về đối tượng enumerate, chứa index và giá trị của toàn bộ các phần tử của danh sách dưới dạng tuple.
  • len(): Trả về độ dài (số lượng phần tử) của danh sách.
  • danh sách(): Chuyển hóa một đối tượng có thể lặp (tuple, string, set, dictionary) thành danh sách.
  • max(): Trả về phần tử lớn nhất trong danh sách.
  • min(): Trả về phần tử nhỏ nhất trong danh sách.
  • sorted(): Trả về danh sách mới đã được xếp đặt.
  • sum(): Trả về tổng của toàn bộ các phần tử trong danh sách.

5. Tuple

Tuple trong Python là một chuỗi các phần tử có thứ tự giống như danh sách. Sự độc đáo giữa danh sách và tuple là tất cả chúng ta chẳng thể biến đổi các phần tử trong tuple khi đã gán, nhưng trong danh sách thì các phần tử có thể biến đổi.

Tuple hay được dùng cho các dữ liệu không cho phép sửa đổi và mau hơn danh sách vì nó chẳng thể biến đổi auto. Một tuple được khái niệm bằng dấu ngoặc đơn (), các phần tử trong tuple cách nhau bằng dấu phẩy (,).

Chẳng hạn:

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 chẳng thể biến đổi giá trị của nó.

t = (10, "quan tri mang", 2j)
#t[0:2] = (10, 'quan tri đưa')
print("t[0:2] = ", t[0:2])

Chạy code trên ta được kết quả:

t[0:2] = (10, 'quan tri đưa')

Tuple hơn danh sách ở điểm nào?

Vì tuple và danh sách khá giống nhau, nên chúng hay được dùng trong những tình huống tương đương nhau. Không những thế, tuple vẫn có những lợi thế khẳng định đối với danh sách, như:

  • Tuple hay được dùng cho các kiểu dữ liệu không đồng nhất (khác nhau) và danh sách thường sử dụng cho các kiểu dữ liệu (đồng nhất) giống nhau.
  • Vì tuple chẳng thể biến đổi, việc lặp qua các phần tử của tuple mau hơn đối với danh sách. Chính vì như vậy, trong trường hợp này tuple chiếm ưu điểm về năng suất hơn danh sách một tí.
  • Tuple chứa những phần tử không bao giờ thay đổi, có thể được sử dụng như key cho dictionary. Với danh sách, điều này chẳng thể làm được.
  • Nếu có dữ liệu không bao giờ thay đổi việc triển khai nó như một tuple sẽ bảo đảm rằng dữ liệu đó được bảo vệ chống ghi (write-protected).

Tạo một tuple

Tuple được tạo bằng cách đặt toàn bộ các phần tử của nó trong dấu ngoặc đơn (), phân chia bằng dấu phẩy. Bạn có thể bỏ dấu ngoặc đơn nếu mong muốn, nhưng nên thêm nó vào cho code rõ ràng và cụ thể hơn.

Tuple không bị hạn chế 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, danh sách, 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ó cách gọi khác 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 cầu kỳ 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 để nêu 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))

Truy cập vào các phần tử của 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 danh sách, nên mình không lấy chẳng hạn rõ ràng, các bạn có thể xem lại phần danh sách nha.

Index: Sử dụng toán tử index [] để truy cập vào phần tử trong tuple với index khởi đầu bằng 0. Nghĩa là nếu tuple có 6 phần tử thì index của nó sẽ khởi nguồn 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à chẳng thể là số thập phân hay bất kỳ kiểu dữ liệu nào khác, nếu như không sẽ tạo lỗi TypeError. Những tuple lồng nhau được truy cập bằng cách 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.

Xắt lát: Có thể truy cập đến một loạt phần tử trong tuple bằng cách dùng toán tử xắt lát : (dấu 2 chấm).

Biến đổi một tuple

Không giống như danh sách, tuple chẳng thể biến đổi. Điều này có nghĩa là các phần tử của một tuple chẳng thể biến đổi một khi đã được gán. Nhưng, nếu bản thân phần tử này là một kiểu dữ liệu có thể biến đổi (như danh sách ví dụ) thì các phần tử lồng nhau có thể được biến đổi. Tất cả 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])

# chẳng thể biến đổi phần tử của tuple
# Nếu bạn bỏ dấu # ở dòng 8
# Bạn sẽ thu đượ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à danh sách
# danh sách có thể biến đổi, nên phần tử đó có thể biến đổi
# Output: (1, 3, 5, [8, 9])
my_tuple[3][0] = 8
print(my_tuple)

# Nếu cần biến đổ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)

Xóa tuple

Các phần tử trong tuple chẳng thể biến đổi nên tất cả chúng ta cũng chẳ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 keyword del như dưới đây:

QTM = ('q','u','a','n','t','r','i','m','a','n','g','.','c','o','m')

# Chẳng thể xóa phần tử của tuple
# Nếu bạn chạy lệnh del QTM[3]
# sẽ tạo thành lỗi:
# TypeError: 'tuple' object doesn't support item deletion

# Có thể xóa toàn thể tuple
del QTM
# Sau đó thử chạy print (QTM) sẽ trả về lỗi
# NameError: name 'QTM' is not defined

Phương pháp và hàm dùng với tuple trong Python

Phương pháp thêm phần tử và xóa phần tử chẳng thể sử dụng với tuple, chỉ có 2 mẹo sau là dùng được:

  • count(x): Đếm số phần tử x trong tuple.
  • index(x): Trả về giá trị index của phần tử x trước hết mà nó gặp trong tuple.
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 danh sách, gồm có:

  • all(): Trả về giá trị True nếu toàn bộ các phần tử của tuple là true hoặc tuple rỗng.
  • any(): Trả về True nếu bất kỳ phần tử nào của tuple là true, nếu tuple rỗng trả về False.
  • enumerated(): Trả về đối tượng enumerate (liệt kê), chứa cặp index và giá trị của toàn bộ phần tử của tuple.
  • len(): Trả về độ dài (số phần tử) của tuple.
  • max(): Trả về phần tử lớn nhất của tuple.
  • min(): Trả về phần tử nhỏ nhất của tuple.
  • sorted(): Lấy phần tử trong tuple và trả về danh sách mới được xếp đặt (tuple không xếp đặt được).
  • sum(): Trả về tổng toàn bộ các phần tử trong tuple.
  • tuple(): Chuyển hóa những đối tượng có thể lặp (danh sách, string, set, dictionary) thành tuple.

Kiểm soát phần tử trong tuple

Bạn có thể kiểm soát xem một phần tử đã tồn tại trong tuple hay chưa với keyword in.

QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m']

# Kiểm soát 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)

Lặp qua các phần tử của tuple trong Python

Sử dụng vòng lặp for để lặp qua các phần tử trong tuple.

for ngon_ngu in ('Python','C++','Website'):
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 Website

6. Set

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ể biến đổ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,…

Cách tạo set

Set được tạo bằng cách đặt toàn bộ các phần tử trong dấu ngoặc nhọn, phân chia bằng dấu phẩy hoặc sử dụng hàm set(). Set không hạn chế số lượng phần tử, nó có thể chứa nhiều kiểu biến khác nhau, nhưng chẳng thể chứa phần tử có thể biến đổi được như danh sách, set hay dictionary.

Chẳng hạn 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ẽ thu đượ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ốn khó. 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 soát 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 soát kiểu dữ liệu của qtm
# Output: <class 'set'>
print(type(qtm))

Làm sao mà biến đổi set trong Python

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. Cho nên toán tử cắt [] sẽ không làm việc trên set. Nếu cố ý dùng, bạn sẽ thu được cảnh báo lỗi như dưới đây:

>>> a[1]
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <modulevàgt;
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 cập nhật(). Cập nhật() có thể nhận tuple, danh sách, 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ẽ auto 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ẽ thu đượ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.cập nhật([2,3,4])
print(my_set)

# Thêm danh sách và set
# Output: {1, 2, 3, 4, 5, 6, 8}
my_set.cập nhật([4,5], {1,6,8})
print(my_set)

Xóa phần tử khỏi set

Bạn dùng discard() và remove() để xóa phần tử rõ ràng 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ẽ thu đượ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 mẹo pop(). Set không có thứ tự, không có cách nào để xác nhận 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 sử 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 bỗng nhiên
print(my_set.pop())

# xóa phần tử khác bằng pop()
# Output: phần tử bị xóa bỗng nhiên
my_set.pop()
print(my_set)

# clear my_set
#Output: set()
my_set.clear()
print(my_set)

Các toán tử set trong Python

Set hay được dùng để chứa các toán tử tập hợp như hợp, giao, hiệu, bù. Có cả mẹo và toán tử để thực hiện những phép toán tập hợp này.

Xem Thêm  7 Ví dụ để tìm hiểu câu lệnh SQL UPDATE - ví dụ về lệnh cập nhật trong sql

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 toàn bộ các phần tử của A và B. Hợp được trình diễn bằng cách dùng toán tử | hoặc sử dụng mẹo 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))

Các mẹo dùng trên set

Phương phápMiêu tảadd()Thêm một phần tử vào set.clear()Xóa toàn bộ phần tử của set.sao chép()Trả về bản copy 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 toàn bộ 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()Update 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ử bỗng 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()Update 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.cập nhật()Update set với hợp của chính nó và set khác.

Kiểm soát phần tử trong set

Bạn có thể kiểm soát một đối tượng xem nó có nằm trong set không, sử dụng keyword in.

# Khởi tạo my_set
my_set = set("Quantrimang.com")

# Kiểm soát xem Q có trong my_set không
# Output: True
print('Q' in my_set)

# Kiểm soát xem q có trong my_set không
# Output: False
print('q' in my_set)

Lặp qua phần tử của 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 thu được kết quả như sau:

t
y
P
h
o
n

Hàm thường dùng trên set

Các hàm thường dùng trên set bao gồm all(), any(), enumerate(), len(), max(), min(), sorted(), sum(). Tính năng của những hàm này khá giống với khi bạn sử dụng trên danh sách, tuple, bạn có thể xem thêm nếu chưa rõ nha.

Frozenset trong Python

Frozenset là một lớp mới, có dấu hiệu của một set, nhưng phần tử của nó chẳng thể biến đổi được sau khoảng thời gian gán. Để dễ hình dung thì tuple là danh sách bất biến còn frozenset là set bất biến.

Các set có thể biến đổi được nhưng chẳng thể băm (hash) được, vì vậy chẳ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 phụ trợ các mẹo như sao chép(), difference(), intersection(), isdisjoint(), issubset(), issuperset(), symmetric_difference() và union(). Vì chẳng thể biến đổi nên mẹo add() hay remove() không sử dụng được trên frozenset.

7. Dictionary

Dictionary là tập hợp các cặp khóa giá trị không có thứ tự. Nó hay được dùng khi tất cả chúng ta có một sll 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 hiểu rằng khóa để lấy giá trị.

Cách tạo dictionary trong Python

Trong Python, dictionary được khái niệm 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 dùng hàm dict() được tích hợp sẵn.

Chẳng hạn:

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 soát kiểu dữ liệu của d ta được kết quả:

>>> type(dict2)
<class 'dict'>

Truy cập phần tử của dictionary

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ệ

Biến đổi, thêm phần tử cho dictionary

Dictionary có thể biến đổi, nên có thể thêm phần tử mới hoặc biến đổi giá trị của các phần tử hiện có bằng cách dùng toán tử gán. Nếu key đã có, giá trị sẽ được update, 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ệ'}

#update 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)

Xóa phần tử từ dictionary

Bạn có thể xóa phần tử rõ ràng của dictionary bằng cách 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). Toàn bộ các phần tử trong dictionary có thể bị xóa song song bằng cách sử dụng clear(). không dừng lại ở đó, keyword del cũng có thể dùng để xóa một phần tử hoặc toàn thể 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ử rõ ràng
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 toàn bộ 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)

Các mẹo và hàm cho dictionary

Đây là những mẹo thường dùng với dictionary:

MethodMô tảclear()Xóa toàn bộ phần tử của dictionary.sao chép()Trả về một bản sao shollow sao chép 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 ra. 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 như không thêm key với value là d và trả về d (default là None).cập nhật([other])Update dictionary với cặp key/value từ other, ghi đè lên các key đã có.values()Trả về kiểu lượt xem mới của value trong dictionary.

Các hàm tích hợp như all(), any(), len(), cmp(), sorted(),… hay được dùng với dictionary để thực hiện những bổ phận khác nhau.

Dictionary comprehension trong Python

Dictionary comprehension là cách dễ dàng, đúc kết để 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, toàn bộ đặt trong dấu {}. Dưới đây là chẳng hạn 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 tự 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 nên dictionary mới như chẳng hạn dưới đây:

lap_phuong_chan = {x: x*x*x for x in range (10) if xphần trăm2==0}
# output: {0: 0, 2: 8, 4: 64, 6: 216, 8: 512}
print(lap_phuong_chan)

Kiểm soát và lặp qua phần tử trong dictionary

Bạn chỉ có thể kiểm soát key của phần tử đã có trong dictionary hay chưa bằng cách sử dụng in, và chẳ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.

8. Chuyển hóa giữa các kiểu dữ liệu

Tất cả chúng ta có thể chuyển hóa giữa các kiểu dữ liệu khác nhau bằng cách dùng hàm chuyển hóa kiểu khác nhau như int() (kiểu số nguyên), float() số thập phân, str() chuỗi,…

Chẳng hạn:

>>> float(11)
11.0

Chuyển hóa từ kiểu float sang kiểu int sẽ bị giảm giá trị (khiến cho nó gần với số không hơn).

Chẳng hạn:

int(18.6)
18

Chuyển hóa từ string sang hoặc trái lại cần có các giá trị tương thích.

Bạn có thể thực hiện chuyển hóa chuỗi này sang chuỗi khác:

>>> set([2,4,6])
{2,4,6}
>>> tuple({3,5,7})
(3,5,7)
>>> danh sách('quantrimang')
['q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g']

Để chuyển hóa sang dictionary, mỗi phần tử phải là một cặp như chẳng hạn dưới đây:

>>> dict([[2,4],[1,3]])
{2: 4, 1: 3}
>>> dict([(3,9),(4,16)])
{3: 9, 4: 16}

9. Bước trước hết nhắm tới lập trình

Hiển nhiên, tất cả chúng ta có thể sử dụng Python cho những tác vụ cầu kỳ hơn là thêm vài phần tử vào chuỗi. Chẳng hạn, 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 khởi đầu bằng hai phần tử 0 và 1 hoặc 1 và 1, các phần tử sau đó được cài đặt 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 thành phần tử kế đến
... a, b = 0, 1
>>> while b < 10:
... print(b)
... a, b = b, a+b
...
1
1
2
3
5
8

Chẳng hạn này giới thiệu một số chức năng mới:

  • Dòng trước hết chứa một phép gán kép: Biến a và b song song thu được giá trị 0 và 1. Dòng cuối cùng, nó được sử dụng lại, trổ tài rằng các biểu thức ở phía bên phải sẽ được tính (ở giai đoạn này là cộng tổng a và b) trước khi bất kỳ hành động gán nào được diễn ra. Biểu thức bên phải được tính từ trái sang phải
  • Vòng lặp while sẽ được thực thi nếu điều kiện (ở giai đoạn này là bvàlt;10) vẫn đúng: Trong Python, cũng giống C, bất kỳ giá trị số nguyên khác 0 nào cũng đúng, 0 là sai. Điều kiện có thể là một chuỗi, danh mục, thậm chí một chuỗi tuần tự hay bất kì thứ gì có độ dài khác 0 đều đúng, chuỗi rỗng sẽ sai. Phép kiểm soát trong chẳng hạn trên là một so sánh khá dễ dàng. Các toán tử so sánh chuẩn được viết giống như C: < (bé hơn), > (to hơn), == (bằng), <=, >= và != (không bằng/khác).
  • Thân của vòng lặp được viết thụt vào trong: Thụt đầu dòng là cách mà Python nhóm các lệnh. Tại dấu nhắc lệnh, bạn có thể nhấn tab hoặc phím phương pháp để thụt lề. Một trình soạn thảo code sẽ phụ trợ tốt hơn cho việc nhập những đoạn code Python cầu kỳ, thông thường các trình soạn thảo này đề có thụt lề auto. Khi nhập một khối lệnh bạn phải chèn thêm một dòng trống ở cuối cùng để chấm dứt khối lệnh (vì trình nghiên cứu cú pháp chẳng thể nghiên cứu lúc nào bạn hoàn tất dòng lệnh cuối cùng trong khối). Chú ý là mỗi dòng trong một khối lệnh căn bản phải được thụt vào cùng một khoảng giống nhau.
  • Hàm print() viết ra giá trị của các đối số mà nó được phân phối: Nó khác với việc chỉ viết những biểu thức bạn mong muốn viết (như trong chẳng hạn dùng Python như một cái máy tính) theo cách khắc phục nhiều đối số, số lượng dấu chấm động và chuỗi. Các chuỗi được in sẽ không có dấu ngoặc kép, một khoảng trắng được chèn vào giữa các mục, vì vậy, bạn có thể định dạng chúng theo ý thích, giống như vậy này:
>>> 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 chấm dứt 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 đã khởi đầ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 kế đến về các câu lệnh, kết cấu dữ liệu trong Python nhé.

Bài tiếp: Lệnh if, if…else, if…elif…else trong Python

Bài trước: Khám phá chương trình Python trước hết

Viết một bình luận