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

Trong phần trước, chúng ta đã làm quen với chương trình Python đầu tiên 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 sử dụng Python như một chiếc máy tính, học về số, chuỗi, list và đi bước đầu tiên hướng tới lập trình Python.

Vì bài viết sẽ liệt kê những nội dung quan trọng nhất của tất cả 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 ví dụ cụ thể để bạn dễ hình dung.

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

1. Biến trong Python

Biến là một vị trí trong bộ nhớ đượ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 vị trí bộ nhớ khác nhau. Các quy tắc để viết tên một biến giống như quy 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 tự động dựa vào 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ệ.

Ví dụ:

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 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 hỗ trợ số nguyên, số thập phân và số phức, chúng lần lượt được định nghĩa 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. Ví dụ: 5 là số nguyên, 5.0 là số thập phân. Python cũng hỗ trợ số phức và sử dụng hậu tố j hoặc J để chỉ phần ảo. Ví dụ: 3+5j. Ngoài int và float, Python hỗ trợ thêm 2 loại số nữa là Decimal và Fraction. 

Ta sẽ dùng hàm type() để kiểm tra xem biến hoặc giá trị thuộc lớp số nào và hàm isinstance() để kiểm tra xem chúng có thuộc về một class cụ thể 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 tra 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ị giới hạn độ dài, số thập phân bị giới hạn đến 16 số sau dấu thập phân.

