Bản thân trong Python đại diện cho thể hiện của lớp. Không giống như điều này trong C ++, "bản thân" không phải là một từ khóa, nó chỉ là một quy ước mã hóa. Thông thường, đối số đầu tiên của một phương thức được gọi là self. Bạn có thể đặt cho tham số đầu tiên của phương thức của mình bất kỳ tên nào bạn muốn, nhưng bạn nên tuân theo quy ước gọi nó là self. Nó liên kết các thuộc tính với các đối số đã cho. Việc sử dụng self giúp dễ dàng phân biệt giữa các thuộc tính [và phương thức] của thể hiện với các biến cục bộ
Bạn có thể khai báo các biến trong một lớp mà không cần sử dụng tham chiếu tự thân, nhưng sau đó các biến đó sẽ được chia sẻ bởi tất cả các phiên bản của lớp đó, đây có thể không phải là điều bạn dự định. Trong ví dụ trên, bản thân. tuổi = tuổi tác và bản thân. name = name đang khai báo "biến thể hiện" [trái ngược với "biến lớp"], các giá trị của chúng sẽ là duy nhất cho các đối tượng được khởi tạo của lớp đó. Nếu không, tất cả học sinh sẽ có cùng tên và tuổi
Tuy nhiên, một phương thức đối tượng, yêu cầu bạn tạo một biến, đó là một Động vật, trong trường hợp này, cần có đối số self
class Animal[]:
def objectMethod[self]:
print "This is an object method which needs an instance of a class"
Phương thức self cũng được sử dụng để tham chiếu đến một trường biến trong lớp
class Animal[]:
#animalName made in constructor
def Animal[self]:
self.animalName = "";
def getAnimalName[self]:
return self.animalName
Trong trường hợp này, self đang đề cập đến biến animalName của cả lớp. NHỚ. Nếu bạn có một biến trong một phương thức, self sẽ không hoạt động. Biến đó chỉ đơn giản tồn tại khi phương thức đó đang chạy. Để định nghĩa các trường [các biến của cả lớp], bạn phải định nghĩa chúng BÊN NGOÀI các phương thức của lớp
Nếu bạn không hiểu một từ nào về những gì tôi đang nói, thì hãy Google "Lập trình hướng đối tượng. "Một khi bạn hiểu điều này, bạn thậm chí sẽ không cần phải hỏi câu hỏi đó. ]
Nếu bạn đã lập trình bằng Python [lập trình hướng đối tượng] một thời gian, thì bạn chắc chắn đã bắt gặp các phương thức có tham số đầu tiên là
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3Trước tiên chúng ta hãy cố gắng hiểu tham số tự định kỳ này là gì
Bản thân trong Python là gì?
Trong lập trình hướng đối tượng, bất cứ khi nào chúng ta định nghĩa các phương thức cho một lớp, chúng ta sử dụng
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 làm tham số đầu tiên trong mỗi trường hợp. Hãy xem định nghĩa của một lớp có tên là cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
5class Cat:
def __init__[self, name, age]:
self.name = name
self.age = age
def info[self]:
print[f"I am a cat. My name is {self.name}. I am {self.age} years old."]
def make_sound[self]:
print["Meow"]
Trong trường hợp này, tất cả các phương thức, bao gồm cả
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
6, có tham số đầu tiên là cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3Chúng ta biết rằng lớp là bản thiết kế cho các đối tượng. Bản thiết kế này có thể được sử dụng để tạo ra nhiều đối tượng. Hãy tạo hai đối tượng khác nhau từ lớp trên
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
Từ khóa
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 được sử dụng để đại diện cho một thể hiện [đối tượng] của lớp đã cho. Trong trường hợp này, hai đối tượng cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
5 class Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
0 và class Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
1 có thuộc tính riêng là class Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
2 và class Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
3. Nếu không có đối số tự, thì cùng một lớp không thể chứa thông tin cho cả hai đối tượng nàyTuy nhiên, vì lớp chỉ là một bản thiết kế nên
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 cho phép truy cập vào các thuộc tính và phương thức của từng đối tượng trong python. Điều này cho phép mỗi đối tượng có các thuộc tính và phương thức riêng. Do đó, thậm chí rất lâu trước khi tạo các đối tượng này, chúng ta đã tham chiếu các đối tượng là cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 trong khi định nghĩa lớpTại sao bản thân được xác định rõ ràng mọi lúc?
Ngay cả khi chúng ta hiểu cách sử dụng của
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3, nó vẫn có vẻ kỳ lạ, đặc biệt là đối với các lập trình viên đến từ các ngôn ngữ khác, rằng ____2_______3 được truyền dưới dạng tham số một cách rõ ràng mỗi khi chúng ta định nghĩa một phương thức. Như The Zen of Python đã nói, "Rõ ràng tốt hơn ngầm"Vì vậy, tại sao chúng ta cần phải làm điều này? . Chúng ta có một lớp
class Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
8 định nghĩa một phương thức class Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
9 để tính khoảng cách từ gốc tọa độclass Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
Bây giờ chúng ta hãy khởi tạo lớp này và tìm khoảng cách
>>> p1 = Point[6,8]
>>> p1.distance[]
10.0
Trong ví dụ trên,
>>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0 xác định ba tham số nhưng chúng tôi chỉ chuyển hai tham số [6 và 8]. Tương tự, >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
1 yêu cầu một đối số nhưng không có đối số nào được thông qua. Tại sao Python không phàn nàn về số đối số này không khớp?Điều gì xảy ra trong nội bộ?
>>> p1 = Point[6,8]
>>> p1.distance[]
10.0
2 và >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
3 trong ví dụ trên là khác nhau và không hoàn toàn giống nhau>>> type[Point.distance]
>>> type[p1.distance]
Chúng ta có thể thấy rằng cái đầu tiên là một hàm và cái thứ hai là một phương thức. Một điều đặc biệt về các phương thức [trong Python] là chính đối tượng được truyền làm đối số đầu tiên cho hàm tương ứng
Trong trường hợp của ví dụ trên, cuộc gọi phương thức
>>> p1 = Point[6,8]
>>> p1.distance[]
10.0
4 thực sự tương đương với >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
5Nói chung, khi chúng ta gọi một phương thức với một số đối số, hàm lớp tương ứng được gọi bằng cách đặt đối tượng của phương thức trước đối số đầu tiên. Vì vậy, bất cứ thứ gì như
>>> p1 = Point[6,8]
>>> p1.distance[]
10.0
6 trở thành >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
7. Quá trình gọi là tự động trong khi quá trình nhận thì không [rõ ràng]Đây là lý do tham số đầu tiên của hàm trong lớp phải là chính đối tượng đó. Viết tham số này là
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 chỉ là một quy ước. Nó không phải là từ khóa và không có ý nghĩa đặc biệt trong Python. Chúng tôi có thể sử dụng các tên khác [như >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
9] nhưng điều đó không được khuyến khích lắm. Hầu hết các nhà phát triển đều phản đối việc sử dụng các tên khác với tên cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 và làm giảm khả năng đọc của mã [Khả năng đọc được tính]Bản ngã có thể tránh được
Bây giờ bạn đã rõ rằng bản thân đối tượng [thể hiện] được truyền tự động dưới dạng đối số đầu tiên. Hành vi ngầm định này có thể tránh được khi tạo một phương thức tĩnh. Xét ví dụ đơn giản sau
class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
Ở đây,
>>> type[Point.distance]
>>> type[p1.distance]
1 là một hàm trang trí làm cho >>> type[Point.distance]
>>> type[p1.distance]
2 trở nên tĩnh. Hãy để chúng tôi khởi tạo lớp này và gọi phương thức>>> a = A[]
>>> a.stat_meth[]
Look no self was passed
Từ ví dụ trên, chúng ta có thể thấy rằng hành vi ngầm truyền đối tượng làm đối số đầu tiên đã được tránh khi sử dụng một phương thức tĩnh. Nói chung, các phương thức tĩnh hoạt động giống như các hàm cũ đơn giản [Vì tất cả các đối tượng của một lớp đều chia sẻ các phương thức tĩnh]
>>> type[A.stat_meth]
>>> type[a.stat_meth]
Tự ở đây để ở lại
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 rõ ràng không phải là duy nhất đối với Python. Ý tưởng này được mượn từ Modula-3. Sau đây là trường hợp sử dụng khi nó trở nên hữu íchKhông có khai báo biến rõ ràng trong Python. Họ bắt đầu hành động trong nhiệm vụ đầu tiên. Việc sử dụng
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 giúp dễ dàng phân biệt giữa các thuộc tính thể hiện [và phương thức] với các biến cục bộTrong ví dụ đầu tiên, bản thân. x là một thuộc tính thể hiện trong khi x là một biến cục bộ. Chúng không giống nhau và chúng nằm trong các không gian tên khác nhau
Nhiều người đã đề xuất biến self thành một từ khóa trong Python, như
>>> type[Point.distance]
>>> type[p1.distance]
5 trong C++ và Java. Điều này sẽ loại bỏ việc sử dụng dư thừa của cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
3 rõ ràng khỏi danh sách tham số chính thức trong các phương thứcMặc dù ý tưởng này có vẻ hứa hẹn nhưng nó sẽ không xảy ra. Ít nhất là không phải trong tương lai gần. Lý do chính là khả năng tương thích ngược. Đây là một blog của chính người tạo ra Python giải thích lý do tại sao bản thân rõ ràng phải ở lại
__init__[] không phải là hàm tạo
Một kết luận quan trọng có thể được rút ra từ thông tin cho đến nay là phương thức
>>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0 không phải là hàm tạo. Nhiều lập trình viên Python ngây thơ bị nhầm lẫn với nó vì >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0 được gọi khi chúng ta tạo một đối tượngKiểm tra kỹ hơn sẽ tiết lộ rằng tham số đầu tiên trong
>>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0 chính là đối tượng [đối tượng đã tồn tại]. Hàm >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0 được gọi ngay sau khi đối tượng được tạo và được sử dụng để khởi tạo nóVề mặt kỹ thuật, hàm tạo là một phương thức tự tạo đối tượng. Trong Python, phương thức này là
class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1. Một chữ ký phổ biến của phương pháp này là__new__[cls, *args, **kwargs]
Khi
class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 được gọi, chính lớp đó sẽ tự động được chuyển thành đối số đầu tiên [class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
3]Một lần nữa, giống như bản thân, cls chỉ là một quy ước đặt tên. Ngoài ra, *args và **kwargs được sử dụng để lấy số lượng đối số tùy ý trong khi gọi phương thức trong Python
Một số điều quan trọng cần nhớ khi triển khai
class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 là
1 luôn được gọi trướcclass A[object]: @staticmethod def stat_meth[]: print["Look no self was passed"]
0>>> p1 = Point[6,8] >>> p1.distance[] 10.0
- Đối số đầu tiên là chính lớp đó được truyền ngầm
- Luôn trả về một đối tượng hợp lệ từ
1. Không bắt buộc, nhưng công dụng chính của nó là tạo và trả về một đối tượngclass A[object]: @staticmethod def stat_meth[]: print["Look no self was passed"]
Hãy xem một ví dụ
class Point[object]:
def __new__[cls,*args,**kwargs]:
print["From new"]
print[cls]
print[args]
print[kwargs]
# create our object and return it
obj = super[].__new__[cls]
return obj
def __init__[self,x = 0,y = 0]:
print["From init"]
self.x = x
self.y = y
Bây giờ, hãy khởi tạo nó
cat1 = Cat['Andy', 2]
cat2 = Cat['Phoebe', 3]
0Ví dụ này minh họa rằng
class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 được gọi trước >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0. Chúng ta cũng có thể thấy rằng tham số cls trong class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 chính là lớp đó [class Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
8]. Cuối cùng, đối tượng được tạo bằng cách gọi phương thức class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 trên lớp cơ sở đối tượngTrong Python,
>>> a = A[]
>>> a.stat_meth[]
Look no self was passed
3 là lớp cơ sở mà từ đó tất cả các lớp khác được dẫn xuất. Trong ví dụ trên, chúng tôi đã thực hiện việc này bằng cách sử dụng super[]Sử dụng __new__ hay __init__?
Bạn có thể đã thấy
>>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0 rất thường xuyên nhưng việc sử dụng class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 rất hiếm. Điều này là do hầu hết thời gian bạn không cần ghi đè lên nó. Nói chung, >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0 được sử dụng để khởi tạo đối tượng mới được tạo trong khi class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 được sử dụng để kiểm soát cách tạo đối tượngChúng ta cũng có thể sử dụng
class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 để khởi tạo các thuộc tính của một đối tượng, nhưng về mặt logic thì nó phải nằm trong >>> p1 = Point[6,8]
>>> p1.distance[]
10.0
0Tuy nhiên, một cách sử dụng thực tế của
class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 có thể là hạn chế số lượng đối tượng được tạo từ một lớpGiả sử chúng ta muốn có một lớp
>>> type[A.stat_meth]
>>> type[a.stat_meth]
1 để tạo các thể hiện đại diện cho bốn đỉnh của một hình vuông. Chúng tôi có thể kế thừa từ lớp trước đó của chúng tôi class Point[object]:
def __init__[self,x = 0,y = 0]:
self.x = x
self.y = y
def distance[self]:
"""Find distance from origin"""
return [self.x**2 + self.y**2] ** 0.5
8 [ví dụ thứ hai trong bài viết này] và sử dụng class A[object]:
@staticmethod
def stat_meth[]:
print["Look no self was passed"]
1 để thực hiện hạn chế này. Đây là một ví dụ để hạn chế một lớp chỉ có bốn trường hợp