Hướng dẫn how do you represent a point in python? - làm thế nào để bạn đại diện cho một điểm trong python?

7.1. Lập trình hướng đối tượng¶Object-oriented programming¶

Python là ngôn ngữ lập trình hướng đối tượng, có nghĩa là nó cung cấp các tính năng hỗ trợ lập trình hướng đối tượng (OOP).object-oriented programming language, which means that it provides features that support object-oriented programming ( OOP).

Lập trình hướng đối tượng có nguồn gốc từ những năm 1960, nhưng đến giữa những năm 1980, nó trở thành mô hình lập trình chính được sử dụng trong việc tạo ra phần mềm mới. Nó được phát triển như một cách để xử lý kích thước và độ phức tạp tăng nhanh của các hệ thống phần mềm và để giúp việc sửa đổi các hệ thống lớn và phức tạp này theo thời gian dễ dàng hơn.

Cho đến nay chúng tôi đã viết các chương trình bằng cách sử dụng một mô hình lập trình thủ tục. Trong lập trình thủ tục, trọng tâm là viết các chức năng hoặc thủ tục hoạt động trên dữ liệu. Trong lập trình hướng đối tượng, trọng tâm là việc tạo các đối tượng chứa cả dữ liệu và chức năng cùng nhau.objects which contain both data and functionality together.

7.2. Các loại hợp chất do người dùng xác địnhUser-defined compound types¶

Bây giờ chúng tôi sẽ giới thiệu một từ khóa Python mới, lớp, về bản chất xác định một loại dữ liệu mới. Chúng tôi đã sử dụng một số loại tích hợp Python, trong suốt cuốn sách này, giờ đây chúng tôi đã sẵn sàng để tạo loại do người dùng định nghĩa:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Hãy xem xét khái niệm của một điểm toán học. Trong hai chiều, một điểm là hai số (tọa độ) được coi là một đối tượng. Trong ký hiệu toán học, các điểm thường được viết theo dấu ngoặc đơn với dấu phẩy ngăn cách tọa độ. Ví dụ,

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Một cách tự nhiên để thể hiện một điểm trong Python là với hai giá trị số. Sau đó, câu hỏi là làm thế nào để nhóm hai giá trị này thành một đối tượng ghép. Giải pháp nhanh chóng và bẩn là sử dụng danh sách hoặc tuple, và đối với một số ứng dụng có thể là lựa chọn tốt nhất.

Một giải pháp thay thế là xác định một loại hợp chất do người dùng xác định mới, được gọi là một lớp. Cách tiếp cận này liên quan đến nỗ lực hơn một chút, nhưng nó có những lợi thế sẽ sớm rõ ràng.class. This approach involves a bit more effort, but it has advantages that will be apparent soon.

Một định nghĩa lớp trông như thế này:

Các định nghĩa của lớp có thể xuất hiện ở bất cứ đâu trong một chương trình, nhưng chúng thường ở gần đầu (sau các câu lệnh

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Định nghĩa này tạo ra một lớp mới gọi là

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    "Point class for storing mathematical points."

Bằng cách tạo lớp

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Biến

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Có thể hữu ích khi nghĩ về một lớp như một nhà máy để tạo ra các đối tượng, vì vậy lớp

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

7.3. Thuộc tính¶Attributes¶

Giống như các đối tượng trong thế giới thực, các trường hợp đối tượng có cả hình thức và chức năng. Biểu mẫu bao gồm các yếu tố dữ liệu có trong trường hợp.

Chúng ta có thể thêm các thành phần dữ liệu mới vào một thể hiện bằng ký hiệu DOT:dot notation:

Cú pháp này tương tự như cú pháp để chọn một biến từ một mô -đun, chẳng hạn như

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

Biểu đồ trạng thái sau đây cho thấy kết quả của các bài tập sau:

Biến

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

Chúng ta có thể đọc giá trị của một thuộc tính bằng cách sử dụng cùng một cú pháp:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Biểu thức

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Bạn có thể sử dụng ký hiệu DOT như một phần của bất kỳ biểu thức nào, vì vậy các câu sau đây là hợp pháp:

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Dòng đầu ra đầu ra

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

7.4. Phương pháp khởi tạo và ________ 76¶The initialization method and >>> p = Point(3, 4) >>> p.x 3 >>> p.y 4 >>> p.distance_from_origin() 5.0 >>> q = Point(5, 12) >>> q.x 5 >>> q.y 12 >>> q.distance_from_origin() 13.0 >>> r = Point(0, 0) >>> r.x 0 >>> r.y 0 >>> r.distance_from_origin() 0.0 6¶

Vì lớp

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Để giải quyết vấn đề này, chúng tôi thêm một phương thức khởi tạo vào lớp của chúng tôi.initialization method to our class.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Một phương pháp hoạt động giống như một hàm nhưng nó là một phần của một đối tượng. Giống như một thuộc tính dữ liệu, nó được truy cập bằng ký hiệu DOT.method behaves like a function but it is part of an object. Like a data attribute it is accessed using dot notation.

Phương thức khởi tạo là một phương thức đặc biệt được gọi tự động khi một đối tượng được tạo bằng cách gọi lớp. Tên của phương pháp này là

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

Không có xung đột giữa thuộc tính

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Hãy để thêm một phương pháp khác,

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

Hãy để tạo ra một vài trường hợp điểm, nhìn vào các thuộc tính của chúng và gọi phương thức mới của chúng tôi trên chúng:

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

Khi xác định một phương thức, tham số đầu tiên đề cập đến thể hiện được tạo. Đó là thông lệ để đặt tên cho tham số này tự. Trong phiên ví dụ ở trên, tham số

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

7.5. Các thể hiện dưới dạng tham sốInstances as parameters¶

Bạn có thể chuyển một thể hiện dưới dạng tham số cho một hàm theo cách thông thường. Ví dụ:

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

    def print_point(self):
        print('({0}, {1})'.format(self.x, self.y))

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

    def print_point(self):
        print('({0}, {1})'.format(self.x, self.y))

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

Để chuyển đổi

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

    def print_point(self):
        print('({0}, {1})'.format(self.x, self.y))

1. Thụt ý định định nghĩa chức năng sao cho nó ở bên trong định nghĩa lớp.

2. Đổi tên tham số thành

   >>> p = Point(3, 4)
   >>> p.x
   3
   >>> p.y
   4
   >>> p.distance_from_origin()
   5.0
   >>> q = Point(5, 12)
   >>> q.x
   5
   >>> q.y
   12
   >>> q.distance_from_origin()
   13.0
   >>> r = Point(0, 0)
   >>> r.x
   0
   >>> r.y
   0
   >>> r.distance_from_origin()
   0.0
   

   6.

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

    def print_point(self):
        print('({0}, {1})'.format(self.x, self.y))

Bây giờ chúng ta có thể gọi phương thức bằng cách sử dụng ký hiệu DOT.

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Đối tượng mà phương thức được gọi được gán cho tham số đầu tiên, vì vậy trong trường hợp này

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

Cú pháp cho một cuộc gọi chức năng,

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

    def print_point(self):
        print('({0}, {1})'.format(self.x, self.y))

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

    def print_point(self):
        print('({0}, {1})'.format(self.x, self.y))

Trong lập trình hướng đối tượng, các đối tượng là các tác nhân hoạt động. Một lời cầu khẩn như

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

Sự thay đổi trong quan điểm này có thể lịch sự hơn, nhưng không rõ ràng là nó hữu ích. Trong các ví dụ chúng ta đã thấy cho đến nay, nó có thể không. Nhưng đôi khi chuyển trách nhiệm từ các chức năng vào các đối tượng giúp bạn có thể viết các chức năng linh hoạt hơn và giúp việc duy trì và sử dụng lại mã dễ dàng hơn.

7.6. Các tính năng hướng đối tượngObject-oriented features¶

Không dễ để xác định lập trình hướng đối tượng, nhưng chúng tôi đã thấy một số đặc điểm của nó:

1. Các chương trình được tạo thành từ các định nghĩa lớp có chứa các thuộc tính có thể là dữ liệu (biến thể hiện) hoặc hành vi (phương thức).

2. Mỗi định nghĩa đối tượng tương ứng với một số đối tượng hoặc khái niệm trong thế giới thực và các hàm hoạt động trên đối tượng đó tương ứng với các cách các đối tượng trong thế giới thực tương tác.

3. Hầu hết các tính toán được thể hiện dưới dạng hoạt động trên các đối tượng.

Ví dụ, lớp

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

7.7. Thời gian¶Time¶

Như một ví dụ khác về loại do người dùng xác định, chúng tôi sẽ xác định một lớp gọi là

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Định nghĩa lớp trông như thế này:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Khi chúng tôi gọi lớp

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Dưới đây là phương thức

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Để tiết kiệm không gian, chúng tôi sẽ bỏ phương thức khởi tạo, nhưng bạn nên bao gồm nó:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

mà bây giờ chúng ta có thể gọi các trường hợp theo thời gian theo cách thông thường:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

7.8. Đối số tùy chọnOptional arguments¶

Chúng tôi đã thấy các chức năng tích hợp có một số lượng đối số khác nhau. Ví dụ,

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Có thể viết các chức năng do người dùng xác định với danh sách đối số tùy chọn. Ví dụ: chúng tôi có thể nâng cấp phiên bản

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Đây là phiên bản gốc:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Đây là phiên bản mới và được cải tiến:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Tham số thứ ba,

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Nếu chúng tôi cung cấp tham số thứ ba, nó sẽ ghi đè mặc định:overrides the default:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Chúng tôi có thể viết lại phương thức khởi tạo của mình cho lớp

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Khi chúng ta khởi tạo một đối tượng

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Vì các tham số hiện là tùy chọn, tuy nhiên, chúng ta có thể bỏ qua chúng:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Hoặc chỉ cung cấp tham số đầu tiên:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Hoặc hai tham số đầu tiên:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Cuối cùng, chúng tôi có thể cung cấp một tập hợp con của các tham số bằng cách đặt tên chúng một cách rõ ràng:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

7.9. Một phương pháp khác¶Another method¶

Hãy để thêm một phương thức

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Bây giờ chúng ta có thể gọi

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Một lần nữa, đối tượng mà phương thức được gọi được gán cho tham số đầu tiên,

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

7.10. Một ví dụ với hai ____ 104S¶An example with two >>> type(Point) <class 'type'> >>> p = Point() >>> type(p) <class '__main__.Point'> 04s¶

Hãy để thêm một phương thức Boolen,

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Chúng ta chỉ có thể chuyển đổi một trong các tham số thành

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Chúng tôi gọi phương thức này trên một đối tượng và chuyển sang đối tượng khác như một đối số:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Bạn gần như có thể đọc lời mời như tiếng Anh: Nếu Time1 là sau thời gian2, thì

7.10.1. Các chức năng và sửa đổi thuần túy (một lần nữa)Pure functions and modifiers (again)¶

Trong một vài phần tiếp theo, chúng tôi sẽ viết hai phiên bản của một hàm gọi là

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Sau đây là phiên bản sơ bộ của

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Hàm tạo ra một đối tượng

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Dưới đây là một ví dụ về cách sử dụng chức năng này. Chúng tôi sẽ tạo hai đối tượng

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Đầu ra của chương trình này là

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Vấn đề là chức năng này không giải quyết các trường hợp trong đó số giây hoặc phút tăng lên đến hơn sáu mươi. Khi điều đó xảy ra, chúng ta phải mang thêm giây vào cột phút hoặc thêm phút vào cột giờ.

Ở đây, một phiên bản sửa chữa thứ hai của chức năng:

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Mặc dù chức năng này là chính xác, nó bắt đầu trở nên lớn. Sau đó, chúng tôi sẽ đề xuất một cách tiếp cận thay thế mang lại mã ngắn hơn.

7.10.2. Người sửa đổiModifiers¶

Có những lúc nó hữu ích cho một hàm để sửa đổi một hoặc nhiều đối tượng mà nó nhận được là tham số. Thông thường, người gọi giữ một tham chiếu đến các đối tượng mà nó đi qua, do đó, bất kỳ thay đổi nào mà hàm thực hiện đều có thể nhìn thấy cho người gọi. Các chức năng hoạt động theo cách này được gọi là sửa đổi.modifiers.

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Dòng đầu tiên thực hiện hoạt động cơ bản; Phần còn lại liên quan đến các trường hợp đặc biệt mà chúng tôi đã thấy trước đây.

Chức năng này có đúng không? Điều gì xảy ra nếu tham số

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Hàm này bây giờ là chính xác, nhưng nó không phải là giải pháp hiệu quả nhất.

7.11. Phát triển nguyên mẫu so với kế hoạchPrototype development versus planning¶

Cho đến nay trong chương này, chúng tôi đã sử dụng một cách tiếp cận để phát triển chương trình mà chúng tôi sẽ gọi là phát triển nguyên mẫu. Chúng tôi đã viết một bản nháp thô (hoặc nguyên mẫu) thực hiện tính toán cơ bản và sau đó thử nghiệm nó trên một vài trường hợp, sửa lỗi khi chúng tôi tìm thấy chúng.prototype development. We wrote a rough draft (or prototype) that performed the basic calculation and then tested it on a few cases, correcting flaws as we found them.

Mặc dù cách tiếp cận này có thể có hiệu quả, nhưng nó có thể dẫn đến mã phức tạp không cần thiết - vì nó liên quan đến nhiều trường hợp đặc biệt - và không đáng tin cậy - vì khó có thể biết nếu chúng tôi đã tìm thấy tất cả các lỗi.

Một giải pháp thay thế được lên kế hoạch phát triển, trong đó cái nhìn sâu sắc cấp cao về vấn đề có thể giúp chương trình dễ dàng hơn nhiều. Trong trường hợp này, cái nhìn sâu sắc là một đối tượng

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Khi chúng tôi viết

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Quan sát này cho thấy một cách tiếp cận khác cho toàn bộ vấn đề - chúng ta có thể chuyển đổi đối tượng

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Bây giờ, tất cả những gì chúng ta cần là một cách để chuyển đổi từ một số nguyên sang đối tượng

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Bạn có thể phải suy nghĩ một chút để thuyết phục bản thân rằng kỹ thuật này để chuyển đổi từ cơ sở này sang cơ sở khác là chính xác. Giả sử bạn bị thuyết phục, bạn có thể sử dụng các chức năng này để viết lại

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Phiên bản này ngắn hơn nhiều so với bản gốc và việc chứng minh rằng nó là chính xác hơn nhiều (giả sử, như thường lệ, các chức năng mà nó gọi là chính xác).

7.12. Sự khái quát¶Generalization¶

Trong một số cách, việc chuyển đổi từ cơ sở 60 thành cơ sở 10 và trở lại khó hơn là chỉ xử lý thời gian. Chuyển đổi cơ sở là trừu tượng hơn; Trực giác của chúng tôi để đối phó với thời gian là tốt hơn.

Nhưng nếu chúng ta có cái nhìn sâu sắc để coi thời gian là số 60 và đầu tư viết các chức năng chuyển đổi (

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Nó cũng dễ dàng hơn để thêm các tính năng sau này. Ví dụ, hãy tưởng tượng trừ hai

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Trớ trêu thay, đôi khi làm cho một vấn đề khó khăn hơn (hoặc tổng quát hơn) làm cho nó dễ dàng hơn (bởi vì có ít trường hợp đặc biệt hơn và ít cơ hội hơn cho lỗi).

7.13. Thuật toánAlgorithms¶

Khi bạn viết một giải pháp chung cho một lớp các vấn đề, trái ngược với một giải pháp cụ thể cho một vấn đề duy nhất, bạn đã viết một thuật toán. Chúng tôi đã đề cập đến từ này trước đây nhưng không định nghĩa nó một cách cẩn thận. Không dễ để xác định, vì vậy chúng tôi sẽ thử một vài cách tiếp cận.algorithm. We mentioned this word before but did not define it carefully. It is not easy to define, so we will try a couple of approaches.

Đầu tiên, hãy xem xét một cái gì đó không phải là một thuật toán. Khi bạn học cách nhân các số một chữ số, có lẽ bạn đã ghi nhớ bảng nhân. Trong thực tế, bạn đã ghi nhớ 100 giải pháp cụ thể. Loại kiến ​​thức đó không phải là thuật toán.

Nhưng nếu bạn lười biếng, có lẽ bạn đã lừa dối bằng cách học một vài thủ thuật. Ví dụ: để tìm sản phẩm của

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Tương tự, các kỹ thuật bạn đã học để bổ sung với việc mang theo, trừ với vay và phân chia dài đều là tất cả các thuật toán. Một trong những đặc điểm của thuật toán là chúng không yêu cầu bất kỳ trí thông minh nào để thực hiện. Chúng là các quy trình cơ học trong đó mỗi bước theo sau từ cuối cùng theo một bộ quy tắc đơn giản.

Theo tôi, thật đáng xấu hổ khi con người dành quá nhiều thời gian cho trường học để thực hiện các thuật toán, theo nghĩa đen, không đòi hỏi trí thông minh.

Mặt khác, quá trình thiết kế các thuật toán là thú vị, thách thức trí tuệ và là một phần trung tâm của những gì chúng ta gọi là lập trình.

Một số điều mà mọi người làm một cách tự nhiên, không gặp khó khăn hoặc suy nghĩ có ý thức, là khó nhất để diễn đạt thuật toán. Hiểu ngôn ngữ tự nhiên là một ví dụ tốt. Tất cả chúng ta đều làm điều đó, nhưng cho đến nay không ai có thể giải thích cách chúng ta làm điều đó, ít nhất là không ở dạng thuật toán.

7.14. Điểm được xem xét lạiPoints revisited¶

Hãy để viết lại lớp

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Phương thức tiếp theo,

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

In một đối tượng

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Khi chúng tôi viết một lớp mới, chúng tôi hầu như luôn bắt đầu bằng cách viết

def print_point(p):
    print('({0}, {1})'.format(p.x, p.y))

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

7.15. Người vận hành quá tảiOperator overloading¶

Một số ngôn ngữ cho phép thay đổi định nghĩa của các toán tử tích hợp khi chúng được áp dụng cho các loại do người dùng xác định. Tính năng này được gọi là quá tải toán tử. Nó đặc biệt hữu ích khi xác định các loại toán học mới.operator overloading. It is especially useful when defining new mathematical types.

Ví dụ: để ghi đè người vận hành bổ sung

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Như thường lệ, tham số đầu tiên là đối tượng mà phương thức được gọi. Tham số thứ hai được đặt tên thuận tiện

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Bây giờ, khi chúng tôi áp dụng toán tử

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Biểu thức

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Nếu toán hạng bên trái của

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Nếu toán hạng bên trái của

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Kết quả là một

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Ví dụ này cho thấy cả hai loại nhân:

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Điều gì xảy ra nếu chúng ta cố gắng đánh giá

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Thật không may, thông báo lỗi là một chút mờ đục. Ví dụ này cho thấy một số khó khăn của lập trình hướng đối tượng. Đôi khi nó đủ khó chỉ để tìm ra mã nào đang chạy.

Để biết ví dụ đầy đủ hơn về quá tải toán tử, xem Phụ lục (quá tải tham chiếu).

7.16. Sự đa hìnhPolymorphism¶

Hầu hết các phương pháp chúng tôi đã viết chỉ hoạt động cho một loại cụ thể. Khi bạn tạo một đối tượng mới, bạn viết các phương thức hoạt động trên loại đó.

Nhưng có một số hoạt động nhất định mà bạn sẽ muốn áp dụng cho nhiều loại, chẳng hạn như các hoạt động số học trong các phần trước. Nếu nhiều loại hỗ trợ cùng một bộ hoạt động, bạn có thể viết các chức năng hoạt động trên bất kỳ loại nào trong số đó.

Ví dụ: hoạt động

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Phương pháp này sẽ hoạt động cho bất kỳ giá trị nào của

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Chúng ta có thể gọi nó với các giá trị số:

Hoặc với

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Trong trường hợp đầu tiên,

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Một chức năng như thế này có thể lấy các tham số với các loại khác nhau được gọi là đa hình.polymorphic.

Một ví dụ khác, hãy xem xét phương pháp

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Vì phương thức

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Ở đây, một ví dụ áp dụng

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Tất nhiên, chúng tôi dự định áp dụng chức năng này vào danh sách, vì vậy không có gì đáng ngạc nhiên khi nó hoạt động. Điều đáng ngạc nhiên là nếu chúng ta có thể áp dụng nó vào

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Để xác định xem một hàm có thể được áp dụng cho một loại mới hay không, chúng tôi áp dụng quy tắc đa hình cơ bản: nếu tất cả các hoạt động bên trong hàm có thể được áp dụng cho loại, hàm có thể được áp dụng cho loại. Các hoạt động trong phương pháp bao gồm

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

Sau đó, chúng ta có thể chuyển

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Loại đa hình tốt nhất là loại không chủ ý, nơi bạn phát hiện ra rằng một hàm bạn đã viết có thể được áp dụng cho một loại mà bạn chưa từng lên kế hoạch.

7.17. Bảng chú giải¶Glossary¶

Một loại hợp chất do người dùng xác định. Một lớp cũng có thể được coi là một mẫu cho các đối tượng là trường hợp của nó.

Để tạo một thể hiện của một lớp.

Một đối tượng thuộc về một lớp.

Một loại dữ liệu ghép thường được sử dụng để mô hình hóa một thứ hoặc khái niệm trong thế giới thực.

Một trong những mục dữ liệu được đặt tên tạo thành một thể hiện.

Một hàm không sửa đổi bất kỳ đối tượng nào mà nó nhận được dưới dạng tham số. Hầu hết các chức năng thuần túy đều có kết quả.

Một hàm thay đổi một hoặc nhiều đối tượng mà nó nhận được dưới dạng tham số. Hầu hết các sửa đổi là vô hiệu.

Một phong cách thiết kế chương trình trong đó phần lớn các chức năng là thuần túy.

Một cách phát triển các chương trình bắt đầu với một nguyên mẫu và dần dần kiểm tra và cải thiện nó.

Một cách phát triển các chương trình liên quan đến cái nhìn sâu sắc cấp cao về vấn đề và lập kế hoạch nhiều hơn là phát triển gia tăng hoặc phát triển nguyên mẫu.

Một ngôn ngữ cung cấp các tính năng, chẳng hạn như các lớp và kế thừa do người dùng xác định, tạo điều kiện cho lập trình hướng đối tượng.

Một phong cách lập trình trong đó dữ liệu và các hoạt động thao tác nó được tổ chức thành các lớp và phương pháp.

Một hàm được xác định bên trong định nghĩa lớp và được gọi trên các trường hợp của lớp đó. : Ghi đè :: để thay thế mặc định. Các ví dụ bao gồm thay thế một tham số mặc định bằng một đối số cụ thể và thay thế một phương thức mặc định bằng cách cung cấp một phương thức mới cùng tên.

Một phương thức đặc biệt được gọi tự động khi một đối tượng mới được tạo và khởi tạo các thuộc tính của đối tượng.

Mở rộng các toán tử tích hợp (

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Một hoạt động được xác định trong đại số tuyến tính nhân lên hai

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Một hoạt động được xác định trong đại số tuyến tính nhân lên từng tọa độ của

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Một chức năng có thể hoạt động trên nhiều loại. Nếu tất cả các hoạt động trong một hàm có thể được áp dụng cho một loại, thì hàm có thể được áp dụng cho một loại.

Loại điểm trong Python là gì?

P1 trong Python là gì?

__ str __ trong Python là gì?

Bản thân có phải là một con trỏ trong Python không?