Python cho lớp 10 là gì?

9. 1. Đôi lời về tên và đối tượng

Các đối tượng có tính riêng biệt và nhiều tên [trong nhiều phạm vi] có thể được liên kết với cùng một đối tượng. Điều này được gọi là bí danh trong các ngôn ngữ khác. Điều này thường không được đánh giá cao trong cái nhìn đầu tiên về Python và có thể được bỏ qua một cách an toàn khi xử lý các loại cơ bản không thay đổi [số, chuỗi, bộ dữ liệu]. Tuy nhiên, bí danh có thể có tác động đáng ngạc nhiên đối với ngữ nghĩa của mã Python liên quan đến các đối tượng có thể thay đổi như danh sách, từ điển và hầu hết các loại khác. Điều này thường được sử dụng vì lợi ích của chương trình, vì bí danh hoạt động giống như con trỏ ở một số khía cạnh. Ví dụ, việc truyền một đối tượng là rẻ vì quá trình thực hiện chỉ truyền một con trỏ;

9. 2. Phạm vi Python và không gian tên

Trước khi giới thiệu các lớp học, trước tiên tôi phải nói với bạn đôi điều về quy tắc phạm vi của Python. Định nghĩa lớp chơi một số thủ thuật gọn gàng với không gian tên và bạn cần biết cách phạm vi và không gian tên hoạt động để hiểu đầy đủ những gì đang diễn ra. Ngẫu nhiên, kiến ​​thức về chủ đề này rất hữu ích cho bất kỳ lập trình viên Python nâng cao nào

Hãy bắt đầu với một số định nghĩa

Một không gian tên là ánh xạ từ tên đến đối tượng. Hầu hết các không gian tên hiện được triển khai dưới dạng từ điển Python, nhưng điều đó thường không đáng chú ý theo bất kỳ cách nào [ngoại trừ hiệu suất] và nó có thể thay đổi trong tương lai. Ví dụ về không gian tên là. tập hợp các tên dựng sẵn [chứa các hàm như và các tên ngoại lệ dựng sẵn]; . Theo một nghĩa nào đó, tập hợp các thuộc tính của một đối tượng cũng tạo thành một không gian tên. Điều quan trọng cần biết về các không gian tên là hoàn toàn không có mối quan hệ nào giữa các tên trong các không gian tên khác nhau;

Nhân tiện, tôi sử dụng thuộc tính từ cho bất kỳ tên nào sau dấu chấm — ví dụ: trong biểu thức

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

Các thuộc tính có thể là chỉ đọc hoặc ghi. Trong trường hợp sau, có thể gán cho các thuộc tính. Thuộc tính mô-đun có thể ghi. bạn có thể viết

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

x = MyClass[]

x = MyClass[]

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

Không gian tên được tạo tại các thời điểm khác nhau và có thời gian tồn tại khác nhau. Không gian tên chứa tên dựng sẵn được tạo khi trình thông dịch Python khởi động và không bao giờ bị xóa. Không gian tên chung cho một mô-đun được tạo khi định nghĩa mô-đun được đọc vào; . Các câu lệnh được thực thi bởi lệnh gọi cấp cao nhất của trình thông dịch, được đọc từ tệp tập lệnh hoặc tương tác, được coi là một phần của mô-đun có tên , vì vậy chúng có không gian tên chung của riêng chúng. [Các tên dựng sẵn thực sự cũng tồn tại trong một mô-đun; cái này được gọi là. ]

Không gian tên cục bộ cho một hàm được tạo khi hàm được gọi và bị xóa khi hàm trả về hoặc đưa ra một ngoại lệ không được xử lý trong hàm. [Thật ra, quên sẽ là cách tốt hơn để mô tả những gì thực sự xảy ra. ] Tất nhiên, mỗi lời gọi đệ quy đều có không gian tên cục bộ của riêng chúng

Phạm vi là một vùng văn bản của chương trình Python nơi không gian tên có thể truy cập trực tiếp. “Có thể truy cập trực tiếp” ở đây có nghĩa là một tham chiếu không đủ tiêu chuẩn đến một tên cố gắng tìm tên đó trong không gian tên

Mặc dù phạm vi được xác định tĩnh nhưng chúng được sử dụng động. Bất cứ lúc nào trong quá trình thực thi, có 3 hoặc 4 phạm vi lồng nhau có không gian tên có thể truy cập trực tiếp

• phạm vi trong cùng, được tìm kiếm đầu tiên, chứa tên địa phương

• phạm vi của bất kỳ chức năng kèm theo nào, được tìm kiếm bắt đầu bằng phạm vi kèm theo gần nhất, chứa các tên không cục bộ, nhưng cũng không phải toàn cầu

• phạm vi next-to-last chứa tên chung của mô-đun hiện tại

• phạm vi ngoài cùng [được tìm kiếm cuối cùng] là không gian tên chứa các tên dựng sẵn

