Python cơ bản

Tài liệu lý thuyết dùng trong các khóa học lập trình và thuật toán với Python của thầy Nguyễn Chí Thức

Copyright Ⓒ 2018 Nguyễn Chí Thức
gthuc.nguyen@gmail.com

Python - các phép toán số học

Sử dụng biến - ví dụ

d10 = 5
d9 = 7
d8 = 12

tongdiem = d10 * 10 + d9 * 9 + d8 * 8
hocsinh = d10 + d9 + d8

print(tongdiem / hocsinh)
					

8.708333333333334

Sử dụng biến - ví dụ

d10 = 6
d9 = 7
d8 = 11

tongdiem = d10 * 10 + d9 * 9 + d8 * 8
hocsinh = d10 + d9 + d8

print(tongdiem / hocsinh)
					

8.791666666666666

Xâu ký tự trong Python

                    a = 6
                    b = 11
                    print("a + b")      # in ra "a + b"
                    print(a + b)        # in ra "17"
                    print("12 * 5")     # in ra "12 * 5"
                    print(12 * 5)       # in ra "60"
                    

Xâu ký tự trên nhiều dòng

                        message = '''Good morning!
                        How's it going?'''
                        print(message)

                        s = """Trời nhẹ dần lên cao, hồn tôi dường như bóng chim
                        Vờn đôi cánh mềm lặng lẽ kiếm chốn nao bình yên"""
                        print(s)
                    

Ký tự đặc biệt trong xâu