Những con số chúng là làm việc hàng ngày thường là hệ số 10, nhưng lập trình viên máy tính (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. Để biểu diễn những hệ số này trong Python, ta đặt một tiền tố thích 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à ví dụ 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ẽ nhận đượ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 đổi giữa các kiểu số trong Python 

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

Ví dụ: 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 đổi giữa các kiểu số một cách rõ ràng. Những hàm này thậm chí có thể chuyển đổi 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 đổi 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 chúng ta ngạc nhiên đô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ó vẻ không phải vậy. Nếu bạn kiểm tra tính đúng sai của phép toán này trong Python, sẽ nhận được kết quả là False.

>>> (1.1 + 2.2) == 3.3

False

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

Điều này là do, các số thập phân được thực hiện trong phần cứng máy tính dưới dạng phân số nhị phân, vì máy tính chỉ hiểu các số nhị phân (0 và 1) nên hầu hết các phân số thập phân mà chúng ta biết, không thể được lưu trữ chính xác trong máy tính. 

Ví dụ, ta không thể biểu 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 đổi phần thập phân 0.1, sẽ dẫn đến phần nhị phân dài vô hạn của 0.000110011001100110011... và máy tính chỉ lưu trữ một phần số hữu hạn sau dấu . của nó thôi. Do đó, số được lưu trữ chỉ xấp xỉ 0.1 chứ không bao giờ bằng 0.1. Đó là lý do vì sao, phép cộng chúng ta nói đến ở trên không đưa ra kết quả như chúng ta mong đợi. Đó là giới hạn của phần cứng máy tính 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

Để khắc phục vấn đề này, chúng ta có thể sử dụng mô-đun Decimal trong Python. Trong khi 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 chúng ta 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 khá quan trọng, ví dụ như 25.50kg sẽ chính xác hơn 25.5kg, vì 2 chữ số thập phân vẫn chính 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 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 so với code trên.

Bạn có thể thắc mắc trong phần phép nhân, tại 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 trả lời là tính hiệu quả, các phép toán với số float được hiện nhanh hơn các phép toán Decimal.

Khi 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 ứng dụng tài chính, cần biểu diễn phần thập phân chính xác.
• Khi muốn kiểm soát mức độ chính xác của số.
• Khi 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 cung cấp 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ể nhận được những kết quả không bình thường, điều này là do hạn chế của phần cứng máy tính như đã thảo luậ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 thích 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ố hỗ trợ đầy đủ các phép toán cơ 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 cung cấp các mô-đun math và random để giải quyết các vấn đề toán học khác như lượng giác, logarit, xác suất và thống kê, v.v... Vì mô-đun math có khá nhiều hàm và thuộc tính, nên mình tính sẽ làm một bài riêng để liệt kê chúng. Dưới đây là ví dụ 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ư máy tính bỏ túi

Trình thông dịch hoạt động như một máy tính đơn giản: 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á đơn giản: các toán tử như +, -, * và / làm việc giống như trong hầu hết các ngôn ngữ lập trình khác (Pascal, C), dấu ngoặc đơn () có thể được sử dụng để nhóm. Ví dụ:

>>> 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 (ví dụ 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ư ví dụ 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 tiếp theo:

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

Nếu một biến không được định nghĩa (gán giá trị), cố gắng sử dụng biến đó, bạn sẽ nhận đượ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 <module>
NameError: name 'n' is not defined

Python hỗ 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 đổi toán hạng số nguyên sang số thập phân):

>>> 4 * 3.75 - 1
14.0

Trong 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 dễ dàng thực hiện các phép tính tiếp theo hơn. Ví dụ:

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

Bạn nên coi biến này là read-only, đừng gán giá trị cho nó - vì nếu tạo ra 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 làm đượ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ự. Máy tính không xử lý các ký tự, chúng chỉ làm việc với số nhị phân. Dù bạn có thể nhìn thấy các ký tự trên màn hình, nhưng chúng được lưu trữ và xử lý nội bộ dưới dạng kết hợp của số 0 và 1. Việc chuyển đổi ký tự thành số được gọi là mã hóa và quá trình ngược lại được gọi là giải mã. ASCII và Unicode là 2 trong số những mã hóa phổ biến thường được sử dụng.

Trong Python, string là một dãy các ký tự Unicode. Unicode bao gồm mọi ký tự trong tất cả các ngôn ngữ và mang 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 biểu 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.

>>> 'spam eggs'  # dấu nháy đơn
'spam 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ó vẻ hơi khác với đầu vào (dấu nháy kèm theo có thể thay đổi) nhưng hai chuỗi này là tương đương. 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), ngược 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.
Second line.'  # 
 nghĩa là dòng mới
>>> s  # không có print(), 
 sẽ được viết trong kết quả đầu ra
'First line.
Second line.'
>>> print(s)  # có print(), 
 sẽ tạo ra dòng mới
First line.
Second line.

Nếu không 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 đầu tiên:

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

Chuỗi ký tự dạng chuỗi có thể viết trên nhiều dòng bằng cách sử dụng 3 dấu nháy: """...""" hoặc '...'. Kết thúc dòng tự động 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. Ví dụ:

print("""
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

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

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

Escape Sequence	Mô tả
ewline	Dấu gạch chéo ngược và dòng mới bị bỏ qua
	Dấu gạch chéo ngược
'	Dấu nháy đơn
"	Dấu nháy kép
a	ASCII Bell
	ASCII Backspace
f	ASCII Formfeed
	ASCII Linefeed
	ASCII Carriage Return
	ASCII Horizontal Tab
v	ASCII Vertical Tab
ooo	Ký tự có giá trị bát phân là ooo
xHH	Ký tự có giá trị thập lục phân là HH

Ví dụ: Hãy chạy từng lệnh riêng lẻ 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ày
thà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ự đầu tiên được đánh số 0. Không có kiểu ký tự riêng biệt, mỗi ký tự đơn giản là một con số:

>>> word = 'Python'
>>> word[0]  # ký tự ở vị trí số 0
'P'
>>> word[5]  # ký tự ở vị trí số 5
'n' 

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

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

Lưu ý rằng vì -0 cũng tương tự như 0, nên các chỉ số âm bắt đầu từ -1.

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

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

Hãy để ý đến cách các ký tự được giữ lại và loại trừ. Nó luôn đảm bảo 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ó thiết lập mặc định khá hữu ích, có 2 chỉ số bị bỏ qua theo mặc định, là 0 và kích thước của chuỗi được cắt.

>>> word[:2]   # các ký tự từ đầu đến vị trí thứ 2 (loại bỏ)
'Py'
>>> word[4:]   # các ký tự từ vị trí 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ớ cách 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, ví dụ:

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

Hàng đầu tiên của số mang đến vị trí 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 tất cả các ký tự nằm giữa i và j, tương ứng.

Đối với các chỉ số không âm, chiều 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 giới hạn. Ví dụ, chiều dài của word[1:3] là 2.

Cố gắng 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 <module>
IndexError: string index out of range

Tuy nhiên, các chỉ mục bên ngoài phạm vi lát cắt vẫn được xử lý gọn gàng khi được sử dụng để cắt:

>>> word[4:42] # cắt ký tự từ vị trí thứ 4 đến 42

'on'

>>> word[42:] # cắt ký tự sau vị trí 42

'

Thay đổi hoặc xóa chuỗi

Các chuỗi Python không thể thay đổi - chúng là cố định. Vì vậy, nếu cứ cố tình gán một ký tự nào đó cho vị trí đã được lập chỉ mục thì bạn sẽ nhận được thông 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 tốt nhất là tạo mới:

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

Bạn khô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 bộ chuỗi, bằng cách sử dụng từ khóa 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 tự động.

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

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

>>> prefix = 'Py'
>>> prefix 'thon'  # khô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 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'

Tính năng này đặc biệt hữu ích khi 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 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 tra phần tử của chuỗi

Giống list 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ư ví dụ đế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 thấy
print('Có', count,'chữ i được tìm thấy')

Để kiểm tra một chuỗi con có trong chuỗi hay chưa, hãy dùng từ khóa 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 ích trong khi lặp.

qtm_str = 'Python'

# enumerate()
qtm_enum = list(enumerate(qtm_str))

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

Phương thức format() để định dạng chuỗi

Phương thức format() rất linh hoạt 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ố vị trí hoặc từ khóa để chỉ định thứ tự.

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

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

# sử dụng từ khóa để sắp xếp thứ tự
tu_khoa_thu_tu = "{s}, {b} và {j}".format(j='Quản',b='Trị',s='Mạng')
print('
--- Thứ tự theo từ khóa ---')
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 vị trí ---
Trị, Quản và Mạng

--- Thứ tự theo từ khóa ---
Mạng, Trị và Quản

Phương thức 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 :. Ví dụ, 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 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 cách sprintf() được sử dụng trong ngôn 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 thức thường được sử dụng trong string

Có rất nhiều phương thức đượ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 có 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 Mang Chấm Com'
>>> 'Quan Tri Mang Chấm Com'.find('Qua')
0
>>> 'Quan Tri Mang Chấm Com'.replace('Chấm','.')
'Quan Tri Mang . Com'

4. Danh sách (list)

Python cung cấp 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 năng nhất là danh sách (list).

Cách tạo list trong Python

Trong Python, list được biểu diễn bằng dãy các giá trị, được phân tách nhau bằng dấu phẩy, nằm trong dấu []. Các danh sách 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]

List không giới hạn 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 list, như chuỗi, số nguyên, số thập phân,...

list1 = [] # list rỗng

list2 = [1, 2, 3] # list số nguyên

list3 = [1, "Hello", 3.4] # list với kiểu dữ liệu hỗn hợp

Bạn cũng có thể tạo các list lồng nhau (danh sách chứa trong danh sách), ví dụ:

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 list 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: list indices must be integers or slices, not float
# TypeError: index của list phải là số nguyên hoặc slice, không phải số thập phân
qtm_list[2.0]

List 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])

# List 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 đơn giản 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])

Cắt lát (slice) list trong Python

Python cho phép truy cập vào một dải phần tử của list bằng cách sử dụng toán tử cắt lát : (dấu hai chấm). Mọi hành động cắt list đều trả về list 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:])

Để cắt lát list, 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 list mới là bản sao của list 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[:])

Thay đổi hoặc thêm phần tử vào list

List cũng hỗ trợ các hoạt động như nối list:

>>> 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, list là kiểu dữ liệu có thể thay đổi. Ví dụ, bạn có thể thay đổi các mục trong list:

>>> cubes = [1, 8, 27, 65, 125]  # có vẻ 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 list bằng cách sử dụng các phương thức, chẳng hạn 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ể thay đổi cả kích thước của list 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 list bằng cách thay tất cả các phần tử bằng một list rỗng
>>> letters[:] = []
>>> letters
[]

Hàm len() cũng có thể áp dụng với list:

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

Xóa hoặc loại bỏ phần tử khỏi list trong Python

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

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 bộ list 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 nhất đị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 list dưới dạng stack (ngăn xếp) (cấu trúc dữ liệu first in last out - vào đầu tiên, ra cuối cùng).

Ngoài ra, phương thức clear() cũng được dùng để làm rỗng một list (xóa tất cả các phần tử trong list).

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: [] (list rỗng)
print(my_list)

Cách cuối cùng để xóa các phần tử trong một list là gán một list 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 thức list trong Python 

Những phương thức có sẵn cho list trong Python gồm:

• append(): Thêm phần tử vào cuối list.
• extend(): Thêm tất cả phần tử của list hiện tại vào list khác.
• insert(): Chèn một phần tử vào index cho trước.
• remove(): Xóa phần tử khỏi list.
• pop(): Xóa phần tử khỏi list và trả về phần tử tại index đã cho.
• clear(): Xóa tất cả phần tử của list.
• index(): Trả về index của phần tử phù hợp đầu tiên.
• count(): Trả về số lượng phần tử đã đếm được trong list như một đối số.
• sort(): Sắp xếp các phần tử trong list theo thứ tự tăng dần.
• reverse(): Đảo ngược thứ tự các phần tử trong list.
• copy(): Trả về bản sao của list.

Ví dụ:

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)

Ví dụ 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)

List comprehension: Cách tạo list mới ngắn gọn

List 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 [].

Ví dụ:

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 đương 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 list comprehension của Python. Lệnh if có thể lọc các phần tử trong list hiện tại để tạo thành list mới. Dưới đây là ví dụ:

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 tra phần tử có trong list không

Sử dụng keyword in để kiểm tra xem một phần tử đã có trong list hay chưa. Nếu phần tử đã tồn tại, kết quả trả về là True, và ngược 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 list

Sử dụng vòng lặp for để lặp qua các phần tử trong list như ví dụ dưới đây:

for ngon_ngu in ['Python','Java','C']:
    print("Tôi thích lập trình",ngon_ngu)

Kết qu