3.-an-informal-introduction-to-python.md

description
[email protected]

3. Giới thiệu không chính thức về Python

Trong các ví dụ sau, đầu vào và đầu ra được phân biệt bằng sự hiện diện hoặc vắng mặt của các lời nhắc (>>> và …): để lặp lại ví dụ, bạn phải nhập mọi thứ sau dấu nhắc, khi lời nhắc xuất hiện; các dòng không bắt đầu bằng dấu nhắc là đầu ra từ trình thông dịch.

Nhiều ví dụ trong hướng dẫn này, kể cả những ví dụ được nhập vào tại dấu nhắc tương tác, bao gồm các bình luận. Nhận xét trong Python bắt đầu bằng ký tự băm # và mở rộng đến cuối dòng vật lý. Nhận xét (comment) có thể xuất hiện ở đầu dòng hoặc sau khoảng trắng hoặc code, nhưng không xuất hiện trong chuỗi ký tự. Một ký tự băm trong một chuỗi ký tự chỉ là một ký tự băm. Vì các chú thích phải làm rõ code và không được Python giải thích, chúng có thể bị bỏ qua khi gõ vào các ví dụ.

Một số ví dụ:

# Đây là comment đầu tiên 
spam = 1  # và đây là comment thứ hai
          # ... và giờ là thứ ba!
text = "# Đây không phải là comment vì nó nằm trong dấu ngoặc kép."

3.1. Sử dụng Python như một máy tính

Hãy thử một số lệnh Python đơn giản. Khởi động trình thông dịch và đợi lời nhắc chính, >>>. (Sẽ không mất nhiều thời gian.)

3.1.1. Numbers

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 một biểu thức vào nó và nó sẽ viết giá trị. Cú pháp biểu thức rất đơn giản: các toán tử +, -, * và / làm việc giống như trong hầu hết các ngôn ngữ khác (ví dụ, Pascal hoặc 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ân chia luôn trả về một số dấu phẩy nổi
1.6

Các số nguyên (ví dụ: 2, 4, 20) có kiểu dữ liệu int, các số nguyên có phần phân số (ví dụ: 5.0, 1.6) có kiểu dữ liệu float. Chúng ta sẽ xem thêm về các kiểu số sau trong hướng dẫn này. Phép chia (/) luôn trả về một số thực. Để thực hiện phép chia và nhận kết quả nguyên (loại bỏ bất kỳ kết quả phân số nào), bạn có thể sử dụng toán tử //; để tính phần còn lại, bạn có thể sử dụng %:

>>> 17 / 3  # phép chia bình thường trả về một số thực
5.666666666666667
>>>
>>> 17 // 3  # phép chia loại bỏ phần dư
5
>>> 17 % 3  # toán tử % trả về phần dư của phép chia
2
>>> 5 * 3 + 2  # kết quả_  số bị chia + số dư
17

Với Python, có thể sử dụng toán tử ** để tính toán các quyền hạn [1]:

>>> 5 ** 2  # 5 mũ 2
25
>>> 2 ** 7  # 2 mũ 7
128

Dấu bằng (=) được sử dụng để gán một giá trị cho một biến. Sau đó, không có kết quả nào được hiển thị trước dấu nhắc tương tác tiếp theo:

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

Nếu một biến không phải là “được định nghĩa” (gán một giá trị), cố gắng sử dụng nó sẽ cho bạn một lỗi:

>>> n  # cố gắng truy cập biến không xác định
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Có hỗ trợ đầy đủ cho điểm nổi; 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 thành dấu phẩy động:

>>> 4 * 3.75 - 1
14.0

Trong chế độ tương tác, biểu thức được in cuối cùng được gán cho biến _. Điều này có nghĩa rằng khi bạn đang sử dụng Python như một máy tính bàn, nó sẽ dễ dàng hơn để tiếp tục tính toán, ví dụ:

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

Biến này cần được xử lý dưới dạng chỉ đọc bởi người dùng. Không chỉ định rõ ràng giá trị cho nó - bạn sẽ tạo một biến cục bộ độc lập có cùng tên che giấu biến tích hợp với hành vi ma thuật của nó. Ngoài int và float, Python hỗ trợ các kiểu số khác, chẳng hạn như Decimal (thập phân) và Fraction (phân số). Python cũng có hỗ trợ tích hợp cho các số phức và sử dụng hậu tố j hoặc J để biểu thị phần ảo (ví dụ: 3 + 5j).

3.1.2. Strings

Bên cạnh các số, Python cũng có thể thao tác các chuỗi, có thể được biểu diễn theo nhiều cách. Chúng có thể được đặt trong dấu nháy đơn ('...') hoặc dấu ngoặc kép ("...") với cùng kết quả [2]. \ có thể được sử dụng để thoát khỏi dấu ngoặc kép:

>>> 'spam eggs'  # dòng nháy đơn
'spam eggs'
>>> 'doesn\'t'  # sử dụng `\'` để thoát khỏi trích dẫn
"doesn't"
>>> "doesn't"  # ... hoặc sử dụng dấu ngoặc kép thay thế
"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 đầu ra được đính kèm trong dấu ngoặc kép và các ký tự đặc biệt được thoát bằng dấu gạch chéo ngược. Trong khi điều này đôi khi có thể trông khác với đầu vào (dấu ngoặc đơn kèm theo có thể thay đổi), hai chuỗi là tương đương nhau. Chuỗi được đặt trong dấu ngoặc kép nếu chuỗi chứa một dấu trích dẫn duy nhất và không có dấu ngoặc kép, nếu không nó sẽ được bao trong dấu nháy đơn. Hàm print () tạo ra một đầu ra dễ đọc hơn, bằng cách bỏ qua các dấu ngoặc kép kèm theo và bằng cách in các ký tự thoát và ký tự đặc biệt:

>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print('"Isn\'t," she said.')
"Isn't," she said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a new line
First line.
Second line.

Nếu bạn không muốn các ký tự được bắt đầu bằng \ để được hiểu là các ký tự đặc biệt, bạn có thể sử dụng các chuỗi thô bằng cách thêm dấu r trước trích dẫn đầu tiên:

>>> print('C:\some\name')  # đây \n có nghĩa là dòng mới!
C:\some
ame
>>> print(r'C:\some\name')  # ghi chú r trước trích dẫn
C:\some\name

Chuỗi chữ có thể kéo dài nhiều dòng. Một cách là sử dụng dấu ngoặc kép: "" "..." "" hoặc '' '...' ''. Kết thúc các dòng được 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 \ ở cuối dòng. Ví dụ:

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

tạo đầu ra sau (lưu ý rằng dòng mới ban đầu không được bao gồm):

Usage: thingy [OPTIONS]
     -h                        Hiển thị thông báo sử dụng này
     -H hostname               Hostname kết nối tới

Các chuỗi có thể được nối (dán lại với nhau) với toán tử + và lặp lại với *:

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

Hai hoặc nhiều chuỗi ký tự (tức là các ký tự được đặt giữa các dấu ngoặc kép) cạnh nhau được tự động nối.

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

Tính năng này đặc biệt hữu ích khi bạn muốn ngắt chuỗi dài:

>>> text = ('Đặt một số chuỗi trong dấu ngoặc đơn '
...         'để chúng kết hợp với nhau.')
>>> text
'Đặt một số chuỗi trong dấu ngoặc đơn để chúng kết hợp với nhau..'

Điều này chỉ hoạt động với hai chữ cái, không phải với các biến hoặc biểu thức:

>>> prefix = 'Py'
>>> prefix 'thon'  # không thể nối một biến và một chuỗi ký tự
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

Nếu bạn muốn ghép các biến hoặc một biến và một chữ, hãy sử dụng dấu +:

>>> prefix + 'thon'
'Python'

Các chuỗi có thể được lập chỉ mục (chỉ số con), với ký tự đầu tiên có chỉ mục 0. Không có loại ký tự riêng biệt; một ký tự đơn giản chỉ là một chuỗi có kích thước:

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

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

>>> word[-1]  # kí tự ở vị trí cuối cùng
'n'
>>> word[-2]  # kí tự ở vị trí cạnh vị trí cuối cùng
'o'
>>> word[-6]
'P'

Lưu ý rằng vì -0 giống với 0, các chỉ số âm tính bắt đầu từ -1. Ngoài việc lập chỉ mục, việc cắt cũng được hỗ trợ. Trong khi lập chỉ mục được sử dụng để lấy các ký tự riêng lẻ, việc cắt cho phép bạn lấy chuỗi con:

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

Lưu ý cách bắt đầu luôn được bao gồm và kết thúc luôn bị loại trừ. Điều này đảm bảo rằng s [: i] + s [i:] luôn bằng s:

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

Các chỉ mục slice có các giá trị mặc định hữu ích; một chỉ mục đầu tiên bị bỏ qua mặc định là 0, chỉ mục thứ hai bị bỏ qua mặc định là kích thước của chuỗi bị cắt.

>>> word[:2]   # loại trừ kí tự từ đầu đến vị trí 2
'Py'
>>> word[4:]   # bao gồm các kí tự từ vị trí 4 đến cuối
'on'
>>> word[-2:]  # bao gồm các kí tự từ vị trí cạnh cuối đến cuối cùng
'on'

Một cách để nhớ cách các slice hoạt động như thế nào khi nghĩ đến các chỉ mục như chỉ giữa các ký tự, với cạnh trái của ký tự đầu tiên được đánh số 0. Sau đó, cạnh phải của ký tự cuối cùng của một chuỗi ký tự n có chỉ mục 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ố cho vị trí của các chỉ số 0…6 trong chuỗi; hàng thứ hai cung cấp cho các chỉ âm tương ứng. Cắt từ i đến j bao gồm tất cả các ký tự giữa các cạnh có nhãn i và j, tương ứng. Đối với các chỉ số không âm, chiều dài của một phần là sự khác biệt của các chỉ số, nếu cả hai đều nằm trong giới hạn. Ví dụ: độ dài của từ word[1:3] là 2. Cố gắng sử dụng mục quá lớn sẽ dẫn đến 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, ngoài phạm vi, mục được xử lý một cách duyên dáng khi được sử dụng để cắt:

>>> word[4:42]
'on'
>>> word[42:]
''

Các chuỗi Python không thể thay đổi - chúng không thay đổi được. Do đó, việc gán cho một vị trí được lập chỉ mục trong chuỗi sẽ dẫn đến một 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 bạn cần một chuỗi khác, bạn nên tạo một chuỗi mới:

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

Hàm dựng sẵn len trả về độ dài của một chuỗi:

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

3.1.3. Lists

Python nhận biết một số kiểu dữ liệu phức hợp, được sử dụng để nhóm các giá trị khác lại với nhau. Linh hoạt nhất là danh sách, có thể được viết dưới dạng danh sách các giá trị được phân tách bằng dấu phẩy (các mục) giữa các dấu ngoặc vuông. Danh sách có thể chứa các mục thuộc nhiều loại khác nhau, nhưng thường tất cả các mục đều có cùng loại.

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

Giống như chuỗi (và tất cả các loại trình tự tích hợp khác), danh sách có thể được lập chỉ mục và mục:

>>> squares[0]  # lập chỉ mục trả về mục
1
>>> squares[-1]
25
>>> squares[-3:]  # mục trả về một danh sách mới
[9, 16, 25]

Tất cả các thao tác mục trả về một danh sách mới chứa các phần tử được yêu cầu. Điều này có nghĩa là mục sau trả về một bản sao mới của danh sách:

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

Danh sách cũng hỗ trợ các hoạt động như nối:

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

Không giống như chuỗi, không thay đổi, danh sách là loại có thể thay đổi, tức là có thể thay đổi nội dung của chúng:

>>> cubes = [1, 8, 27, 65, 125]  # Có gì đó sai ở đây
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # thay thế giá trị sai
>>> cubes
[1, 8, 27, 64, 125]

Bạn cũng có thể thêm các mục mới vào cuối danh sách, bằng cách sử dụng phương thức append () (chúng ta sẽ xem thêm về các phương thức sau):

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

Chuyển nhượng cho mục cũng có thể, và điều này thậm chí có thể thay đổi kích thước của danh sách hoặc 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ế một số giá trị
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # bây giờ loại bỏ chúng
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # xóa danh sách bằng cách thay thế tất cả các phần tử bằng danh sách trống
>>> letters[:] = []
>>> letters
[]

Hàm len () cũng được áp dụng cho các danh sách:

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

Có thể lồng danh sách (tạo danh sách chứa danh sách khác), ví dụ:

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

3.2. Các bước đầu tiên hướng tới lập trình

Tất nhiên, chúng ta có thể sử dụng Python cho các nhiệm vụ phức tạp hơn là thêm hai và hai với nhau. Ví dụ, chúng ta có thể viết một chuỗi con đầu tiên của dãy Fibonacci như sau:

>>> # Chuỗi Fibonacci:
... # Tổng của hai yếu tố xác định
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

Ví dụ này giới thiệu một số tính năng mới.

• Dòng đầu tiên chứa một phép gán nhiều: các biến a và b đồng thời lấy các giá trị mới 0 và 1. Trên dòng cuối cùng, nó được sử dụng một lần nữa, chứng minh rằng các biểu thức ở phía bên tay phải được đánh giá đầu tiên trước bất kỳ bài tập nào. diễn ra. Các biểu thức bên phải được đánh giá từ trái sang phải.
• Vòng lặp while thực thi chỉ cần điều kiện (ở đây: b <10) vẫn đúng. Trong Python, giống như trong C, bất kỳ giá trị số nguyên khác không là đúng; số không là sai. Các điều kiện cũng có thể là một chuỗi hoặc danh sách giá trị, trên thực tế bất kỳ trình tự; bất kỳ điều gì có độ dài khác 0 là đúng, các chuỗi rỗng là sai. Thử nghiệm được sử dụng trong ví dụ này là so sánh đơn giản. Toán tử so sánh chuẩn được viết giống như trong C: < (nhỏ hơn), > (lớn hơn), == (bằng), <= (nhỏ hơn hoặc bằng), > = (lớn hơn hoặc bằng) và ! = (không bằng).
• Phần thân của vòng lặp được thụt vào: thụt đầu dòng là cách thức phân nhóm của Python. Tại dấu nhắc tương tác, bạn phải nhập một tab hoặc (các) khoảng trống cho mỗi dòng thụt vào. Trong thực tế, bạn sẽ chuẩn bị đầu vào phức tạp hơn cho Python với một trình soạn thảo văn bản; tất cả các trình soạn thảo văn bản đều có cơ sở thụt lề tự động. Khi một câu lệnh ghép được nhập tương tác, nó phải được theo sau bởi một dòng trống để biểu thị hoàn thành (vì trình phân tích cú pháp không thể đoán được khi bạn đã gõ dòng cuối cùng). Lưu ý rằng mỗi dòng trong một khối cơ bản phải được thụt vào cùng một khoảng cách.
• Hàm print () ghi giá trị của các đối số (s) nó được đưa ra. Nó khác với việc viết biểu thức bạn muốn viết (như chúng ta đã làm trước đó trong ví dụ về máy tính) theo cách nó xử lý nhiều đối số, số lượng dấu chấm động và chuỗi. Các chuỗi được in không có dấu ngoặc kép và khoảng trắng được chèn vào giữa các mục, vì vậy bạn có thể định dạng mọi thứ một cách độc đáo, như sau:

>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536

Kết thúc đối số từ khóa có thể được sử dụng để tránh dòng mới sau đầu ra hoặc kết thúc đầu ra bằng một chuỗi khác:

>>> a, b = 0, 1
>>> while b < 1000:
...     print(b, end=',')
...     a, b = b, a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Chú thích

[1] Vì ** có ưu tiên cao hơn -, -3 ** 2 sẽ được hiểu là - (3 ** 2) và do đó dẫn đến -9. Để tránh điều này và nhận được 9, bạn có thể sử dụng (-3) ** 2.

[2] Không giống như các ngôn ngữ khác, các ký tự đặc biệt như \n có cùng ý nghĩa với cả dấu nháy đơn ('...') và dấu ngoặc kép ("..."). Sự khác biệt duy nhất giữa hai điều này là trong một dấu nháy đơn bạn không cần phải thoát "(nhưng bạn phải thoát \') và ngược lại.