Nếu một tên được khai báo là toàn cầu, thì tất cả các tham chiếu và phép gán sẽ chuyển trực tiếp đến phạm vi tiếp theo chứa tên toàn cục của mô-đun. Để rebind các biến được tìm thấy bên ngoài phạm vi trong cùng, câu lệnh có thể được sử dụng;

Thông thường, phạm vi cục bộ tham chiếu tên cục bộ của hàm hiện tại [theo văn bản]. Các chức năng bên ngoài, phạm vi cục bộ tham chiếu cùng một không gian tên với phạm vi toàn cầu. không gian tên của mô-đun. Định nghĩa lớp đặt một không gian tên khác trong phạm vi cục bộ

Điều quan trọng là phải nhận ra rằng phạm vi được xác định theo văn bản. phạm vi toàn cầu của một chức năng được xác định trong một mô-đun là không gian tên của mô-đun đó, bất kể chức năng được gọi từ đâu hoặc bằng bí danh nào. Mặt khác, việc tìm kiếm tên thực tế được thực hiện một cách linh hoạt, trong thời gian chạy — tuy nhiên, định nghĩa ngôn ngữ đang phát triển theo hướng phân giải tên tĩnh, tại thời điểm “biên dịch”, vì vậy đừng dựa vào độ phân giải tên động. [Thực tế, các biến cục bộ đã được xác định tĩnh. ]

Một điều đặc biệt của Python là - nếu không có hoặc câu lệnh nào có hiệu lực - việc gán cho các tên luôn đi vào phạm vi trong cùng. Bài tập không sao chép dữ liệu — chúng chỉ liên kết tên với đối tượng. Điều này cũng đúng với việc xóa. câu lệnh

x = MyClass[]

x = MyClass[]

Câu lệnh có thể được sử dụng để chỉ ra rằng các biến cụ thể tồn tại trong phạm vi toàn cầu và sẽ được phục hồi ở đó;

def scope_test[]:
    def do_local[]:
        spam = "local spam"

    def do_nonlocal[]:
        nonlocal spam
        spam = "nonlocal spam"

    def do_global[]:
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local[]
    print["After local assignment:", spam]
    do_nonlocal[]
    print["After nonlocal assignment:", spam]
    do_global[]
    print["After global assignment:", spam]

scope_test[]
print["In global scope:", spam]

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

9. 3. Cái nhìn đầu tiên về lớp học

Các lớp giới thiệu một chút cú pháp mới, ba loại đối tượng mới và một số ngữ nghĩa mới

class ClassName:
    
    .
    .
    .
    

x = MyClass[]

class MyClass:
    """A simple example class"""
    i = 12345

    def f[self]:
        return 'hello world'

x = MyClass[]

x = MyClass[]

x = MyClass[]

x = MyClass[]

x = MyClass[]

x = MyClass[]

x = MyClass[]

def __init__[self]:
    self.data = []

x = MyClass[]

x = MyClass[]

x = MyClass[]

x = MyClass[]

>>> class Complex:
..     def __init__[self, realpart, imagpart]:
..         self.r = realpart
..         self.i = imagpart
...
>>> x = Complex[3.0, -4.5]
>>> x.r, x.i
[3.0, -4.5]

x = MyClass[]

>>> class Complex:
..     def __init__[self, realpart, imagpart]:
..         self.r = realpart
..         self.i = imagpart
...
>>> x = Complex[3.0, -4.5]
>>> x.r, x.i
[3.0, -4.5]

>>> class Complex:
..     def __init__[self, realpart, imagpart]:
..         self.r = realpart
..         self.i = imagpart
...
>>> x = Complex[3.0, -4.5]
>>> x.r, x.i
[3.0, -4.5]

x.counter = 1
while x.counter >> class Complex:
..     def __init__[self, realpart, imagpart]:
..         self.r = realpart
..         self.i = imagpart
...
>>> x = Complex[3.0, -4.5]
>>> x.r, x.i
[3.0, -4.5]

x = MyClass[]

>>> class Complex:
..     def __init__[self, realpart, imagpart]:
..         self.r = realpart
..         self.i = imagpart
...
>>> x = Complex[3.0, -4.5]
>>> x.r, x.i
[3.0, -4.5]

x = MyClass[]

>>> class Complex:
..     def __init__[self, realpart, imagpart]:
..         self.r = realpart
..         self.i = imagpart
...
>>> x = Complex[3.0, -4.5]
>>> x.r, x.i
[3.0, -4.5]

x = MyClass[]

x.f[]

>>> class Complex:
..     def __init__[self, realpart, imagpart]:
..         self.r = realpart
..         self.i = imagpart
...
>>> x = Complex[3.0, -4.5]
>>> x.r, x.i
[3.0, -4.5]

x.counter = 1
while x.counter >> class Complex:
..     def __init__[self, realpart, imagpart]:
..         self.r = realpart
..         self.i = imagpart
...
>>> x = Complex[3.0, -4.5]
>>> x.r, x.i
[3.0, -4.5]

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

x.counter = 1
while x.counter