1.面向对象
当谈论面向对象编程(OOP)时,我们指的是一种程序设计的方法,它以对象的概念为中心,而不是以函数或逻辑为中心。面向对象编程的主要特征包括:
-
封装(Encapsulation):将数据(属性)和操作数据的方法(方法或函数)捆绑在一起,以防止对数据的直接访问和修改,从而提高安全性和灵活性。
-
继承(Inheritance):允许一个类(称为子类或派生类)继承另一个类(称为父类或基类)的属性和方法。这种机制促进了代码重用和层次结构的建立。
-
多态(Polymorphism):允许使用统一的接口处理不同的数据类型或对象,即不同类的对象可以用相同的方式调用。
面向对象的技术有:
- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 方法:类中定义的函数。
- 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- 数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
- 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
- 局部变量:定义在方法中的变量,只作用于当前实例的类。
- 实例变量:在类的声明中,属性是用变量来表示的,这种变量就称为实例变量,实例变量就是一个用 self 修饰的变量。
- 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
- 实例化:创建一个类的实例,类的具体对象。
- 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
和其它编程语言相比,Python 在尽可能不增加新的语法和语义的情况下加入了类机制。
面向对象编程的优势包括代码重用性、灵活性和可维护性。它适合大型软件项目,因为它可以将复杂的系统分解为相对简单的、易于理解的部分(对象),并且有助于提高开发速度和减少错误。
2.类的定义
类定义
语法格式如下:
class ClassName: <statement-1> . . . <statement-N>
类实例化后,可以使用其属性,实际上,创建一个类之后,可以通过类名访问其属性。
类对象
类对象支持两种操作:属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法:obj.name。
类对象创建后,类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:
class MyClass:
def __init__(self):
self.i = 12345
"""一个简单的类实例"""
def f(self):
return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为:", x.i)
print("MyClass类的方法 f 输出为: ", x.f())
'''
执行以上程序输出结果为:
MyClass 类的属性 i 为: 12345
MyClass类的方法 f 输出为: hello world
'''
以上创建了一个新的类实例并将该对象赋给局部变量 x,x 为空的对象。
类有一个名为 __init__() 的特殊方法(构造方法),该方法在类实例化时会自动调用,像下面这样:
def __init__(self):
self.data = []
类定义了 __init__() 方法,类的实例化操作会自动调用 __init__() 方法。如下实例化类 MyClass,对应的 __init__() 方法就会被调用:
class MyClass:
def __init__(self):
self.data = []
x = MyClass()
当然, __init__() 方法可以有参数,参数通过 __init__() 传递到类的实例化操作上。例如:
class Complex:
def __init__(self, real_part, image_part):
self.r = real_part
self.i = image_part
x = Complex(3.0, -4.5)
print(x.r, x.i)
# 输出结果:3.0 -4.5
self 代表类的实例,而非类
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 默认它的名称是 self。
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
'''
以上实例执行结果为:
<__main__.Test object at 0x0000022F9F120E90>
<class '__main__.Test'>
'''
从执行结果可以很明显的看出,self 代表的是类的实例,代表当前对象的地址,而 self.class 则指向类。
self 不是 python 关键字,我们把他换成 csdn 也是可以正常执行的:
class Test:
def prt(csdn):
print(csdn)
print(csdn.__class__)
t = Test()
t.prt()
'''
以上实例执行结果为:
<__main__.Test object at 0x00000247F6F80ED0>
<class '__main__.Test'>
'''
在 Python中,self 是一个惯用的名称,用于表示类的实例(对象)自身。它是一个指向实例的引用,使得类的方法能够访问和操作实例的属性。
当你定义一个类,并在类中定义方法时,第一个参数通常被命名为 self,尽管你可以使用其他名称,但最好还是使用 self,以保持代码的一致性和可读性。
class MyClass:
def __init__(self, value):
self.value = value
def display_value(self):
print(self.value)
# 创建一个类的实例
obj = MyClass(42)
# 调用实例的方法
obj.display_value()
# 输出 42
在上面的例子中,self 是一个指向类实例的引用,它在 __init__ 构造函数中用于初始化实例的属性,也在 display_value 方法中用于访问实例的属性。通过使用 self,你可以在类的方法中访问和操作实例的属性,从而实现类的行为。
3.类的属性与方法
类的私有属性
__private_attrs:两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print(self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretCount) # 报错,实例不能访问私有变量
'''
执行以上程序输出结果为:
1
2
2
Traceback (most recent call last):
File "xxx.py", line 16, in <module>
print(counter.__secretCount) # 报错,实例不能访问私有变量
^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'JustCounter' object has no attribute '__secretCount'
'''
类的方法
在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self,且为第一个参数,self 代表的是类的实例。
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
print(self.name, self.age, id(self))
def get_self(self):
return self
def show_self(self):
return f"姓名 {self.name}, 年龄 {self.age}"
s0 = Student("xcy", 21)
print(id(s0))
print(s0.show_self())
print(s0 == s0.get_self(), s0 is s0.get_self())
'''
执行结果为:
xcy 21 1917880439376
1917880439376
姓名 xcy, 年龄 21
True True
'''
self 的名字并不是规定死的,上文已经提到,最好还是使用self。
类的私有方法
__private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 ,不能在类的外部调用。self.__private_methods。
class Site:
def __init__(self, name, url):
self.name = name # public
self.__url = url # private
def who(self):
print('name : ', self.name)
print('url : ', self.__url)
def __foo(self): # 私有方法
print('这是私有方法')
def foo(self): # 公共方法
print('这是公共方法')
self.__foo()
x = Site('CSDN', 'www.CSDN.com')
x.who() # 正常输出
x.foo() # 正常输出
x.__foo() # 报错
'''
以上实例执行结果:
name : CSDN
url : www.CSDN.com
这是公共方法
这是私有方法
Traceback (most recent call last):
File "xxx.py", line 22, in <module>
x.__foo() # 报错
^^^^^^^
AttributeError: 'Site' object has no attribute '__foo'
'''
类的专有方法
_ _init_ _ | 构造函数,在生成对象时调用 |
_ _del_ _ | 析构函数,释放对象时使用 |
_ _len_ _ | 获得长度 |
_ _setitem_ _ | 按照索引赋值 |
_ _getitem_ _ | 按照索引获取值 |
_ _cmp_ _ | 比较运算 |
_ _call_ _ | 函数调用 |
_ _add_ _ | 加运算 |
_ _sub_ _ | 减运算 |
_ _mul_ _ | 乘运算 |
_ _truediv_ _ | 除运算 |
_ _mod_ _ | 求余运算 |
_ _pow_ _ | 乘方 |
_ _repr_ _ | 打印,转换 |
# 魔法函数
class MyLei:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return self.name
def __len__(self):
return len(self.name)
def __eq__(self, other):
return self.age == other.age
def __ne__(self, other):
return self.age == other.age
def __lt__(self, other):
return self.age < other.age
ml = MyLei("hh", 22)
ml1 = MyLei("xx", 22)
print(ml)
print(ml.__len__())
print(ml == ml1)
print(ml != ml1)
print(ml < ml1)
'''
实例结果为
hh
2
True
True
False
'''
# 构造函数和析构函数
class MyOpen:
def __new__(cls, *args, **kwargs):
instance = super().__new__(cls)
return instance
def __init__(self):
print("hhhh")
def __str__(self):
return 'hhh'
def __del__(self):
print("xxx")
mo = MyOpen()
print(mo)
# 执行结果为:
# hhhh
# hhh
# xxx
在实践中,面向对象编程语言提供了丰富的工具和语法来实现封装、继承和多态,使得开发人员能够更有效地组织和管理代码。
标签:__,Python,self,好多,对象,实例,print,方法,def From: https://blog.csdn.net/2402_86120726/article/details/140670998