• Xâu có thể được đóng trong cặp dấu nháy đơn, vậy nếu trong xâu cũng có dấu nháy đơn (ví dụ xâu "I'm good)"?
• Ta có thể dùng 1 trong 3 cách sau:

                        s = "I'm great"       # dùng dấu nháy kép
                        print(s)
                        s = 'I\'m great'      # đánh dấu ký tự đặc biệt bằng dấu \
                        print(s)
                        s = '''I'm great'''   # dùng cú pháp của 'xâu trên nhiều dòng'
                        print(s)

                    

• Kỹ thuật đánh dấu ký tự đặc biệt trong xâu ở trên, trong tiếng Anh là "Escape special characters"

Một số ký tự đặc biệt trong xâu

Nối xâu

                        msg1 = 'Hello, '
                        msg2 = '. How are you?'
                        name = 'Thuc'

                        print(msg1 + name + msg2)

                        # in ra:
                        # Hello, Thuc. How are you?
                    

Nhân xâu với một số

                        print('#-' * 10)
                        print('* ' * 20)
                    

                        #-#-#-#-#-#-#-#-#-#-
                        * * * * * * * * * * * * * * * * * * * *
                    

Kiểu dữ liệu

• Trong lập trình, mỗi biểu thức/giá trị/biến có kiểu dữ liệu riêng
• Các kiểu dữ liệu cơ bản có thể kể đến: số nguyên, số thực (số thập phân), xâu ký tự...
• Việc phân biệt các kiểu dữ liệu là quan trọng, vì mỗi kiểu dữ liệu có các phép toán, thao tác xử lý khác nhau

Kiểu dữ liệu và các phép toán tương ứng

Kiểu dữ liệu xâu ký tự (String)

                        'python'

                        "programming"

                        """
                        This is a sample of
                        multiline string
                        """

                        "hello" + " world"

                        'hello\n' * 20
                    

Kiểu dữ liệu số nguyên (integer)

                        12
                        543
                        214 * 5233
                        3425 - 425
                        32 // 2
                        452 % 12
                        34 ** 3
                    

Kiểu dữ liệu số thực (float)

                        12.0
                        543.7
                        214 * 12.0
                        342.6 - 42.5
                        32 / 2
                        34.3 ** 3
                    

Phép toán trên các kiểu dữ liệu khác nhau

                        12 + 12.0                  # trả ra số thực
                        "s" * 10                   # trả ra xâu
                        12 / 6                     # trả ra số thực
                        "sda" + "a"                # trả ra xâu
                        "My number is " + 15       # LỖI: TypeError
                        "My number is " + str(15)  # dùng hàm str() để đổi số
                                                   # thành xâu trước khi nối
                    

Chuyển đổi giữa các kiểu dữ liệu (type casting)

• Hàm str() chuyển một giá trị thành xâu
• Hàm int() chuyển một giá trị số nguyên
• Hàm float() chuyển một giá trị số thực

                        str(12) + "34"        # "1234"
                        12 + int("34")        # 46
                        int(1.12)             # 1 (số thực chuyển sang số
                                              # nguyên sẽ mất phần thập phân)
                        "12.1" * 2            # "12.112.1"
                        float("12.1") * 2     # 24.2
                        float(5) + 6          # 11.0
                    

Nhúng giá trị vào trong xâu

• Xét chương trình in ra lời chào 3 người như sau:

                            print("Chào An, bạn khỏe không?")
                            print("Chào Bình, bạn khỏe không?")
                            print("Chào Cường, bạn khỏe không?")
                        

• 3 lời chào giống hệt nhau, chỉ khác tên (nằm giữa xâu), ta có thế dùng kỹ thuật "nhúng" các tên này vào một mẫu lời chào cho trước như sau:

                            s = "Chào %s, bạn khỏe không?"
                            print(s % "An")
                            print(s % "Bình")
                            print(s % "Cường")
                        

Nhúng giá trị vào trong xâu

                            s = "Chào %s, bạn khỏe không?"
                            print(s % "An")
                            print(s % "Bình")
                            print(s % "Cường")
                        

• Các bước để nhúng giá trị vào xâu:
• Đánh dấu các vị trí cần chèn giá trị vào trong xâu bằng %s
• Khi kết thúc xâu, thêm dấu %
• Liệt kê các giá trị cần chèn vào xâu sau dấu % theo thứ tự cần chèn

Nhúng giá trị vào trong xâu

• Để chèn nhiều giá trị vào xâu, các giá trị này phải để trong ngoặc đơn, cách nhau bằng dấu phẩy:

                            a, b = 11, 123
                            print("%s * %s = %s" % (a, b, a * b))

                            # in ra:
                            # 11 * 123 = 1353
                        

• Lưu ý: đây là kỹ thuật tương đối "cũ" để nhúng giá trị trong xâu, nhưng vẫn hữu dụng. Kỹ thuật mới hơn là sử dụng string.format() sẽ học trong phần sau của khóa này.

Chú thích (comment) trong Python

• Trong lập trình, ta hay dùng các chú thích (comment) để giải nghĩa cho các đoạn mã trong chương trình:

                            unit_price = 12  # đơn giá, tính bằng đô la
                            amount = 3       # số lượng
                            total_cose       # tổng tiền cần thanh toán
                        

• Trong Python, chú thích được bắt đầu bằng dấu #
• Các chú thích chỉ dùng để làm rõ nghĩa chương trình cho người lập trình, máy tính sẽ bỏ qua các chú thích này khi chạy chương trình

Nhập-xuất dữ liệu (data input - output)

• Các chương trình máy tính đều làm việc với các dữ liệu (data): thông tin tài khoản, điểm, các con số...
• Chương trình máy tính nhận dữ liệu vào và xử lý để cho ra kết quả (dữ liệu ra)
• Dữ liệu vào có thể từ nhiều nơi: người dùng nhập từ bàn phím, từ file, từ mạng...
• Dữ liệu ra có thể gửi ra nhiều nơi: in ra màn hình, xuất ra file, gửi tin nhắn qua mạng..

Nhập-xuất dữ liệu

• Trong phần đầu của khóa học, ta chỉ xét việc nhập dữ liệu từ bàn phím và xuất dữ liệu ra màn hình
• Phần cuối của khóa học sẽ làm việc với nhập xuất dữ liệu từ file (tập tin) trên máy tính
• Để xuất (in ra) dữ liệu ra màn hình trong Python, ta dùng hàm print() như đã học trong bài học trước
• Để nhập dữ liệu từ bàn phím, ta dùng hàm input()

Nhập dữ liệu với hàm print()

• Lệnh input() sẽ dừng chương trình và chờ người dùng nhập vào đoạn chữ từ bàn phím, đến khi người dùng bấm Enter
• Để lưu giá trị nhập vào này, ta có thể dùng biến
• Chương trình sau chờ người dùng nhập vào tên của mình, và in ra lời chào tương ứng

                            name = input()
                            print('Xin chào %s!' % name)
                        

Nhập dữ liệu với hàm print()

• Lưu ý quan trọng: hàm input() luôn luôn nhập vào 1 xâu ký tự (string)
• Nếu cần xử lý với kiểu dữ liệu khác, ta cần chuyển đổi kiểu dữ liệu. (Xem lại ở bài học trước )

Chuyển đổi kiểu dữ liệu nhập vào bởi hàm print()

• Nhắc lại: hàm input() luôn luôn nhập vào 1 xâu ký tự (string)
• Ví dụ: chương trình nhập vào 2 số nguyên và in ra tổng của chúng:

                            a = input()
                            b = input()
                            print(a+b)
                        

• Chạy chương trình trên và nhập vào 2 số trên 2 dòng:

                            5
                            7

                        

• Chương trình sẽ in ra kết quả SAI:

57

Chuyển đổi kiểu dữ liệu nhập vào

                            a = input()
                            b = input()
                            print(a+b)        # phép nối hai xâu, không phải phép cộng 2 số
                        

• Chương trình trên là SAI do a, b nhập vào bởi hàm input() là 2 xâu ký tự. Nên phép cộng ở dòng thứ 3 sẽ là phép nối 2 xâu
• Chương trình đúng phải chuyển dữ liệu nhập vào thành số (integer) trước khi cộng:

                            a = int(input())
                            b = int(input())
                            print(a+b)        # phép cộng 2 số
                        

Chuyển đổi kiểu dữ liệu nhập vào

                            a = int(input())
                            b = int(input())
                            print(a+b)        # phép cộng 2 số
                        

• Chạy chương trình trên và nhập vào 2 số trên 2 dòng:

                            5
                            7

                        

• Chương trình sẽ in ra kết quả ĐÚNG:

12

Chuyển đổi kiểu dữ liệu nhập vào

• Để cộng 2 số thực, ta cần chuyển sang kiểu float:

                            a = float(input())
                            b = float(input())
                            print(a+b)        # phép cộng 2 số
                        

• Chạy chương trình trên và nhập vào 2 số thực trên 2 dòng:

                            5
                            7.1

                        

• Chương trình sẽ in ra kết quả:

12.1

Nhắc lại kiểu dữ liệu và ép kiểu

• Xem lại khái niệm và ví dụ về kiểu dữ liệu tại đây.
• Xem lại ví dụ về việc chuyển đổi giữa các kiểu dữ liệu (ép kiểu) tại đây.

Làm tròn số với hàm round()

• Tất cả các phép tính toán trên máy tính đều không chính xác tuyệt đối, mà có độ chính xác (precision) nhất định
• Chạy thử ví dụ sau:

                            a, b = 0.1, 0.2
                            print(a + b)   # phải ra 0.3 ???
                        

• Thực tế, chương trình sẽ in ra kết quả:

0.30000000000000004

• Bài học: trong hầu hết các trường hợp tính toán với số thực, ta cần làm tròn kết quả trước khi in ra

Làm tròn số với hàm round()

• Để làm tròn số trong Python, ta dùng hàm round():

round(số_cần_làm_tròn, số_chữ_số_sau_dấu_phẩy)

• Ví dụ:

                            a, b = 0.1, 0.256
                            print(round(a + b, 2))   # Làm tròn đến 2 chữ số sau dấu phẩy
                        

• Chương trình sẽ in ra kết quả:

0.36

• Mở rộng: tham số thứ 2 của hàm round() (số_chữ_số_sau_dấu_phẩy) có thể âm

Cách khác để làm tròn số trong Python

• Cách 1: dùng hàm round():

                            a, b = 0.1, 0.256
                            print(round(a + b, 2))   # Làm tròn đến 2 chữ số sau dấu phẩy
                        

• Cách 2: dùng kỹ thuật nhúng giá trị trong xâu với đánh dấu %nf, với n là số chữ số sau dấu phẩy:

                            a, b = 0.1, 0.256
                            print("%.2f" % (a + b))   # Làm tròn đến 2 chữ số sau dấu phẩy
                        

• Cả 2 chương trình đều in ra cùng kết quả:

0.36

• Mở rộng cách 3: dùng string.format()

Sử dụng module math

• Mặc định Python chỉ có các phép toán cơ bản trên số (+, -, *, /, round...)
• Module math cung cấp thêm nhiều hàm nâng cao hơn trên số
• Ví dụ, hàm math.ceil(a) sẽ làm tròn số a lên (trả ra số nguyên nhỏ nhất, lớn hơn hoặc bằng a).
• Để sử dụng các hàm trong module math, trước tiên ta cần nhập khẩu (import) module này:

                            import math
                            print(math.ceil(1.2))     # in ra 2
                        

Một số hàm và hằng số phổ biến trong module math

Sử dụng module math - ví dụ

                        import math
                        print(math.pi)              # in ra 3.141592653589793
                        print(math.e)               # in ra 2.718281828459045
                        print(math.floor(1.9))      # in ra 1
                        print(math.ceil(2.1))       # in ra 3
                        print(math.trunc(-1.9))     # in ra -1
                        print(math.factorial(5))    # in ra 120
                        print(math.gcd(12, 18))     # in ra 6
                    

Câu lệnh điều kiện

• Các chương trình chúng ta đã học đều chạy lần lượt từng dòng, không bỏ qua dòng nào
• Trong nhiều trường hợp, ta cần điều khiển chương trình chạy theo một số điều kiện nhất định
• Xét ví dụ sau:

Viết chương trình nhập vào số nguyên n, kiểm tra xem n là số chẵn hay số lẻ.

• Với các kiến thức đã học, ta có thể giải quyết bài toán này không?

Câu lệnh if - else trong Python

Viết chương trình nhập vào số nguyên n, kiểm tra xem n là số chẵn hay số lẻ.

• Để giải quyết bài toán này, ta cần câu lệnh mới: câu lệnh if để kiểm tra điều kiện:

                            n = int(input())
                            if n % 2 == 0:   # số chẵn là số chia cho 2 có số dư = 0
                              print("chẵn")
                            else:
                              print("lẻ")
                        

• Thử chạy chương trình trên vài lần, mỗi lần nhập vào một số tự nhiên khác nhau và theo dõi kết quả

Câu lệnh if - else trong Python

                        n = int(input())
                        if n % 2 == 0:     # số chẵn là số chia cho 2 có số dư = 0
                          print("chẵn")    # thụt vào đầu dòng 1 tab hoặc 2 dấu cách
                        else:              # lưu ý: cần dấu hai chấm
                          print("lẻ")      # thụt vào đầu dòng, thẳng với dòng 03
                    

• Ở dòng số 02, ta dùng 2 dấu bằng (==) để so sánh 2 số (lưu ý phân biệt với dấu = là phép gán giá trị cho biến)
• Sau khi kiểm tra điều kiện ở dòng 02 bằng lệnh if, ta cần dấu hai chấm (:).
• Dòng 03 chỉ được thực hiện khi điều kiện ở dòng 02 là ĐÚNG (tức khi số dư của n khi chia cho 2 bằng 0). Dòng này nằm trong lệnh if, nên cần được thụt vào đầu dòng (1 dấu tab hoặc 2 dấu cách)
• Dòng 04 chứa chữ else và dấu hai chấm(:) để bắt đầu nhánh ngược lại với điều kiện if ỏ dòng 02
• Dòng 05 chỉ được thực hiện khi điều kiện ở dòng 02 là SAI (tức khi số dư của n khi chia cho 2 KHÁC 0). Dòng này nằm trong lệnh else, nên cần được thụt vào đầu dòng (thẳng với dòng 03)

Câu lệnh if - else trong Python

                        if điều_kiện:
                          các lệnh cần thực hiện khi điều_kiện ĐÚNG
                        else:
                          các lệnh cần thực hiện khi điều_kiện SAI
                    

• Sau điều_kiện và sau else, ta cần dấu hai chấm (:).
• Các lệnh bên dưới dấu hai chấm cần thụt vào đầu dòng (thường là 1 dấu tab hoặc 2 dấu cách)
• Các dòng thụt vào đầu dòng (dòng 02 và 04) phải thẳng nhau (căn thẳng lề trái với nhau)

Câu lệnh if trong Python

• Nhánh else có thể được bỏ qua, nếu chỉ cần thực hiện một số lệnh khi điều_kiện đúng. Ví dụ:

                            x = int(input())
                            if x < 0:
                              x = -x
                            print(x)
                    

• Chương trình trên thực hiện việc đảo dấu của x khi x âm. Khi x không âm, thì không tác động gì vào biến x (dòng 03 sẽ không thực hiện)
• Ý nghĩa của chương trình trên:

Nhập vào số nguyên x, in ra giá trị tuyệt đối của x.

• Mở rộng: chương trình trên tương đương với hàm abs(x) có sẵn trong Python.

Điều kiện - kiểu dữ liệu boolean

                        if điều_kiện:
                          các lệnh cần thực hiện khi điều_kiện ĐÚNG
                        else:
                          các lệnh cần thực hiện khi điều_kiện SAI
                    

• Như đã nói từ trước: các biến/giá trị trong lập trình đều có kiểu dữ liệu nhất định. Vậy điều_kiện trong câu lệnh if ở trên có kiểu dữ liệu gì?
• điều_kiện ở đây chỉ nhận 2 giá trị: ĐÚNG hoặc SAI, và không phải một trong các kiểu dữ liệu đã biết (int, float hay string)
• Kiểu dữ liệu chỉ nhận 2 giá trị ĐÚNG hoặc SAI trong Python gọi là kiểu dữ liệu Boolean (kiểu logic)
• Biến kiểu boolean chỉ nhận 2 giá trị: True (đúng) và False (sai). Lưu ý viết hoa chữ cái đầu (True và False).

Các phép so sánh trong Python

Các phép so sánh trong Python thực hiện việc so sánh 2 giá trị và trả ra kết quả kiểu Boolean. Vì vậy các phép toán này có thể dùng làm điều kiện cho lệnh if:

                                5 + 2 == 7          # True
                                'hello' == "Hello"  # False
                            

                                5 + 2 > 6           # True
                                12.4 > 13           # False
                            

                                5 + 2 < 7           # False
                                12.4 < 13           # True
                            

Các phép so sánh trong Python (tiếp)

Các phép so sánh trả ra kết quả kiểu Boolean và có thể dùng làm điều kiện cho lệnh if:

                                5 + 2 >= 7          # True
                                5 + 2 >= 6          # True
                            

                                5 + 2 <= 7          # True
                                5 + 2 <= 6          # False
                            

                                5 + 2 != 7          # False
                                5 + 2 != 6          # True
                                "hello" != "Hello"  # True
                            

Các phép toán trên kiểu dữ liệu Boolean

Các phép toán sau nhận vào 1 hoặc 2 giá trị kiểu Boolean, và trả ra kết quả là một giá trị kiểu Boolean

                                # tương đương với 7 <= 5
                                not 7 > 5      # False
                            

                                5 < 6 and 5 < 7   # True
                                5 < 6 and 5 > 7   # False
                            

                                5 < 6 or 5 < 7    # False
                                5 < 6 or 5 > 7    # True
                            

Bảng chân trị của các phép toán trên kiểu dữ liệu Boolean

Điều kiện gộp - các phép toán với kiểu dữ liệu Boolean

• Sử dụng các phép toán với kiểu dữ liệu boolean, chúng ta có thể viết các điều kiện phức tạp hơn (điều kiện gộp)
• Lưu ý: phép toán and được thực hiện trước (độ ưu tiên cao hơn) phép toán or. Trong trường hợp cần thực hiện or trước thì cần đặt phép toán or trong cắp dấu ngoặc đơn ().
• Kiểm tra n có phải là số chẵn có 2 chữ số hay không:

                            if (n >= 10) and (n < 100) and (n % 2 == 0):
                        

• Kiểm tra xem 3 số a, b, c có phải là 3 cạnh của một tam giác hay không:

                            if (a + b > c) and (b + c > a) and (c + a > b):
                        

• Kiểm tra xem năm y có phải là năm nhuận không:

                            if (y % 4 == 0 and y % 100 != 0) or y % 400 == 0:
                        

Rẽ nhiều nhánh với if-elif-else

• Lệnh if-else thực hiện kiểm tra một điều kiện và làm chương trình rẽ thành 2 nhánh, thực hiện khi điều kiện ban đầu là đúng hoặc sai
• Với bài toán cần rẽ nhiều nhánh hơn, ta dùng thêm câu lệnh elif ở giữa if và else.
• Xét bài toán sau:

Nhập vào số tự nhiên n < 1000, in ra màn hình số chữ số của n.

Ta cần:

• in ra 1 nếu n < 10
• in ra 2 nếu n >= 10 và n < 100
• in ra 3 nếu n > 100 (vì đề bài đã cho n < 1000)

Rẽ nhiều nhánh với if-elif-else

Nhập vào số tự nhiên n < 1000, in ra màn hình số chữ số của n.

                        if n < 10:
                            print(1)
                        elif n < 100:   # đến đây không cần kiểm tra n >= 10 nữa vì đã điều kiện n < 10 ở trên đã sai
                            print(2)
                        else:           # trường hợp còn lại, đến đây không cần kiểm tra n >= 100 nữa vì cả 2 điều kiện ở trên đã sai
                            print(3)
                    

• Nếu điều kiện ở dòng 01 là ĐÚNG, dòng thứ 02 mới được thực hiện và khi đó các nhánh sau (từ dòng 03 đến 06) không được thực hiện nữa
• Nếu điều kiện ở dòng 01 SAI (khi đó n >= 10) thì điều kiện ở dòng thứ 03 mới được kiểm tra. Khi đó:
• Nếu điều kiện này ĐÚNG (n < 100) thì n là số có 2 chữ số, thực hiện in ra số 2 ở dòng 04, và không thực hiện các dòng 05-06 nữa.
• Nếu điều kiện này SAI (tức là n>=100) thì thực hiện nhánh else (nhánh còn lại) ở dòng 06: in ra 3

Rẽ nhiều nhánh với if-elif-else - ví dụ

Nhập vào 3 số nguyên a, b, c. In ra màn hình giá trị nhỏ nhất trong 3 số đó.

                        a = int(input())
                        b = int(input())
                        c = int(input())
                        if a <= b and a <= c:
                            print(a)
                        elif b <= c and b <= a:
                            print(b)
                        else:
                            print(c)
                    

Lưu ý: có thể có nhiều nhánh elif liên tục. Thử giải quyết bài toán sau:

Nhập vào 5 số nguyên. In ra màn hình giá trị nhỏ nhất trong 5 số đó.

Câu lệnh điều kiện lồng nhau

• Các câu lệnh if, if-else, if-elif-else có thể lồng nhau với số cấp tùy ý, tạo nên các đoạn chương trình với các nhánh phức tạp hơn.
• Lưu ý 1: các lệnh lồng bên trong phải thụt vào cách đầu dòng xa hơn so với các lệnh bên ngoài.
• Lưu ý 2: các lệnh lồng bên trong cùng cấp phải cách lề trái một khoảng bằng nhau.
• Xét bài toán sau: Nhập vào 2 số nguyên, in ra màn hình:
  • Tổng của 2 số đó, nếu cả 2 số đều dương
  • Tích của 2 số đó nếu cả 2 số đều âm
  • Nếu không in ra màn hình số lớn hơn trong 2 số đó

Câu lệnh điều kiện lồng nhau - ví dụ

• Xét bài toán sau: Nhập vào 2 số nguyên, in ra màn hình:
  • Tổng của 2 số đó, nếu cả 2 số đều dương
  • Tích của 2 số đó nếu cả 2 số đều âm
  • Nếu không in ra màn hình số lớn hơn trong 2 số đó

                        a = int(input())
                        b = int(input())

                        if a > 0 and b > 0:
                          print(a+b)
                        elif a < 0 and b < 0:
                          print(a*b)
                        else:
                          if a > b:         # lưu ý thụt vào đầu dòng, thẳng với dòng 05 và 07
                            print(a)        # lưu ý thụt vào đầu dòng, xa hơn xo với dòng trên
                          else:
                            print(b)        # lưu ý thụt vào đầu dòng, thẳng với dòng 10
                    

Lệnh lặp trong lập trình

• Các chương trình máy tính thường thực hiện một số thao tác lặp đi lặp lại một cách tự động.
• Khả năng lặp đi lặp lại một việc một cách chính xác, không xảy ra lỗi là ưu thế vượt trội của máy tính so với con người.
• Các công việc lặp đi lặp lại một số công việc được gọi là "vòng lặp".
• Python có 2 vòng loại vòng lặp là for và while.
• Trong phần này, chúng ta sẽ tìm hiểu vòng lặp for.
• Trước tiên, chúng ta ôn lại một số khái niệm đã biết.

Phép gán lại (reassignment) giá trị cho biến

• Một biến có thể được gán lại một giá trị khác, bằng dấu =. Khi đó biến sẽ được đặt giá trị mới, và giá trị cũ sẽ không còn nữa.

                            a = 5
                            print(a)   # in ra 5
                            a = 7
                            print(a)   # in ra 7, giá trị cũ (5) ko còn nữa
                            b = a      # gán b = a, lúc này b = 7
                            a = 3      # gán a = 3, lúc này a = 3, b vẫn = 7
                        

• Cần lưu ý phân biệt phép gán (=) và phép so sánh bằng (==)
  • Phép gán đặt giá trị mới cho biến: a = 5
  • Phép so sánh bằng kiểm tra 2 giá trị có bằng nhau không, trả ra True hoặc False, và không làm thay đổi giá trị của biến: a == 5

Cập nhật (updating) giá trị cho biến

• Phép gán được thực hiện như sau: đầu tiên, tính giá trị của biểu thức bên phải dấu =, sau đó gán kết quả cho biến bên trái dấu =.
• Một dạng phép gán lại giá trị được sử dụng phổ biến trong lập trình là phép cập nhật (thay đổi) giá trị của biến bằng cách tính toán trên chính biến đó

                            a = 5
                            a = 3 * a + 1
                            print(a)        # in ra 16
                        

• Dòng 02 có nghĩa là: lấy giá trị hiện tại của biến a, nhân với 3 rồi cộng thêm 1, sau đó đặt lại giá trị nhận được (16) vào biến a.

Cập nhật (updating) giá trị cho biến

• Trước khi cập nhật lại giá trị cho biến, ta cần khởi tạo (initialize) giá trị ban đầu cho biến trước.

                            x = x + 1   # LỖI chưa khởi tạo: NameError: name 'x' is not defined
                        

• Khởi tạo giá trị ban đầu cho biến:

                            x = 0       # khởi tạo giá trị ban đầu
                            x = x + 1   # OK
                        

Cập nhật giá trị cho biến

• Để cập nhật giá trị cho biến, trong Python có một số cú pháp tắt như sau:

Vòng lặp for trong Python

• Ví dụ đầu tiên: lặp lại một số lần nhất định:

                            for i in range(5):
                                print("Hello")
                        

• Chương trình trên lặp lại 5 lần lệnh print("Hello") và cho ra kết quả:

                            Hello
                            Hello
                            Hello
                            Hello
                            Hello
                        

Cú pháp mở rộng của lệnh print()

• Hàm print(s) mặc định in ra giá trị của s và kết thúc bằng dấu xuống dòng:

                            for i in range(3):
                                print("Hello")
                            # Kết quả:
                            # Hello
                            # Hello
                            # Hello
                        

• Hàm print(a, b, c,...) có thể in ra nhiều giá trị cùng lúc, mỗi giá trị sẽ mặc định cách nhau bằng dấu cách:

                            print("Hello", "from", "Python", 3, "!")
                            # Kết quả:
                            # Hello from Python 3 !
                        

Cú pháp mở rộng của lệnh print()

• Có thể thay đổi dấu xuống dòng mặc định khi kết thúc lệnh print bằng tham số end = ..., ví dụ, để kết thúc bằng dấu cách:

                            for i in range(10):
                                print("Hello", end = " ")
                            # Kết quả:
                            # Hello Hello Hello Hello Hello Hello Hello Hello Hello Hello
                        

• Có thể thay đổi dấu cách mặc định phân cách giữa các giá trị in ra bởi hàm print bằng tham số sep = ..., ví dụ:

                            print("Hello", "from", "Python", 3, "!", sep = '-')
                            # Kết quả:
                            # Hello-from-Python-3-!
                        

Hàm range(n)

                        for i in range(5):
                            print("Hello")
                    

• Hàm range(5) trong ví dụ trên trả ra một danh sách các số từ 0 đến 4
• Vòng lặp for sẽ lặp qua lần lượt từng giá trị trong danh sách này (từ 0 đến 4) và gán lại (re-assign) lại giá trị này cho biến lặp (biến i trong ví dụ trên).
• Từ 0 đến 4 (range(5)) có 5 số, do vậy chương trình trên in ra 5 chữ Hello

Hàm range(n)

• Xét ví dụ sau:

                            for n in range(5):
                                print(n, end = " ")
                        

• Vòng lặp for sẽ lặp qua lần lượt từng giá trị trong danh sách trả về bởi hàm range(5) (từ 0 đến 4) và gán lại (re-assign) lại từng giá trị này cho biến lặp (biến n).
• Như vậy, n sẽ nhận các giá trị lần lượt là 0, 1, 2, 3, 4. Với mỗi giá trị đó, thân vòng lặp (lệnh print(n)) được gọi một lần. Kết quả chương trình như sau:

                            0 1 2 3 4
                        

Hàm range(n)

• In ra các số từ 0 đến 100, mỗi số trên một dòng:

                            n = 101
                            for i in range(n):
                                print(i)
                        

• Tổng quát: hàm range(n) trả ra danh sách n số tự nhiên từ 0 đến n - 1

Hàm range(n, m) với 2 tham số

                            for n in range(5, 10):
                                print(n, end = " ")
                        

• Hàm range(5, 10) trả ra danh sách các số từ 5 đến 9.
• Kết quả chương trình như sau:

                            5 6 7 8 9
                        

• Tổng quát: hàm range(n,m) trả ra danh sách các số nguyên từ n đến m-1: [n, n+1, n+2 ... m-1]
• Lưu ý, trong hàm range(n, m), dãy số kết quả luôn luôn có chứa số n và không chứa số m.

Hàm range(n, m, s) với 3 tham số

                            for n in range(5, 12, 2):
                                print(n, end = " ")
                        

• Hàm range(5, 12, 2) trả ra danh sách các số cách 2, từ 5 đến 11, cụ thể là danh sách các số: [5, 7, 9, 11]
• Kết quả chương trình như sau:

                            5 7 9 11
                        

• Tổng quát: hàm range(n, m, s) trả ra danh sách các số nguyên cách nhau s đơn vị (bước nhảy), từ n đến trước số m: [n, n+s, n+2s, n+3s ... m-1]
• Lưu ý, trong hàm range(n, m, s), dãy số kết quả luôn luôn có chứa số n và không chứa số m.

Hàm range(n, m, s) với bước nhảy âm (s < 0)

• Khi n > m và s < 0, hàm range trả ra danh sách các số giảm dần, từ n đến m+1, mỗi số cách nhau -s. Ví dụ

                            for n in range(12, 5, -2):
                                print(n)
                        

• Hàm range(12, 5, -2) trả ra danh sách các số cách 2, giảm dần từ 12 đến 6. Kết quả:

                            12 10 8 6
                        

• Tổng quát: hàm range(n, m, -s) trả ra danh sách các số nguyên cách nhau s đơn vị (bước nhảy), giảm dần từ n đến trước số m: [n, n-s, n-2s, n-3s ... m+1]
• Lưu ý, trong hàm range(n, m, -s), dãy số kết quả luôn luôn có chứa số n và không chứa số m.

Vòng lặp for-in-range: ví dụ

• In ra các số tự nhiên chẵn có 2 chữ số:

                            for n in range(10, 100, 2):
                                print(n, end = " ")
                        

• In ra các số tự nhiên lẻ có 2 chữ số theo chiều giảm dần:

                            for n in range(99, 10, -2):
                                print(n, end = " ")
                        

• Nhập vào 2 số nguyên A, B (A < B). In ra các số tự nhiên từ A đến B trên cùng 1 dòng:

                            a, b = int(input()), int(input())
                            for n in range(a, b+1):
                                print(n, end = " ")
                        

Vòng lặp for-in-range: ví dụ

• Nhập vào số tự nhiên n, tính n! = 1 × 2 × 3 × ... × n

                            n = int(input())
                            factorial = 1
                            for i in range(1, n+1):
                                factorial *= i

                            print(factorial)
                        

• Nhập vào số n, in ra màn hình n số Fibonacci đầu tiên: 1 1 2 3 5 8 13 ...

                            n = int(input())
                            a, b = 0, 1
                            for i in range(n):
                                a, b = b, a + b
                                print(a, end = " ")
                        

Vòng lặp for lồng nhau

• Các vòng lặp for có thể lồng nhau với số cấp tùy ý, tạo nên các đoạn chương trình với các cấu trúc phức tạp hơn.
• Lưu ý 1: các lệnh lồng bên trong phải thụt vào cách đầu dòng xa hơn so với các lệnh bên ngoài.
• Lưu ý 2: các lệnh lồng bên trong cùng cấp phải cách lề trái một khoảng bằng nhau.

Vòng lặp for lồng nhau

• Nhập vào số n <= 9 là số bậc thang. Ở mỗi bậc thang thứ k, in ra các số từ 1 đến k liền nhau như ví dụ sau:

                            Với n = 4, cần in ra:
                            1
                            12
                            123
                            1234

                            Với n = 6, cần in ra:
                            1
                            12
                            123
                            1234
                            12345
                            123456
                        

Vòng lặp for lồng nhau

• Nhập vào số n <= 9 là số bậc thang. Ở mỗi bậc thang thứ k, in ra các số từ 1 đến k liền nhau:

                            n = int(input())

                            for i in range(1, n + 1):
                              for j in range(1, i + 1):
                                print(j, end='')
                              print()            # xuống dòng khi hết một bậc thang
                        

Vòng lặp for-in

• Vòng lặp for-in (không dùng range) có thể được dùng để duyệt lần lượt các phần tử của danh sách (list), xâu (string) hoặc tuble.
• Chúng ta sẽ gặp vòng lặp for này ở các bài học sau của khóa học.

Nội dung

• Xâu ký tự trong Python
• Chiều dài của xâu
• Chỉ số của các ký tự
• Cắt xâu (string slices)
• Tính bất biến của xâu
• Các phép toán trên xâu
• Duyệt xâu với vòng lặp for
• Một số hàm phổ biến với xâu
• Tìm kiếm trong xâu
• Định dạng dữ liệu trong xâu
• Biểu thức chính quy

Xâu ký tự trong Python

• Như chúng ta đã biết, kiểu dữ liệu "văn bản" trong lập trình được gọi là xâu (chuỗi) ký tự (tiếng Anh là String)
• Trong Python, một xâu ký tự có thể được tao ra bằng nhiều cách khác nhau:
• Nhập dữ liệu vào từ bàn phím với hàm input()
• Khai báo trong chương trình trong dấu nháy kép (""), hoặc nháy đơn (''), hoặc cú pháp xâu trên nhiều dòng (""" """, ''' ''')
• Kết quả của các phép toán, các hàm trên kiểu xâu ký tự: nối 2 xâu, nhân xâu với số, string.join()...
• Chuyển đổi giá trị thành kiểu xâu với hàm str()
• Đọc từ file và các nguồn dữ liệu vào khác...

Xâu ký tự trong Python - vi dụ

• Một số ví dụ tạo ra xâu trong Python:

                            name = input()
                            lastname = input()
                            template = "Hello, %s!"
                            msg = template % name
                            line = "-*" * 20
                            fullname = name + lastname
                            res = "a + b = " + str(101)
                        

Ký tự trong xâu, chiều dài xâu

• Xâu ký tự là một chuỗi liên tục các thành phần (chữ cái, chữ số, dấu cách, các dâu câu...), được gọi là các ký tự (character)
• Số lượng các ký tự trong một xâu được gọi là chiều dài (length) của xâu
• Để tính chiều dài của một xâu strong Python, ta dùng hàm len(s):

                            s = "Hello, Python!"
                            print(len(s))          # 14
                        

• Xâu trên gồm 14 ký tự: 11 chữ cái, 1 dấu cách, 1 dấy phẩy và 1 dấu chấm than

Chỉ số của các ký tự trong xâu

• Các ký tự trong xâu được đánh số từ trái qua phải, bắt đầu từ 0
• Số thứ tự của ký tự trong xâu được gọi là chỉ số (index) của ký tự trong xâu
• Như vậy, ký tự đầu tiên trong xâu s có chỉ số là 0, ký tự cuối cùng có chỉ số là len(s)-1
• Để lấy ký tự có chỉ số i của xâu s, ta dùng cú pháp: s[i]
• Khi chỉ số nằm ngoài phạm vi cho phép (lớn hơn len(s)-1), chương trình sẽ bị lỗi khi chạy

                            s = "Hello, Python!"
                            print(s[0])                 # 'H'
                            print(s[1])                 # 'e'
                            print(s[len(s)-1])          # '!'

                            # LỖI - tràn chỉ số: IndexError: string index out of range
                            print(s[len(s)])
                        

Chỉ số của các ký tự trong xâu

• Các ký tự trong xâu được đánh chỉ số từ 0 đến len(s)-1. Xem ví dụ sau:

                            s = "Hello!"
                            print(s[0])                 # 'H'
                            print(s[1])                 # 'e'
                            print(s[len(s)-1])          # '!'

                            # LỖI - tràn chỉ số: IndexError: string index out of range
                            print(s[len(s)])
                        

Chỉ số của các ký tự trong xâu - chỉ số âm

• Chỉ số của ký tự trong xâu có thể là số âm: s[-1] trả ra ký tự cuối cùng của xâu s, s[-2] - ký tự thứ 2 từ cuối...

                            s = "Hello!"
                            print(s[-1])                # '!'
                            print(s[-2])                # 'o'
                            print(s[-len(s)])           # 'H'

                            # LỖI - tràn chỉ số: IndexError: string index out of range
                            print(s[-len(s)-1])
                        

Kỹ thuật cắt xâu (string slices)

• Kỹ thuật cắt xâu được dùng để lấy ra một phần của xâu (xâu con - substring)
• Cú pháp: s[a:b]
• s[a:b] sẽ trả ra một xâu con gồm b-a ký tự, bắt đầu từ ký tự có chỉ số a đến b-1 (không bao gồm ký tự s[b])
• Cú pháp đoạn cắt này làm việc tương tự hàm range(a, b) đã học

                            s = "Hello, Python!"
                            print(s[0:5])               # 'Hello'
                            print(s[4:8])               # 'o, P'
                            print(s[-10:-6])            # 'o, P'
                            print(s[7:-2])              # 'Pytho'
                        

Kỹ thuật cắt xâu (string slices)

• s[a:b] - xâu con gồm b-a ký tự, từ a đến b-1
• Khi a bỏ trống, s[:b] sẽ mặc định lấy từ đầu xâu (a mặc định = 0)
• Khi b bỏ trống, s[a:] sẽ mặc định lấy đến cuối xâu (b mặc định = len(s))
• Đặc biệt: s[:] trả ra chính xâu s

                            s = "Hello, Python!"
                            print(s[:5])               # 'Hello'
                            print(s[:])                # 'Hello, Python!'
                            print(s[7:])               # 'Python!'
                        

Cắt xâu với bước nhảy

• s[a:b:s] - trả ra xâu gồm các ký tự có chỉ số cách nhau một khoảng cách đều s, bắt đầu từ a đến trước b
• Cú pháp đoạn cắt với bước nhảy này làm việc tương tự hàm range(a, b, s) với 3 tham số đã học
• Một số ví dụ:
  • s[::2] - trả ra các ký tự có chỉ số chẵn trong xâu
  • s[1::2] - trả ra các ký tự có chỉ số lẻ trong xâu
  • s[2:-1:2] - trả ra các ký tự có chỉ số chẵn trong xâu, bắt đầu từ s[2] và bỏ qua ký tự cuối cùng

                            s = "Hello, Python!"
                            print(s[::2])                 # 'Hlo yhn'
                            print(s[1::2])                # 'el,Pto!'
                            print(s[1:8:3])               # 'eoP'
                        

Cắt xâu với bước nhảy âm

• Tương tự hàm range(a, b, s) với 3 tham số, bước nhảy s trong cú pháp cắt xâu có thể âm
• s[a:b:-s] - trả ra xâu gồm các ký tự có chỉ số cách nhau một khoảng cách đều s, bắt đầu từ b lùi về trước a (ở đây a>b)
• Một số ví dụ:
  • s[8:2:-2] - trả ra xâu gồm các ký tự s[8], s[6], s[4]
  • s[::-1] - trả ra xâu đảo ngược của xâu s

                            s = "Hello, Python!"
                            print(s[::-2])              # '!otP,le'
                            print(s[::-1])              # '!nohtyP ,olleH'
                            print(s[8:2:-2])            # 'y o'
                            print(s[-2::-2])            # 'nhy olH'
                        

Tính bất biến của xâu trong Python

• Trong Python, một xâu sau khi đã được tạo ra thì không thể thay đổi được (immutability of string)
• Các thao tác trên xâu (cắt, lấy ký tự, các hàm trên xâu...) đều không làm thay đổi nội dung của xâu ban đầu, mà luôn tao ra một xâu mới

                            s = 'Hello'
                            t = s          # s và t cùng trỏ vào 1 xâu
                            t = s[2:4]     # tạo ra xâu mới 'll' và gán cho t
                            print(s)       # 'Hello' (s không đổi)
                            print(t)       # 'll'
                            s[0] = 'h'     # LỖI! (nội dung xâu không thể thay đổi)
                            s[0:2] = "HE"  # LỖI! (nội dung xâu không thể thay đổi)
                        

Mã (code) của các ký tự

• Mọi dữ liệu trên máy tính đều được lưu trữ dưới dạng số (chính xác hơn là số nhị phân), bao gồm cả các ký tự trong xâu
• Như vậy mỗi ký tự được lưu thành một số khác nhau, được gọi là "mã" (code) của chúng. Danh sách tất cả các mã của các ký tự được gọi là bảng mã ký tự (character table)
• Bảng mã đơn giản nhất là bảng mã ASCII gồm 256 ký tự đánh số từ 0 đến 255, trong đó có tất cả các ký tự ta có thể nhìn thấy trên bàn phím (US Keyboard) hàng ngày
• Bảng mã phổ biến nhất hiện nay là bảng mã Unicode chứa tất cả các chữ cái của hầu hết các ngôn ngữ trên thế giới, và nhiều ký tự khác như ký tự toán học, biểu tượng cảm xúc...

Mã (code) của các ký tự

• Mã của một số ký tự phổ biến trong bảng mã ASCII (cũng là 256 đầu tiên của rất nhiều các bảng mã hiện đại sau này):
  • Các chữ cái tiếng Anh in thường (a-z) có mã từ 97 đến 122
  • Các chữ cái tiếng Anh in hoa (A-Z) có mã từ 65 đến 90
  • Các chữ số (0-9) có mã từ 48 đến 57
  • Dấu cách có mã là 32
• Trong Python:
  • Để lấy mã của một ký tự nào đó, ta dùng hàm ord(ký_tự)
  • Để tạo ra một ký tự từ mã của nó, ta dùng hàm chr(mã_ký_tự)

                            print(chr(97))              # a
                            print(chr(122))             # z
                            print(ord('A'))             # 65
                            print(ord('Z'))             # 90
                            print(chr(ord('A') + 32))   # a
                            print(chr(ord('z') - 32))   # Z
                        

So sánh xâu và ký tự

• Do các ký tự tương ứng với mã của chúng (là số), nên ta có thể so sánh chúng với nhau
• Kết quả của các phép so sánh ==, !=, >, <, >=, <= chính là kết quả so sánh 2 mã tương ứng của chúng. Như vậy các phép so sánh sau trả ra True: 'z' > 'Z', 'A' > '0', 'Z' == 'Z'
• Hai xâu được so sánh với nhau bằng cách so sánh từng ký tự có cùng chỉ số của chúng, từ trái qua phải:
  • 1. So sánh 2 ký tự đầu của chúng. Nếu ký tự đầu của xâu nào có mã lớn hơn, thì xâu đó lớn hơn, nếu không (2 ký tự đầu 2 xâu bằng nhau) thì qua bước 2
  • 2. So sánh 2 ký tự thứ 2 (ký tự tiếp theo) của chúng. Xâu nào có ký tự có mã lớn hơn thì xâu đó lớn hơn, nếu không chuyển qua ký tự tiếp theo
  • 3. Cứ như vậy lần lượt so sánh các ký tự tiếp theo cho đến khi gặp ký tự mà 2 xâu khác nhau hoặc một trong hai xâu không còn ký tự nào. Khi đó:
    • Nếu gặp ký tự mà 2 xâu khác nhau, thì xâu nào có ký tự tương ứng có mã lớn hơn thì lớn hơn
    • Nếu cả 2 xâu đều không còn ký tự nào để so sánh thì 2 xâu đó bằng nhau
    • Nếu một xâu không còn ký tự nào để so sánh, xâu còn lại vẫn còn (độ dài lớn hơn), thì xâu dài hơn sẽ lớn hơn

So sánh xâu và ký tự - ví dụ

                        print('z' > 'A')              # True
                        print('A' > '9')              # True
                        print('z' == 'Z')             # False
                        print('z' != 'z')             # False
                        s = "Hello"
                        print(s == "Hello")           # True
                        print("Hell" < s)             # True
                        print("hell" < s)             # False
                        print(s != "hello")           # True
                        print("right" >= "left")      # True
                        print(s >= "")                # True
                    

Toán tử in và not in

• Toán tử in được dùng để kiểm tra xem một xâu có nằm trong một xâu khác hay không.
• Toán tử not in kiểm tra điều ngược lại: s1 not in s2 trả ra True nếu xâu s1 không có trong xâu s2

                        s = "Python thầy Thức"
                        print("Python" in s)        # True
                        print("python" in s)        # False
                        print("Thuc" not in s)      # True
                        print("Thức" not in s)      # False
                    

Duyệt qua các ký tự trong xâu bằng vòng lặp for

• Để xử lý từng ký tự trong xâu, ta có thể dùng vòng lặp for để lấy trực tiếp từng ký tự, hoặc duyệt theo từng chỉ số của ký tự trong xâu.
• Để lấy trực tiếp các ký tự của xâu s mà không cần quan tâm đến chỉ số, ta dùng cú pháp: for c in s: (c là tên biến bất kỳ).
• Ví dụ: in ra các ký tự không phải số của xâu:

                            s = "He2l3l4o834672!"
                            for c in s:
                              if c not in "0123456789":
                                print(c, end = "")

                            # kết quả:
                            # Hello!
                        

Duyệt qua các ký tự trong xâu bằng vòng lặp for

• Khi cần lấy cả chỉ số của các ký tự, ta dùng vòng lặp for-in-range để duyệt qua các chỉ số của các ký tự trong xâu.
• Nhắc lại: các ký tự trong xâu s được đánh chỉ số từ 0 đến len(s)-1, từ trái quả phải.
• Ví dụ: in ra chỉ số của các dấu cách trong xâu:

                            s = "Hello, Python. What's your latest version?"
                            for i in range(len(s)):
                              if s[i] == " ":
                                print(i, end = " ")

                            # Kết quả:
                            # 6 14 21 26 33
                        

Một số hàm phổ biến với xâu

• Các hàm dưới đây làm việc trên kiểu dữ liệu xâu ký tự
• Để gọi các hàm này trên xâu s, ta dùng cú pháp s.tên_hàm(tham_số_nếu_cần)
• Lưu ý: các hàm này tạo ra xâu mới mà không thay đổi nội dung xâu ban đầu

Tên hàm	Ý nghĩa
s.upper()	Chuyển tất cả các chữ cái trong xâu s thành chữ IN HOA
s.lower()	Chuyển tất cả các chữ cái trong xâu s thành chữ in thường
s.title()	Viết hoa các chữ cái ở đầu các từ và viết thường các ký tự khác trong xâu s
s.strip()	Xóa bỏ các khoảng trắng ở đầu và cuối xâu s
s.lstrip()	Xóa bỏ các khoảng trắng ở đầu xâu s
s.rstrip()	Xóa bỏ các khoảng trắng ở cuối xâu s
s.count(sub)	Đếm số lần xuất hiện của xâu sub trong xâu s (trả ra số nguyên)

Một số hàm phổ biến với xâu - ví dụ

• Lưu ý: các hàm này tạo ra xâu mới mà không thay đổi nội dung xâu ban đầu

                            s = "   heLllllo, pyThon!   "

                            print(s.upper())      # "   HELLLLLO, PYTHON!   "
                            print(s.lower())      # "   helllllo, python!   "
                            print(s.title())      # "   Helllllo, Python!   "
                            print(s.strip())      # "heLllllo, pyThon!"
                            print(s.lstrip())     # "heLllllo, pyThon!   "
                            print(s.rstrip())     # "   heLllllo, pyThon!"
                            print(s.count("l"))   # 4

                        

Tìm kiếm và thay thế trong xâu

• Tìm kiếm và thay thế là thao tác xử lý văn bản rất phổ biến và quan trọng trong mọi ngôn ngữ lập trình
• Trong Python có một số hàm hỗ trợ việc tìm kiếm, thay thế trong xâu như bảng bên dưới

Tên hàm	Ý nghĩa
s.find(sub)	Trả ra chỉ số (vị trí) đầu tiên bắt đầu xuất hiện xâu sub bên trong xâu s Nếu không có xâu sub trong s, trả ra -1
s.rfind(sub)	Trả ra chỉ số cuối cùng bắt đầu xuất hiện xâu sub bên trong xâu s Nếu không có xâu sub trong s, trả ra -1
s.startswith(sub)	Trả ra True nếu xâu s bắt đầu bằng xâu sub
s.endswith(sub)	Trả ra False nếu xâu s kết thúc bằng xâu sub
s.replace(s1, s2)	Trả ra xâu mới bằng cách thay thế tất cả các xâu s1 trong s thành s2

Tìm kiếm và thay thế trong xâu - ví dụ

                        s = "In the hole"
                        print(s.find("h"))               # 4
                        print(s.find("H"))               # -1
                        print(s.rfind("h"))              # 7
                        print(s.startswith("In"))        # True
                        print(s.startswith("in"))        # False
                        print(s.endswith("ole"))         # True
                        print(s.endswith("elo"))         # False
                        print(s.replace("h", "H"))       # 'In tHe Hole'
                        

Tìm kiếm và thay thế trong xâu - ví dụ

• Xóa bỏ đoạn nằm giữa chữ 'h' đầu tiên và chữ 'h' cuối cùng của xâu:

                            s = "In the hole in the ground there lived a hobbit"
                            a, b = s.find('h')
                            b = s.rfind('h')
                            s = s[:a+1] + s[b:]
                            print(s)              # 'In thhobbit'
                        

• Đảo ngược đoạn nằm giữa chữ 'h' đầu tiên và chữ 'h' cuối cùng của xâu:

                            s = "In the hole in the ground there lived a hobbit"
                            a, b = s.find('h'), s.rfind('h')
                            s = s[:a+1] + s[b-1:a:-1] + s[b:]
                            print(s)
                            # 'In th a devil ereht dnuorg eht ni eloh ehobbit'
                        

Định dạng dữ liệu trong xâu

• Trong Python có nhiều cách có thể chèn (nhúng) và định dạng dữ liệu bên trong một xâu ký tự. Chúng ta đã biết kỹ thuật sử dụng cú pháp % để nhúng giá trị vào xâu.
• Phần này giới thiệu kỹ hơn về cú pháp này, và 2 kỹ thuật mới hơn để chèn và định dạng dữ liệu trong xâu:
  • Sử dụng hàm string.format() (từ Python 2.6)
  • Sử dụng f-strings (từ Python 3.6)

Định dạng dữ liệu trong xâu

• Kỹ thuật sử dụng dấu % hỗ trợ nhúng giá trị các kiểu dữ liệu: string (%s), int (%d) và double/float (%f) vào xâu.

                            # Nhúng xâu và số nguyên
                            print("%s is %d years old." % ("Peter", 11))        # 'Peter is 11 years old.'

                            # padding (thêm khoảng trắng phía trước)
                            print("%10d" % 1024)                                # '      1024'

                            # padding (thêm số 0 phía trước)
                            print("%010d" % 1024)                               # '0000001024'

                            # Nhúng số thực - mặc định lấy 6 chữ số thập phân
                            print("pi number is %f" % (3.141592653589793))      # 'pi number is 3.141593'

                            # Lấy 3 chữ số thập phân (làm tròn)
                            print("pi number is %.3f" % (3.141592653589793))    # 'pi number is 3.142'
                            print("pi number is %.3f" % (3.1))                  # 'pi number is 3.100'

                            print("%10.3f" % (3.141592653589793))               # '     3.142'

                        

Định dạng dữ liệu trong xâu

• Sử dụng hàm string.format() được giới thiệu từ Python 2.6. Các vị trí cần chèn giá trị vào được đánh dấu bằng cặp dấu {}.
• string.format() cho phép đặt tên cho các vị trí cần chèn giá trị, và làm việc với nhiều kiểu dữ liệu hơn (ví dụ: ngày tháng...).

                            # Nhúng xâu và số nguyên
                            print("{} is {} years old.".format("Peter", 11))          # 'Peter is 11 years old.'

                            # padding (thêm khoảng trắng phía trước)
                            print("{:10d}".format(1024))                              # '      1024'

                            # padding (thêm số 0 phía trước)
                            print("%010d" % 1024)                                     # '0000001024'

                            # Nhúng số thực - mặc định lấy 6 chữ số thập phân
                            print("pi number is {:f}".format(3.141592653589793))      # 'pi number is 3.141593'

                            # Lấy 3 chữ số thập phân (làm tròn)
                            print("pi number is {:10.3f}".format(3.141592653589793))  # 'pi number is      3.142'

                            # Đặt tên cho các vị trí cần chèn
                            print("{name} is {age} years old.".format(age=12, name="John"))
                            # 'John is 12 years old.'

                            from datetime import datetime
                            print('{:%Y-%m-%d %H:%M:%S}'.format(datetime(2018, 1, 1, 12, 15, 20)))
                            # '2018-01-01 12:15:20'

                        

Định dạng dữ liệu trong xâu

• Cú pháp f-strings được giới thiệu từ Python 3.6, ngắn gọn hơn cho phép chèn giá trị biến hoặc biểu thức trực tiếp vào bên trong xâu.

                            name, age = "Peter", 11
                            r, pi = 2, 3.141592653589793

                            # Nhúng xâu và số nguyên
                            print(f"{name} is {age} years old.")            # 'Peter is 11 years old.'

                            # padding (thêm khoảng trắng/số 0 phía trước)
                            print(f"{age:10}")                              # '        11'
                            print(f"{age:010}")                             # '0000000011'

                            # Nhúng số thực - mặc định lấy 6 chữ số thập phân
                            print(f"pi number is {pi:10.4}")                # 'pi number is      3.142'

                            # Nhúng biểu thức
                            print(f"Diện tích hình tròn bán kính {r} = {pi*r*r:.3}")
                            # 'Diện tích hình tròn bán kính 2 = 12.6'

                            # Ngày tháng
                            from datetime import datetime
                            today = datetime(year=2018, month=1, day=31)
                            print(f"{today:%B %d, %Y}")                     # 'January 31, 2018'
                        

Biểu thức chính quy (Regular expressions)

• Biểu thức chính quy là kỹ thuật cao cấp hơn để xử lý xâu
• Biểu thức chính quy có trong hầu hết các ngôn ngữ lập trình hiện đại
• Được sử dụng trong các tác vụ tìm kiếm, thay thế phức tạp hơn so với các hàm xử lý xâu thông thường
• Kỹ thuật sử dụng biểu thức chính quy nằm ngoài phạm vi của khóa học cơ bản. Bạn đọc quan tâm có thể tự tìm hiểu thêm ở đây.

Nội dung

Ngôn ngữ lập trình Pascal

• Ra đời năm 1970, là ngôn ngữ lập trình kinh điển cho thế hệ 8x, 9x
• Khá phù hợp và rất phổ biến trong các trường học cho môn tin học, cấu trúc dữ liệu & giải thuật
• Hiện nay hầu như không được sử dụng đến trong các ứng dụng thực tế
• Lý do duy nhất còn cần đến Pascal: hiện vẫn là ngôn ngữ bắt buộc trong các cuộc thi học sinh giỏi tin học khối THCS tại Việt Nam

Môi trường làm việc

• Môi trường phổ biến trong thi cử: Free Pascal → cần phải thành thạo!
• Công cụ thuận tiện hơn: Charm Pascal
• Công cụ chuyên nghiệp (và phức tạp) hơn: Lazarus IDE
• Môi trường nộp bài trong khóa học: Hackerrank

Hello, Pascal!

                                    print("Hello, Python!")
                                

                                    begin
                                        writeln('Hello, Pascal!');
                                        readln;
                                    end.
                                

• Chương trình Pascal cần nằm giữa begin và end. (lưu ý dấu chấm sau chữ end)
• Kết thúc mỗi lệnh trong Pascal cần một dấu chấm phẩy (;)
• Lùi đầu dòng cho các lệnh trong Pascal là khuyến khích nhưng không bắt buộc.
• Xâu ký tự trong Pascal được đặt trong cặp dấu nháy đơn ('...')
• Pascal là ngôn ngữ không phân biệt hoa - thường (có thể viết begin, Begin, hoặc BEGIN đều được)

Biến trong Pascal

                                    a = 12
                                    b = 34.5
                                    print(a)
                                    print(b)
                                

                                    var a : integer;
                                        b : real;
                                    begin
                                        a := 12;
                                        b := 34.5;
                                        writeln(a);
                                        writeln(b);
                                        readln;
                                    end.
                                

• Biến trong Pascal cần được khai báo trước thân chương trình bằng từ khóa var trước khi được sử dụng.
• Khi khai báo biến, cần chỉ ra kiểu dữ liệu của biến (interger, real trong ví dụ trên)
• Để gán giá trị cho biến trong Pascal, ta dùng ký hiệu := (phép gán trong Python là =)
• Pascal là ngôn ngữ không phân biệt hoa - thường (có thể viết integer, Integer, hoặc INTEGER đều được)

Các kiểu dữ liệu cơ bản trong Pascal

Các phép toán số học

Các phép toán so sánh

Các phép toán logic

Các phép toán với xâu ký tự

Một số hàm có sẵn trong Pascal

Chú thích trong Pascal

• Chú thích là các đoạn giải thích giúp người đọc chương trình dễ hiểu hơn
• Chú thích chỉ có tác dụng với người đọc, máy tính sẽ bỏ qua các chú thích khi biên dịch/thực thi chương trình

//...

#...

{...} hoặc (*...*)

{
...
...
}
hoặc
(*
...
...
*)

#...
#...
#...

Thứ tự ưu tiên của các phép trong Pascal

Trong Pascal, các phép toán được thực hiện theo thứ tự ưu tiên như sau (phép toán liệt kê trước được thực hiện trước):

• Lời gọi hàm
• Dấu ngoặc: ()
• Phép toán một ngôi (một toán hạng): NOT, -
• Các phép toán: *, /, DIV, MOD, AND
• Các phép toán: +, -, OR, XOR
• Các phép so sánh: =, <, >, <=, >=, <>, IN

Xuất (in ra) dữ liệu trong Pascal

writeln(a);

print(a)

write(a);

print(a, end='')

writeln(a, b);

print(a, b, sep='')

writeln(a, ' ', b);

print(a, b)

Xuất (in ra) dữ liệu trong Pascal (tiếp)

writeln(a: 10);

print("%10d" % a)

writeln(a: 20);

print("%20s" % a)

writeln(x:0:2);

print("%.2f" % x)

Nhập dữ liệu trong Pascal

                                    var s: String;
                                    ...
                                    readln(s);

s = input()

                                    var s: String;
                                    ...
                                    write('Nhập vào s: ');
                                    readln(s);

s = input('Nhập vào s: ')

                                    var a: Integer;
                                    ...
                                    readln(a);

a = int(input())

                                    var x: Real;
                                    ...
                                    readln(x);

x = float(input())

Nhập dữ liệu trong Pascal (tiếp)

                                    var a, b, c: Integer;
                                    ...
                                    readln(a, b, c);
                                

                                a, b, c = [int(s) for s in input().split()]

                                    var a, b: Integer;
                                    ...
                                    // nhập số a,
                                    // nhưng chưa xuống dòng
                                    read(a);
                                    // sau đó nhập b,
                                    // rồi xuống dòng
                                    readln(b);
                                

                                a, b = list(map(int, input().split()))

                                    readln();
                                

                                input()

Câu lệnh rẽ nhánh IF trong Pascal

                                    if điều_kiện then begin
                                       ...
                                    end;
                                

                                    if điều_kiện:
                                       ...
                                

                                    if điều_kiện then begin
                                       khối_lệnh_1
                                    end
                                    else begin
                                       khối_lệnh_2
                                    end;
                                

                                    if điều_kiện:
                                       khối_lệnh_1
                                    else:
                                       khối_lệnh_2
                                

Lưu ý:

• Lùi đầu dòng là bắt buộc với Python, nhưng không bắt buộc với Pascal.
• Trước từ khóa else trong Pascal KHÔNG ĐƯỢC có dấu chấm phẩy (;).

Câu lệnh rẽ nhánh IF trong Pascal (tiếp)

                                    if điều_kiện_1 then begin
                                       khối_lệnh_1
                                    end
                                    else if điều_kiện_2 then begin
                                       khối_lệnh_2
                                    end
                                    else begin
                                       khối_lệnh_3
                                    end;
                                

                                    if điều_kiện_1:
                                       khối_lệnh_1
                                    elif điều_kiện_2:
                                       khối_lệnh_2
                                    else:
                                       khối_lệnh_3
                                

Lưu ý:

• Lùi đầu dòng là bắt buộc với Python, nhưng không bắt buộc với Pascal.
• Trước từ khóa else trong Pascal KHÔNG ĐƯỢC có dấu chấm phẩy (;).

Câu lệnh rẽ nhánh CASE trong Pascal

                                    case biểu_thức of
                                        giá_trị_1: lệnh_1;
                                        giá_trị_2: lệnh_2;
                                        giá_trị_3: lệnh_3;
                                        ...
                                        giá_trị_n: lệnh_n;
                                    else lệnh_n+1
                                    end;
                                

                                    if biểu_thức == giá_trị_1:
                                       lệnh_1
                                    elif biểu_thức == giá_trị_2:
                                       lệnh_2
                                    ...
                                    elif biểu_thức == giá_trị_n:
                                       lệnh_n
                                    else:
                                       lệnh_n+1
                                

Lưu ý với lệnh CASE trong Pascal:

• biểu_thức phải là kiểu đếm được (số nguyên, ký tự, boolean, liệt kê)
• Các giá_trị_i phải là hằng số (không được chứa biến)
• Các lệnh_i nếu bao gồm nhiều lệnh, phải đặt trong khối begin...end;

Vòng lặp FOR trong Pascal

                                    for i := 1 to n do begin
                                       ...
                                    end;
                                

                                    for i in range(1, n+1):
                                       ...
                                

                                    for i := n downto 1 do begin
                                       ...
                                    end;
                                

                                    for i in range(n, 0, -1):
                                       ...
                                

Lưu ý:

• Lùi đầu dòng là bắt buộc với Python, nhưng không bắt buộc với Pascal.
• Biến lặp i phải có kiểu số nguyên và cũng cần được khai báo trước.
• Vòng lặp FOR trong Pascal không được linh hoạt như Python. Pascal chỉ có 2 kiểu lặp FOR là lặp tiến - TO (tăng dần 1 đơn vị) và lặp lùi - DOWNTO (giảm dần 1 đơn vị). Nếu cần lặp phức tạp hơn, có thể dùng WHILE hoặc REPEAT.

Vòng lặp WHILE trong Pascal

                                    while điều_kiện do begin
                                       ...
                                    end;
                                

                                    while điều_kiện:
                                       ...
                                

Lưu ý:

• Vòng lặp WHILE trong Pascal và Python hoạt động hoàn toàn tương tự nhau, với ý nghĩa: Khi điều_kiện còn ĐÚNG, thì còn thực thi thân vòng lặp.
• Lùi đầu dòng là bắt buộc với Python, nhưng không bắt buộc với Pascal.
• Giống như điều kiện trong câu lệnh IF, điều_kiện có kiểu boolean (chỉ có 2 giá trị True hoặc False), và có thể kết hợp các phép toán logic (and, or, not) để tạo thành điều kiện phức tạp hơn.

Vòng lặp REPEAT trong Pascal

                                    repeat
                                       ...
                                    until điều_kiện;
                                

                                    KHÔNG CÓ
                                

Lưu ý:

• Ý nghĩa của vòng lặp REPEAT: Thực thi thân vòng lặp cho đến khi điều_kiện ĐÚNG, khi điều_kiện còn SAI thì còn lặp lại tiếp.
• Câu lệnh REPEAT đã được đánh dấu kết thúc bằng UNTIL, nên không cần BEGIN và END
• điều_kiện là biểu thức kiểu boolean.

So sánh vòng lặp REPEAT và WHILE

• Giống nhau: đều dựa vào điều_kiện để quyết định tiếp tục hay kết thúc vòng lặp
• WHILE kiểm tra điều kiện trước khi thực hiện câu lệnh trong thân vòng lặp; còn REPEAT thực hiện thân vòng lặp xong mới kiểm tra điều kiện.
• Do vậy thân vòng lặp REPEAT sẽ luôn được thực hiện ít nhất một lần, điều này không đúng với vòng lặp WHILE, thân vòng lặp WHILE có thể không được thực hiện lần nào.
• Vòng lặp WHILE sẽ tiếp tục lặp khi điều kiện còn ĐÚNG; còn vòng lặp REPEAT sẽ tiếp tục lặp khi điều kiện còn SAI. Nói cách khác, vòng lặp WHILE sẽ dừng lại khi điều kiện SAI; còn REPEAT sẽ dừng lại khi điều kiện ĐÚNG.

Các câu lệnh điều khiển vòng lặp

                                    break;
                                

                                    break
                                

                                    continue;
                                

                                    continue
                                

Lưu ý:

• Các câu lệnh break và continue áp dụng cho tất cả 3 loại vòng lặp: FOR, WHILE và REPEAT.
• Nếu các vòng lặp lồng nhau, câu lệnh break và continue chỉ có tác dụng với vòng lặp trong cùng.
• Câu lệnh break còn có tác dụng chấm dứt cả câu lệnh rẽ nhánh case ... of

Kiểu dữ liệu mảng (array)

• Một mảng trong Pascal xác định một danh sách các phần tử CÙNG KIỂU, với SỐ LƯỢNG PHẦN TỬ CỐ ĐỊNH
• Mảng trong Pascal là kiểu dữ liệu tự định nghĩa, ta định nghĩa kiểu dữ liệu mảng bằng từ khóa TYPE. Ví dụ sau định nghĩ kiểu dữ liệu mảng số nguyên gồm 100 phần tử, và khai báo hai mảng a và b có kiểu dữ liệu mới này:

                            TYPE myArray = array[0..99] of INTEGER;
                            VAR  a, b: myArray;
                        

• Phần [0..99] là phần định nghĩa chỉ số của mảng. Trong Pascal, chỉ số có thể là bất kỳ kiểu dữ liệu đếm được nào. Tuy nhiên để tương thích với các ngôn ngữ khác, trừ các trường hợp đặc biệt cần thiết, ta nên chọn chỉ số là số nguyên bắt đầu từ 0.
• Có thể khai báo trực tiếp mảng mà không cần đến TYPE, tuy nhiên luôn luôn dùng TYPE để khai báo kiểu mảng trước khi sử dụng là một thói quen tốt.

Kiểu dữ liệu mảng (tiếp)

• Cú pháp tổng quát để định nghĩa kiểu dữ liệu mảng và khai báo biến với kiểu dữ liệu này như sau:

                            TYPE
                                tên_kiểu_DL = array[kiểu_chỉ_số] of kiểu_DL_của_phần_tử;

                            VAR
                                tên_biến: tên_kiểu_DL;
                        

• Trong đó:
• tên_kiểu_DL là tên tự chọn, tuân theo quy tắc đặt tên biến
• kiểu_DL_của_phần_tử là kiểu dữ liệu của các phần tử của mảng. LƯU Ý: Trong Pascal, tất cả các phần tử của mảng phải có cùng một kiểu dữ liệu.
• kiểu_chỉ_số khai báo loại chỉ số của kiểu dữ liệu mới này. Trong Pascal, kiểu chỉ số này có thể là bất kỳ kiểu dữ liệu đếm được nào. Phổ biến nhất là kiểu đoạn con, bao gồm một đoạn các số nguyên, ví dụ:

                                TYPE
                                    myArray1 = array[1..25] of Int64;
                                    myArray2 = array[0..100] of Boolean;
                                    myArray3 = array[-10..10] of Double;
                            

Sử dụng mảng trong Pascal

• Các phần tử của mảng được truy xuất (lấy giá trị hoặc gán giá trị) bằng chỉ số, theo cú pháp: a[i], với a là tên biến kiểu mảng, i là chỉ số của phần tử cần truy xuất.
• Để duyệt các phần tử của mảng, ta dùng các vòng lặp, phổ biến nhất là vòng lặp FOR.
• Ví dụ chương trình sau in ra màn hình 100 số chính phương đầu tiên, mỗi số trên một dòng:

                            TYPE myArray = array[0..99] of Int64;
                            VAR  a: myArray;
                                 i : Integer;
                            BEGIN
                                FOR i := 0 TO 99 DO
                                    a[i] := i*i;
                                WriteLn('Result:');
                                FOR i := 0 TO 99 DO
                                    WriteLn(a[i]);
                            END.
                        

Mảng trong Pascal vs danh sách trong Python

• Đều là kiểu dữ liệu có cấu trúc, dùng để chứa một danh sách các giá trị có thể được duyệt bằng vòng lặp. Tuy nhiên so với danh sách trong Python, mảng trong Pascal hạn chế hơn rất nhiều. Một số điểm cần lưu ý: