Python là một trong những ngôn ngữ lập trình phổ biến nhất thế giới hiện nay. Nó được tạo ra vào năm 1991 bởi Guido van Rossum
Theo van Rossum, Python là một
“ngôn ngữ lập trình cấp cao và triết lý thiết kế cốt lõi của nó là tất cả về khả năng đọc mã và cú pháp cho phép các lập trình viên diễn đạt các khái niệm trong một vài dòng mã. ”
Lợi ích của việc học Python
Python là một trong những ngôn ngữ đơn giản nhất mà bạn có thể học và làm việc cùng. Bạn có thể sử dụng nó để phát triển phần mềm, phát triển web phía máy chủ, học máy, toán học và bất kỳ loại tập lệnh nào mà bạn có thể nghĩ ra
Điểm hay của Python là nó được sử dụng rộng rãi và được chấp nhận bởi nhiều công ty và tổ chức học thuật. Điều này làm cho nó trở thành một lựa chọn thực sự tốt, đặc biệt nếu bạn mới bắt đầu hành trình viết mã của mình
Python cũng có một cộng đồng lớn các nhà phát triển sử dụng nó và sẵn sàng giúp đỡ bạn nếu bạn gặp khó khăn hoặc có thắc mắc. Cộng đồng này đã xuất bản nhiều thư viện mã nguồn mở mà bạn có thể bắt đầu sử dụng. Họ cũng tích cực tiếp tục cải thiện chúng
Cú pháp của Python khá giống với tiếng Anh nên bạn dễ hiểu và sử dụng khá trực quan
Python chạy trên một hệ thống thông dịch, nghĩa là bạn không cần phải đợi trình biên dịch biên dịch mã rồi thực thi nó. Thay vào đó, bạn có thể xây dựng nguyên mẫu một cách nhanh chóng
Nó cũng hoạt động trên các nền tảng khác nhau, chẳng hạn như Windows, Linux, Mac, Raspberry Pi, v.v.
Vì vậy, bạn thấy đấy – đó là một ngôn ngữ lập trình tuyệt vời, cho dù bạn mới bắt đầu hay bạn đang muốn thêm một công cụ hữu ích khác vào bộ công cụ của mình
Đây là những gì chúng tôi sẽ trình bày trong cuốn sách này
Mục lục
Thụt lề trong Python
So với các ngôn ngữ khác, Python đặc biệt coi trọng việc thụt đầu dòng
Trong các ngôn ngữ lập trình khác, khoảng trắng và thụt đầu dòng chỉ được sử dụng để làm cho mã dễ đọc hơn và đẹp hơn. Nhưng trong Python, chúng đại diện cho một khối mã con
Đoạn mã sau sẽ không hoạt động vì dòng thứ hai không đúng mục đích
if 100 > 10:
print["100 is greater than 10"]
Để nó hoạt động bình thường, vết lõm sẽ giống như sau
if 100 > 10:
print["100 is greater than 10"]
Điều này có vẻ khó hiểu, nhưng bạn có thể sử dụng trình chỉnh sửa mã làm nổi bật các lỗi cú pháp đó khá sinh động. Hơn nữa, bạn càng viết nhiều mã Python, bạn càng dễ dàng coi những vết lõm như vậy là bản chất thứ hai.
Theo mặc định, Python sử dụng bốn khoảng trắng để thụt lề thích hợp
Bình luận trong Python
Chúng tôi sử dụng các nhận xét để chỉ định các phần của chương trình mà trình thông dịch Python sẽ bỏ qua và không được thực thi. Điều này có nghĩa là mọi thứ được viết bên trong nhận xét hoàn toàn không được xem xét và bạn có thể viết bằng bất kỳ ngôn ngữ nào bạn muốn, kể cả ngôn ngữ mẹ đẻ của bạn
Trong Python, bạn bắt đầu một bình luận với ký hiệu # phía trước dòng
# This is a comment in Python
Bạn cũng có thể bao gồm nhiều nhận xét mở rộng hơn trong nhiều dòng bằng cách sử dụng ba dấu ngoặc kép
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
phương thức print[] trong Python
Chúng tôi sẽ sử dụng phương pháp
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
20 vì nó giúp chúng tôi xem kết quả trong bảng điều khiểnBạn không cần biết nó hoạt động như thế nào đằng sau hậu trường hoặc thậm chí biết phương pháp đó là gì ngay bây giờ. Chỉ cần nghĩ về nó như một cách để chúng tôi hiển thị kết quả từ mã của chúng tôi trong bảng điều khiển
Toán tử trong PythonToán tử số học trong Python
Mặc dù bạn chỉ cần lấy điện thoại ra khỏi túi và thực hiện một số phép tính, nhưng bạn cũng nên làm quen với việc triển khai một số toán tử số học trong Python
Khi chúng ta muốn cộng hai số, chúng ta sử dụng dấu cộng, giống như trong toán học
print[50 + 4] # 54
Tương tự, đối với phép trừ, chúng ta sử dụng dấu trừ
print[50 - 4] # 46
Để nhân, chúng tôi sử dụng dấu sao hoặc dấu hoa thị
print[50 * 4] # 200
Khi thực hiện phép chia ta dùng dấu gạch chéo
________số 8Điều này dẫn đến số float. Nếu muốn chỉ lấy số nguyên khi thực hiện phép chia [hay còn gọi đơn giản là chia tầng] thì ta dùng dấu phân số kép
print[50 // 4] # 12
print[8 / 4] # 2
Chúng ta cũng có thể tìm phần còn lại của một số chia cho một số khác bằng cách sử dụng dấu phần trăm
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
21if 100 > 10:
print["100 is greater than 10"]
1Thao tác này có thể hữu ích đặc biệt trong trường hợp chúng ta muốn kiểm tra xem một số là số lẻ hay số chẵn. Một số là số lẻ nếu chia cho 2 dư 1. Nếu không, nó thậm chí còn
Đây là một minh họa
if 100 > 10:
print["100 is greater than 10"]
0Khi muốn nâng một số lên lũy thừa xác định ta dùng dấu sao kép
if 100 > 10:
print["100 is greater than 10"]
1Toán tử gán trong Python
Bạn sử dụng các toán tử này để gán giá trị cho các biến
Khi chúng ta khai báo một biến, chúng ta sử dụng dấu bằng
if 100 > 10:
print["100 is greater than 10"]
2Chúng ta cũng có thể khai báo nhiều biến trên cùng một dòng
if 100 > 10:
print["100 is greater than 10"]
3Chúng ta có thể sử dụng điều này như một cách để trao đổi giá trị giữa các biến. Ví dụ: giả sử chúng tôi có hai biến
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
22 và """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
23 và chúng tôi muốn chuyển đổi giá trị của chúngMột cách hợp lý để làm điều đó là giới thiệu một biến thứ ba đóng vai trò là biến tạm thời.
if 100 > 10:
print["100 is greater than 10"]
4Chúng ta có thể làm điều đó trong một dòng theo cách sau
if 100 > 10:
print["100 is greater than 10"]
5Chúng ta cũng có thể hợp nhất toán tử gán với toán tử số học
Trước tiên hãy xem cách chúng ta có thể làm điều đó để bổ sung
Giả sử rằng chúng ta có các biến sau
if 100 > 10:
print["100 is greater than 10"]
6Bây giờ chúng tôi muốn thêm giá trị của
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
24 vào """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
25. Để làm điều đó, chúng ta nên viết như sauif 100 > 10:
print["100 is greater than 10"]
7Điều này có thể không chính xác, vì phía bên tay phải không bằng phía bên tay trái. Tuy nhiên, trong trường hợp này, chúng tôi chỉ đơn giản là thực hiện một bài tập chứ không phải so sánh cả hai vế của phương trình
Để làm điều này một cách nhanh chóng, chúng ta có thể sử dụng mẫu sau
if 100 > 10:
print["100 is greater than 10"]
8Điều này tương đương với tuyên bố trước đó
Tương tự, chúng ta có thể làm tương tự với các toán tử số học khác
phép trừ
if 100 > 10:
print["100 is greater than 10"]
9Phép nhân
# This is a comment in Python
0Phân công
# This is a comment in Python
1toán tử modulo
# This is a comment in Python
2nhà điều hành điện
# This is a comment in Python
3Toán tử so sánh trong Python
Bạn có thể đã học cách so sánh cơ bản các số ở trường, chẳng hạn như kiểm tra xem một số cụ thể có lớn hơn số khác hay không hoặc liệu chúng có bằng nhau không
Chúng ta có thể sử dụng hầu hết các toán tử giống nhau trong Python để thực hiện các phép so sánh như vậy
Hãy xem chúng hoạt động
Toán tử bình đẳng
Bạn có thể kiểm tra xem hai số có bằng nhau hay không bằng cách sử dụng toán tử
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
26# This is a comment in Python
4Biểu thức cuối cùng đánh giá là Sai vì
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
27 không bằng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
28Có một toán tử khác mà bạn có thể sử dụng để kiểm tra xem 2 số có bằng nhau không. Đây là một toán tử mà bạn có thể chưa từng thấy trong các lớp toán của mình được viết chính xác theo cách này. Đây là nhà điều hành
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
29Hãy so sánh xem
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
27 không bằng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
28# This is a comment in Python
5Biểu thức này đánh giá là True vì
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
27 thực sự không bằng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
28Toán tử bất đẳng thức
Bây giờ ở đây chúng ta sẽ xem cách kiểm tra xem một số có lớn hơn một số khác không
# This is a comment in Python
6Đây là điều mà bạn nên biết từ các lớp học toán của mình
Khi muốn kiểm tra xem một số có lớn hơn hoặc bằng một số khác hay không, chúng ta cần sử dụng toán tử này
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
34# This is a comment in Python
7Tương tự, để kiểm tra xem một số có nhỏ hơn hoặc bằng một số khác hay không, chúng ta có
# This is a comment in Python
8Toán tử logic
Trong môn toán phổ thông, bạn có thể đã học về các toán tử logic như
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
35 và """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
36Nói một cách ngắn gọn, để một biểu thức được đánh giá là True khi sử dụng
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
35, cả hai câu lệnh đều phải đúng. Trong Python, chúng tôi triển khai nó bằng cách sử dụng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
35# This is a comment in Python
9Ví dụ này sẽ đánh giá là True vì
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
39 lớn hơn """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
40, đánh giá là True và """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
28 nhỏ hơn """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
39, cũng đánh giá là True. Từ đó, chúng tôi nhận được True và True, đánh giá là TrueHãy lấy một ví dụ khi một biểu thức
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
35 sẽ đánh giá thành """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
44"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
0"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
27 không lớn hơn """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
39, vì vậy câu lệnh ở vế trái sẽ có giá trị là Sai. Bất kể vế bên phải là gì, chúng ta sẽ nhận được toàn bộ biểu thức bằng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
44, vì Sai và bất kỳ giá trị nào khác [như Đúng] sẽ dẫn đến SaiKhi bạn có các câu lệnh mà ít nhất một trong số chúng sẽ đánh giá là Đúng, thì chúng ta nên sử dụng toán tử
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
36"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
1Điều này sẽ được đánh giá là Đúng vì câu lệnh ở vế bên phải được đánh giá là Đúng - vì vậy ít nhất một trong số chúng là đúng
Nếu cả hai câu đều Sai, thì cuối cùng thì kết quả của
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
36 là """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
44"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
2Điều này sai vì 0 không lớn hơn 2 và 0 cũng không lớn hơn 1. Vì vậy, toàn bộ biểu thức là Sai
Các kiểu dữ liệu trong PythonBiến trong Python
Bạn có thể nghĩ về các biến như là các khối xây dựng của bất kỳ chương trình máy tính nào mà bạn có thể viết.
Bạn có thể sử dụng các biến để lưu trữ các giá trị và sau đó sử dụng lại chúng bao nhiêu lần tùy thích. Thời điểm bạn muốn thay đổi một giá trị, bạn chỉ có thể thay đổi nó ở một nơi và giá trị mới mà bạn vừa thay đổi sẽ được phản ánh ở mọi nơi khác nơi biến đó được sử dụng
Mỗi biến trong Python là một đối tượng
Một biến được tạo tại thời điểm nó được khởi tạo với một giá trị
Dưới đây là các quy tắc chung cho các biến Python
- Tên biến phải bắt đầu bằng một chữ cái hoặc ký tự gạch dưới. Nó không thể bắt đầu bằng một số
- Tên biến chỉ có thể chứa các ký tự chữ và số và dấu gạch dưới [A-z, 0-9 và _ ]
- Tên biến phân biệt chữ hoa chữ thường, nghĩa là
51,""" This is a comment in Python. Here we are typing in another line and we are still inside the same comment block. In the previous line we have a space, because it's allowed to have spaces inside comments. Let's end this comment right here. """
52 và""" This is a comment in Python. Here we are typing in another line and we are still inside the same comment block. In the previous line we have a space, because it's allowed to have spaces inside comments. Let's end this comment right here. """
53 đều là các biến khác nhau""" This is a comment in Python. Here we are typing in another line and we are still inside the same comment block. In the previous line we have a space, because it's allowed to have spaces inside comments. Let's end this comment right here. """
Hãy xác định biến đầu tiên của chúng tôi
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
3Trong ví dụ này, chúng tôi đang khởi tạo một biến có tên tuổi và gán giá trị 28 cho nó
Chúng ta có thể định nghĩa các biến khác cùng với nó, như
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
4Chúng tôi có thể sử dụng gần như bất kỳ tên nào mà chúng tôi muốn, nhưng tốt hơn hết là sử dụng những tên mà cả bạn và bất kỳ đồng nghiệp nào làm việc cùng bạn đều có thể hiểu được
Chúng tôi có các loại biến khác trong Python, chẳng hạn như số float, chuỗi và giá trị boolean. Chúng tôi thậm chí có thể tạo các loại tùy chỉnh của riêng mình
Hãy xem một ví dụ về một biến chứa số float
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
5Như bạn có thể thấy, việc khởi tạo này khá giống với khi chúng ta có các số nguyên. Ở đây chúng tôi chỉ thay đổi giá trị bên phải. Trình thông dịch Python đủ thông minh để biết rằng chúng ta đang xử lý một loại biến khác, cụ thể là một loại biến float
Hãy xem một ví dụ về một chuỗi
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
6Chúng tôi đặt các giá trị chuỗi trong dấu ngoặc kép hoặc dấu ngoặc đơn để chỉ định giá trị mà chúng tôi muốn lưu trữ trong các biến chuỗi
Khi chúng tôi muốn lưu trữ các giá trị boolean, chúng tôi cần sử dụng các từ dành riêng, cụ thể là Đúng và Sai
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
7Chúng ta cũng có thể lưu trữ một giá trị boolean khi chúng ta có các biểu thức dẫn đến một giá trị boolean, chẳng hạn như khi chúng ta so sánh một số với một số khác, chẳng hạn như
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
8Biến này sẽ được khởi tạo với giá trị Sai vì 5 nhỏ hơn 6
Số trong Python
Chúng tôi có ba loại số trong Python. số nguyên, số float và số phức
số nguyên
Số nguyên đại diện cho số nguyên có thể là cả dương và âm và không chứa bất kỳ phần thập phân nào
Dưới đây là một vài ví dụ về số nguyên.
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
54, """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
55, """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
56, v.v.Khi cộng, trừ, nhân hai số nguyên ta được một số nguyên
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
9Đây đều là số nguyên
Điều này cũng bao gồm các trường hợp khi chúng ta nâng một số lên lũy thừa
print[50 + 4] # 54
0Khi chúng ta muốn chia hai số nguyên, chúng ta sẽ nhận được một số float
Booleans
Kiểu boolean đại diện cho các giá trị thực, True và False. Bạn đã học giải thích về kiểu này trong phần Số, vì các phép toán luận thực sự là kiểu con của kiểu số nguyên
Cụ thể hơn, hầu như luôn luôn giá trị Sai có thể được coi là
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
40, trong khi giá trị True có thể được coi là """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
54Như vậy, chúng ta cũng có thể thực hiện các phép toán số học với chúng
print[50 + 4] # 54
1Ngoại lệ đối với các biểu diễn số nguyên như vậy của các giá trị Boolean là khi các giá trị này là các chuỗi như "Sai" và "Đúng"
phao nổi
Số thực là số có chứa phần thập phân, chẳng hạn như
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
59, """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
60, """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
61, v.v.Chúng ta cũng có thể chuyển đổi thành số thực bằng cách sử dụng hàm
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
62print[50 + 4] # 54
2Khi cộng, trừ hoặc chia hai số float, hoặc một số float và một số nguyên, cuối cùng chúng ta sẽ nhận được một số float
print[50 + 4] # 54
3Số phức
Số phức có cả phần thực và phần ảo ta viết như sau
print[50 + 4] # 54
4Chuỗi trong Python
Chuỗi đại diện cho các ký tự được đặt trong dấu nháy đơn hoặc dấu nháy kép. Cả hai đều được đối xử như nhau
print[50 + 4] # 54
5Nếu chúng tôi muốn bao gồm một trích dẫn bên trong một chuỗi, chúng tôi cần cho Python biết rằng nó không được đóng chuỗi mà chỉ cần thoát khỏi trích dẫn đó
print[50 + 4] # 54
6Khi muốn thêm một dòng mới vào một chuỗi, chúng ta có thể thêm ký tự đặc biệt
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
63print[50 + 4] # 54
7Vì các chuỗi là các mảng ký tự, nên chúng ta có thể lập chỉ mục các ký tự cụ thể bằng cách sử dụng các chỉ mục. Các chỉ mục bắt đầu từ 0 và đi hết cho đến khi độ dài của chuỗi trừ đi 1
Chúng tôi loại trừ chỉ mục bằng độ dài của chuỗi vì chúng tôi bắt đầu lập chỉ mục từ 0 chứ không phải từ 1
Đây là một ví dụ
print[50 + 4] # 54
8Trong ví dụ này, nếu chúng ta chọn các ký tự riêng lẻ của chuỗi, chúng sẽ mở ra như sau
print[50 + 4] # 54
9Chúng tôi cũng có thể sử dụng các chỉ mục phủ định, điều đó có nghĩa là chúng tôi bắt đầu từ cuối chuỗi bằng
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
64. Chúng tôi không thể sử dụng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
40 để lập chỉ mục từ cuối chuỗi, vì """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
66print[50 - 4] # 46
0Chúng tôi cũng có thể thực hiện cắt và chỉ bao gồm một phần của chuỗi chứ không phải toàn bộ chuỗi. Ví dụ: nếu chúng ta muốn lấy các ký tự bắt đầu từ một chỉ mục cụ thể cho đến một chỉ mục cụ thể, chúng ta nên viết theo cách sau.
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
67, không bao gồm ký tự tại chỉ mục """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
68print[50 - 4] # 46
1Nếu chúng ta muốn bắt đầu từ một chỉ mục cụ thể và tiếp tục lấy tất cả các ký tự còn lại của chuỗi cho đến khi kết thúc, chúng ta có thể bỏ qua việc chỉ định chỉ mục kết thúc, như sau
print[50 - 4] # 46
2Nếu chúng ta muốn bắt đầu từ 0 và đi đến một chỉ mục cụ thể, chúng ta chỉ cần chỉ định chỉ mục kết thúc
print[50 - 4] # 46
3Điều này có nghĩa là giá trị của
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
69 bằng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
70 [không bao gồm ký tự ở vị trí 2] + """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
71Lưu ý rằng các chuỗi trong Python là bất biến. Điều này có nghĩa là một khi đối tượng chuỗi đã được tạo thì không thể sửa đổi nó, chẳng hạn như cố gắng thay đổi một ký tự trong chuỗi
Để minh họa, giả sử chúng ta muốn thay đổi ký tự đầu tiên trong chuỗi, cụ thể là chuyển đổi
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
72 bằng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
73 theo cách sauprint[50 - 4] # 46
4Bây giờ, nếu chúng tôi cố gắng in
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
69, chúng tôi sẽ gặp lỗi như sauprint[50 - 4] # 46
5Nếu chúng ta cần một chuỗi mới, chúng ta chỉ cần tạo một chuỗi mới
Toán tử chuỗi
Chúng ta có thể nối các chuỗi bằng toán tử
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
75print[50 - 4] # 46
6Chúng ta có thể sử dụng toán tử nhân
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
76 với các chuỗi và sốBạn có thể sử dụng điều này để lặp lại chuỗi đó nhiều lần. Ví dụ: nếu chúng ta muốn lặp lại một chuỗi 5 lần nhưng không muốn viết thủ công 5 lần, chúng ta chỉ cần nhân chuỗi đó với số 5
print[50 - 4] # 46
7Các phương thức tích hợp chuỗi
Có một số phương thức tích hợp sẵn của chuỗi mà chúng ta có thể sử dụng có thể giúp chúng ta thao tác với chúng dễ dàng hơn
phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
77
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
77 là một phương thức mà chúng ta có thể sử dụng để lấy độ dài của một chuỗiprint[50 - 4] # 46
8phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
79
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
Chúng ta có thể sử dụng
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
79 để thay thế một ký tự hoặc một chuỗi con của một chuỗi bằng một ký tự hoặc chuỗi con khácprint[50 - 4] # 46
9phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
81
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
81 xóa khoảng trắng có thể ở đầu hoặc cuối chuỗiprint[50 * 4] # 200
0phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
83
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
Chúng ta có thể sử dụng
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
83 để chuyển đổi một chuỗi thành một mảng các chuỗi con dựa trên một mẫu cụ thể được đề cập là dấu phân cáchVí dụ: giả sử rằng chúng ta muốn lưu tất cả các từ của một câu trong một mảng các từ. Những từ này được phân tách bằng khoảng trắng, vì vậy chúng ta sẽ cần thực hiện việc tách dựa trên đó
print[50 * 4] # 200
1phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
85
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
85 là đối diện của """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
83. từ một mảng các chuỗi, nó trả về một chuỗi. Quá trình nối được cho là xảy ra với một dấu phân cách được chỉ định ở giữa mỗi phần tử của mảng mà cuối cùng dẫn đến một chuỗi được nối duy nhấtprint[50 * 4] # 200
2phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
88
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
Chúng ta có thể sử dụng
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
88 để đếm số lần một ký tự hoặc một chuỗi con xuất hiện trong một chuỗiprint[50 * 4] # 200
3Phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
90
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
90 cho phép chúng tôi tìm một ký tự hoặc một chuỗi con trong một chuỗi và trả về chỉ mục của nó. Trong trường hợp nó không tìm thấy nó, nó sẽ chỉ trả về """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
64print[50 * 4] # 200
4"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
93
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
93 chuyển đổi tất cả các ký tự của chuỗi thành chữ thườngprint[50 * 4] # 200
5"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
95
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
95 chuyển đổi tất cả các ký tự của chuỗi thành chữ hoaprint[50 * 4] # 200
6phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
97
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
Chúng ta có thể sử dụng ________ 397 để chuyển ký tự đầu tiên của chuỗi thành chữ hoa
print[50 * 4] # 200
7phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
99
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
99 chuyển đổi các ký tự bắt đầu của mỗi từ [các chuỗi được phân tách bằng khoảng trắng] của một chuỗi thành chữ hoaprint[50 * 4] # 200
8Phương pháp print[50 + 4] # 54
01
print[50 + 4] # 54
print[50 + 4] # 54
01 là một phương thức mà chúng ta có thể sử dụng để kiểm tra xem tất cả các ký tự trong chuỗi có phải là chữ hoa khôngprint[50 * 4] # 200
9phương pháp print[50 + 4] # 54
03
print[50 + 4] # 54
print[50 + 4] # 54
03 kiểm tra tương tự xem tất cả các ký tự có phải là chữ thường khôngprint[50 / 4] # 12.5
print[8 / 4] # 2.0
0Phương pháp print[50 + 4] # 54
05
print[50 + 4] # 54
print[50 + 4] # 54
05 trả về True nếu tất cả các ký tự trong chuỗi là các chữ cái trong bảng chữ cáiprint[50 / 4] # 12.5
print[8 / 4] # 2.0
1phương pháp print[50 + 4] # 54
07
print[50 + 4] # 54
print[50 + 4] # 54
07 trả về True nếu tất cả ký tự trong chuỗi là sốprint[50 / 4] # 12.5
print[8 / 4] # 2.0
2Định dạng chuỗi
Định dạng một chuỗi có thể khá hữu ích vì bạn có thể sử dụng nó khá thường xuyên bất kể loại dự án hoặc tập lệnh mà bạn đang thực hiện.
Trước tiên hãy minh họa lý do tại sao chúng ta cần định dạng và bao gồm phép nội suy chuỗi
Hãy tưởng tượng rằng tôi muốn phát triển một phần mềm chào đón mọi người ngay khi họ bước vào, chẳng hạn như
print[50 / 4] # 12.5
print[8 / 4] # 2.0
3Điều này bây giờ trông thật tuyệt, nhưng tôi không phải là người duy nhất sử dụng nó, phải không?
Tôi chỉ là một trong những người được sử dụng nó
Bây giờ nếu ai đó đến và đăng nhập, tôi sẽ phải sử dụng tên riêng của họ, chẳng hạn như
print[50 / 4] # 12.5
print[8 / 4] # 2.0
4Đây chỉ là người dùng thực sự đầu tiên của tôi đang đăng ký. Tôi không đếm chính mình
Bây giờ, hãy nghĩ rằng tôi gặp may mắn và người dùng thứ hai cũng xuất hiện vào sáng thứ Sáu và ứng dụng của chúng ta sẽ hiển thị
print[50 / 4] # 12.5
print[8 / 4] # 2.0
5Như bạn có thể thấy, chúng tôi đang đạt được một số thành tựu từ góc độ kinh doanh vì hai người dùng mới vừa xuất hiện, nhưng đây không phải là triển khai có thể mở rộng. Chúng tôi đang viết một biểu thức
print[50 + 4] # 54
09 rất tĩnhBạn nên nhớ rằng chúng ta sắp đề cập đến một thứ mà tôi đã giới thiệu ở phần đầu
Có, chúng ta sẽ cần sử dụng các biến và bao gồm một biến bên cạnh chuỗi, như sau
print[50 / 4] # 12.5
print[8 / 4] # 2.0
6Điều này linh hoạt hơn nhiều
Đây là một cách để làm điều đó
Một cách khác bạn có thể thực hiện việc này là sử dụng phương thức có tên là
print[50 + 4] # 54
10Chúng ta có thể sử dụng dấu ngoặc nhọn để chỉ định những nơi chúng ta muốn đặt giá trị động, chẳng hạn như sau
print[50 / 4] # 12.5
print[8 / 4] # 2.0
7Điều này bây giờ sẽ đặt tham số đầu tiên của phương thức
print[50 + 4] # 54
10 bên trong dấu ngoặc nhọn đầu tiên, trong trường hợp của chúng ta là print[50 + 4] # 54
12. Sau đó, trong lần xuất hiện thứ hai của dấu ngoặc nhọn, nó sẽ đặt tham số thứ hai của phương thức print[50 + 4] # 54
10Nếu chúng ta cố gắng in giá trị của chuỗi, chúng ta sẽ nhận được kết quả như sau
print[50 / 4] # 12.5
print[8 / 4] # 2.0
8Chúng ta có thể chỉ định các tham số với các chỉ mục bên trong dấu ngoặc nhọn như sau có thể được sử dụng
print[50 / 4] # 12.5
print[8 / 4] # 2.0
9Chúng ta cũng có thể chỉ định các tham số bên trong phương thức
print[50 + 4] # 54
10 và sử dụng các từ cụ thể đó bên trong dấu ngoặc nhọn làm tham chiếuprint[50 // 4] # 12
print[8 / 4] # 2
0Chúng ta có thể kết hợp cả hai loại đối số trong một ví dụ, chẳng hạn như sau
print[50 // 4] # 12
print[8 / 4] # 2
1Như bạn có thể thấy, việc sử dụng các đối số được đặt tên trái ngược với các đối số vị trí có thể ít bị lỗi hơn, vì thứ tự của chúng trong phương thức
print[50 + 4] # 54
10 không quan trọngChúng tôi cũng có thể sử dụng một cách khác để định dạng chuỗi bao gồm bắt đầu chuỗi bằng
print[50 + 4] # 54
16 hoặc print[50 + 4] # 54
17 trước dấu ngoặc kép mở hoặc dấu ngoặc kép ba và bao gồm tên của các biến mà chúng tôi muốn đưa vào cuốiprint[50 // 4] # 12
print[8 / 4] # 2
2Đây là một ví dụ khác mà chúng tôi đang sử dụng thương ba sau
print[50 + 4] # 54
17print[50 // 4] # 12
print[8 / 4] # 2
3Danh sách trong Python
Nếu bạn nhìn vào giá sách, bạn có thể thấy rằng những cuốn sách được xếp chồng lên nhau và đặt sát nhau. Bạn có thể thấy rằng có rất nhiều ví dụ về việc thu thập và cấu trúc các phần tử theo một cách nào đó
Cái này cũng khá quan trọng trong lập trình máy tính. Chúng ta không thể tiếp tục khai báo vô số biến và quản lý chúng một cách dễ dàng
Giả sử chúng ta có một lớp sinh viên và muốn lưu tên của họ. Chúng ta có thể bắt đầu lưu tên của họ tùy theo vị trí của họ trong lớp học
print[50 // 4] # 12
print[8 / 4] # 2
4Danh sách có thể tiếp tục kéo dài, điều này sẽ khiến chúng tôi khá khó theo dõi tất cả chúng
May mắn thay, có một cách dễ dàng hơn để chúng ta đưa chúng vào một bộ sưu tập trong Python được gọi là danh sách
Hãy tạo một danh sách có tên là sinh viên và lưu trữ trong danh sách đó tất cả các tên được khai báo trong khối mã trước đó
print[50 // 4] # 12
print[8 / 4] # 2
5Điều này là đẹp hơn, phải không?
Hơn nữa, theo cách này, chúng ta sẽ dễ dàng quản lý và thao tác với các phần tử trong danh sách hơn
Bạn có thể nghĩ rằng, "Chà, tôi chỉ cần gọi trước và nhận giá trị được lưu trữ trong đó sẽ dễ dàng hơn đối với tôi. Bây giờ không thể lấy giá trị từ danh sách mới này, được gọi là sinh viên"
Nếu chúng tôi không thể đọc và sử dụng những yếu tố mà chúng tôi vừa lưu trữ trong danh sách, điều đó sẽ khiến nó trở nên kém hữu ích hơn
May mắn thay, danh sách có chỉ mục bắt đầu từ 0. Điều này có nghĩa là nếu chúng ta muốn lấy phần tử đầu tiên trong danh sách, chúng ta cần sử dụng chỉ số 0 chứ không phải chỉ số 1 như bạn nghĩ
Trong ví dụ trên, các mục danh sách có các chỉ mục tương ứng
print[50 // 4] # 12
print[8 / 4] # 2
6Bây giờ, nếu chúng ta muốn lấy phần tử đầu tiên, chúng ta chỉ cần viết
print[50 // 4] # 12
print[8 / 4] # 2
7Nếu chúng ta muốn lấy phần tử thứ hai, chúng ta chỉ cần viết
print[50 // 4] # 12
print[8 / 4] # 2
8Như bạn có thể thấy, chúng ta chỉ cần viết tên của danh sách và chỉ số tương ứng của phần tử mà chúng ta muốn lấy trong dấu ngoặc vuông
Tất nhiên, danh sách này không cố định. Chúng ta có thể thêm các yếu tố vào nó, như khi một học sinh mới tham gia lớp học
Hãy thêm một phần tử mới vào danh sách sinh viên với giá trị Besfort
print[50 // 4] # 12
print[8 / 4] # 2
9Chúng ta cũng có thể thay đổi giá trị của một phần tử hiện có. Để làm điều đó, chúng ta chỉ cần khởi tạo lại phần tử cụ thể đó của danh sách với một giá trị mới
Ví dụ: hãy thay đổi tên của học sinh đầu tiên
if 100 > 10:
print["100 is greater than 10"]
10Danh sách có thể chứa các loại biến khác nhau, ví dụ: chúng ta có thể có một chuỗi chứa số nguyên, số float và chuỗi
if 100 > 10:
print["100 is greater than 10"]
11cắt lát
Tương tự như chuỗi, danh sách cũng có thể được cắt lát, kết quả là trả về một danh sách mới. Điều này có nghĩa là danh sách ban đầu không thay đổi
Hãy xem cách chúng ta có thể lấy ba phần tử đầu tiên của danh sách bằng cách sử dụng phép cắt
if 100 > 10:
print["100 is greater than 10"]
12Như bạn có thể thấy, chúng tôi đã chỉ định 0 làm chỉ mục bắt đầu và 3 làm chỉ mục nơi quá trình cắt sẽ dừng lại, ngoại trừ phần tử ở chỉ mục kết thúc
Nếu chúng ta chỉ muốn bắt đầu từ một chỉ mục và lấy tất cả các phần tử còn lại trong danh sách, nghĩa là end_index phải là chỉ mục cuối cùng, thì chúng ta có thể bỏ qua và hoàn toàn không phải viết chỉ mục cuối cùng
if 100 > 10:
print["100 is greater than 10"]
13Tương tự, nếu chúng ta muốn bắt đầu từ đầu danh sách và thực hiện cắt cho đến một chỉ mục cụ thể, thì chúng ta có thể bỏ qua việc viết chỉ mục 0 hoàn toàn, vì Python đủ thông minh để suy ra điều đó
if 100 > 10:
print["100 is greater than 10"]
14Chuỗi trong Python là bất biến, trong khi danh sách có thể thay đổi, nghĩa là chúng ta có thể sửa đổi nội dung của danh sách sau khi chúng ta khai báo chúng
Để minh họa, giả sử chúng ta muốn thay đổi ký tự đầu tiên trong chuỗi, cụ thể là chuyển đổi
print[50 + 4] # 54
19 bằng print[50 + 4] # 54
20 theo cách sauif 100 > 10:
print["100 is greater than 10"]
15Bây giờ, nếu chúng tôi cố gắng in
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
69, chúng tôi sẽ gặp lỗi như sauprint[50 - 4] # 46
5Bây giờ nếu chúng ta có một danh sách và muốn sửa đổi phần tử đầu tiên của nó, thì chúng ta có thể thực hiện thành công
if 100 > 10:
print["100 is greater than 10"]
17Chúng ta có thể mở rộng một danh sách bằng cách nối nó với một danh sách khác bằng cách sử dụng toán tử
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
75if 100 > 10:
print["100 is greater than 10"]
18Cách lồng danh sách vào trong danh sách khác
Chúng ta có thể lồng một danh sách vào trong một danh sách khác như thế này
if 100 > 10:
print["100 is greater than 10"]
19Những danh sách này thậm chí không cần phải có cùng độ dài
Để truy cập các phần tử của danh sách nằm trong danh sách, chúng ta cần sử dụng chỉ mục kép
Hãy xem cách chúng ta có thể truy cập phần tử ________ 523 bên trong danh sách ________ 524. Vì
print[50 + 4] # 54
23 là một phần tử trong danh sách print[50 + 4] # 54
24 được định vị ở chỉ số 0 nên chúng ta chỉ cần làm như sauif 100 > 10:
print["100 is greater than 10"]
00Bây giờ, hãy giả sử rằng chúng ta muốn truy cập
print[50 + 4] # 54
27 bên trong danh sách print[50 + 4] # 54
24. Vì print[50 + 4] # 54
27 nằm ở chỉ mục """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
54, nên chúng tôi sẽ cần sử dụng các chỉ mục kép sauif 100 > 10:
print["100 is greater than 10"]
01Liệt kê các phương thức
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
77 là phương pháp mà bạn có thể sử dụng để tìm độ dài của danh sáchif 100 > 10:
print["100 is greater than 10"]
02Cách thêm phần tử vào danh sách
Chúng tôi cũng có thể mở rộng danh sách bằng cách thêm các phần tử mới hoặc chúng tôi cũng có thể xóa các phần tử
Chúng ta có thể thêm các phần tử mới vào cuối danh sách bằng phương thức
print[50 + 4] # 54
32if 100 > 10:
print["100 is greater than 10"]
03Nếu chúng ta muốn thêm các phần tử vào các chỉ mục cụ thể trong danh sách, chúng ta có thể sử dụng phương thức
print[50 + 4] # 54
33. Chúng tôi chỉ định chỉ mục trong đối số đầu tiên và phần tử mà chúng tôi muốn thêm vào danh sách làm đối số thứ haiif 100 > 10:
print["100 is greater than 10"]
04Cách xóa phần tử khỏi danh sách
Chúng ta có thể xóa các phần tử khỏi danh sách bằng phương pháp
print[50 + 4] # 54
34, phương thức này sẽ xóa phần tử cuối cùng trong danh sáchif 100 > 10:
print["100 is greater than 10"]
05Chúng ta cũng có thể chỉ định chỉ mục của một phần tử trong danh sách cho biết chúng ta nên xóa phần tử nào trong danh sách
if 100 > 10:
print["100 is greater than 10"]
06Chúng tôi cũng có thể xóa các phần tử khỏi danh sách bằng cách sử dụng câu lệnh
print[50 + 4] # 54
35 và sau đó chỉ định giá trị của phần tử mà chúng tôi muốn xóaif 100 > 10:
print["100 is greater than 10"]
07Chúng tôi cũng có thể xóa các lát danh sách bằng cách sử dụng
print[50 + 4] # 54
35if 100 > 10:
print["100 is greater than 10"]
08Chúng tôi có thể làm điều này bằng cách sử dụng
print[50 + 4] # 54
37if 100 > 10:
print["100 is greater than 10"]
09print[50 + 4] # 54
38 cho phép chúng tôi đảo ngược các phần tử trong danh sách. Điều này khá dễ dàng và đơn giảnif 100 > 10:
print["100 is greater than 10"]
10tìm kiếm chỉ mục
Lấy các phần tử của danh sách bằng chỉ mục rất đơn giản. Tìm chỉ mục của các phần tử của danh sách cũng dễ dàng. Chúng ta chỉ cần sử dụng phương thức
print[50 + 4] # 54
39 và đề cập đến phần tử mà chúng ta muốn tìm trong danh sáchif 100 > 10:
print["100 is greater than 10"]
11Tư cách thành viên
Điều này khá trực quan và liên quan đến cuộc sống thực. Chúng ta có thể tự hỏi liệu thứ gì đó có phải là một phần của thứ gì đó hay không
Điện thoại của tôi có ở trong túi quần hoặc túi xách không?
Email của đồng nghiệp của tôi có được đưa vào CC không?
Là bạn của tôi trong quán cà phê này?
Trong Python, nếu chúng ta muốn kiểm tra xem một giá trị có phải là một phần của thứ gì đó hay không, chúng ta có thể sử dụng toán tử
print[50 + 4] # 54
40if 100 > 10:
print["100 is greater than 10"]
12Vì 1 được bao gồm trong mảng
print[50 + 4] # 54
41, nên biểu thức ước tính là TrueChúng ta cũng có thể sử dụng nó không chỉ với mảng số mà còn với mảng ký tự.
if 100 > 10:
print["100 is greater than 10"]
13Vì
print[50 + 4] # 54
42 không phải là một nguyên âm và không được bao gồm trong mảng đã khai báo, nên biểu thức ở dòng thứ hai của đoạn mã trước sẽ cho kết quả là SaiTương tự, chúng ta cũng có thể kiểm tra xem có thứ gì không được bao gồm hay không bằng cách sử dụng
print[50 + 4] # 54
43if 100 > 10:
print["100 is greater than 10"]
14Vì 2 không được bao gồm trong mảng, nên biểu thức sẽ đánh giá là True
Cách sắp xếp các phần tử trong danh sách
Sắp xếp các phần tử trong danh sách là điều mà thỉnh thoảng bạn có thể cần thực hiện.
print[50 + 4] # 54
44 là một phương thức tích hợp giúp bạn có thể sắp xếp các phần tử trong danh sách theo thứ tự tăng dần theo thứ tự bảng chữ cái hoặc sốif 100 > 10:
print["100 is greater than 10"]
15Có các phương pháp danh sách khác mà chúng tôi chưa đưa vào đây
hiểu danh sách
Khả năng hiểu danh sách thể hiện một cách ngắn gọn trong đó chúng tôi sử dụng vòng lặp
print[50 + 4] # 54
45 để tạo danh sách mới từ danh sách hiện có. Kết quả cuối cùng luôn là một danh sách mớiHãy bắt đầu với một ví dụ mà chúng tôi muốn nhân từng số của danh sách với 10 và lưu kết quả đó vào một danh sách mới. Đầu tiên, hãy làm điều này mà không cần sử dụng khả năng hiểu danh sách
if 100 > 10:
print["100 is greater than 10"]
16Chúng ta có thể thực hiện điều đó bằng cách sử dụng khả năng hiểu danh sách theo cách sau
if 100 > 10:
print["100 is greater than 10"]
17Chúng tôi cũng có thể bao gồm các điều kiện khi thực hiện các thao tác hiểu danh sách này
Giả sử rằng chúng ta muốn lưu một danh sách các số dương
Trước khi viết cách triển khai điều này bằng cách sử dụng khả năng hiểu danh sách, hãy viết cách tạo danh sách chỉ các số lớn hơn 0 trong một danh sách khác và tăng các số dương đó lên 100
if 100 > 10:
print["100 is greater than 10"]
18Chúng ta có thể làm tương tự bằng cách sử dụng hiểu danh sách
if 100 > 10:
print["100 is greater than 10"]
19Như bạn có thể thấy, điều này ngắn hơn nhiều và sẽ mất ít thời gian hơn để viết
Chúng tôi cũng có thể sử dụng khả năng hiểu danh sách với nhiều danh sách
Hãy lấy một ví dụ mà chúng tôi muốn thêm từng phần tử của danh sách với từng phần tử trong danh sách khác
if 100 > 10:
print["100 is greater than 10"]
20Cuối cùng, chúng ta sẽ nhận được một danh sách kết quả có cùng số phần tử với danh sách có độ dài dài nhất
Bộ dữ liệu trong Python
Bộ dữ liệu là bộ sưu tập được sắp xếp theo thứ tự và không thay đổi, nghĩa là nội dung của chúng không thể thay đổi. Chúng được sắp xếp theo thứ tự và chúng ta có thể truy cập các phần tử của chúng bằng chỉ mục
Hãy bắt đầu với bộ dữ liệu đầu tiên của chúng tôi
if 100 > 10:
print["100 is greater than 10"]
21Tất cả các hoạt động lập chỉ mục và cắt mà chúng ta đã thấy trong phần danh sách cũng áp dụng cho các bộ dữ liệu
if 100 > 10:
print["100 is greater than 10"]
22Bạn có thể tìm thấy chỉ mục của một phần tử bên trong một tuple bằng cách sử dụng phương thức
print[50 + 4] # 54
39if 100 > 10:
print["100 is greater than 10"]
23Chúng tôi cũng có thể nối hoặc hợp nhất hai bộ dữ liệu bằng cách sử dụng toán tử
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
75if 100 > 10:
print["100 is greater than 10"]
24kiểm tra tư cách thành viên
Chúng ta có thể kiểm tra xem một phần tử có phải là một phần của bộ hay không bằng cách sử dụng các toán tử
print[50 + 4] # 54
40 và print[50 + 4] # 54
43 giống như với danh sáchif 100 > 10:
print["100 is greater than 10"]
25Làm thế nào để lồng hai bộ dữ liệu
Thay vì hợp nhất, chúng ta cũng có thể lồng các bộ vào một bộ duy nhất bằng cách sử dụng các bộ mà chúng ta muốn lồng bên trong dấu ngoặc đơn
if 100 > 10:
print["100 is greater than 10"]
26tính bất biến
Vì các bộ dữ liệu là bất biến, chúng tôi không thể thay đổi chúng sau khi chúng tôi tạo chúng. Điều này có nghĩa là chúng ta không thể thêm hoặc xóa các phần tử trong chúng hoặc nối một bộ vào một bộ khác
Chúng tôi thậm chí không thể sửa đổi các phần tử hiện có trong một bộ dữ liệu. Nếu chúng ta cố gắng sửa đổi một phần tử trong tuple, chúng ta sẽ gặp vấn đề như sau
if 100 > 10:
print["100 is greater than 10"]
27Từ điển trong Python – Cấu trúc dữ liệu khóa-giá trị
Như chúng ta đã thấy trước đây, các phần tử trong danh sách được liên kết với các chỉ mục mà chúng ta có thể sử dụng để tham chiếu các phần tử đó
Có một cấu trúc dữ liệu khác trong Python cho phép chúng tôi chỉ định các chỉ mục tùy chỉnh của riêng mình chứ không chỉ các số. Chúng được gọi là từ điển, và chúng tương tự như từ điển mà chúng ta sử dụng để tìm nghĩa của những từ chúng ta không hiểu
Giả sử rằng bạn đang cố gắng học tiếng Đức và có một từ mới mà bạn chưa có cơ hội học trước đây mà bạn vừa thấy ở chợ. máy đánh bóng
Giờ đây, bạn có thể nhấc điện thoại lên và tra nghĩa tương ứng của nó bằng tiếng Anh bằng Google Dịch hoặc bất kỳ ứng dụng nào khác mà bạn chọn. Nhưng nếu bạn sử dụng từ điển vật lý, bạn sẽ cần tìm từ này bằng cách truy cập trang cụ thể đó và kiểm tra nghĩa của từ đó ngay bên cạnh. Tham chiếu hoặc chìa khóa cho ý nghĩa của từ này sẽ là thuật ngữ Wasser
Bây giờ, nếu chúng ta muốn triển khai điều này trong Python, chúng ta không nên sử dụng danh sách chỉ có chỉ mục là số. Chúng ta nên sử dụng từ điển để thay thế
Đối với từ điển, chúng tôi sử dụng dấu ngoặc nhọn và mỗi phần tử có hai phần. khóa và giá trị
Trong ví dụ trước của chúng tôi, khóa là từ tiếng Đức, trong khi giá trị là bản dịch của từ đó sang tiếng Anh, như bạn có thể thấy trong ví dụ sau
if 100 > 10:
print["100 is greater than 10"]
28Bây giờ, khi chúng ta muốn truy cập các phần tử cụ thể trong từ điển, chúng ta chỉ cần sử dụng các phím. Ví dụ: giả sử rằng chúng ta muốn hiểu nghĩa của từ Brot trong tiếng Anh. Để làm điều đó, chúng ta chỉ cần tham chiếu phần tử đó bằng khóa đó
if 100 > 10:
print["100 is greater than 10"]
29Khi chúng tôi in giá trị mà chúng tôi nhận được, chúng tôi sẽ nhận được bản dịch sang tiếng Anh
Tương tự, chúng ta có thể nhận được bản dịch tiếng Anh của từ Milch bằng cách lấy giá trị của phần tử có Milch làm khóa
if 100 > 10:
print["100 is greater than 10"]
30Chúng tôi cũng có thể lấy giá trị của một phần tử trong từ điển bằng cách sử dụng
print[50 + 4] # 54
50 và chỉ định khóa của mục mà chúng tôi muốn lấyif 100 > 10:
print["100 is greater than 10"]
31Cả khóa và giá trị đều có thể thuộc bất kỳ loại dữ liệu nào
Từ điển có thể có các giá trị trùng lặp, nhưng tất cả các khóa phải là duy nhất. Hãy xem ví dụ này để xem ý tôi là gì
if 100 > 10:
print["100 is greater than 10"]
32Chúng tôi có thể tạo từ điển bằng cách sử dụng
print[50 + 4] # 54
51if 100 > 10:
print["100 is greater than 10"]
33Cách thêm giá trị mới vào một lệnh
Chúng ta có thể thêm các giá trị mới bên trong từ điển bằng cách chỉ định một khóa mới và một giá trị tương ứng. Sau đó, Python sẽ tạo một phần tử mới bên trong từ điển đó
if 100 > 10:
print["100 is greater than 10"]
34Nếu chúng tôi chỉ định khóa của một phần tử đã là một phần của từ điển, thì phần tử đó sẽ được sửa đổi
if 100 > 10:
print["100 is greater than 10"]
35Cách xóa các phần tử khỏi dict
Nếu chúng tôi muốn xóa các phần tử khỏi từ điển, chúng tôi có thể sử dụng phương pháp
print[50 + 4] # 54
34 và cũng chỉ định khóa của phần tử mà chúng tôi muốn xóaif 100 > 10:
print["100 is greater than 10"]
36Chúng tôi cũng có thể xóa các giá trị bằng cách sử dụng
print[50 + 4] # 54
53 để xóa cặp khóa-giá trị được chèn cuối cùng bắt đầu từ Python 3. 7. Trong các phiên bản trước, nó xóa một cặp ngẫu nhiênif 100 > 10:
print["100 is greater than 10"]
37Có một cách khác mà chúng ta có thể xóa các phần tử, cụ thể là bằng cách sử dụng câu lệnh
print[50 + 4] # 54
35if 100 > 10:
print["100 is greater than 10"]
38Làm thế nào để có được độ dài của một dict
Chúng ta có thể lấy độ dài của một từ điển bằng cách sử dụng
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
77 giống như với danh sách và bộ dữ liệuif 100 > 10:
print["100 is greater than 10"]
39Tư cách thành viên
Nếu chúng tôi muốn kiểm tra xem một khóa đã là một phần của từ điển hay chưa để chúng tôi tránh ghi đè nó, chúng tôi có thể sử dụng toán tử
print[50 + 4] # 54
40 và print[50 + 4] # 54
43 giống như với danh sách và bộ dữ liệuif 100 > 10:
print["100 is greater than 10"]
40Bao quát
Chúng ta có thể sử dụng khả năng hiểu giống như với danh sách để tạo từ điển một cách nhanh chóng
Để giúp chúng tôi làm điều đó, chúng tôi sẽ cần sử dụng một phương thức có tên là
print[50 + 4] # 54
58 để chuyển đổi một từ điển thành một danh sách các bộ dữ liệu. Phần tử ở chỉ số 0 là khoá, còn ở vị trí chỉ số 1 ta có giá trịTrước tiên hãy xem phương pháp
print[50 + 4] # 54
58 đang hoạt độngif 100 > 10:
print["100 is greater than 10"]
41Bây giờ, hãy tạo một từ điển mới từ từ điển hiện có này
print[50 + 4] # 54
60 bằng cách sử dụng khả năng hiểuChúng ta có thể cho rằng một giáo sư có tâm trạng vui vẻ và đủ hào phóng để thưởng cho mỗi sinh viên số điểm thưởng là
print[50 + 4] # 54
61. Chúng tôi muốn thêm những điểm mới này cho mỗi học sinh bằng cách lưu những điểm mới này vào một từ điển mớiif 100 > 10:
print["100 is greater than 10"]
42Đặt trong Python
Bộ là bộ sưu tập dữ liệu không có thứ tự và không được lập chỉ mục. Vì các phần tử trong tập hợp không được sắp xếp theo thứ tự nên chúng ta không thể truy cập các phần tử bằng cách sử dụng chỉ mục hoặc sử dụng phương thức
print[50 + 4] # 54
50Chúng ta có thể thêm các bộ, nhưng không thể thêm từ điển hoặc danh sách vào một tập hợp
Chúng tôi không thể thêm các phần tử trùng lặp trong bộ. Điều này có nghĩa là khi chúng ta muốn loại bỏ các phần tử trùng lặp khỏi một loại tập hợp khác, chúng ta có thể sử dụng tính duy nhất này trong các tập hợp
Hãy bắt đầu tạo bộ đầu tiên của chúng tôi bằng cách sử dụng dấu ngoặc nhọn như sau
if 100 > 10:
print["100 is greater than 10"]
43Chúng tôi cũng có thể tạo các bộ bằng cách sử dụng hàm tạo
print[50 + 4] # 54
63if 100 > 10:
print["100 is greater than 10"]
44Giống như tất cả các cấu trúc dữ liệu, chúng ta có thể tìm độ dài của một tập hợp bằng cách sử dụng phương pháp
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
77if 100 > 10:
print["100 is greater than 10"]
45Cách thêm phần tử vào tập hợp
Chúng ta có thể thêm một phần tử vào một tập hợp bằng cách sử dụng phương thức
print[50 + 4] # 54
65if 100 > 10:
print["100 is greater than 10"]
46Nếu chúng ta muốn thêm nhiều hơn một phần tử, thì chúng ta cần sử dụng phương thức
print[50 + 4] # 54
66. Chúng tôi sử dụng làm đầu vào cho phương thức này là danh sách, bộ dữ liệu, chuỗi hoặc tập hợp khácif 100 > 10:
print["100 is greater than 10"]
47Cách xóa phần tử khỏi tập hợp
Nếu chúng ta muốn xóa các phần tử khỏi tập hợp, chúng ta có thể sử dụng các phương thức
print[50 + 4] # 54
67 hoặc print[50 + 4] # 54
37if 100 > 10:
print["100 is greater than 10"]
48Nếu chúng tôi cố gắng xóa một phần tử không thuộc tập hợp bằng cách sử dụng
print[50 + 4] # 54
37, thì chúng tôi sẽ gặp lỗiif 100 > 10:
print["100 is greater than 10"]
49Để tránh những lỗi như vậy khi xóa phần tử khỏi tập hợp, chúng ta có thể sử dụng phương pháp
print[50 + 4] # 54
67if 100 > 10:
print["100 is greater than 10"]
50Đặt hoạt động lý thuyết
Nếu bạn còn nhớ những bài học toán ở trường trung học, bạn hẳn đã biết về hợp, giao và hiệu của hai tập hợp phần tử. Các hoạt động này cũng được hỗ trợ cho các bộ trong Python
liên hiệp
Union đại diện cho tập hợp tất cả các phần tử duy nhất từ cả hai tập hợp. Chúng ta có thể tìm hợp của hai tập hợp bằng cách sử dụng toán tử đường ống
print[50 + 4] # 54
71 hoặc phương pháp print[50 + 4] # 54
72if 100 > 10:
print["100 is greater than 10"]
51Ngã tư
Giao đại diện cho tập hợp chứa các phần tử nằm trong cả hai tập hợp. Chúng ta có thể tìm thấy nó bằng cách sử dụng toán tử
print[50 + 4] # 54
73 hoặc phương pháp print[50 + 4] # 54
74if 100 > 10:
print["100 is greater than 10"]
52Sự khác biệt
Sự khác biệt giữa hai bộ đại diện cho bộ sưu tập chỉ chứa các phần tử trong bộ đầu tiên, nhưng không có trong bộ thứ hai. Chúng ta có thể tìm thấy sự khác biệt giữa hai tập hợp bằng cách sử dụng toán tử
print[50 + 4] # 54
75 hoặc phương pháp print[50 + 4] # 54
76if 100 > 10:
print["100 is greater than 10"]
53Như bạn có thể nhớ từ thời trung học, việc sắp xếp các tập hợp khi chúng ta tìm thấy sự khác biệt của hai tập hợp là quan trọng, điều này không xảy ra với hợp và giao
Điều này tương tự với số học, trong đó
print[50 + 4] # 54
77 không bằng print[50 + 4] # 54
78if 100 > 10:
print["100 is greater than 10"]
54Chuyển đổi kiểu trong PythonChuyển đổi giữa các loại nguyên thủy
Python là ngôn ngữ lập trình hướng đối tượng. Đó là lý do tại sao nó sử dụng các hàm khởi tạo của các lớp để thực hiện chuyển đổi từ kiểu này sang kiểu khác
Phương pháp print[50 + 4] # 54
79
print[50 + 4] # 54
print[50 + 4] # 54
79 là một phương thức mà bạn sử dụng để chuyển đổi một số nguyên bằng chữ, bằng số float [làm tròn nó thành số nguyên trước đó, nghĩa là 3. 1 đến 3] hoặc một chuỗi ký tự [với điều kiện chuỗi đại diện cho một ký tự int hoặc float]if 100 > 10:
print["100 is greater than 10"]
55phương pháp """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
62
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
62 được sử dụng tương tự để tạo số float từ một số nguyên, số float hoặc chuỗi ký tự [với điều kiện chuỗi đại diện cho một ký tự print[50 + 4] # 54
83 hoặc print[50 + 4] # 54
84]if 100 > 10:
print["100 is greater than 10"]
56Phương pháp print[50 + 4] # 54
85
print[50 + 4] # 54
Chúng ta có thể sử dụng
print[50 + 4] # 54
85 để tạo chuỗi từ chuỗi, số nguyên, số float và nhiều loại dữ liệu khácif 100 > 10:
print["100 is greater than 10"]
57chuyển đổi khác
Để chuyển đổi từ kiểu cấu trúc dữ liệu này sang kiểu cấu trúc dữ liệu khác ta làm như sau
if 100 > 10:
print["100 is greater than 10"]
58Hãy để chúng tôi bắt đầu với các loại cụ thể, để nó trở nên rõ ràng hơn nhiều
Chuyển đổi thành danh sách
Chúng ta có thể chuyển đổi một tập hợp, bộ dữ liệu hoặc từ điển thành danh sách bằng hàm tạo
print[50 + 4] # 54
87if 100 > 10:
print["100 is greater than 10"]
59Khi chuyển đổi một từ điển thành một danh sách, chỉ các khóa của nó sẽ biến nó thành một danh sách
if 100 > 10:
print["100 is greater than 10"]
60Nếu chúng ta muốn giữ cả khóa và giá trị của một từ điển, trước tiên chúng ta cần sử dụng phương thức
print[50 + 4] # 54
58 để chuyển đổi nó thành một danh sách các bộ trong đó mỗi bộ là một khóa và một giá trịif 100 > 10:
print["100 is greater than 10"]
61Chuyển đổi thành bộ dữ liệu
Tất cả các cấu trúc dữ liệu có thể được chuyển đổi thành một bộ bằng cách sử dụng phương thức khởi tạo
print[50 + 4] # 54
89, bao gồm cả từ điển Trong trường hợp đó, chúng tôi nhận được một bộ với các khóa của từ điểnif 100 > 10:
print["100 is greater than 10"]
62Chuyển đổi thành bộ
Tương tự, tất cả các cấu trúc dữ liệu có thể được chuyển đổi thành một tập hợp bằng cách sử dụng phương thức xây dựng
print[50 + 4] # 54
63, bao gồm cả từ điển. Trong trường hợp đó, chúng tôi nhận được một tập hợp các khóa của từ điểnif 100 > 10:
print["100 is greater than 10"]
63Chuyển đổi sang từ điển
Chuyển đổi thành từ điển không thể được thực hiện với bất kỳ loại bộ, danh sách hoặc bộ nào, vì từ điển biểu thị cấu trúc dữ liệu trong đó mỗi phần tử chứa cả khóa và giá trị
Việc chuyển đổi danh sách hoặc bộ thành từ điển có thể được thực hiện nếu mỗi phần tử trong danh sách cũng là danh sách có hai phần tử hoặc bộ có hai phần tử
if 100 > 10:
print["100 is greater than 10"]
64Trong trường hợp khi muốn chuyển một tập hợp thành một từ điển, chúng ta cần mỗi phần tử là một bộ có độ dài 2
if 100 > 10:
print["100 is greater than 10"]
65Nếu chúng tôi cố gắng thực hiện chuyển đổi một tập hợp có mỗi phần tử dưới dạng danh sách có độ dài 2 thành từ điển, chúng tôi sẽ gặp lỗi
if 100 > 10:
print["100 is greater than 10"]
66Sau khi chúng tôi chạy khối mã cuối cùng, chúng tôi sẽ gặp lỗi
if 100 > 10:
print["100 is greater than 10"]
67Kết thúc các kiểu dữ liệu
Tóm lại, Python có nhiều loại dữ liệu mà bạn có thể sử dụng để lưu trữ dữ liệu. Những loại dữ liệu này rất quan trọng cần biết để bạn có thể chọn loại phù hợp với nhu cầu của mình
Đảm bảo sử dụng đúng loại dữ liệu cho tác vụ trước mặt bạn để tránh lỗi và tối ưu hóa hiệu suất
Kiểm soát luồng trong PythonCâu điều kiện
Khi bạn nghĩ về cách chúng ta suy nghĩ và cũng giao tiếp với nhau, bạn có thể có ấn tượng rằng chúng ta thực sự luôn sử dụng các điều kiện
- Nếu bây giờ là 8 giờ sáng, tôi bắt xe buýt và đi làm
- Nếu tôi đói, tôi ăn
- Nếu mặt hàng này rẻ, tôi có thể mua được
Đây cũng là điều mà bạn có thể làm trong lập trình. Chúng ta có thể sử dụng các điều kiện để kiểm soát luồng thực thi
Để làm điều đó, chúng tôi sử dụng thuật ngữ dành riêng nếu và một biểu thức đánh giá giá trị Đúng hoặc Sai. Sau đó, chúng tôi cũng có thể sử dụng một câu lệnh khác trong đó chúng tôi muốn luồng tiếp tục trong trường hợp điều kiện if không được đáp ứng
Để dễ hiểu hơn, giả sử rằng chúng ta có một ví dụ mà chúng ta muốn kiểm tra xem một số có dương không
if 100 > 10:
print["100 is greater than 10"]
68Nếu chúng ta có số = 2. chúng ta sẽ nhập vào nhánh if và thực thi lệnh được sử dụng để in văn bản sau trong bảng điều khiển
if 100 > 10:
print["100 is greater than 10"]
69Nếu chúng ta có một số khác, chẳng hạn như -1, chúng ta sẽ thấy trong bảng điều khiển thông báo sau được in
if 100 > 10:
print["100 is greater than 10"]
70Chúng tôi cũng có thể thêm các điều kiện bổ sung - và không chỉ 2 như trên - bằng cách sử dụng elif được đánh giá khi biểu thức if không được đánh giá
Hãy xem một ví dụ để bạn dễ hiểu hơn
if 100 > 10:
print["100 is greater than 10"]
71Bây giờ nếu chúng ta có số = 0, điều kiện đầu tiên sẽ không được đáp ứng, vì giá trị không lớn hơn 0. Như bạn có thể đoán, vì số đã cho bằng 0, chúng ta sẽ thấy thông báo sau được in trong bảng điều khiển
if 100 > 10:
print["100 is greater than 10"]
72Trong trường hợp giá trị âm, chương trình của chúng ta sẽ vượt qua hai điều kiện đầu tiên vì chúng không được thỏa mãn và sau đó chuyển sang nhánh khác và in thông báo sau trong bảng điều khiển
if 100 > 10:
print["100 is greater than 10"]
73Vòng lặp/Iterator
Vòng lặp thể hiện khả năng chương trình thực hiện lặp đi lặp lại một tập lệnh cho đến khi một điều kiện nhất định được đáp ứng. Chúng ta có thể làm điều đó với cả while và for
Trước tiên chúng ta hãy xem phép lặp với for
vòng lặp for trong Python
Vòng lặp này đơn giản và khá dễ hiểu. Tất cả những gì bạn phải làm là chỉ định trạng thái bắt đầu và đề cập đến phạm vi mà nó sẽ lặp lại, như bạn có thể thấy trong ví dụ sau
if 100 > 10:
print["100 is greater than 10"]
74Trong ví dụ này, chúng tôi đang lặp lại từ 1 đến 7 và in từng số [từ 1 đến 7 trừ 7] trong bảng điều khiển
Chúng ta có thể thay đổi cả số đầu và số cuối trong dãy theo ý muốn. Bằng cách này, chúng tôi có thể khá linh hoạt tùy thuộc vào các tình huống cụ thể của chúng tôi
vòng lặp while trong Python
Bây giờ hãy mô tả các phép lặp với while. Đây cũng là một cách khác để thực hiện các phép lặp cũng khá đơn giản và trực quan
Ở đây chúng ta cần chỉ định một điều kiện bắt đầu trước khối while và cũng cập nhật điều kiện tương ứng
Vòng lặp while cần một “điều kiện vòng lặp. ” Nếu nó vẫn đúng, nó tiếp tục lặp lại. Trong ví dụ này, khi
print[50 + 4] # 54
91 là print[50 + 4] # 54
92 thì điều kiện vòng lặp bằng """
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
44if 100 > 10:
print["100 is greater than 10"]
75Khối while này sẽ in các câu lệnh giống như mã mà chúng ta đã sử dụng với khối for
lặp lại. Vòng qua cấu trúc dữ liệu
Bây giờ chúng ta đã bao quát cả phép lặp và danh sách, chúng ta có thể chuyển sang các cách lặp qua danh sách
Chúng tôi không chỉ lưu trữ mọi thứ trong cấu trúc dữ liệu và để chúng ở đó lâu đời. Chúng tôi được cho là có thể sử dụng các yếu tố đó trong các tình huống khác nhau
Hãy lấy danh sách các sinh viên của chúng tôi từ trước
print[50 // 4] # 12
print[8 / 4] # 2
5Bây giờ, để duyệt qua danh sách, chúng ta chỉ cần gõ
if 100 > 10:
print["100 is greater than 10"]
77Vâng, thật đơn giản. Chúng tôi đang lặp qua từng phần tử trong danh sách và in các giá trị của chúng
Chúng tôi cũng có thể làm điều này cho từ điển. Nhưng vì phần tử trong từ điển có 2 phần [key và value] nên chúng ta cần xác định cả key và value như sau
if 100 > 10:
print["100 is greater than 10"]
78Chúng tôi cũng chỉ có thể lấy các khóa từ các thành phần của từ điển
if 100 > 10:
print["100 is greater than 10"]
79Lưu ý rằng khóa và giá trị chỉ đơn giản là tên biến mà chúng tôi đã chọn để minh họa cho phép lặp. Nhưng chúng ta có thể sử dụng bất kỳ tên nào chúng ta muốn cho các biến của mình, chẳng hạn như ví dụ sau
if 100 > 10:
print["100 is greater than 10"]
80Lần lặp lại này sẽ in cùng một thứ trong bảng điều khiển như khối mã trước cái cuối cùng
Chúng ta cũng có thể có các vòng lặp lồng nhau. Ví dụ: giả sử chúng ta muốn duyệt qua một danh sách các số và tìm tổng của từng phần tử với từng phần tử khác của danh sách. Chúng ta có thể làm điều đó bằng cách sử dụng các vòng lặp
print[50 + 4] # 54
45 lồng nhauif 100 > 10:
print["100 is greater than 10"]
81Cách dừng vòng lặp for
Đôi khi chúng ta có thể cần thoát khỏi vòng lặp
print[50 + 4] # 54
45 trước khi kết thúc. Đây có thể là trường hợp khi một điều kiện đã được đáp ứng hoặc chúng tôi đã tìm thấy những gì chúng tôi đang tìm kiếm và không cần phải tiếp tục nữaTrong những tình huống đó, chúng ta có thể sử dụng
print[50 + 4] # 54
96 để dừng bất kỳ lần lặp nào khác của vòng lặp print[50 + 4] # 54
45Giả sử rằng chúng ta muốn kiểm tra xem có một số âm trong danh sách hay không. Trong trường hợp chúng tôi tìm thấy số đó, chúng tôi sẽ ngừng tìm kiếm nó
Hãy thực hiện điều này bằng cách sử dụng
print[50 + 4] # 54
96if 100 > 10:
print["100 is greater than 10"]
82Như chúng ta có thể thấy, thời điểm chúng ta đạt -3, chúng ta thoát khỏi vòng lặp
print[50 + 4] # 54
45 và dừng lạiCách bỏ qua một lần lặp
Cũng có thể có trường hợp chúng tôi muốn bỏ qua một số lần lặp lại vì chúng tôi không quan tâm đến chúng và chúng không quan trọng lắm. Chúng ta có thể làm điều đó bằng cách sử dụng
print[50 - 4] # 46
00 để ngăn chặn việc thực thi mã bên dưới nó trong khối mã đó và chuyển quy trình thực thi sang lần lặp tiếp theoif 100 > 10:
print["100 is greater than 10"]
83print[50 - 4] # 46
01 là một câu lệnh chúng ta có thể sử dụng để trợ giúp khi chúng ta chuẩn bị triển khai một phương thức hoặc điều gì đó nhưng chúng ta chưa thực hiện và không muốn gặp lỗiNó giúp chúng tôi thực thi chương trình ngay cả khi một số phần của mã bị thiếu
if 100 > 10:
print["100 is greater than 10"]
84Tuyên bố có điều kiện Tóm tắt
Tóm lại, Python cung cấp các câu lệnh có điều kiện để giúp bạn kiểm soát luồng chương trình của mình
Câu lệnh
print[50 - 4] # 46
02 chỉ cho phép bạn chạy một khối mã nếu một điều kiện nhất định được đáp ứng. Câu lệnh print[50 - 4] # 46
03 chỉ cho phép bạn chạy một khối mã nếu một điều kiện khác được đáp ứng. Và câu lệnh print[50 - 4] # 46
04 chỉ cho phép bạn chạy một khối mã nếu không có điều kiện nào khác được đáp ứngNhững câu lệnh này rất hữu ích để kiểm soát luồng chương trình của bạn
Hàm trong PythonCó rất nhiều trường hợp chúng ta cần sử dụng đi sử dụng lại cùng một khối mã. Dự đoán đầu tiên của chúng tôi là viết nó bao nhiêu lần tùy thích
Về mặt khách quan, nó hoạt động, nhưng sự thật là, đây là một cách thực hành rất tệ. Chúng ta đang làm những công việc lặp đi lặp lại có thể khá nhàm chán và nó cũng dễ mắc nhiều lỗi hơn mà chúng ta có thể bỏ qua
Đây là lý do tại sao chúng ta cần bắt đầu sử dụng các khối mã mà chúng ta có thể xác định một lần và sau đó sử dụng cùng mã đó ở bất kỳ nơi nào khác
Chỉ cần nghĩ về điều này trong cuộc sống thực. Bạn thấy một video YouTube đã được quay và tải lên YouTube một lần. Sau đó, nó sẽ được nhiều người khác xem, nhưng video vẫn giữ nguyên video được tải lên ban đầu
Nói cách khác, chúng tôi sử dụng các phương thức làm đại diện cho một tập hợp các hướng dẫn mã hóa mà sau đó được cho là được gọi ở bất kỳ nơi nào khác trong mã và chúng tôi không phải viết lại nhiều lần.
Trong trường hợp muốn sửa đổi phương thức này, chúng ta chỉ cần thay đổi nó ở nơi nó được khai báo đầu tiên và những nơi khác mà nó được gọi không phải làm gì cả
Để xác định một phương thức trong Python, chúng tôi bắt đầu bằng cách sử dụng từ khóa
print[50 - 4] # 46
05, sau đó là tên của hàm và sau đó là danh sách các đối số mà chúng tôi muốn sử dụng. Sau đó, chúng ta cần bắt đầu viết phần thân của phương thức trong một dòng mới sau khi thụt đầu dòngif 100 > 10:
print["100 is greater than 10"]
85Như bạn có thể thấy từ phần đánh dấu cú pháp, cả
print[50 - 4] # 46
05 và print[50 - 4] # 46
07 đều là các từ khóa trong Python mà bạn không thể sử dụng để đặt tên cho các biến của mìnhBây giờ, bất cứ nơi nào chúng ta muốn gọi
print[50 - 4] # 46
08[] này, chúng ta chỉ cần gọi nó ở đó và không phải lo lắng về việc triển khai nó hoàn toànVì chúng tôi đã xác định phương thức này, chúng tôi có thể gọi nó theo cách sau
if 100 > 10:
print["100 is greater than 10"]
86Bạn có thể nghĩ rằng đây là một phương thức đơn giản và bắt đầu hỏi, tại sao chúng ta thậm chí còn bận tâm viết một phương thức cho nó?
Bạn đúng rồi. Đây là một phương pháp rất đơn giản chỉ để giới thiệu cho bạn cách chúng ta có thể thực hiện các chức năng
Hãy viết hàm tìm tổng các số nằm giữa hai số xác định
if 100 > 10:
print["100 is greater than 10"]
87Bây giờ đây là một tập hợp các hướng dẫn mà bạn có thể gọi ở những nơi khác và không phải viết lại tất cả
if 100 > 10:
print["100 is greater than 10"]
88Lưu ý rằng các hàm xác định một phạm vi, có nghĩa là các biến được xác định trong phạm vi đó không thể truy cập được bên ngoài phạm vi đó
Ví dụ: chúng ta không thể truy cập biến có tên
print[50 - 4] # 46
09 bên ngoài phạm vi của hàmif 100 > 10:
print["100 is greater than 10"]
89print[50 - 4] # 46
09 chỉ có thể truy cập bên trong phần thân của phương thức nàyĐối số mặc định trong Hàm
Khi chúng ta gọi các hàm, chúng ta có thể tạo một số đối số tùy chọn bằng cách viết giá trị ban đầu cho chúng ở phần đầu của hàm
Hãy lấy một ví dụ về việc lấy tên của người dùng làm đối số bắt buộc và để đối số thứ hai là đối số tùy chọn
if 100 > 10:
print["100 is greater than 10"]
90Bây giờ chúng ta sẽ gọi hàm này với cả hai đối số
if 100 > 10:
print["100 is greater than 10"]
91Bây giờ chúng ta có thể gọi hàm tương tự mặc dù đối số thứ hai không được chỉ định
if 100 > 10:
print["100 is greater than 10"]
92Danh sách đối số từ khóa
Chúng ta có thể định nghĩa đối số của hàm là từ khóa
if 100 > 10:
print["100 is greater than 10"]
93Bây giờ, chúng ta có thể gọi hàm này bằng cách viết các đối số dưới dạng từ khóa
if 100 > 10:
print["100 is greater than 10"]
94Như bạn có thể thấy, chúng ta có thể bỏ qua
print[50 - 4] # 46
11 vì nó không bắt buộc. Chúng ta cũng có thể thay đổi thứ tự của các đối số khi gọi hàm và nó vẫn hoạt động như cũif 100 > 10:
print["100 is greater than 10"]
95Vòng đời dữ liệu
Các biến được khai báo bên trong một hàm không thể được truy cập bên ngoài nó. Họ bị cô lập
Hãy xem một ví dụ để minh họa điều này
if 100 > 10:
print["100 is greater than 10"]
96Tương tự, chúng ta không thể thay đổi các biến bên trong các hàm đã được khai báo bên ngoài các hàm và không được truyền dưới dạng đối số
if 100 > 10:
print["100 is greater than 10"]
97Cách thay đổi dữ liệu bên trong hàm
Chúng ta có thể thay đổi dữ liệu có thể thay đổi được truyền qua hàm dưới dạng đối số. Dữ liệu có thể thay đổi đại diện cho dữ liệu mà chúng tôi có thể sửa đổi ngay cả sau khi nó đã được khai báo. Ví dụ, danh sách là dữ liệu có thể thay đổi
if 100 > 10:
print["100 is greater than 10"]
98Trong trường hợp dữ liệu không thay đổi, chúng ta chỉ có thể sửa đổi biến bên trong hàm, còn giá trị thực bên ngoài hàm đó sẽ không thay đổi. Dữ liệu bất biến là chuỗi và số
if 100 > 10:
print["100 is greater than 10"]
99Nếu chúng ta thực sự muốn cập nhật các biến không thay đổi thông qua một hàm, chúng ta có thể gán giá trị trả về của hàm cho biến không thay đổi
# This is a comment in Python
00Hàm Lambda
Các hàm lambda là các hàm ẩn danh mà chúng ta có thể sử dụng để trả về kết quả. Chúng ta có thể viết các hàm lambda bằng mẫu cú pháp sau
# This is a comment in Python
01Biểu thức chỉ có thể được viết trong một dòng
Hãy bắt đầu minh họa các chức năng ẩn danh này bằng một vài ví dụ
Chúng ta sẽ bắt đầu với một hàm nhân mỗi đầu vào với 10
# This is a comment in Python
02Hãy viết một ví dụ khác trong đó chúng tôi kiểm tra xem đối số đã cho có tích cực hay không
# This is a comment in Python
03Lưu ý rằng chúng ta không thể sử dụng mệnh đề
print[50 - 4] # 46
02 mà không có mệnh đề print[50 - 4] # 46
04 bên trong hàm lambdaĐến đây, bạn có thể thắc mắc, tại sao chúng ta cần sử dụng các hàm lambda, vì chúng dường như gần giống với các hàm khác?
Chúng ta có thể thấy điều đó được minh họa trong phần sau
Hàm làm đối số của hàm
Cho đến nay, chúng ta đã thấy các cách gọi hàm sử dụng số và chuỗi. Chúng ta thực sự có thể gọi các hàm với bất kỳ loại đối tượng Python nào
Chúng tôi thậm chí có thể cung cấp toàn bộ hàm làm đối số của hàm, có thể cung cấp mức độ trừu tượng có thể khá hữu ích
Hãy xem một ví dụ mà chúng tôi muốn thực hiện một số chuyển đổi từ đơn vị này sang đơn vị khác
# This is a comment in Python
04Bây giờ, chúng ta có thể tạo một hàm tổng quát và chuyển một hàm khác làm đối số
# This is a comment in Python
05Bây giờ chúng ta có thể gọi
print[50 - 4] # 46
14 như thế này# This is a comment in Python
06Như bạn có thể thấy, chúng ta đã viết
print[50 - 4] # 46
15 như một tham số của hàm print[50 - 4] # 46
14. Chúng ta có thể sử dụng các chức năng đã được xác định khác như thế# This is a comment in Python
07Bây giờ chúng ta có thể sử dụng lambdas và làm cho loại trừu tượng này đơn giản hơn nhiều
Thay vì viết tất cả bốn hàm đó, chúng ta chỉ cần viết một hàm lambda ngắn gọn và sử dụng nó làm tham số khi gọi hàm
print[50 - 4] # 46
14# This is a comment in Python
08Điều này tất nhiên là đơn giản hơn
Hãy sử dụng một vài ví dụ khác với các chức năng tích hợp
Hàm print[50 - 4] # 46
18
print[50 - 4] # 46
map[] là một hàm tích hợp để tạo một đối tượng mới bằng cách nhận kết quả bằng cách gọi một hàm trên từng thành phần của danh sách hiện có
# This is a comment in Python
09Hãy xem một ví dụ về cách viết hàm lambda dưới dạng hàm của bản đồ
Hãy nhân ba mỗi số trong danh sách bằng cách sử dụng khả năng hiểu danh sách
# This is a comment in Python
10Chúng ta có thể thực hiện điều đó bằng cách sử dụng hàm
print[50 - 4] # 46
18 và hàm lambda# This is a comment in Python
11Điều này tạo ra một danh sách mới. Danh sách cũ không thay đổi
chức năng print[50 - 4] # 46
20
print[50 - 4] # 46
Đây là một chức năng tích hợp khác mà chúng ta có thể sử dụng để lọc các phần tử của danh sách thỏa mãn một điều kiện
Trước tiên, hãy lọc ra các phần tử phủ định khỏi danh sách bằng cách sử dụng tính năng hiểu danh sách
# This is a comment in Python
12Bây giờ, chúng ta sẽ lọc các phần tử bằng cách sử dụng
print[50 - 4] # 46
20 và hàm lambda. Hàm này trả về một đối tượng mà chúng ta có thể chuyển đổi thành danh sách bằng cách sử dụng print[50 + 4] # 54
87# This is a comment in Python
13Bây giờ bạn sẽ hiểu cách bạn có thể gọi các hàm với các hàm khác làm đối số và tại sao lambda lại hữu ích và quan trọng
Trang trí trong Python
Một trình trang trí đại diện cho một chức năng chấp nhận một chức năng khác làm đối số
Chúng ta có thể nghĩ về nó như một cách năng động để thay đổi cách hoạt động của một hàm, phương thức hoặc lớp mà không cần phải sử dụng các lớp con.
Khi một chức năng đang được truyền dưới dạng đối số cho trình trang trí, nó sẽ được sửa đổi và sau đó được trả về dưới dạng một chức năng mới
Hãy bắt đầu với một chức năng cơ bản mà chúng ta muốn trang trí
# This is a comment in Python
14Trong ví dụ này, chúng tôi chỉ đơn giản là trả về một danh sách đảo ngược
Chúng ta cũng có thể viết một hàm chấp nhận một hàm khác làm đối số
# This is a comment in Python
15Chúng ta cũng có thể lồng một hàm bên trong một hàm khác
# This is a comment in Python
16Trong ví dụ này,
print[50 - 4] # 46
23 bây giờ là một hàm cục bộ và không thể được gọi bên ngoài phạm vi của hàm print[50 - 4] # 46
24Bây giờ chúng ta có thể viết decorator đầu tiên của chúng ta
# This is a comment in Python
17print[50 - 4] # 46
25 là một hàm trang trí lấy đầu vào là một hàm khác. Để gọi nó, chúng ta cần viết một chức năng khác# This is a comment in Python
18Bây giờ chúng ta có thể gọi trình trang trí với chức năng mới của mình làm đối số
# This is a comment in Python
19Đây là ví dụ hoàn chỉnh
# This is a comment in Python
20Chúng ta cũng có thể gọi một decorator bằng cách sử dụng các chú thích. Để làm điều đó, chúng tôi sử dụng dấu
print[50 - 4] # 46
26 trước tên của trình trang trí mà chúng tôi muốn gọi và đặt nó ngay trên tên của chức năng# This is a comment in Python
21Bây giờ, chúng ta chỉ cần gọi hàm
print[50 - 4] # 46
27 và trình trang trí sẽ được áp dụng trong đó# This is a comment in Python
22Cách xếp đồ trang trí
Chúng ta cũng có thể sử dụng nhiều decorator cho một hàm. Thứ tự thực hiện của chúng bắt đầu từ trên xuống dưới, nghĩa là trình trang trí đã được xác định trước sẽ được áp dụng trước, sau đó là trình thứ hai, v.v.
Hãy thực hiện một thử nghiệm đơn giản và áp dụng cùng một công cụ trang trí mà chúng tôi đã xác định trong phần trước hai lần
Trước tiên hãy hiểu điều đó có nghĩa là gì
Vì vậy, trước tiên chúng tôi gọi trình trang trí để đảo ngược danh sách
print[50 - 4] # 46
28 đến print[50 - 4] # 46
29Sau đó, chúng tôi áp dụng nó một lần nữa, nhưng bây giờ với kết quả được trả về từ lần gọi trình trang trí trước đó
print[50 - 4] # 46
29 => print[50 - 4] # 46
28Nói cách khác, đảo ngược danh sách và sau đó đảo ngược danh sách đảo ngược đó một lần nữa sẽ trả về thứ tự ban đầu của danh sách
Hãy xem điều này với các nhà trang trí
# This is a comment in Python
23Tôi sẽ giải thích điều này với một ví dụ khác
Hãy triển khai một trình trang trí khác chỉ trả về các số lớn hơn 1. Sau đó, chúng tôi muốn đảo ngược danh sách được trả về với trình trang trí hiện có của chúng tôi
# This is a comment in Python
24Bây giờ chúng ta có thể gọi trình trang trí này và trình trang trí khác mà chúng ta đã triển khai
# This is a comment in Python
25Đây là ví dụ hoàn chỉnh
# This is a comment in Python
26Cách truyền đối số cho hàm trang trí
Chúng ta cũng có thể truyền đối số cho các hàm trang trí
# This is a comment in Python
27Trang trí tích hợp
Python đi kèm với nhiều bộ trang trí tích hợp sẵn, chẳng hạn như
print[50 - 4] # 46
32, print[50 - 4] # 46
33, print[50 - 4] # 46
34, v.v. Chúng tôi sẽ đề cập đến những điều này trong chương tiếp theoKết thúc chức năng
Python là một ngôn ngữ tuyệt vời để viết các hàm vì chúng dễ viết
Các hàm lambda là một cách tuyệt vời để tạo các hàm nhỏ, ngắn gọn trong Python. Chúng hoàn hảo khi bạn không cần chức năng toàn diện hoặc khi bạn chỉ muốn kiểm tra một đoạn mã
Trình trang trí Python là một cách tuyệt vời để cải thiện khả năng đọc và bảo trì mã. Chúng cho phép bạn mô đun hóa mã của mình và làm cho mã có tổ chức hơn. Bạn cũng có thể sử dụng chúng để thực hiện các tác vụ khác nhau như ghi nhật ký, xử lý ngoại lệ và kiểm tra. Vì vậy, nếu bạn đang tìm cách dọn dẹp mã Python của mình, hãy cân nhắc sử dụng trình trang trí
Lập trình hướng đối tượng trong PythonNếu bạn đi mua bánh quy tại một cửa hàng địa phương, bạn sẽ nhận được một phiên bản cookie đã được sản xuất thành nhiều bản khác
Có một máy cắt bánh quy tại một nhà máy đã được sử dụng để sản xuất một số lượng lớn bánh quy, sau đó được phân phối khắp các cửa hàng khác nhau, nơi những chiếc bánh quy đó sau đó được phục vụ cho khách hàng cuối cùng
Chúng ta có thể coi khuôn cắt bánh quy đó như một bản thiết kế đã được thiết kế một lần và được sử dụng nhiều lần sau đó. Chúng tôi cũng sử dụng loại bản thiết kế này trong lập trình máy tính
Một bản thiết kế được dùng để tạo ra vô số bản sao khác được gọi là một lớp. Chúng ta có thể nghĩ về một lớp giống như một lớp được gọi là Bánh quy, Nhà máy, Tòa nhà, Sách, Bút chì, v.v. Chúng ta có thể sử dụng lớp cookie như một kế hoạch chi tiết để tạo bao nhiêu trường hợp tùy thích mà chúng ta gọi là các đối tượng
Nói cách khác, bản thiết kế là các lớp được sử dụng làm công cụ cắt cookie, trong khi cookie được phục vụ tại các cửa hàng khác nhau là đối tượng
Lập trình hướng đối tượng đại diện cho cách tổ chức chương trình bằng cách sử dụng các lớp và đối tượng. Chúng tôi sử dụng các lớp để tạo các đối tượng. Các đối tượng tương tác với nhau
Chúng tôi không sử dụng cùng một bản thiết kế cho mọi đối tượng hiện có. Có một kế hoạch chi tiết để sản xuất sách, một kế hoạch khác để sản xuất bút chì, v.v. Chúng ta cần phân loại chúng dựa trên các thuộc tính và chức năng của chúng
Một đối tượng được tạo từ lớp Pencil có thể có loại màu, nhà sản xuất, độ dày cụ thể, v.v. Đây là những thuộc tính. Một đối tượng bút chì cũng có thể viết đại diện cho chức năng hoặc phương thức của nó
Chúng tôi sử dụng các lớp và đối tượng trong các ngôn ngữ lập trình khác nhau, bao gồm cả Python
Hãy xem lớp Xe đạp rất cơ bản trông như thế nào trong Python
# This is a comment in Python
28Chúng tôi đã sử dụng từ khóa lớp để chỉ ra rằng chúng tôi sắp bắt đầu viết một lớp và sau đó chúng tôi nhập tên của lớp
Chúng tôi đã thêm
print[50 - 4] # 46
01 vì chúng tôi không muốn trình thông dịch Python la mắng chúng tôi bằng cách ném lỗi vì không tiếp tục viết phần mã còn lại thuộc về lớp nàyBây giờ, nếu chúng ta muốn tạo các đối tượng mới từ lớp Xe đạp này, chúng ta chỉ cần viết tên của đối tượng [có thể là bất kỳ tên biến nào bạn muốn] và khởi tạo nó bằng phương thức khởi tạo Xe đạp [] được sử dụng để tạo mới.
# This is a comment in Python
29Trong trường hợp này, favorite_bike là một đối tượng được tạo từ lớp Xe đạp. Nó có tất cả các chức năng và thuộc tính của lớp Xe đạp
Chúng tôi có thể làm phong phú lớp Xe đạp của mình và bao gồm các thuộc tính bổ sung để chúng tôi có thể có những chiếc xe đạp tùy chỉnh, phù hợp với nhu cầu của chúng tôi
Để làm điều đó, chúng ta có thể định nghĩa một phương thức khởi tạo có tên là init như sau
# This is a comment in Python
30Lưu ý cách sử dụng dấu gạch dưới trước và sau tên
print[50 - 4] # 46
36 của phương thức. Chúng đại diện cho các chỉ báo để trình thông dịch Python coi phương thức đó là một phương thức đặc biệtĐây là một phương pháp không trả về bất cứ điều gì. Đó là một cách thực hành tốt để định nghĩa nó là phương thức đầu tiên của lớp, để các nhà phát triển khác cũng có thể thấy nó ở một dòng cụ thể
Bây giờ, nếu chúng ta muốn tạo các đối tượng mới bằng cách sử dụng bản thiết kế xe đạp này, chúng ta chỉ cần viết
# This is a comment in Python
31Chúng tôi đã cung cấp các tham số tùy chỉnh của mình cho chiếc xe đạp này và đang chuyển chúng cho phương thức khởi tạo. Sau đó, chúng tôi nhận được một chiếc xe đạp mới với những thuộc tính cụ thể đó. Như bạn có thể biết, chúng tôi đang tạo ra một chiếc xe đạp leo núi màu xám của thương hiệu
print[50 - 4] # 46
37Chúng ta cũng có thể tạo các đối tượng từ các lớp bằng cách sử dụng các đối số tùy chọn như sau
# This is a comment in Python
32Bây giờ chúng ta vừa tạo đối tượng này với các thuộc tính này, hiện không thể truy cập được bên ngoài phạm vi của lớp
Điều này có nghĩa là chúng ta đã tạo đối tượng mới này từ lớp Xe đạp, nhưng các thuộc tính tương ứng của nó không thể truy cập được. Để truy cập chúng, chúng tôi có thể triển khai các phương thức giúp chúng tôi truy cập chúng
Để làm điều đó, chúng ta sẽ định nghĩa
print[50 - 4] # 46
38 và print[50 - 4] # 46
39, đại diện cho các phương thức mà chúng ta sử dụng để lấy và đặt giá trị cho các thuộc tính của đối tượng. Chúng tôi sẽ sử dụng một chú thích có tên là ________ 634 để giúp chúng tôi thực hiện điều đóHãy xem nó với mã
# This is a comment in Python
33Chúng ta có thể viết getters và setters cho tất cả các thuộc tính của lớp
# This is a comment in Python
34Bây giờ chúng ta đã định nghĩa chúng, chúng ta có thể gọi các phương thức getter này là các thuộc tính
# This is a comment in Python
35Chúng tôi cũng có thể sửa đổi giá trị mà chúng tôi đã sử dụng ban đầu cho bất kỳ thuộc tính nào bằng cách nhập tên của đối tượng và thuộc tính mà chúng tôi muốn thay đổi nội dung
# This is a comment in Python
36Các lớp của chúng ta cũng có thể có các phương thức khác chứ không chỉ getters và setters
Hãy định nghĩa một phương thức bên trong lớp Xe đạp mà sau đó chúng ta có thể gọi từ bất kỳ đối tượng nào mà chúng ta đã tạo từ lớp đó
# This is a comment in Python
37Chúng tôi đã tạo một phương thức rất đơn giản trong đó chúng tôi đang chuẩn bị một chuỗi là kết quả từ các thuộc tính của đối tượng mà chúng tôi đang tạo. Sau đó chúng ta có thể gọi phương thức này giống như bất kỳ phương thức nào khác
Hãy xem điều này trong hành động
# This is a comment in Python
38Các phương thức trong Python
Các phương thức tương tự như các hàm mà chúng tôi đã trình bày ở trên
Tóm lại, chúng tôi nhóm một vài câu lệnh trong một khối mã gọi là phương thức. Ở đó, chúng tôi thực hiện một số thao tác mà chúng tôi dự kiến sẽ được thực hiện nhiều lần và không muốn viết đi viết lại chúng. Cuối cùng, chúng tôi có thể không trả lại bất kỳ kết quả nào cả
Có ba loại phương thức trong Python
- phương pháp cá thể
- phương pháp lớp
- phương pháp tĩnh
Hãy nói ngắn gọn về cấu trúc tổng thể của các phương thức và sau đó đi sâu hơn một chút vào chi tiết cho từng loại phương thức
Thông số
Các tham số của một phương thức giúp chúng ta có thể chuyển các giá trị động mà sau đó có thể được xem xét khi thực hiện các câu lệnh bên trong phương thức
Câu lệnh
print[50 - 4] # 46
07 đại diện cho câu lệnh sẽ là câu lệnh cuối cùng được thực thi trong phương thức đó. Nó là một chỉ báo để trình thông dịch Python dừng thực thi bất kỳ dòng nào khác và trả về một giá trịTự luận
Đối số đầu tiên của một phương thức trong Python là
print[50 - 4] # 46
42, đây cũng là một trong những điểm khác biệt giữa phương thức và hàm. Nó đại diện cho một tham chiếu đến đối tượng mà nó thuộc về. Nếu chúng ta không chỉ định làm đối số đầu tiên của phương thức khi được khai báo, thì đối số đầu tiên sẽ được coi là tham chiếu đến đối tượngChúng ta chỉ viết nó khi chúng ta khai báo phương thức, nhưng chúng ta không cần đưa nó vào khi chúng ta gọi phương thức cụ thể đó bằng cách sử dụng một đối tượng làm trình gọi
Chúng tôi không bắt buộc phải đặt tên cho nó là
print[50 - 4] # 46
42, nhưng đó là một quy ước được thực hiện rộng rãi bởi các nhà phát triển viết mã Python trên toàn thế giớiHãy định nghĩa một phương thức thể hiện bên trong lớp
print[50 - 4] # 46
44 mà sau đó chúng ta có thể gọi từ bất kỳ đối tượng nào mà chúng ta đã tạo từ lớp đó# This is a comment in Python
37Chúng tôi đã tạo một phương thức rất đơn giản trong đó chúng tôi đang chuẩn bị một chuỗi là kết quả từ các thuộc tính của đối tượng mà chúng tôi đang tạo. Sau đó chúng ta có thể gọi phương thức này giống như bất kỳ phương thức nào khác
# This is a comment in Python
40phương pháp lớp
Chúng tôi đã đề cập đến các phương thức cá thể cho đến nay. Đây là những phương thức mà chúng ta có thể gọi với các đối tượng
Các phương thức lớp là các phương thức mà chúng ta có thể gọi bằng tên lớp và chúng ta có thể truy cập mà không cần phải tạo bất kỳ đối tượng mới nào
Vì nó là một loại phương thức cụ thể, chúng ta cần nói với trình thông dịch Python rằng nó thực sự khác. Chúng tôi làm điều đó bằng cách thay đổi cú pháp
Chúng tôi sử dụng chú thích
print[50 - 4] # 46
32 phía trên một phương thức lớp và print[50 - 4] # 46
46 tương tự như việc sử dụng print[50 - 4] # 46
42 cho các phương thức ví dụ. print[50 - 4] # 46
46 chỉ là một cách thông thường để chỉ lớp đang gọi phương thức – bạn không cần phải sử dụng tên nàyHãy khai báo phương thức hạng nhất của chúng ta
# This is a comment in Python
41Bây giờ hãy gọi phương thức lớp này mà chúng ta vừa khai báo
# This is a comment in Python
42Lưu ý rằng chúng ta không phải viết bất kỳ đối số nào khi gọi phương thức
print[50 - 4] # 46
49. Mặt khác, khi chúng ta khai báo các phương thức và phương thức thể hiện, chúng ta phải luôn bao gồm ít nhất một đối sốphương pháp tĩnh
Đây là những phương thức không có quan hệ trực tiếp với biến lớp hoặc biến thể hiện. Bạn có thể coi chúng như các hàm tiện ích được cho là giúp chúng ta làm điều gì đó với các đối số được truyền khi gọi chúng.
Chúng ta có thể gọi chúng bằng cách sử dụng cả tên lớp và đối tượng được tạo bởi lớp đó nơi phương thức này được khai báo. Điều này có nghĩa là chúng không cần phải có đối số đầu tiên liên quan đến đối tượng hoặc lớp gọi chúng [như trường hợp sử dụng tham số
print[50 - 4] # 46
42 cho các phương thức mẫu và print[50 - 4] # 46
46 cho các phương thức lớp]Không có giới hạn về số lượng đối số mà chúng ta có thể sử dụng để gọi chúng
Để tạo nó, chúng ta cần sử dụng chú thích
print[50 - 4] # 46
33Hãy tạo một phương thức tĩnh
# This is a comment in Python
43Các phương thức tĩnh không thể sửa đổi các thuộc tính của lớp hoặc cá thể. Chúng có nghĩa là giống như các chức năng tiện ích
Nếu chúng tôi cố gắng thay đổi một lớp học, chúng tôi sẽ gặp lỗi
# This is a comment in Python
44Nếu chúng ta cố gắng gọi phương thức tĩnh này ngay bây giờ, chúng ta sẽ gặp lỗi
________ 245 ________ 246Điều này là do các phương thức tĩnh không có bất kỳ tham chiếu nào đến
print[50 - 4] # 46
42 vì chúng không liên quan trực tiếp đến các đối tượng hoặc lớp và vì vậy chúng không thể sửa đổi các thuộc tínhcông cụ sửa đổi quyền truy cập
Khi tạo các lớp, chúng ta có thể hạn chế quyền truy cập vào các thuộc tính và phương thức nhất định để chúng không thể truy cập dễ dàng.
Chúng tôi có công cụ sửa đổi truy cập
print[50 - 4] # 46
54 và print[50 - 4] # 46
55Hãy xem cách cả hai làm việc
thuộc tính công cộng
Thuộc tính công khai là những thuộc tính có thể truy cập từ cả bên trong và bên ngoài lớp
Theo mặc định, tất cả các thuộc tính và phương thức đều công khai trong Python. Nếu chúng tôi muốn chúng ở chế độ riêng tư, chúng tôi cần chỉ định rằng
Hãy xem một ví dụ về thuộc tính công cộng
# This is a comment in Python
47Trong khối mã trước, cả
print[50 - 4] # 46
56 và print[50 - 4] # 46
57 đều có thể truy cập bên ngoài lớp vì chúng là print[50 - 4] # 46
54 và có thể được truy cập cả bên trong và bên ngoài lớp# This is a comment in Python
48thuộc tính riêng tư
Các thuộc tính private chỉ có thể được truy cập trực tiếp từ bên trong lớp
Chúng ta có thể tạo các thuộc tính thuộc tính bằng cách sử dụng dấu gạch dưới kép, như bạn có thể thấy trong ví dụ sau
# This is a comment in Python
49Bây giờ nếu chúng ta thử truy cập vào
print[50 - 4] # 46
59, chúng ta sẽ gặp lỗi# This is a comment in Python
50Bây giờ chúng ta hãy xem một ví dụ nơi chúng ta đang khai báo các phương thức riêng tư bằng cách sử dụng dấu gạch dưới kép ở phía trước tên của phương thức mà chúng ta muốn đặt ở chế độ riêng tư
# This is a comment in Python
51Bây giờ, nếu chúng ta muốn gọi phương thức riêng tư này từ bên ngoài lớp, một lỗi sẽ xảy ra
# This is a comment in Python
52Việc có các biến riêng tư trong Python không phải là một thông lệ phổ biến. Tuy nhiên, các nhà phát triển có thể thấy cần phải hạn chế quyền truy cập để các biến cụ thể không bị truy cập và sửa đổi một cách bất cẩn
Cách ẩn thông tin trong Python
Khi bạn ra ngoài và sử dụng máy pha cà phê, bạn sẽ không biết tất cả các chi tiết kỹ thuật đằng sau chiếc máy đó
Điều này cũng tương tự với chiếc xe của bạn. Khi ngồi vào ghế lái, bạn không phân tích và hiểu hết chi tiết từng bộ phận của xe. Bạn có một số ý tưởng cơ bản về chúng, nhưng ngoài ra, bạn chỉ tập trung vào việc lái xe
Đây là một loại hạn chế quyền truy cập từ những người bên ngoài, để họ không phải lo lắng về các chi tiết chính xác đang diễn ra bên trong
Chúng ta cũng có thể làm điều đó trong Python
Cho đến nay chúng ta đã thấy các khối nền tảng của lập trình hướng đối tượng, chẳng hạn như lớp và đối tượng.
Các lớp là các bản thiết kế được sử dụng để tạo các thể hiện được gọi là các đối tượng. Chúng ta có thể sử dụng các đối tượng của các lớp khác nhau để tương tác với nhau và xây dựng một chương trình mạnh mẽ
Khi chúng tôi làm việc trên các chương trình của riêng mình, chúng tôi có thể không cần cho mọi người biết về tất cả các chi tiết mà các lớp của chúng tôi có. Vì vậy, chúng tôi có thể giới hạn quyền truy cập vào chúng, để các thuộc tính nhất định ít có khả năng bị truy cập ngoài ý muốn và bị sửa đổi sai
Để giúp chúng tôi làm điều đó, chúng tôi ẩn các phần của một lớp và chỉ cung cấp một giao diện có ít chi tiết hơn về hoạt động bên trong của lớp chúng tôi
Chúng ta có thể ẩn dữ liệu theo hai cách
- đóng gói
- trừu tượng
Hãy bắt đầu với Đóng gói
Đóng gói là gì?
Đóng gói không phải là điều gì đó đặc biệt và duy nhất chỉ dành cho Python. Các ngôn ngữ lập trình khác cũng sử dụng nó
Tóm lại, chúng ta có thể định nghĩa nó là ràng buộc dữ liệu và phương thức trong một lớp. Sau đó chúng tôi sử dụng lớp này để tạo các đối tượng
Chúng tôi đóng gói các lớp bằng cách sử dụng công cụ sửa đổi truy cập
print[50 - 4] # 46
55 mà sau đó có thể hạn chế quyền truy cập trực tiếp vào các thuộc tính đó. Điều này có thể hạn chế kiểm soátSau đó, chúng tôi phải viết các phương thức công khai có thể cung cấp quyền truy cập vào thế giới bên ngoài
Các phương thức này được gọi là
print[50 - 4] # 46
38 và print[50 - 4] # 46
39Phương thức getter là phương thức mà chúng ta sử dụng để lấy giá trị của một thuộc tính
Setter là một phương thức mà chúng ta sử dụng để thiết lập giá trị của một thuộc tính
Trước tiên, hãy xác định một phương thức
print[50 - 4] # 46
63 và một phương thức print[50 - 4] # 46
64 mà chúng ta có thể sử dụng để lấy các giá trị# This is a comment in Python
53Bây giờ, hãy sử dụng lớp này để thiết lập kiểu và cũng lấy kiểu
# This is a comment in Python
54Những gì chúng ta đã làm cho đến nay là thiết lập và cũng đọc giá trị của một thuộc tính riêng tư của một đối tượng được tạo từ lớp
print[50 - 4] # 46
65Chúng ta cũng có thể định nghĩa
print[50 - 4] # 46
38 và print[50 - 4] # 46
39 bằng cách sử dụng chú thích print[50 - 4] # 46
34Hãy xem nó với mã
# This is a comment in Python
55Bây giờ chúng ta đã định nghĩa chúng, chúng ta có thể gọi các phương thức getter này là các thuộc tính
# This is a comment in Python
56Chúng tôi cũng có thể sửa đổi giá trị mà chúng tôi đã sử dụng ban đầu cho bất kỳ thuộc tính nào bằng cách chỉ cần nhập tên của đối tượng và thuộc tính mà chúng tôi muốn sửa đổi
# This is a comment in Python
57Các lớp của chúng ta cũng có thể có các phương thức khác, không chỉ getters và setters
Hãy định nghĩa một phương thức bên trong lớp Xe đạp mà sau đó chúng ta có thể gọi từ bất kỳ đối tượng nào mà chúng ta đã tạo từ lớp đó
# This is a comment in Python
37Chúng tôi đã tạo một phương thức rất đơn giản trong đó chúng tôi đang chuẩn bị một chuỗi là kết quả từ các thuộc tính của đối tượng mà chúng tôi đang tạo. Sau đó chúng ta có thể gọi phương thức này giống như bất kỳ phương thức nào khác
Hãy xem điều này trong hành động
# This is a comment in Python
38Nhưng tại sao chúng ta cần đóng gói?
Điều này có vẻ khá hứa hẹn và lạ mắt, nhưng bạn có thể chưa hiểu rõ. Bạn có thể cần một số lý do bổ sung tại sao bạn cần loại ẩn này
Để lái nó về nhà, hãy tham gia một lớp khác, nơi chúng tôi có một thuộc tính riêng gọi là
print[50 - 4] # 46
69. Giả sử rằng chúng tôi không quan tâm đến việc đóng gói và chúng tôi chỉ cố gắng xây dựng một lớp nhanh chóng và sử dụng nó trong dự án của chúng tôi cho khách hàng kế toán của chúng tôiHãy nói rằng chúng ta có lớp sau
# This is a comment in Python
60Bây giờ, hãy tạo một đối tượng
print[50 - 4] # 46
70 mới và khởi tạo các thuộc tính của nó tương ứng# This is a comment in Python
61Vì
print[50 - 4] # 46
69 không được bảo vệ theo bất kỳ cách nào, chúng tôi có thể đặt mức lương mới cho đối tượng mới này mà không gặp vấn đề gì# This is a comment in Python
62Như chúng ta có thể thấy, người này đã nhận được mức lương gấp năm lần so với những gì anh ta nhận được trước đây mà không cần trải qua bất kỳ hình thức đánh giá hay phỏng vấn nào. Trong thực tế, nó đã xảy ra trong một vài giây. Điều đó có lẽ sẽ ảnh hưởng nặng nề đến ngân sách của công ty
chúng tôi không muốn làm điều đó. Chúng tôi muốn hạn chế quyền truy cập vào thuộc tính
print[50 - 4] # 46
69 để nó không được gọi từ những nơi khác. Chúng tôi có thể làm điều đó bằng cách sử dụng dấu gạch dưới kép trước tên thuộc tính như bạn có thể thấy bên dưới# This is a comment in Python
63Hãy tạo một đối tượng mới
# This is a comment in Python
64Bây giờ, nếu chúng tôi cố gắng truy cập các thuộc tính của nó, chúng tôi không thể làm như vậy vì chúng là các thuộc tính riêng tư
# This is a comment in Python
65Việc cố gắng truy cập vào bất kỳ thuộc tính nào sẽ dẫn đến lỗi
# This is a comment in Python
66Chúng tôi chỉ có thể triển khai một phương thức trả về các thuộc tính nhưng chúng tôi không cung cấp bất kỳ cách nào để ai đó tăng lương một cách lén lút
# This is a comment in Python
67Bây giờ, chúng ta có thể truy cập thông tin của các đối tượng được tạo bởi lớp này
# This is a comment in Python
68Tóm lại, tính đóng gói giúp chúng ta bảo vệ các thuộc tính của đối tượng và cung cấp quyền truy cập chúng theo cách có kiểm soát
Kế thừa trong Python
Trong cuộc sống thực, chúng ta có thể chia sẻ nhiều đặc điểm với những người khác
Tất cả chúng ta đều cần ăn, uống nước, làm việc, ngủ, di chuyển, v.v. Những hành vi và đặc điểm này cùng nhiều hành vi và đặc điểm khác được chia sẻ giữa hàng tỷ người trên khắp thế giới
Chúng không phải là thứ gì đó độc đáo mà chỉ thế hệ chúng tôi mới có. Những đặc điểm này đã có từ lâu như con người có
Đây cũng là điều sẽ trường tồn cho các thế hệ mai sau
Chúng ta cũng có thể có một số đặc điểm được chia sẻ nhất định giữa các đối tượng và lớp mà chúng ta tự triển khai trong lập trình máy tính bằng cách sử dụng tính kế thừa. Điều này bao gồm cả thuộc tính và phương thức
Hãy tưởng tượng rằng chúng ta có một lớp tên là
print[50 - 4] # 46
73. Nó phải chứa tiêu đề, tác giả, số trang, danh mục, ISBN, v.v. Chúng tôi sẽ giữ cho lớp của chúng tôi đơn giản và chỉ sử dụng hai thuộc tính# This is a comment in Python
69Bây giờ, chúng ta có thể tạo một đối tượng từ lớp này và truy cập nó
# This is a comment in Python
70Bây giờ chúng ta hãy tạo một lớp con của lớp
print[50 - 4] # 46
73 kế thừa các thuộc tính và phương thức từ lớp print[50 - 4] # 46
73, nhưng cũng có một phương thức bổ sung gọi là print[50 - 4] # 46
76# This is a comment in Python
71Lưu ý cú pháp mà chúng tôi nói với Python rằng
print[50 - 4] # 46
77 là một lớp con của lớp print[50 - 4] # 46
73# This is a comment in Python
72Nếu chúng ta cố gắng truy cập phương thức mới này từ các đối tượng của lớp
print[50 - 4] # 46
73, chúng ta sẽ gặp lỗi# This is a comment in Python
73Điều này xảy ra bởi vì phương thức
print[50 - 4] # 46
80 này chỉ có thể được truy cập từ các đối tượng của print[50 - 4] # 46
77# This is a comment in Python
74Tuy nhiên, chúng ta có thể truy cập bất kỳ phương thức nào được định nghĩa trong lớp cha, trong trường hợp của chúng ta là lớp
print[50 - 4] # 46
73# This is a comment in Python
75Trong các lớp trước,
print[50 - 4] # 46
73 được coi là lớp cha hoặc lớp cha, trong khi đó, print[50 - 4] # 46
77 được coi là lớp con hoặc lớp conHàm print[50 - 4] # 46
85
print[50 - 4] # 46
Có một hàm đặc biệt gọi là
print[50 - 4] # 46
85 mà chúng ta có thể sử dụng từ một lớp con để tham chiếu đến lớp cha của nó mà không cần viết tên chính xác của lớp chaChúng tôi sử dụng nó với các trình khởi tạo hoặc khi gọi các thuộc tính hoặc phương thức của các lớp cha
Hãy xem cả ba trong số chúng được minh họa bằng các ví dụ
Cách sử dụng print[50 - 4] # 46
85 với bộ khởi tạo
print[50 - 4] # 46
Chúng ta có thể sử dụng
print[50 - 4] # 46
85 bên trong phương thức khởi tạo của lớp con và thậm chí gọi hàm tạo của siêu lớp# This is a comment in Python
76Chúng ta cũng có thể thay thế
print[50 - 4] # 46
85 bằng tên của lớp cha, lớp này sẽ hoạt động lại theo cách tương tự# This is a comment in Python
77Ngay cả việc thay đổi thứ tự của các dòng bên trong hàm tạo của con cũng sẽ không gây ra bất kỳ lỗi nào
Cách sử dụng print[50 - 4] # 46
85 với các thuộc tính lớp của lớp cha
print[50 - 4] # 46
Chúng ta có thể sử dụng
print[50 - 4] # 46
85 để truy cập các thuộc tính lớp của lớp cha, điều này có thể hữu ích đặc biệt khi cả lớp cha và lớp con sử dụng cùng tên cho một thuộc tínhĐể thấy điều đó trong thực tế, hãy giả sử rằng chúng ta có một thuộc tính lớp được gọi là
print[50 - 4] # 46
92, thuộc tính này có cả trong lớp cha và lớp con. Chúng tôi muốn truy cập biến này từ cả lớp cha và lớp conĐể làm điều đó, chúng ta chỉ cần viết
print[50 - 4] # 46
85 và sau đó là tên của biến# This is a comment in Python
78Bây giờ, nếu chúng ta gọi phương thức
print[50 - 4] # 46
94, chúng ta sẽ in nội dung sau trong bảng điều khiển# This is a comment in Python
79Cách sử dụng print[50 - 4] # 46
85 với các phương thức của lớp cha
print[50 - 4] # 46
Tương tự, chúng ta có thể gọi các phương thức trong lớp cha bằng cách sử dụng
print[50 - 4] # 46
85# This is a comment in Python
80Đây là tất cả những gì bạn cần biết về
print[50 - 4] # 46
85Các loại thừa kế
Chúng ta có thể có các kiểu kế thừa khác nhau dựa trên mối quan hệ của lớp cha và lớp con
- Đơn
- đa cấp
- Thứ bậc
- Nhiều
- Hỗn hợp
Chúng ta có thể có một lớp chỉ kế thừa từ một lớp khác
# This is a comment in Python
812. Kế thừa đa cấpĐây là một kiểu thừa kế khác trong đó một lớp kế thừa từ một lớp khác kế thừa từ một lớp khác. Lớp A kế thừa từ Lớp B kế thừa từ Lớp C
Hãy thực hiện điều này trong Python
# This is a comment in Python
823. Kế thừa thứ bậcKhi chúng ta dẫn xuất nhiều lớp con từ cùng một lớp cha, thì chúng ta có kế thừa phân cấp. Các lớp con này kế thừa từ lớp cha
# This is a comment in Python
834. đa thừa kếChúng ta có thể có một kiểu kế thừa khác, cụ thể là đa kế thừa giúp chúng ta có thể kế thừa từ nhiều lớp cùng một lúc
Giả sử rằng chúng ta có một lớp tên là
print[50 - 4] # 46
98 và một lớp khác tên là print[50 - 4] # 46
99Sau đó, chúng ta có thể triển khai một lớp khác rồi kế thừa từ cả hai lớp
# This is a comment in Python
845. thừa kế laiKế thừa hỗn hợp là sự kết hợp giữa kế thừa đa cấp và đa cấp
# This is a comment in Python
85Bây giờ, nếu chúng ta tạo một đối tượng từ lớp
print[50 * 4] # 200
00, chúng ta có thể gọi tất cả các phương thức trong tất cả các lớp# This is a comment in Python
86Đa hình trong Python
Đây là một khái niệm quan trọng khác từ Lập trình hướng đối tượng đề cập đến khả năng một đối tượng hoạt động giống như các dạng khác nhau và gọi các hành vi khác nhau.
Một ví dụ về hàm dựng sẵn sử dụng tính đa hình là phương thức
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
77 có thể được sử dụng cho cả chuỗi và danh sách# This is a comment in Python
87Chúng ta có thể lấy một ví dụ khác với một lớp tên là
print[50 * 4] # 200
02. Chúng ta có thể có các lớp con khác nhau kế thừa các phương thức và thuộc tính từ lớp cha đó, cụ thể là các lớp như print[50 * 4] # 200
03, print[50 * 4] # 200
04, print[50 * 4] # 200
05, print[50 * 4] # 200
06, v.v.Giả sử rằng chúng ta muốn triển khai một phương thức trong lớp
print[50 * 4] # 200
02 để lấy diện tíchMỗi loại nơi cư trú có kích thước khác nhau, vì vậy mỗi lớp con nên có cách triển khai khác nhau
Bây giờ chúng ta có thể định nghĩa các phương thức thành các lớp con như
08print[50 * 4] # 200
09print[50 * 4] # 200
10print[50 * 4] # 200
11print[50 * 4] # 200
Điều này sẽ buộc chúng ta phải nhớ tên của từng phân lớp, điều này có thể gây nhàm chán và cũng dễ mắc lỗi khi chúng ta gọi chúng.
May mắn thay, có một phương pháp đơn giản hơn mà chúng ta có thể sử dụng đến từ tính đa hình
Chúng ta có thể có tính đa hình bằng cách sử dụng cả phương thức và tính kế thừa
Trước tiên hãy xem cách chúng ta có thể triển khai tính đa hình bằng các phương thức
Đa hình sử dụng các phương pháp
Giả sử rằng chúng ta có hai lớp, cụ thể là
print[50 * 4] # 200
03 và print[50 * 4] # 200
04. Cả hai đều có phương thức print[50 * 4] # 200
14 trả về một giá trịMỗi người trong số họ sẽ có một triển khai tùy chỉnh
Bây giờ phương thức mà chúng ta sẽ gọi phụ thuộc vào kiểu lớp của đối tượng
# This is a comment in Python
88Hãy tạo hai đối tượng từ các lớp này
# This is a comment in Python
89Bây giờ, chúng ta có thể đặt cả hai đối tượng vào một danh sách và gọi cùng một phương thức cho cả hai đối tượng
# This is a comment in Python
90Sau khi chúng tôi thực hiện điều đó, chúng tôi sẽ thấy phần sau trong bảng điều khiển
# This is a comment in Python
91Đây là cách bạn thực hiện tính đa hình với các phương thức
Đa hình có kế thừa
Chúng ta không chỉ có thể gọi một phương thức từ một lớp cha. Chúng ta cũng có thể sử dụng cùng một tên nhưng có cách triển khai khác nhau cho từng lớp con
Trước tiên hãy xác định một siêu lớp
# This is a comment in Python
92Sau đó, chúng tôi sẽ triển khai các lớp con
print[50 * 4] # 200
03 và print[50 * 4] # 200
04 của lớp cha print[50 * 4] # 200
02# This is a comment in Python
93Như chúng ta có thể thấy, cả hai lớp con đều có phương thức
print[50 * 4] # 200
18 nhưng cách triển khai khác nhauBây giờ chúng ta có thể tạo các đối tượng mới từ các lớp con và gọi phương thức này sẽ đa hình dựa trên đối tượng gọi nó
# This is a comment in Python
94Sau khi chúng tôi thực hiện điều đó, chúng tôi sẽ thấy phần sau trong bảng điều khiển
# This is a comment in Python
95Đây là một ví dụ khác về tính đa hình trong đó chúng tôi triển khai cụ thể một phương thức có cùng tên
Nhập bằng PythonMột trong những lợi ích chính của việc sử dụng ngôn ngữ phổ biến như Python là số lượng lớn thư viện mà bạn có thể sử dụng và hưởng lợi từ đó
Nhiều nhà phát triển trên khắp thế giới rất hào phóng với thời gian và kiến thức của họ và xuất bản rất nhiều thư viện thực sự hữu ích. Những thư viện này có thể giúp chúng tôi tiết kiệm rất nhiều thời gian cả trong công việc chuyên môn cũng như trong các dự án phụ mà chúng tôi có thể làm để giải trí
Dưới đây là một số mô-đun với các phương pháp rất hữu ích mà bạn có thể bắt đầu sử dụng ngay lập tức trong các dự án của mình
19. Thời gian truy cập và chuyển đổiprint[50 * 4] # 200
20. Đọc và ghi tệp CSVprint[50 * 4] # 200
21. hàm toán họcprint[50 * 4] # 200
22. Tạo, gửi và xử lý emailprint[50 * 4] # 200
23. Làm việc với các URLprint[50 * 4] # 200
Để nhập một hoặc nhiều mô-đun, chúng tôi chỉ cần viết
print[50 * 4] # 200
24 và sau đó là tên của các mô-đun mà chúng tôi muốn nhậpHãy nhập mô-đun đầu tiên của chúng tôi
# This is a comment in Python
96Bây giờ, hãy nhập nhiều mô-đun cùng một lúc
# This is a comment in Python
97Khi chúng tôi đã nhập một mô-đun, chúng tôi có thể bắt đầu sử dụng các phương thức bên trong nó
# This is a comment in Python
98Chúng tôi cũng có thể sử dụng tên mới cho các mô-đun đã nhập của mình bằng cách chỉ định bí danh cho chúng là
print[50 * 4] # 200
25 trong đó print[50 * 4] # 200
26 là bất kỳ tên biến nào bạn muốn# This is a comment in Python
99Làm thế nào để hạn chế những gì chúng tôi muốn nhập khẩu
Có những lúc chúng tôi không muốn nhập toàn bộ gói với tất cả các phương thức của nó. Điều này là do chúng tôi muốn tránh ghi đè các phương thức hoặc biến trong mô-đun với các phương thức hoặc biến mà chúng tôi muốn tự triển khai
Chúng tôi có thể chỉ định các bộ phận mà chúng tôi muốn nhập bằng cách sử dụng biểu mẫu sau
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
00Hãy lấy một ví dụ về việc chỉ nhập hàm căn bậc hai từ mô-đun
print[50 * 4] # 200
21"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
01Các vấn đề với việc nhập mọi thứ từ một mô-đun
Chúng tôi cũng có thể nhập mọi thứ từ một mô-đun, điều này có thể trở thành sự cố. Hãy minh họa điều này với một ví dụ
Giả sử rằng chúng ta muốn nhập mọi thứ có trong mô-đun
print[50 * 4] # 200
21. Chúng ta có thể làm điều đó bằng cách sử dụng dấu hoa thị như thế này"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
02Bây giờ, giả sử rằng chúng ta muốn khai báo một biến có tên là
print[50 * 4] # 200
29"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
03Khi chúng tôi cố gắng gọi hàm
print[50 * 4] # 200
30 từ mô-đun toán học, chúng tôi sẽ gặp lỗi, vì trình thông dịch sẽ gọi biến print[50 * 4] # 200
29 mới nhất mà chúng tôi vừa khai báo trong khối mã trước đó"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
04"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
05Cách xử lý ngoại lệ trong PythonKhi chúng tôi đang triển khai các tập lệnh Python hoặc thực hiện bất kỳ loại triển khai nào, chúng tôi sẽ gặp nhiều lỗi được đưa ra ngay cả khi cú pháp đúng
Những loại lỗi xảy ra trong quá trình thực hiện được gọi là ngoại lệ
Chúng ta thực sự không phải đầu hàng và không làm bất cứ điều gì liên quan đến họ. Chúng ta có thể viết các trình xử lý ở đó để làm điều gì đó để việc thực thi chương trình không bị dừng lại
Các ngoại lệ phổ biến trong Python
Dưới đây là một số ngoại lệ phổ biến nhất xảy ra trong Python với các định nghĩa được lấy từ tài liệu Python
- Ngoại lệ - Đây là một lớp là lớp cha của hầu hết các loại ngoại lệ khác xảy ra
- NameError – Xảy ra khi không tìm thấy tên cục bộ hoặc toàn cầu
- AttributeError – Xảy ra khi tham chiếu hoặc gán thuộc tính không thành công
- SyntaxError – Xảy ra khi trình phân tích cú pháp gặp lỗi cú pháp
- TypeError – Xảy ra khi một thao tác hoặc chức năng được áp dụng cho một đối tượng thuộc loại không phù hợp. Giá trị được liên kết là một chuỗi cung cấp thông tin chi tiết về loại không khớp
- ZeroDivisionError – Xảy ra khi đối số thứ hai của phép chia hoặc phép toán modulo bằng 0
- IOError – Xảy ra khi thao tác I/O [chẳng hạn như câu lệnh in, hàm open[] tích hợp sẵn hoặc phương thức của đối tượng tệp] không thành công vì lý do liên quan đến I/O, ví dụ:. g. , "không tìm thấy tệp" hoặc "đĩa đầy"
- ImportError – Xảy ra khi câu lệnh nhập không tìm thấy định nghĩa mô-đun hoặc khi nhập từ … nhập không tìm thấy tên sẽ được nhập
- IndexError – Xảy ra khi một chuỗi con nằm ngoài phạm vi
- KeyError – Xảy ra khi không tìm thấy khóa ánh xạ [từ điển] trong tập hợp các khóa hiện có
- ValueError – Xảy ra khi một thao tác hoặc hàm tích hợp nhận được một đối số có loại phù hợp nhưng giá trị không phù hợp và tình huống không được mô tả bằng một ngoại lệ chính xác hơn, chẳng hạn như IndexError
Có nhiều loại lỗi khác, nhưng bạn không thực sự cần phải xem về chúng bây giờ. Cũng rất khó có khả năng bạn sẽ thấy tất cả các loại lỗi mọi lúc
Bạn có thể xem thêm các loại ngoại lệ trong tài liệu Python
Cách xử lý ngoại lệ trong Python
Hãy bắt đầu với một ví dụ rất đơn giản và viết một chương trình có mục đích đưa ra một lỗi để sau đó chúng ta có thể sửa nó
Chúng ta sẽ thực hiện phép chia cho 0, đây là điều mà bạn có thể đã thấy ở trường
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
06Nếu chúng tôi cố gắng thực hiện điều đó, chúng tôi sẽ gặp lỗi sau trong bảng điều khiển
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
07Nếu chúng tôi gặp phải những sự cố như vậy trong bất kỳ loại chương trình Python nào, chúng tôi nên bắt và bọc lỗi này bên trong một khối
print[50 * 4] # 200
32Chúng ta cần viết bên trong khối
print[50 * 4] # 200
33 phần mã mà chúng ta cho rằng sẽ gây ra lỗi. Sau đó, chúng tôi phát hiện các loại lỗi đó bên trong khối print[50 * 4] # 200
34 bằng cách chỉ định loại lỗi mà chúng tôi loại trừ để xảy ra.Hãy xem ví dụ đầu tiên
Hãy xem cách chúng tôi có thể xử lý lỗi đó để chúng tôi cũng được thông báo rằng lỗi đó đã xảy ra
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
08Như bạn có thể thấy, chúng tôi đang in một thông báo trong bảng điều khiển sau khi chúng tôi đã đến phần xảy ra phép chia cho 0
Ta cũng có thể bỏ hẳn phần
print[50 * 4] # 200
35"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
09Tuy nhiên, điều này không được khuyến khích, vì chúng tôi đang phát hiện tất cả các loại lỗi trong một khối
print[50 * 4] # 200
34 duy nhất và chúng tôi không chắc loại lỗi nào đang được phát hiện [điều này sẽ khá hữu ích cho chúng tôi]Hãy tiếp tục với một loại lỗi khác
Bây giờ chúng ta sẽ thử sử dụng một biến hoàn toàn không được xác định
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
10Trong ví dụ trước, chúng ta đã sử dụng biến
print[50 * 4] # 200
37 trước khi khai báo nó, do đó, một biến print[50 * 4] # 200
38 sẽ bị ném raHãy tiếp tục với một ví dụ khác có thể khá phổ biến
Khi chúng ta sử dụng danh sách, việc sử dụng chỉ mục nằm ngoài phạm vi có thể là một lỗi phổ biến. Điều này có nghĩa là chỉ mục chúng tôi đã sử dụng lớn hơn hoặc nhỏ hơn phạm vi chỉ mục của các thành phần trong danh sách đó
Hãy minh họa điều này bằng một ví dụ, trong đó một
print[50 * 4] # 200
39 sẽ được ném"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
11Chúng tôi cũng có thể sử dụng một khối
print[50 * 4] # 200
33 với nhiều lỗi print[50 * 4] # 200
34"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
12Trong ví dụ trước, ban đầu chúng ta cố gắng nắm bắt xem có biến nào được sử dụng mà không được khai báo hay không. Nếu lỗi này xảy ra, thì khối
print[50 * 4] # 200
34 này sẽ tiếp quản luồng thực thi. Luồng thực thi này sẽ dừng lại ở đóSau đó, chúng tôi cố gắng kiểm tra xem chúng tôi có chia cho 0 không. Nếu lỗi này được đưa ra, thì khối
print[50 * 4] # 200
34 này sẽ đảm nhận việc thực thi và mọi thứ bên trong nó sẽ được thực thi. Tương tự, chúng tôi tiếp tục với phần còn lại của các lỗi được khai báoChúng tôi cũng có thể đặt nhiều lỗi bên trong dấu ngoặc đơn để bắt nhiều ngoại lệ. Nhưng điều này sẽ không hữu ích cho chúng tôi, vì chúng tôi không biết lỗi cụ thể nào đã xảy ra. Nói cách khác, phương pháp sau đây hoạt động, nhưng nó không được khuyến nghị
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
13Từ khóa print[50 * 4] # 200
44
print[50 * 4] # 200
Sau khi
print[50 * 4] # 200
33 và print[50 * 4] # 200
34 được thông qua, có một khối khác mà chúng ta có thể khai báo và thực thi. Khối này bắt đầu bằng từ khóa print[50 * 4] # 200
44 và nó được thực thi bất kể chúng ta có bị ném lỗi hay không"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
14Nếu chúng tôi thực thi khối mã trước đó, chúng tôi sẽ thấy phần sau trong bảng điều khiển
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
15Chúng tôi thường viết mã mà chúng tôi muốn dọn dẹp bên trong khối
print[50 * 4] # 200
44. Điều này bao gồm những việc như đóng tệp, dừng kết nối với cơ sở dữ liệu, thoát khỏi chương trình hoàn toàn, v.v.thử, khác, ngoại trừ
Chúng ta có thể viết các câu lệnh bên trong
print[50 * 4] # 200
33 và print[50 * 4] # 200
34, nhưng chúng ta cũng có thể sử dụng khối print[50 - 4] # 46
04 nơi chúng ta có thể viết mã mà chúng ta muốn thực thi nếu không có lỗi nào được đưa ra"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
16Nếu chúng tôi thực thi mã ở trên, chúng tôi sẽ nhận được phần sau được in trong bảng điều khiển
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
17kết thúc ngoại lệ
Hy vọng rằng bây giờ bạn đã hiểu các trường hợp ngoại lệ và các cách khác nhau mà bạn có thể sử dụng để xử lý chúng. Nếu bạn xử lý chúng một cách chính xác thì sẽ không có bất kỳ sự gián đoạn đột ngột nào khiến chương trình của bạn bị lỗi ngoài ý muốn
Đầu vào của người dùng trong PythonKhi bạn muốn phát triển một chương trình tương tác và nhận đầu vào của người dùng trong dòng lệnh, bạn có thể gọi một hàm có tên là
print[50 * 4] # 200
52Rất đơn giản và tất cả những gì bạn phải làm là khai báo một biến mà bạn muốn lưu giá trị mà người dùng nhập vào
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
18Chúng ta có thể sử dụng giá trị đó và in nó
"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.
Let's end this comment right here.
"""
19Kết thúcCuốn sách này thể hiện nỗ lực của tôi nhằm giúp bạn tìm hiểu những điều cơ bản về Python một cách nhanh chóng và dễ dàng. Có nhiều điều khác cần biết về Python mà tôi không trình bày trong cuốn sách này, nhưng chúng tôi sẽ để nó ở đây
Tôi hy vọng đây là một tài liệu tham khảo hữu ích cho bạn
Bây giờ bạn đã có cơ hội học cách viết Python, hãy ra ngoài đó và tạo tác động tích cực với các dòng mã của bạn
Nhận sách dưới dạng PDF
Bạn có thể đọc cuốn sách này dưới dạng PDF bằng cách tải xuống tại đây
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
Kỹ sư phần mềm có kinh nghiệm và đam mê, chuyên về Machine Learning
Nếu bạn đọc đến đây, hãy tweet cho tác giả để cho họ thấy bạn quan tâm. Tweet một lời cảm ơn
Học cách viết mã miễn phí. Chương trình giảng dạy mã nguồn mở của freeCodeCamp đã giúp hơn 40.000 người có được việc làm với tư cách là nhà phát triển. Bắt đầu