目录
自定义类
属性和方法
三大特性
自定义类
1、标准自定义函数：
-----形参列表是标准的tuple数据类型
def __init__(self):（偷懒）
pass
2、没有形参的自定义函数：
该形式是标准自定义函数的特例。
>>> def abvedu_print():
print("Allow me to make it clear that my silence is not due to the terror this woman instills in me")
#明明就是怂了
3、使用默认值的自定义函数：
在定义函数指定参数时，有时候会有一些默认的值，可以利用“=”先指定在参数列表上，如果在调用的时候没有设置此参数，那么该参数就使用默认的值。
>>> def abvedu_printSymbol(n,symbol = " %"):
for i in range(1,n+1):
print(symbol , end ="")
print()
abvedu_printSymbol(6,'嘟嘟噜~~~~~~')嘟嘟噜~~~~~~嘟嘟噜~~~~~~嘟嘟噜~~~~~~嘟嘟噜~~~~~~嘟嘟噜~~~~~~嘟嘟噜~~~~~~
4、参数个数不确定的自定义函数：
此函数可以接受没有预先设置的参数个数，定义方法是在参数的前面加上“*”。
def abvedu_main(*args):
print("参数分别是：")
for arg in args:
print(arg)
abvedu_main(Okabe Mayuri Itaru Kurisu Moeka RukanFerris Suzuha)
Okabe
Mayuri
Itaru
Kurisu
Moeka
RukanFerris
Suzuha
5、使用lambda隐函数的自定义函数：
Python提供了一种非常有趣、精简好用的一行自定义函数的方法lambda,这是一种可以实现一行语句、用完即丢的自定义函数。
def 函数名称（参数列表）：
return 语句内容def c(参数)
d=lambda 参数:公式
print(d)
c(参数)（高级用法，在此记录）
# 轮胎
class Tire:
def __init__(self, size, createDate):
self.size = size # 尺寸
self.createDate = createDate # 出厂日期
class BenzCar:
brand = '奔驰'
country = '德国'
def __init__(self, color, engineSN, tires):
self.color = color # 颜色
self.engineSN = engineSN # 发动机编号
self.tires = tires
# 创建4个轮胎实例对象
tires = [Tire(20, '20160808') for i in range(4)]
car = BenzCar('red', '234342342342566', tires)
print(car.tires) # BenzCar实例的tires属性，得到一个列表，里面是四个 Tire 实例对象
print(car.tires[0]) # 得到BenzCar实例的tires属性列表里面的第1个Tire 实例对象
print(car.tires[0].size) # 得到BenzCar实例的tires属性列表里面的第1个Tire 实例对象的size属性[<__main__.Tire object at 0x000001FCD736A4C0>, <__main__.Tire object at 0x000001FCD7485820>, <__main__.Tire object at 0x000001FCD74857F0>, <__main__.Tire object at 0x000001FCD7485EE0>]
<__main__.Tire object at 0x000001FCD736A4C0>
20
1.类属性和类方法
定义在类内，并且在各函数成员之外的属性称为类属性，实例之间共享
定义命运石之门类，在该类中定义2个类属性laboratory和country，用于记录特征
class SteinsGate:
laboratory = '秋叶原' # 地方属性 公共特征
country = '日本' # 国家属性
2.实例属性（属性和方法不一样）和实例方法
在类内的函数中定义的属性称为实例属性，作用范围为当前实例。
实例属性在类的内部通过“self.”访问，在外部通过对象实例访问。
实例化之后实例属性只能通过实例名修改
__int__（）
创建好实例后 立即就要 执行 的方法，所以称之为初始化方法。）
def _init_(self,labnum,mantra):
self.labnum =labnum # 成员编号 (self参数变量指向的就是实例对象本身)
self.mantra = mantra # 口头禅
Mayuri = SteinsGate('No.002','嘟嘟噜~~~~~~')
print(Mayuri.labnum)
print(Mayuri.mantra)@staticmethod
静态方法 Mayuri方法是类的静态方法， 静态方法是不能访问实例属性的。
要调用执行该类的静态方法，像这样就可以了
@staticmethod
def Mayuri():
print('嘟嘟噜~~~~~~')
SteinsGate.Mayuri()
嘟嘟噜~~~~~~注意: 如果你的实例属性名称 和 静态属性 重复了
通过类实例访问该属性，访问的是实例属性，通过类实例访问该属性，访问的是实例属性。
__del__()
del 用于删除对象。在 Python，一切都是对象，因此 del 关键字可用于删除变量、列表或列表片段等。
class Timemachine:
def __init__(self): #=0
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象，释放其空间")
organ = Timemachine() #+1
# 变量就对应了一个 Timemachine 类型 的实例对象，具有Timemachine类的一切属性和方法。
cl = organ #+1
del organ #-1
print("***********")调用 __init__() 方法构造对象
***********
调用__del__() 销毁对象，释放其空间原理：
每个 Python 对象都会配置一个计数器，初始 Python 实例对象的计数器值都为 0，
如果有变量引用该实例对象，其计数器的值会加 1，依次类推；
反之，每当一个变量取消对该实例对象的引用，计数器会减 1。
如果一个 Python 对象的的计数器值为 0，则表明没有变量引用该 Python 对象，即证明程序不再需要它，
此时 Python 就会自动调用 __del__() 方法将其回收。
受保护属性
以1个下划线为开头是受保护属性
class Okabe:
_intelligence_quotient=250
def __init__(self):
print("初始化对象智商：",Okabe._intelligence_quotient)
Okabe = Okabe()
print("查询智商：",Okabe._intelligence_quotient)初始化对象智商： 250
查询智商： 250受保护属性可以通过实例名查询
特殊属性
以两个下划线为开头 以两个下划线为结束
def __init__(self):
（过于高深，课本没讲）
私有属性
以两个下划线为开头 不以两个下划线为结束
class Kurisu:
__old = "18岁"
print("初始化对象年龄：", Kurisu.__old)
Kurisu = Kurisu()
print("查询年龄：", Kurisu.__old)Traceback (most recent call last):
File "C:/Users/26025/pythonProject/自定义类.py", line 23, in
class Kurisu:
File "C:/Users/26025/pythonProject/自定义类.py", line 25, in Kurisu
print("初始化对象年龄：", Kurisu.__old)
NameError: name 'Kurisu' is not defined 注意：在类外，不允许直接访问私有数据，但可以通过“实例名._类名__私有属性名”访问
class Kurisu:
__old = "18岁"
print("初始化对象年龄：", Kurisu.__old)
Kurisu = Kurisu()
print("查询年龄：", Kurisu._Kurisu__old)初始化对象年龄： 18岁
查询年龄： 18岁
进程已结束,退出代码0
但可以使用“类的实例名._类名__私有属性名”访问
公有属性
其他符合命题规则的标识符
三大特性1.单继承性
括号参数用于制定要继承的基类，默认基类为object（所有对象的根基类，定义了公用方法的默认实现）
子类会自动拥有父类的一切属性和方法
子类默认无__init__()，则会直接继承父类的
class SteinsGate:
laboratory = '秋叶原' # 地方属性 公共特征
country = '日本' # 国家属性
def __init__(self,labnum,mantra): #__int__创建好实例后 立即就要 执行 的方法，所以称之为初始化方法。）
self.labnum =labnum # 成员编号 ( self 参数变量 指向的 就是 实例对象 本身 )
self.mantra = mantra # 口头禅
print(self.labnum)
print(self.mantra)
class Okabe(SteinsGate):
pass
Okabe = Okabe(labnum="No.001",mantra="El psy congroo")No.001
El psy congroo子类调用基类的__init__()初始化数据时。需要使用super（）才能调用父类的
class SteinsGate:
laboratory = '秋叶原' # 地方属性 公共特征
__country = '日本' # 国家属性
@staticmethod
def pressHorn():
print('嘟嘟~~~~~~')
def __init__(self,labnum,mantra): #__int__创建好实例后 立即就要 执行 的方法，所以称之为初始化方法。）
self.labnum =labnum # 成员编号 ( self 参数变量 指向的 就是实例对象本身 )
self.mantra = mantra # 口头禅
print(self.labnum)
print(self.mantra)
class Okabe(SteinsGate):
__age="18"
Okabe1 = Okabe(labnum="No.001",mantra="El psy congroo")
print(Okabe1.laboratory)
print(Okabe1._Okabe__age)
# print(Okabe._Okabe__country) #不能调用，证明是其假私有属性
class Kakali(Okabe):
def __init__(self,labnum,mantra):
super(Kakali, self).__init__(labnum,mantra)
self.labnum = labnum
self.mantra = mantra一个子类在继承父类的一切特性的基础上，可以有自己的属性和方法。
父类的私有属性子类是无法被继承的。（假私有属性）
No.001
El psy congroo
秋叶原
18
地点报错
None
El psy congroo
进程已结束,退出代码0
子类的初始化方法调用父类的初始化方法 __init__，要传入相应的参数， 像上面那样，然后可以加上自己的特有的初始化代码。如下所示
def __init__(self,labnum,mantra):
super(Kakali, self).__init__(labnum,mantra)
self.labnum = labnum
self.mantra = mantra
def __init__(self,labnum,mantra): ## 先调用父类的初始化方法
Okabe.__init__(self,labnum,mantra)
self.labnum = labnum
self.mantra = mantra注意：如果子类 没有 自己的初始化方法，实例化子类对象时，解释器会自动调用父类初始化方法
（重写覆盖）
def __init__(self):
pass
2.多重继承
注意：如果继承的多个父类中有相同的方法名，但在使用中未指明父类，将会以从左到到右的方法搜索使用
class Okabe(SteinsGate):
__age="18"
dad_featrue="笨蛋中二病傲娇"
# Okabe1 = Okabe(labnum="No.001",mantra="El psy congroo")
class Kurisu(SteinsGate):
__old = "18岁" #父类私有属性不继承子类
mom_featrue = "天才傲娇"
# Kurisu = Kurisu(labnum="No.004",mantra="才不是助手")
class Kakali(Okabe,Kurisu):
def __init__(self): #重写覆盖，不继承父类部分属性
pass
Kakali=Kakali()
#print(Kakali._Kurisu__age)
print(Kakali.mom_featrue)
print(Kakali.dad_featrue)天才傲娇
笨蛋中二病傲娇
进程已结束,退出代码0注意：部分继承
1.未继承部分设为父类的私有属性
2.将未继承部分放入__init__()中，再重写覆盖
如果子类 有自己 的初始化方法，实例化子类对象时，解释器就不会自动化调用父类的初始化方法
3.封装性
举例：外部访问私有属性通过在函数内设定访问私有属性（套娃）
4.多态性
多种多样（庸俗理解）
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）