아래 편집기는 python3 클래스를 기반으로 속성, 메소드, 캡슐화 및 상속에 대한 예제 설명을 제공합니다. 편집자님이 꽤 좋다고 생각하셔서 지금 공유하고 모두에게 참고용으로 드리도록 하겠습니다. 편집기를 따라 살펴보겠습니다
Python 클래스
Python의 클래스는 객체 지향 프로그래밍의 모든 기본 기능을 제공합니다. 클래스의 상속 메커니즘은 여러 기본 클래스를 허용하고 파생 클래스는 기본 클래스. 모든 메서드는 기본 클래스에서 동일한 이름의 메서드를 호출할 수 있습니다.
개체에는 데이터의 양과 유형에 관계없이 포함될 수 있습니다.
Python 클래스는 C++ 클래스와 유사하며 클래스 캡슐화, 상속, 다중 상속, 생성자 및 소멸자를 제공합니다.
python3에서는 모든 클래스의 최상위 상위 클래스가 객체 클래스입니다. Java와 마찬가지로 클래스 정의 시 상위 클래스를 작성하지 않으면 객체 클래스가 바로 상위 클래스가 됩니다.
클래스 정의
클래스 정의의 구문 형식은 다음과 같습니다.
class ClassName: <statement-1> . . . <statement-N>
클래스 객체: 클래스를 생성한 후 클래스 이름을 통해 해당 속성과 메서드에 액세스하고 변경할 수 있습니다
Instance 객체: 클래스가 인스턴스화되면 해당 속성을 사용하여 클래스 객체에 영향을 주지 않고 인스턴스 객체에 속성을 동적으로 추가할 수 있습니다(javascript와 유사).
클래스 속성
점(.)을 사용하여 객체의 속성에 액세스할 수 있습니다.
다음 함수를 사용하여 속성에 액세스할 수도 있습니다.
getattr(obj, name[, default] ): 객체 속성에 액세스합니다.
hasattr(obj,name): 속성이 존재하는지 확인합니다.
setattr(obj,name,value): 속성을 설정합니다. 속성이 존재하지 않으면 새 속성이 생성됩니다
delattr(obj, name): 속성 삭제
Python 내장 클래스 attribute
__dict__: 클래스의 속성(구성된 사전 포함) 클래스의 데이터 속성 중)
__doc__: 클래스의 문서 문자열
__name__: 클래스 이름
__module__: 클래스가 정의된 모듈(클래스의 전체 이름은 '__main__.className'입니다. 가져온 모듈 mymod에 있는 경우 className.__module__은 mymod와 같습니다.)
__bases__: 클래스의 모든 상위 클래스 요소(모든 상위 클래스로 구성된 튜플 포함)
class Person:
"Person类"
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
p = Person('ice', 18, '男')
print(p.name) # ice
print(p.age) # 18
print(p.gender) # 男
print(hasattr(p, 'weight')) # False
# 为p添加weight属性
p.weight = '70kg'
print(hasattr(p, 'weight')) # True
print(getattr(p, 'name')) # ice
print(p.__dict__) # {'age': 18, 'gender': '男', 'name': 'ice'}
print(Person.__name__) # Person
print(Person.__doc__) # Person类
print(Person.__dict__) # {'__doc__': 'Person类', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__init__': <function Person.__init__ at 0x000000000284E950>, 'getName': <function Person.getName at 0x000000000284EA60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__'}
print(Person.__mro__) # (<class '__main__.Person'>, <class 'object'>)
print(Person.__bases__) # (<class 'object'>,)
print(Person.__module__) # __main__클래스의 메서드
클래스 내부에서 def 키를 사용하세요. 클래스에 대한 메소드는 단어로 정의할 수 있습니다. 일반 함수 정의와 달리 클래스 메소드에는 첫 번째 매개변수인 self가 포함되어야 합니다.
클래스의 고유 메소드:
__init__ 생성자, 객체 생성 시
__del__ 소멸자를 호출하고,
__repr__을 사용하여 인덱스에 따라
__setitem__을 인쇄 및 변환하고
__getitem__에 따라 인덱스에 따라 값을 얻습니다.
__len__ 길이를 얻습니다
__cmp__ 비교 연산
__call__ 함수 호출
__add__ 덧셈 연산
__sub__ 빼기 연산
__mul__ 곱셈 연산
__p__나누기 연산
__mod__ 나머지 연산
__pow__() 메서드는 다음과 같습니다. 라는 특별한 방법이 있습니다. 클래스의 생성자 또는 초기화 메서드. 이 메서드는 이 클래스의 인스턴스가 생성될 때 호출됩니다. 이는 C++의 생성자와 동일합니다. 함수는 유사합니다. 사용자 정의 클래스에서 __init__() 메서드를 재정의하면 됩니다.
class Person:
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
# Person实例对象
p = Person('ice', 18, '男')
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# icemethodInstance 메서드: 인스턴스 호출만 전달할 수 있습니다. 인스턴스 메소드의 첫 번째 정의된 매개변수는 인스턴스 자체에 대한 참조만 될 수 있습니다
class Myclass:
def foo(self):
print(id(self),'foo')
a=Myclass()#既然是实例对象，那就要创建实例
a.foo()#输出类里的函数地址
print(id(a))#输出类对象的地址
#结果地址一样class Myclass:
@classmethod#类装饰器
def foo2(cls):
print(id(cls),'foo2')
#类对象，直接可以调用，不需要实例化
print(id(Myclass),'yy')
Myclass.foo2()#直接可以调用class Myclass:
@staticmethod#静态方法
def foo3():
print('foo3')
Myclass.foo3()#没有参数
a.foo3()
#结果foo3클래스 캡슐화 Python은 변수 이름을 사용하여 속성과 메서드의 액세스 권한을 구별합니다. 기본 권한은 C++ 및 java
클래스의 비공개 속성과 동일합니다. __private_attrs: 두 개의 밑줄로 시작합니다. 속성은 비공개로 선언되어 클래스 외부에서 사용하거나 직접 액세스할 수 없습니다. 클래스 내부의 메소드에서 self.__private_attrs를 사용할 때.
클래스의 프라이빗 메서드: __private_method: 두 개의 밑줄로 시작하는 메서드는 프라이빗 메서드로 선언되며 클래스 외부에서 호출할 수 없습니다. 클래스 내에서 self.__private_methods 호출
Python은 인스턴스화된 클래스가 개인 데이터에 액세스하는 것을 허용하지 않지만 object._className__attrName을 사용하여 속성에 액세스할 수 있습니다. 실제로 Python의 내부 사유화 구현은 attrName 속성을 _className__attrName
class Demo:
__id = 123456
def getId(self):
return self.__id
temp = Demo()
# print(temp.__id) # 报错 AttributeError: 'Demo' object has no attribute '__id'
print(temp.getId()) # 123456
print(temp._Demo__id) # 123456클래스 상속으로 변경합니다. 객체 지향 프로그래밍의 주요 이점 중 하나는 코드를 재사용하는 것입니다. 재사용 방법 중 하나는 상속 메커니즘을 이용하는 것입니다. 상속은 클래스 간의 유형 및 하위 유형 관계로 완전히 이해될 수 있습니다.
需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。
在python中继承中的一些特点：
1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__()
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。
多态
如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法
python3.3 类与继承 小例
hon中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
class Base:
def __init__(self):
self.data=[]
def add(self,x):
self.data.append(x)
def addtwice(self,x):
self.add(x)
self.add(x)
# child extends base
class Child(Base):
def plus(self,a,b):
return a+b
oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))对象可以包含任意数量和类型的数据。
python类与c++类相似，提供了类的封装，继承、多继承，构造函数、析构函数。
在python3中，所有类最顶层父类都是object类，与java类似，如果定义类的时候没有写出父类，则object类就是其直接父类。
类定义
类定义语法格式如下：
class ClassName: <statement-1> . . . <statement-N>
类对象：创建一个类之后，可以通过类名访问、改变其属性、方法
实例对象：类实例化后，可以使用其属性，可以动态的为实例对象添加属性(类似javascript)而不影响类对象。
类的属性
可以使用点(.)来访问对象的属性
也可以使用以下函数的方式来访问属性：
getattr(obj, name[, default]) : 访问对象的属性
hasattr(obj,name) : 检查是否存在一个属性
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性
delattr(obj, name) : 删除属性
Python内置类属性
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）
class Person:
"Person类"
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
p = Person('ice', 18, '男')
print(p.name) # ice
print(p.age) # 18
print(p.gender) # 男
print(hasattr(p, 'weight')) # False
# 为p添加weight属性
p.weight = '70kg'
print(hasattr(p, 'weight')) # True
print(getattr(p, 'name')) # ice
print(p.__dict__) # {'age': 18, 'gender': '男', 'name': 'ice'}
print(Person.__name__) # Person
print(Person.__doc__) # Person类
print(Person.__dict__) # {'__doc__': 'Person类', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__init__': <function Person.__init__ at 0x000000000284E950>, 'getName': <function Person.getName at 0x000000000284EA60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__'}
print(Person.__mro__) # (<class '__main__.Person'>, <class 'object'>)
print(Person.__bases__) # (<class 'object'>,)
print(Person.__module__) # __main__类的方法
在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数。
类的专有方法：
__init__ 构造函数，在生成对象时调用
__del__ 析构函数，释放对象时使用
__repr__ 打印，转换
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用
__add__加运算
__sub__减运算
__mul__乘运算
__p__除运算
__mod__求余运算
__pow__称方
__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法，与c++中构造函数类似。只需在自定义的类中重写__init__()方法即可。
class Person:
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
# Person实例对象
p = Person('ice', 18, '男')
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# ice析构函数 __del__ ，__del__在对象消逝的时候被调用，当对象不再被使用时，__del__方法运行：
类的封装
python通过变量名命名来区分属性和方法的访问权限，默认权限相当于c++和java中的public
类的私有属性： __private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。
类的私有方法：__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods
虽然python不允许实例化的类访问私有数据，但可以使用 object._className__attrName 访问属性。其实python内部私有化的实现只是将attrName属性变为了_className__attrName而已
class Demo:
__id = 123456
def getId(self):
return self.__id
temp = Demo()
# print(temp.__id) # 报错 AttributeError: 'Demo' object has no attribute '__id'
print(temp.getId()) # 123456
print(temp._Demo__id) # 123456类的继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。
在python中继承中的一些特点：
1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__()
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。
多态
如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法
python3.3 类与继承 小例
class Base:
def __init__(self):
self.data=[]
def add(self,x):
self.data.append(x)
def addtwice(self,x):
self.add(x)
self.add(x)
# child extends base
class Child(Base):
def plus(self,a,b):
return a+b
oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))위 내용은 python3 클래스를 기반으로 한 속성, 메소드, 캡슐화 및 상속에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
