类与对象

最新推荐文章于 2022-03-24 19:13:06 发布

sxjiao96

最新推荐文章于 2022-03-24 19:13:06 发布

阅读量161

点赞数

本文链接：https://blog.csdn.net/sxjiao96/article/details/108659138

版权

1. 面向对象

例如，在真实世界的校园里有学生和老师，学生有学号、姓名、所在班级等属性(数据)，还有学习、提问、吃饭和走路等动作(方法)。如果我们要开发一个校园管理系统，那么在构建软件系统时，也会有学生和老师等“类”，张同学、李同学是学生类的个体，被称为“对象”，“对象”也被称为“实例”。

2. 定义类

小汽车(Car)类继承了object类，object类是所有类的根类，在Pyt hon中任何一个类(除object外)都直接或间接地继承了object，直接继承object时(object)部分的代码可以省略。

class Car(obj):
	#类体
	pass

3. 创建对象

类相当于一个模板，依据这样的模板来创建对象，就是类的实例化，所以对象也被称为“实例”。

class Car(obj):
	pass
#创建对象
car=Car()

4. 类的成员

在这里插入图片描述

成员变量也被称为数据成员，保存了类或对象的数据。例如，学生的姓名和学号。
构造方法是一种特殊的函数，用于初始化类的成员变量。
成员方法是在类中定义的函数。
属性是对类进行封装而提供的特殊方法。

4.1 实例变量

实例变量就是对象个体特有的“数据”，例如狗狗的名称和年龄等。

#实例变量：（保存了类或对象的数据）。
class X:
	def __init__(self,y,z):
		self.y=y
		self.z=z

#运行 (主要集中于提取数据)（对象.实例变量)：
w = X(21,32)
print(w.y) 
print(w.z)

类中的self表示当前对象，构造方法中的self参数说明这个方法属于实例，self.y中的self表示y属于实例，即实例成员变量。

4.2 构造方法

类中的__init__()方法是一个非常特殊的方法，用来创建和初始化实例变量，这种方法就是**“构造方法”**。在定义__init__()方法时，它的第1个参数应该是self，之后的参数用来初始化实例变量。调用构造方法时不需要传入self参数。

# 构造方法：（特殊的函数，用于初始化类的成员变量）相当于定义class本身。
class X:
	def __init__(self,y,z):
		self.y=y
		self.z=z

# 运行：（主要集中于给函数添加信息）(创建对象调用or使用关键字参数调用)
w = X(21,32)
w = X(y=21,z=32)
print(w.y) 
print(w.z)

4.3 实例方法

实例方法与实例变量一样，都是某个实例(或对象)个体特有的
方法。

定义实例方法时，它的第1个参数也应该是self，这会将当前实例与该方法绑定起来，这也说明该方法属于实例。在调用方法时不需要传入self，类似于构造方法。

# 实力方法： 在class下创建函数，而且必须跟在init后面 （在类中定义的函数）。
class X:
	def __init__(self,y,z):
		self.y=y
		self.z=z
	
	def run(self):
		print('Good boy!{}'.format(self.y))
		print('year{}'.format(self.z))
		
# 运行： （运行整个函数）（对象.实例方法）
Y=X('name', 2)
Y.run()

4.4 类变量

类变量是属于类的变量，不属于单个对象。

例如，有一个Account(银行账户)类，它有三个成员变量:amou nt(账户金额)、interest_rate (利率)和owner(账户名)。amount和 owner对于每一个账户都是不同的，而interest_rate对于所有账户都是相同的。amount和owners是实例变量，interest_rate是所有账户实例共享的变量，它属于类，被称为“类变量”。

#类变量：保存了类或对象的数据
class X:
	unchanged = 0.8
	def __init__(self,y,z):
		self.y=y
		self.z=z

#运行:(类名.类变量)（提取变量）
print(X.unchanged)

4.5 类方法

类方法与类变量类似，属于类，不属于个体实例。在定义类方法时，它的第1个参数不是self，而是类本身。

#类方法：在类中定义的函数
class X:
    unchanged = 0.8
    @classmethod
    def updated(cls,c):
        return cls.unchanged*c

#运行: （类名.类方法）（对class里面的变量进行计算）
new = X.updated(10)
print(new)

类方法可以访问类变量和其他类方法，但不能访问其他实例方法和实例变量。

5. 封装性

封装性是面向对象重要的基本特性之一。封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。

5.1 私有变量

为了防止外部调用者随意存取类的内部数据(成员变量)，内部数据(成员变量)会被封装为“私有变量”。外部调用者只能通过方法调用私有变量。

在默认情况下，Python中的变量是公有的，可以在类的外部访问它们。如果想让它们成为私有变量，则在变量前加上双下画线(__)即可。

#私有变量：（只在class里运行变量）
class X:
	__unchanged = 0.8
	def __init__(self,a,b):
		self.a=a
		self.__b=b
	def c(self):
		print(self.a, self.__b, X.__unchanged*2)

#运行变量:
Y=X('Nice',10)
Y.c()

print(Y.__b) #会报错
print(X.__unchanged) #会报错

5.2 私有方法

私有方法与私有变量的封装是类似的，在方法前加上双下画线(_ _)就是私有方法了。

