Ghi chú. Các hàm lambda lấy tên từ phép tính lambda, là một mô hình tính toán được phát minh bởi Alonzo Church
Bản đồ
Bản đồ hàm tích hợp và bộ lọc là các hàm bậc cao rất hữu ích hoạt động trên danh sách [hoặc các đối tượng tương tự được gọi là iterables].
Hàm map nhận một hàm và một đối số có thể lặp lại, đồng thời trả về một đối số có thể lặp lại mới với hàm được áp dụng cho mỗi đối số.
Ví dụ
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Kết quả
[16, 27, 38, 49, 60]
Chúng ta có thể đạt được kết quả tương tự dễ dàng hơn bằng cách sử dụng cú pháp lambda
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Ghi chú. Để chuyển đổi kết quả thành một danh sách, chúng tôi đã sử dụng danh sách một cách rõ ràng
Lọc
Bộ lọc chức năng lọc một lần lặp bằng cách loại bỏ các mục không khớp với một vị từ [một hàm trả về giá trị Boolean].
Ví dụ.
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Kết quả
[22, 44]
Ghi chú. Giống như bản đồ, kết quả phải được chuyển đổi rõ ràng thành danh sách nếu bạn muốn in nó
Ví dụ.
Điền vào chỗ trống để xóa tất cả các mục lớn hơn 4 khỏi danh sách.
nums = [1, 2, 5, 8, 3, 0, 7]
res = list[filter[lambda x: x < 5, nums]]
print[res]Máy phát điện-1
Trình tạo là một loại có thể lặp lại, như danh sách hoặc bộ.
Không giống như danh sách, chúng không cho phép lập chỉ mục với các chỉ số tùy ý, nhưng chúng vẫn có thể được lặp lại với các vòng lặp for.
Chúng có thể được tạo bằng hàm và câu lệnh suất.
Ví dụ.
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]Kết quả
5
4
3
2
1
Câu lệnh năng suất được sử dụng để xác định trình tạo, thay thế việc trả về hàm để cung cấp kết quả cho người gọi hàm mà không phá hủy các biến cục bộ
Máy phát điện-2
Do thực tế là chúng tạo ra một mục tại một thời điểm, trình tạo không có giới hạn bộ nhớ của danh sách.
Trên thực tế, chúng có thể là vô hạn.
def infinite_sevens[]:
while True:
yield 7
for i in infinite_sevens[]:
print[i]Kết quả
7
7
7
7
7
7
7
…
Ghi chú. Tóm lại, các trình tạo cho phép bạn khai báo một hàm hoạt động giống như một trình vòng lặp, tôi. e. nó có thể được sử dụng trong vòng lặp for
Ví dụ.
Điền vào chỗ trống để tạo trình tạo số nguyên tố, tạo ra tất cả các số nguyên tố trong một vòng lặp. [Xem xét việc có một hàm is_prime đã được xác định].
def get_primes[]:
num = 2
while True:
if is_prime[num]:
yield num
num += 1Máy phát điện-3
Trình tạo hữu hạn có thể được chuyển đổi thành danh sách bằng cách chuyển chúng dưới dạng đối số cho hàm danh sách
def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]Kết quả
[0, 2, 4, 6, 8, 10]
Ghi chú. Sử dụng trình tạo dẫn đến hiệu suất được cải thiện, đó là kết quả của việc tạo giá trị lười biếng [theo yêu cầu], dẫn đến mức sử dụng bộ nhớ thấp hơn. Hơn nữa, chúng ta không cần đợi cho đến khi tất cả các phần tử được tạo ra trước khi bắt đầu sử dụng chúng.
Trang trí-1
Decorators cung cấp một cách để sửa đổi các chức năng bằng cách sử dụng các chức năng khác.
Điều này lý tưởng khi bạn cần mở rộng chức năng của các chức năng mà bạn không muốn sửa đổi.
Ví dụ.
________số 8
Chúng tôi đã định nghĩa một hàm có tên là decor có một tham số duy nhất là func. Bên trong trang trí, chúng tôi đã xác định một chức năng lồng nhau có tên là bọc. Hàm quấn sẽ in một chuỗi, sau đó gọi hàm func[] và in một chuỗi khác. Hàm decor trả về hàm bọc là kết quả của nó.
Chúng ta có thể nói rằng biến được trang trí là một phiên bản được trang trí của print_text - đó là print_text cộng với một thứ gì đó.
Trên thực tế, nếu chúng ta viết một trình trang trí hữu ích, chúng ta có thể muốn thay thế hoàn toàn print_text bằng phiên bản được trang trí để chúng ta luôn có phiên bản print_text “cộng thêm một thứ gì đó”.
Điều này được thực hiện bằng cách gán lại biến chứa hàm của chúng ta.
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Bây giờ print_text tương ứng với phiên bản trang trí của chúng tôi
Trang trí-2
Trong ví dụ trước của chúng tôi, chúng tôi đã trang trí hàm của mình bằng cách thay thế biến chứa hàm bằng một phiên bản được bao bọc
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Mẫu này có thể được sử dụng bất cứ lúc nào, để bọc bất kỳ chức năng nào.
Python cung cấp hỗ trợ để bọc hàm trong bộ trang trí bằng cách chờ định nghĩa hàm trước với tên bộ trang trí và ký hiệu @.
Nếu chúng ta đang định nghĩa một hàm, chúng ta có thể “trang trí” cho hàm đó bằng biểu tượng @ như.
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Điều này sẽ có kết quả tương tự như đoạn mã trên
Ghi chú. Một chức năng duy nhất có thể có nhiều trang trí
đệ quy-1
Đệ quy là một khái niệm rất quan trọng trong lập trình hàm.
Phần cơ bản của đệ quy là tự tham chiếu - các hàm tự gọi. Nó được sử dụng để giải quyết các vấn đề có thể được chia thành các vấn đề con dễ dàng hơn cùng loại.
Một ví dụ cổ điển về hàm được triển khai theo cách đệ quy là hàm giai thừa, hàm này tìm tích của tất cả các số nguyên dương bên dưới một số đã chỉ định.
Ví dụ: 5. [5 giai thừa] là 5 * 4 * 3 * 2 * 1 [120]. Để thực hiện điều này một cách đệ quy, lưu ý rằng 5. = 5 * 4. , 4. = 4 * 3. , 3. = 3 * 2. , và như thế. Nói chung, n. = n * [n-1].
Hơn nữa, 1. = 1. Đây được gọi là trường hợp cơ sở, vì nó có thể được tính toán mà không cần thực hiện thêm bất kỳ giai thừa nào.
Dưới đây là cách triển khai đệ quy của hàm giai thừa.
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Kết quả
120
Ghi chú. Trường hợp cơ sở đóng vai trò là điều kiện thoát của đệ quy
đệ quy-2
Hàm đệ quy có thể là vô hạn, giống như vòng lặp while vô hạn. Những điều này thường xảy ra khi bạn quên triển khai trường hợp cơ sở.
Dưới đây là phiên bản sai của hàm giai thừa. Nó không có trường hợp cơ sở, vì vậy nó chạy cho đến khi trình thông dịch hết bộ nhớ và bị treo.
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Kết quả
Lỗi runtime. vượt quá độ sâu đệ quy tối đa
đệ quy-3
Đệ quy cũng có thể là gián tiếp. Một hàm có thể gọi hàm thứ hai, hàm này gọi hàm thứ nhất, hàm này gọi hàm thứ hai, v.v. Điều này có thể xảy ra với bất kỳ số chức năng nào.
Ví dụ.
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Kết quả
Đúng
Sai
Bộ-1
Bộ là cấu trúc dữ liệu, tương tự như danh sách hoặc từ điển. Chúng được tạo bằng cách sử dụng dấu ngoặc nhọn hoặc hàm set. Chúng chia sẻ một số chức năng với danh sách, chẳng hạn như việc sử dụng in để kiểm tra xem chúng có chứa một mục cụ thể hay không
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Kết quả
Đúng
Sai
Ghi chú. Để tạo một bộ trống, bạn phải sử dụng set[], vì {} tạo một từ điển trống
Bộ-2
Bộ khác với danh sách theo một số cách, nhưng chia sẻ một số thao tác danh sách, chẳng hạn như len.
Chúng không có thứ tự, có nghĩa là chúng không thể được lập chỉ mục.
Chúng không được chứa các phần tử trùng lặp.
Do cách chúng được lưu trữ, việc kiểm tra xem một mục có phải là một phần của tập hợp hay không sẽ nhanh hơn thay vì là một phần của danh sách.
Thay vì sử dụng append để thêm vào một tập hợp, hãy sử dụng add.
Phương thức remove xóa một phần tử cụ thể khỏi một tập hợp; .
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Kết quả
{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6, -7}
Ghi chú. Các ứng dụng cơ bản của bộ bao gồm kiểm tra tư cách thành viên và loại bỏ các mục nhập trùng lặp
Bộ-3
Các tập hợp có thể được kết hợp bằng các phép toán.
Toán tử hợp. kết hợp hai bộ để tạo thành một bộ mới chứa các mục trong một trong hai.
Toán tử giao nhau & chỉ lấy các mục trong cả hai.
Toán tử chênh lệch - nhận các mục trong tập hợp đầu tiên nhưng không phải trong tập hợp thứ hai.
Toán tử hiệu đối xứng ^ nhận các mục trong một trong hai tập hợp, nhưng không phải cả hai.
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Kết quả
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{4, 5, 6}
{
{8, 9, 7}
{1, 2, 3, 7, 8, 9}
StackEdit lưu trữ tài liệu của bạn trong trình duyệt, nghĩa là tất cả tài liệu của bạn được lưu tự động cục bộ và có thể truy cập ngoại tuyến
Cấu trúc dữ liệu
Như chúng ta đã thấy trong các bài học trước, Python hỗ trợ các cấu trúc dữ liệu sau. danh sách, từ điển, bộ dữ liệu, bộ
Khi nào nên sử dụng từ điển
- Khi bạn cần một liên kết hợp lý giữa một phím. cặp giá trị
- Khi bạn cần tra cứu nhanh dữ liệu của mình, dựa trên khóa tùy chỉnh
- Khi dữ liệu của bạn liên tục bị sửa đổi. Hãy nhớ rằng, từ điển có thể thay đổi
Khi nào nên sử dụng các loại khác
- Sử dụng danh sách nếu bạn có bộ sưu tập dữ liệu không cần truy cập ngẫu nhiên. Cố gắng chọn các danh sách khi bạn cần một bộ sưu tập đơn giản, có thể lặp lại và được sửa đổi thường xuyên
- Sử dụng một bộ nếu bạn cần tính duy nhất cho các phần tử
- Sử dụng bộ dữ liệu khi dữ liệu của bạn không thể thay đổi
Nhiều khi, một bộ dữ liệu được sử dụng kết hợp với một từ điển, ví dụ, một bộ dữ liệu có thể đại diện cho một khóa, bởi vì nó không thay đổi
itertools-1
Mô-đun itertools là một thư viện chuẩn chứa một số hàm hữu ích trong lập trình hàm.
Một loại hàm mà nó tạo ra là trình lặp vô hạn.
Hàm đếm tăng vô hạn từ một giá trị.
Chu kỳ hàm lặp vô hạn thông qua một lần lặp [ví dụ: một danh sách hoặc chuỗi].
Hàm repeat lặp lại một đối tượng, vô hạn hoặc một số lần cụ thể.
Ví dụ.
def add_five[x]:
return x + 5
nums = [11, 22, 33, 44, 55]
result = list[map[add_five, nums]]
print[result]
Kết quả
3
4
5
6
7
8
9
10
11
itertools-2
Có nhiều chức năng trong itertools hoạt động trên iterables, theo cách tương tự để ánh xạ và lọc.
Một số ví dụ.
taketime - lấy các mục từ một lần lặp trong khi hàm vị từ vẫn đúng;
chuỗi - kết hợp nhiều lần lặp thành một chuỗi dài;
accumulate - returns a running total of values in an iterable.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
[0, 1, 3, 6, 10, 15, 21, 28]
[0, 1, 3, 6]
itertools-3
Cũng có một số hàm tổ hợp trong itertool, chẳng hạn như tích và hoán vị.
Chúng được sử dụng khi bạn muốn hoàn thành một nhiệm vụ với tất cả các kết hợp có thể có của một số mục.
Ví dụ.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
[['A', 0], ['A', 1], ['B', 0], ['B', 1]]
[['
Lập trình hướng đối tượng
Lớp học-1
Trước đây chúng ta đã xem xét hai mô hình lập trình - mệnh lệnh [sử dụng câu lệnh, vòng lặp và hàm làm chương trình con] và hàm [sử dụng hàm thuần túy, hàm bậc cao và đệ quy]
Một mô hình rất phổ biến khác là lập trình hướng đối tượng**-** [OOP].
Các đối tượng được tạo bằng cách sử dụng các lớp, đây thực sự là tâm điểm của OOP.
Lớp mô tả đối tượng sẽ là gì, nhưng tách biệt với chính đối tượng. Nói cách khác, một lớp có thể được mô tả như một bản thiết kế, mô tả hoặc định nghĩa của một đối tượng.
Bạn có thể sử dụng cùng một lớp làm bản thiết kế để tạo nhiều đối tượng khác nhau.
Các lớp được tạo bằng cách sử dụng từ khóa class và một khối thụt lề, chứa các phương thức của lớp [là các hàm].
Dưới đây là một ví dụ về một lớp đơn giản và các đối tượng của nó.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Ghi chú. Mã này định nghĩa một lớp có tên là Cat, lớp này có hai thuộc tính. màu sắc và chân.
Sau đó lớp được dùng để tạo 3 đối tượng riêng biệt của lớp đó.
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]
1
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]Phương thức init là phương thức quan trọng nhất trong một lớp.
Cái này được gọi khi một thể hiện [đối tượng] của lớp được tạo, sử dụng tên lớp như một hàm.
Tất cả các phương thức phải có tham số đầu tiên là self, mặc dù nó không được truyền rõ ràng, Python sẽ thêm tham số self vào danh sách cho bạn; . Trong một định nghĩa phương thức, self đề cập đến thể hiện gọi phương thức
Các thực thể của một lớp có các thuộc tính, là các phần dữ liệu được liên kết với chúng.
Trong ví dụ này, phiên bản Cat có thuộc tính màu và chân. Chúng có thể được truy cập bằng cách đặt một dấu chấm và tên thuộc tính sau một thể hiện.
Trong một phương thức init, self. do đó, thuộc tính có thể được sử dụng để đặt giá trị ban đầu cho các thuộc tính của một thể hiện.
Ví dụ.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
Ghi chú. gừng
Ghi chú. Trong ví dụ trên, phương thức init nhận hai đối số và gán chúng cho các thuộc tính của đối tượng. Phương thức init được gọi là hàm tạo của lớp
phương pháp
Các lớp có thể có các phương thức khác được xác định để thêm chức năng cho chúng.
Hãy nhớ rằng tất cả các phương thức phải có tham số đầu tiên là self.
Các phương thức này được truy cập bằng cú pháp dấu chấm giống như các thuộc tính.
Ví dụ.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
Fido
Gâu.
Các lớp cũng có thể có các thuộc tính lớp, được tạo bằng cách gán các biến trong nội dung của lớp. Chúng có thể được truy cập từ các thể hiện của lớp hoặc chính lớp đó.
Ví dụ.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
4
4
GHI CHÚ. Thuộc tính lớp được chia sẻ bởi tất cả các phiên bản của lớp
Lớp học-2
Việc cố gắng truy cập một thuộc tính của một phiên bản không được xác định sẽ gây ra AttributeError. Điều này cũng áp dụng khi bạn gọi một phương thức không xác định
Ví dụ
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
Lỗi thuộc tính. Đối tượng ‘Rectangle’ không có thuộc tính ‘color’
Kế thừa-1
Kế thừa cung cấp một cách để chia sẻ chức năng giữa các lớp.
Hãy tưởng tượng một số lớp, Mèo, Chó, Thỏ, v.v. Mặc dù chúng có thể khác nhau theo một số cách [chỉ Dog có thể có phương thức sủa], nhưng chúng có thể giống nhau ở những cách khác [tất cả đều có thuộc tính màu và tên].
Sự giống nhau này có thể được thể hiện bằng cách làm cho tất cả chúng đều kế thừa từ một lớp bậc trên là Động vật, lớp chứa chức năng được chia sẻ.
Để kế thừa một lớp từ một lớp khác, hãy đặt tên lớp cha trong dấu ngoặc đơn sau tên lớp.
Ví dụ.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
nâu
Gâu.
Kế thừa-2
Một lớp kế thừa từ một lớp khác được gọi là lớp con.
Một lớp được kế thừa từ đó được gọi là lớp cha.
Nếu một lớp kế thừa từ một lớp khác có cùng thuộc tính hoặc phương thức, thì nó sẽ ghi đè chúng.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
Gâu
Ghi chú. Trong ví dụ trên, Wolf là lớp cha, Dog là lớp con
Kế thừa-3
Kế thừa cũng có thể là gián tiếp. Một lớp có thể kế thừa từ lớp khác và lớp đó có thể kế thừa từ lớp thứ ba.
Ví dụ.
nums = [11, 22, 33, 44, 55]
result = list[map[lambda x: x+5, nums]]
print[result]Kết quả
Phương pháp A
Phương pháp B
Phương pháp C
Ghi chú. Tuy nhiên, kế thừa vòng tròn là không thể
Kế thừa-4
Hàm super là một hàm liên quan đến thừa kế hữu ích dùng để chỉ lớp cha. Nó có thể được sử dụng để tìm phương thức có tên nhất định trong lớp cha của đối tượng.
Ví dụ.
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Kết quả
2
1
Ghi chú. siêu[]. spam[] gọi phương thức spam của lớp cha
Phương pháp ma thuật-1
Phương thức ma thuật là phương thức đặc biệt có dấu gạch dưới kép ở đầu và cuối tên của chúng.
Họ còn được gọi là kẻ ngu dốt.
Cho đến nay, trường hợp duy nhất chúng tôi gặp phải là
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]Chúng được sử dụng để tạo chức năng không thể biểu diễn dưới dạng phương thức thông thường.
Một cách sử dụng phổ biến của chúng là nạp chồng toán tử.
Điều này có nghĩa là xác định các toán tử cho các lớp tùy chỉnh cho phép sử dụng các toán tử như + và * trên chúng.
Một phương pháp ma thuật ví dụ là
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Kết quả
8
16
Phương thức
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]Như bạn có thể thấy, nó thêm các thuộc tính tương ứng của các đối tượng và trả về một đối tượng mới, chứa kết quả.
Khi đã định nghĩa xong, chúng ta có thể cộng hai đối tượng của lớp lại với nhau.
Phương pháp ma thuật-2
Thêm nhiều phương thức kỳ diệu cho các toán tử phổ biến.
______45 cho -
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]def infinite_sevens[]:
while True:
yield 7
for i in infinite_sevens[]:
print[i]def infinite_sevens[]:
while True:
yield 7
for i in infinite_sevens[]:
print[i]def infinite_sevens[]:
while True:
yield 7
for i in infinite_sevens[]:
print[i]def infinite_sevens[]:
while True:
yield 7
for i in infinite_sevens[]:
print[i]Biểu thức
def infinite_sevens[]:
while True:
yield 7
for i in infinite_sevens[]:
print[i]def infinite_sevens[]:
while True:
yield 7
for i in infinite_sevens[]:
print[i]Tuy nhiên, nếu x chưa triển khai
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]def infinite_sevens[]:
while True:
yield 7
for i in infinite_sevens[]:
print[i]Có r phương thức tương đương cho tất cả các phương thức ma thuật vừa được đề cập.
Ví dụ.
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Kết quả
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Ghi chú. Trong ví dụ trên, chúng ta đã định nghĩa phép chia cho lớp SpecialString của mình
Phương pháp ma thuật-3
Python cũng cung cấp các phương thức kỳ diệu để so sánh.
_______58 cho
def get_primes[]:
num = 2
while True:
if is_prime[num]:
yield num
num += 1Nếu
def get_primes[]:
num = 2
while True:
if is_prime[num]:
yield num
num += 1 def get_primes[]:
num = 2
while True:
if is_prime[num]:
yield num
num += 1Lưu ý. Không có mối quan hệ nào khác giữa các toán tử khác.
Ví dụ.
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Kết quả
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Ghi chú. Như bạn có thể thấy, bạn có thể xác định bất kỳ hành vi tùy chỉnh nào cho các toán tử quá tải
Phương pháp ma thuật-4
Có một số phương thức kỳ diệu để làm cho các lớp hoạt động giống như các thùng chứa.
______66 cho len[]
def get_primes[]:
num = 2
while True:
if is_prime[num]:
yield num
num += 1 def get_primes[]:
num = 2
while True:
if is_prime[num]:
yield num
num += 1. g. , trong vòng lặp for]
def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]Có nhiều phương thức kỳ diệu khác mà chúng tôi sẽ không trình bày ở đây, chẳng hạn như
def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]Ví dụ.
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Kết quả
6
7
Đ
C
Ghi chú. Chúng ta đã override hàm len[] cho class VagueList để trả về một số ngẫu nhiên.
Hàm lập chỉ mục cũng trả về một mục ngẫu nhiên trong một phạm vi từ danh sách, dựa trên biểu thức.
Vòng đời đối tượng-1
Vòng đời của một đối tượng được tạo thành từ việc tạo, thao tác và hủy của nó
Giai đoạn đầu tiên trong vòng đời của một đối tượng là định nghĩa lớp mà nó thuộc về.
Giai đoạn tiếp theo là khởi tạo một thể hiện, khi
def countdown[]:
i=5
while i > 0:
yield i
i -= 1
for i in countdown[]:
print[i]def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]Ghi chú. Sau khi điều này xảy ra, đối tượng đã sẵn sàng để sử dụng. Sau đó, mã khác có thể tương tác với đối tượng, bằng cách gọi các hàm trên
nó và truy cập các thuộc tính của nó. Cuối cùng, nó sẽ hết
được sử dụng và có thể bị hủy.
Vòng đời đối tượng-2
Khi một đối tượng bị hủy, bộ nhớ được phân bổ cho đối tượng đó sẽ được giải phóng và có thể được sử dụng cho các mục đích khác.
Việc hủy đối tượng xảy ra khi số tham chiếu của đối tượng về 0. Số tham chiếu là số biến và các phần tử khác tham chiếu đến một đối tượng.
Nếu không có gì liên quan đến nó [nó có số lượng tham chiếu bằng 0] thì không có gì có thể tương tác với nó, vì vậy nó có thể bị xóa một cách an toàn.
Trong một số trường hợp, hai [hoặc nhiều] đối tượng chỉ có thể được tham chiếu bởi nhau và do đó cũng có thể bị xóa.
Câu lệnh del giảm số lượng tham chiếu của một đối tượng xuống một và điều này thường dẫn đến việc xóa đối tượng đó.
Phương thức kỳ diệu cho câu lệnh del là
def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]Quá trình xóa các đối tượng khi chúng không còn cần thiết được gọi là thu gom rác.
Tóm lại, số lượng tham chiếu của một đối tượng tăng lên khi nó được gán một tên mới hoặc được đặt trong một vùng chứa [danh sách, bộ hoặc từ điển]. Số tham chiếu của đối tượng giảm khi đối tượng bị xóa bằng del, tham chiếu của đối tượng được gán lại hoặc tham chiếu của đối tượng nằm ngoài phạm vi. Khi số lượng tham chiếu của một đối tượng bằng 0, Python sẽ tự động xóa nó.
Ví dụ.
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Ghi chú. Các ngôn ngữ cấp thấp hơn như C không có kiểu quản lý bộ nhớ tự động này
Ẩn dữ liệu-1
Một phần quan trọng của lập trình hướng đối tượng là đóng gói, bao gồm việc đóng gói các biến và hàm có liên quan vào một đối tượng dễ sử dụng duy nhất - một thể hiện của một lớp.
Một khái niệm liên quan là ẩn dữ liệu, trong đó nêu rõ rằng các chi tiết triển khai của một lớp nên được ẩn đi và một giao diện chuẩn rõ ràng sẽ được trình bày cho những người muốn sử dụng lớp đó.
Trong các ngôn ngữ lập trình khác, điều này thường được thực hiện với các phương thức và thuộc tính riêng tư, ngăn chặn truy cập bên ngoài vào các phương thức và thuộc tính nhất định trong một lớp.
Triết lý Python hơi khác một chút. Nó thường được tuyên bố là "tất cả chúng ta đều là người lớn đồng ý ở đây", nghĩa là bạn không nên đặt ra các hạn chế tùy tiện đối với việc truy cập các phần của lớp học. Do đó, không có cách nào để bắt buộc một phương thức hoặc thuộc tính phải hoàn toàn riêng tư
Ghi chú. Tuy nhiên, có nhiều cách để ngăn cản mọi người truy cập vào các phần của một lớp, chẳng hạn như bằng cách biểu thị rằng đó là một
chi tiết triển khai và họ phải tự chịu rủi ro khi sử dụng.
Ẩn dữ liệu-2
Các phương thức và thuộc tính riêng tư yếu có một dấu gạch dưới ở đầu.
Điều này báo hiệu rằng chúng là riêng tư và mã bên ngoài không được sử dụng. Tuy nhiên, nó chủ yếu chỉ là một quy ước và không ngăn mã bên ngoài truy cập chúng.
Hiệu quả thực sự duy nhất của nó là từ module_name import * sẽ không nhập các biến bắt đầu bằng một dấu gạch dưới.
Ví dụ.
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Kết quả
Hàng đợi[[1, 2, 3]]
Hàng đợi[[0, 1, 2, 3]]
Hàng đợi[[0,
[0, 1, 2]
Ghi chú. Trong đoạn mã trên, thuộc tính
def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]Phương thức ma thuật
def numbers[x]:
for i in range[x]:
if i % 2 == 0:
yield i
print[list[numbers[11]]]Ẩn dữ liệu-3
Các phương thức và thuộc tính riêng tư mạnh mẽ có dấu gạch dưới kép ở đầu tên của chúng. Điều này khiến tên của chúng bị xáo trộn, nghĩa là không thể truy cập chúng từ bên ngoài lớp.
Mục đích của việc này không phải để đảm bảo rằng chúng được giữ ở chế độ riêng tư mà để tránh lỗi nếu có các lớp con có phương thức hoặc thuộc tính trùng tên.
Các phương thức được đọc sai tên vẫn có thể được truy cập từ bên ngoài, nhưng bằng một tên khác. Phương thức
def decor[func]:
def wrap[]:
print["============"]
func[]
print["============"]
return wrap
def print_text[]:
print["Hello world!"]
decorated = decor[print_text]
decorated[]def decor[func]:
def wrap[]:
print["============"]
func[]
print["============"]
return wrap
def print_text[]:
print["Hello world!"]
decorated = decor[print_text]
decorated[]Ví dụ.
nums = [11, 22, 33, 44, 55]
res = list[filter[lambda x: x%2==0, nums]]
print[res]Kết quả
7
7
AttributeError. Đối tượng ‘Spam’ không có thuộc tính ‘__egg’
Ghi chú. Về cơ bản, Python bảo vệ các thành viên đó bằng cách thay đổi tên bên trong để bao gồm tên lớp
phương pháp lớp
Các phương thức của các đối tượng mà chúng ta đã xem xét cho đến nay được gọi bởi một thể hiện của một lớp, sau đó được truyền vào tham số self của phương thức.
Các phương thức của lớp thì khác - chúng được gọi bởi một lớp, được truyền cho tham số cls của phương thức.
Một cách sử dụng phổ biến trong số này là các phương thức xuất xưởng, khởi tạo một thể hiện của một lớp, sử dụng các tham số khác với các tham số thường được truyền cho hàm tạo của lớp.
Các phương thức của lớp được đánh dấu bằng một bộ trang trí phương thức lớp.
Ví dụ.
nums = [1, 2, 5, 8, 3, 0, 7]
res = list[filter[lambda x: x < 5, nums]]
print[res]Kết quả
25
new_square là một phương thức của lớp và được gọi trên lớp chứ không phải trên một thể hiện của lớp. Nó trả về một đối tượng mới của lớp cls.
Về mặt kỹ thuật, các tham số self và cls chỉ là quy ước; . Tuy nhiên, chúng được tuân theo một cách phổ biến, vì vậy bạn nên kiên trì sử dụng chúng.
Phương thức tĩnh
Các phương thức tĩnh tương tự như các phương thức của lớp, ngoại trừ việc chúng không nhận thêm bất kỳ đối số nào; .
Chúng được đánh dấu bằng công cụ trang trí phương pháp tĩnh.
Ví dụ.
nums = [1, 2, 5, 8, 3, 0, 7]
res = list[filter[lambda x: x < 5, nums]]
print[res]Ghi chú. Các phương thức tĩnh hoạt động giống như các hàm đơn giản, ngoại trừ thực tế là bạn có thể gọi chúng từ một thể hiện của lớp
Thuộc tính-1
Các thuộc tính cung cấp cách tùy chỉnh quyền truy cập vào các thuộc tính của phiên bản.
Chúng được tạo bằng cách đặt trình trang trí thuộc tính phía trên một phương thức, nghĩa là khi thuộc tính thể hiện có cùng tên với phương thức được truy cập, thì phương thức đó sẽ được gọi thay thế.
Một cách sử dụng phổ biến của thuộc tính là đặt thuộc tính ở chế độ chỉ đọc.
Ví dụ.
nums = [1, 2, 5, 8, 3, 0, 7]
res = list[filter[lambda x: x < 5, nums]]
print[res]Kết quả
Sai
Lỗi thuộc tính. không thể đặt thuộc tính
Thuộc tính-2
Các thuộc tính cũng có thể được đặt bằng cách xác định các hàm setter/getter.
Hàm setter đặt giá trị của thuộc tính tương ứng.
Getter nhận giá trị.
Để xác định trình thiết lập, bạn cần sử dụng trình trang trí có cùng tên với thuộc tính, theo sau là dấu chấm và từ khóa trình thiết lập.
Điều tương tự cũng áp dụng cho việc xác định hàm getter.
Ví dụ.
nums = [1, 2, 5, 8, 3, 0, 7]
res = list[filter[lambda x: x < 5, nums]]
print[res]Kết quả
Sai
Nhập mật khẩu để cho phép dứa. Sw0rdf1sh.
Đúng
Một trò chơi đơn giản
Hướng đối tượng rất hữu ích khi quản lý các đối tượng khác nhau và các mối quan hệ của chúng. Điều đó đặc biệt hữu ích khi bạn đang phát triển trò chơi với các nhân vật và tính năng khác nhau.