#私有方法：（只在class里运行方法）
class X:
	__unchanged = 0.8
	def __init__(self,a,b):
		self.a=a
		self.__b=b
	def __c(self):
		return self.a, self.__b, X.__unchanged*2
	def d(self):
		print(self.__c())
#运行方法
Y=X('Nice',10)
Y.d()

Y.__c() #会报错

5.3 使用属性

为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set (赋值)和get (取值)方法访问。

#使用私有属性：（使用get和set方法，完全在class里面）
class X:
	def __init__(self,a,b):
		self.a=a
		self.__b=b
	def get_b(self): #定义get()
		return self.__b
	def set_b(self,b): #定义set()
		self.__b=b
		
#运行：（get(), set()取值）
Y=X('Nice',10)
print(Y.get_b()) 
#更新数据
Y.set_b(6)
print(Y.get_b()) 

#使用公有属性访问私有：（使用get和set方法）
class X:
	def __init__(self,a,b):
		self.a=a
		self.__b=b
	@property
	def b(self):
		return self.__b
	@b.setter
	def b(self,b):
		self.__b=b
		
#运行：（实例.属性方法）
Y=X('Nice',10)
print(Y.b)
#更新数据
Y.b=6 
print(Y.b)

6. 继承性

6.1 Python中的继承

继承性也是面向对象重要的基本特性之一。

在现实世界中继承关系无处不在。例如猫与动物之间的关系:猫是一种特殊动物，具有动物的全部特征和行为，即数据和操作。在面向对象中动物是一般类，被称为“父类”;猫是特殊类，被称为“子类”。特殊类拥有一般类的全部数据和操作，可称之为子类继承父类。

# 继承：（相当于用X的初始化函数）
class X:
	def __init__(self,a):
		self.a=a
	def show(self):
		return 'Name:{}Age:{}'.format(self.a, self.b)
class Y(X):
	def __init__(self,a,b):
		super().__init__(a)
		self.b=b

# 运行：（只会调用X的变量）
c=Y('Sharon',12)
print(c.show())

6. 2 多继承

当子类继承多个父类时，如果在多个父类中有相同的成员方法或成员变量，则子类优先继承左边父类中的成员方法或成员变量，从左到右继承级别从高到低。

#多继承：（在完全相同的代码下，只会继承在前的方法）
class X:
	def __init__(self,a):
		self.a = a
	def show_info(self):
		return 'X name {}'.format(self.a)
	def A(self):
		print('A1')
class Y:
	def __init__(self, a):
		self.a = a
	def show_info(self):
		return 'Y name {}'.format(self.a)
	def A(self):
		print('A2')
class Z(X,Y):
	def __init__(self,a,b):
		super().__init__(a)
		self.b = b

#运行：（只会继承在前的方法）
m = Z('Alex', 2)
m.A()
print(m.show_info())

6.3 方法重写

如果子类的方法名与父类的方法名相同，则在这种情况下，子类的方法会重写(Override)父类的同名方法。

# 方法重写：（重新编写的方法会覆盖住以前的方法）
class X:
	def __init__(self,a):
		self.a = a
	def show_info(self):
		return 'X name {}'.format(self.a)
	def A(self):
		print('A1')
class Y:
	def __init__(self, a):
		self.a = a
	def show_info(self):
		return 'Y name {}'.format(self.a)
	def A(self):
		print('A2')
class Z(X,Y):
	def __init__(self,a,b):
		super().__init__(a)
		self.b = b
	def show_info(self):
		return 'Name {}, Age{}'.format(self.a, self.b)

# 运行：（结果会是新的方法）
m = Z('Alex', 2)
print(m.show_info())

7. 多态性

多态性也是面向对象重要的基本特性之一。“多态”指对象可以表
现出多种形态。

例如，猫、狗、鸭子都属于动物，它们有“叫”和“动”等行为，但是叫的方式不同，动的方式也不同。

7.1 继承与多态

在多个子类继承父类，并重写父类方法后，这些子类所创建的对
象之间就是多态的。这些对象采用不同的方式实现父类方法。

# 继承与多态：（方法相同的情况下，默认运行首先出现的方法 eg.多继承，如果想要运行第二个或第三个方法，就用此代码）
class X:
	def A(self):
		print('A1')
class Y(X):
	def A(self):
		print('A2')
class Z(X):
	def A(self):
		print('A3')
# 运行：（先设定启动不同class，再设定启动哪个方法）
one = X()
two = Y()
three = Z()

one.A()
two.A()
three.A()

7.2 鸭子类型测试与多态

Python的多态性更加灵活，支持鸭子类型测试。鸭子类型测试指: 若看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为鸭子。

由于支持鸭子类型测试，所以Python解释器不检查发生多态的对象是否继承了同一个父类，只要它们有相同的行为(方法)，它们之间就是多态的。

# 函数与多态：（在class外面设置函数，用来启动内部方法）
def start(obj):
	obj.A()

class X:
	def A(self):
	print('A1')
class Y(X):
	def A(self):
	print('A2')
class Z(X):
	def A(self):
	print('A3')
class new:
	def A(self):
	print('A4')

# 运行：（利用已经设置好的函数）
start(X())
start(Y())
start(Z())
start(new())