一.內(nèi)置類屬性
內(nèi)置類屬性就是魔法屬性,魔法屬性:屬性名的前面和后面都有兩個下劃線.魔法方法:方法的前后都有兩個下劃線
class Person:
"""人類"""
# 類的字段
number = 61
def __init__(self, name1, age1, height1):
# 對象的屬性
self.name = name1
self.age = age1
self.height = height1
# 對象方法
def run(self):
print('%s在跑步' % self.name)
# 類方法
@classmethod
def show_number(cls):
print('人類的數(shù)量為:%d億' % cls.number)
# 靜態(tài)方法
@staticmethod
def destroy():
print('人類在破壞環(huán)境!')
#1.__name__屬性----類的名字(是個字符串)
#類的屬性
name = Person.__name__
print(name, type(name), type(Person))
#Person <class 'str'> <class 'type'>
# 2.__class__屬性 --- 獲取對象對應(yīng)類(是一個類)
#對象的屬性
my_class=p1.__class__
#my_class是一個類,之前類做的事他都能做
p2 = my_class('小明',20,180)
print(p2.name,my_class.__name__)
#小明 Person
#3.__dict__屬性----將對象屬性及其對應(yīng)的值轉(zhuǎn)換成鍵值對存到一個字典中
print(p1.__dict__)
# {'name': '張三', 'age': 28, 'height': 170}
# 4.__doc__屬性 --- 獲取類的說明文檔
# 類的屬性
doc = Person.__doc__
print(doc)
#人類
# 5.__module__屬性 --- 獲取類所在的模塊對應(yīng)的名字
print(Person.__module__)
#__main__
# 6.__bases__屬性 --- 獲取當(dāng)前類的父類
# 類的屬性
print(Person.__bases__)
#(<class 'object'>,)
二.slots魔法
通過slots中存的元素的屬性的值來約束當(dāng)前這個類的對象的屬性.對象的屬性只能比元祖中的元素少,不能多
class Person:
__slots__=('name','age','face')
def __init__(self):
self.name='張三'
self.age=18
self.face=70
p1=Person()
#p1.sex='girl'
#print(p1.sex) 會報AttributeError
注意:一旦在類中給slots屬性賦了值,那么這個類的對象dict屬性就不能使用了
三.屬性的私有化
python中并沒有真正的私有化,python的類中默認(rèn)的屬性和方法都是公開的
1.私有化
a.類中的屬性和方法都可以通過在屬性名和方法名前加兩個下劃線,來讓屬性和方法變成私有的.
b.私有的屬性和方法只能在當(dāng)前的類中使用
class Dog:
# 字段
number = 100
__count = 200
def __init__(self):
# 對象的屬性
self.color = '黃色'
self.age = 3
self.name = '大黃'
self.__sex = '公狗'
# 對象方法
def __eat(self):
print('%s啃骨頭~' % self.name)
def eat(self):
# 在類中可以使用私有的屬性和方法
self.__eat()
print('%s在吃飯~' % self.name)
# 類方法
@classmethod
def shout(cls):
print('count:', cls.__count, Dog.__count)
print('汪汪汪~~~')
@classmethod
def __shout(cls):
print('count:', cls.__count, Dog.__count)
print('汪汪汪~~~')
# 靜態(tài)方法
@staticmethod
def function():
print('看家!!')
# python的類中默認(rèn)的屬性和方法都是公開的
dog1 = Dog
print(Dog.number)
#100
print(dog1.name, dog1.color, dog1.age)
#大黃 黃色 3
dog1.eat()
#大黃啃骨頭~
#大黃在吃飯~
Dog.shout()
#count: 200 200
#汪汪汪~~~
# 在類的外面不能直接使用私有的屬性
# print(Dog.__count)
# AttributeError: type object 'Dog' has no attribute '__count'
2.私有化的原理:在前面有兩個下劃線的屬性名和方法名前添加了'_類名'來阻止外部通過直接訪問屬性名來使用屬性
四.屬性的getter和setter
1.保護(hù)類型的屬性:
a.在聲明對象屬性的時候,在屬性名前加一個下劃線,表示這個屬性是受保護(hù)的屬性,以后訪問這個屬性要通過getter來獲取屬性的值和setter給屬性賦值
b.如果一個屬性已經(jīng)聲明成保護(hù)類型的屬性,我們需要給這個屬性添加getter,而setter視需求添加
2.添加getter
添加getter其實(shí)就是聲明一個沒有參數(shù)有一個返回值的函數(shù)
格式:@property
def 去掉下劃線的屬性名(self):
函數(shù)體中一定要有返回值
可以使用getter的場景:
a.獲取對象某個屬性值之前,想有額外處理,可以給屬性添加getter
b.想要拿到某個屬性被使用的時刻
def下加:count += 1 統(tǒng)計(jì)獲取總共多少次
3.添加setter(給屬性賦值)
添加setter就是聲明一個有一個參數(shù)但是沒有返回值的函數(shù)
格式:@去掉下劃線的屬性名.setter
def 去掉下劃線的屬性名(self,參數(shù))
可以使用setter的場景:
在給屬性賦值前想要再做其他的操作,就給屬性添加setter
class Car:
def __init__(self):
self.color = '黃色'
self.type = '自行車'
#_price屬性是保護(hù)類型
self._price = 2000
#給_price屬性添加getter
@property
def price(self):
print('在使用_price屬性')
return self._price/1000
#想要給一個屬性添加setter,必須先給這個屬性添加getter
@price.setter
def price(self,price):
if isinstance(price,int) or isinstance(price,float):
self._price = price
else:
self._price = 0
car1 = Car()
print(car1.color)
# 添加完getter后就通過getter去獲取屬性的值
# price就是屬性_price的getter
print(car1.price,'k') # 實(shí)質(zhì)是在調(diào)用getter對應(yīng)的方法
#在使用_price屬性
#2.0 k
# 通過setter給_prince屬性賦值。實(shí)質(zhì)是在調(diào)用setter對應(yīng)的方法
car1.price = 1000#賦值
print(car1.price)#通過getter獲取值
#在使用_price屬性
#1.0
car1.price = 'abc'
print(car1.price)
#0.0
練習(xí)：聲明一個員工類，其中有一個屬性是是否已婚（bool），獲取值之前根據(jù)存的值返回'已婚'/'未婚'
class Staff:
def __init__(self, name, salary):
self.name = name
self.salary = salary
self._is_marry = False
@property
def is_marry(self):
if self._is_marry:
return '已婚'
return '未婚'
@is_marry.setter
def is_marry(self, marry):
self._is_marry = marry
staff1 = Staff('張三', 10000)
print(staff1.is_marry)
#未婚
staff1.is_marry = True
print(staff1.is_marry)
#已婚
五.繼承
python中類可以繼承,并且支持多繼承
程序中的繼承:就是讓子類直接擁有父類的屬性和方法(繼承后父類中的內(nèi)容不會因?yàn)楸焕^承而減少)
1.繼承的語法
class 子類(父類):
類的內(nèi)容
注意:如果聲明類的時候,沒有加()寫繼承,那么這個類會自動繼承python的基類object,相當(dāng)于 class 類名(object):
python中所有類都是直接或間接地繼承自object
2.能繼承什么
a.所有的屬性和方法都能繼承
b.slots值不會繼承,但是會影響子類對象的dict屬性,不能獲取到父類繼承下來的屬性
class Person:
"""人類"""
#字段
number = 61
#__slots__ = ('name','age')
def __init__(self,name='張三',age=18):
self.name = name
self.age = age
self.__height = 160
def show_message(self):
print('姓名:%s 年齡:%d'%(self.name,self.age))
@classmethod
def show_number(cls):
print('人類的數(shù)量:%d'%cls.number)
@staticmethod
def complaint():
print('人類毆打小動物!')
class Student(Person):
"""學(xué)生類"""
pass
#創(chuàng)建Person類的對象
p = Person()
#類的字段可以繼承
print(Student.number)
#61
#創(chuàng)建Student類的對象
stu1 = Student()
stu1.name = '李四'
print(stu1.name)
#李四
stu1.show_message()
#姓名:李四 年齡:18
Student.show_number()
#人類的數(shù)量:61
Student.complaint()
#人類毆打小動物!
stu1.sex = 'girl'
print(stu1.__dict__)
#{'name': '李四', 'age': 18, '_Person__height': 160, 'sex': 'girl'}
六.方法的重寫
子類繼承父類,擁有了父類的屬性和方法以后,還可以再添加自己的方法和屬性
1.添加方法和類的字段
直接在子類中聲明相應(yīng)的方法和字段
2.添加對象屬性
對象的屬性是通過繼承父類的init方法而繼承下來的
如果想要在保留父類的對象的同時添加自己的對象屬性,需要在子類的init方法中,
通過super()去調(diào)用父類的init方法
3.方法的重寫
在子類中重新實(shí)現(xiàn)父類的方法,就是重寫
方式一:直接覆蓋父類的實(shí)現(xiàn)
方式二:保留父類的功能,再添加其他的功能
4.類中方法的調(diào)用過程(重點(diǎn)掌握)
先在當(dāng)前這個類中去找,沒有去父類中找,找不到再去父類的父類中找,依次類推,
如果在基類中沒有找到,才崩潰,在第一次找到的位置去調(diào)用
注意:使用super的時候必須是通過super()來代替父類或父類對象
class Animal:
"""動物類"""
number = 100
def __init__(self):
self.age = 0
self.sex = '雌'
def shout(self):
print('嗷嗷叫')
def eat(self):
print('吃東西')
class Cat(Animal):
"""貓類"""
def __init__(self):
# 調(diào)用父類的init方法
super().__init__()
self.name = '小花'
food = '魚'
def shout(self):
print(super())
print('喵喵~')
class Dog(Animal):
"""狗類"""
def shout(self):
# 通過super()調(diào)用父類的方法灌灾，保留父類的功能
super().shout()
print('汪汪!!')
cat1 = Cat()
print(cat1.age)
#0
print(cat1.name)
#小花
cat1.shout()
#<super: <class 'Cat'>, <Cat object>>
#喵喵~
dog1 = Dog()
dog1.shout()
#嗷嗷叫
#汪汪!!
七.init方法的重寫
練習(xí)：寫一個Person類,擁有屬性name,age,sex。要求創(chuàng)建Person對象的時候必須給name和age賦值极景，sex可賦可不賦
再寫一個Staff類繼承自Person類圾浅，要求保留Person中所有的屬性健民，并且添加新的屬性salary狮荔。
要求創(chuàng)建Staff類的對象的時候胎撇，只能給name賦值(必須賦)
class Person:
def __init__(self, name1, age1, sex1='boy'):
self.name = name1
self.age = age1
self.sex = sex1
class Staff(Person):
def __init__(self, name):
super().__init__(name, 18)
self.salary = 0
八.運(yùn)算符的重載
如果希望類的對象支持相應(yīng)的運(yùn)算符操作(例如：+, -, *, /, >, <等)，就必須實(shí)現(xiàn)相應(yīng)的魔法方法殖氏。
這個過程就叫運(yùn)算符的重載
+: add()
: gt
一般情況需要對>或者<進(jìn)行重載晚树，重載后可以通過sort方法直接對對象的列表進(jìn)行排序
class Student:
def __init__(self, name='', age=0, score=0):
self.name = name
self.age = age
self.score = score
# self：+前面的對象
# other: +后面的對象
def __add__(self, other):
return self.score + other.score
# 重載 > 符號
# 注意：重載>和<可以只重載一個，另外一個對應(yīng)的功能自動取反
def __gt__(self, other):
return self.age > other.age
# 重寫魔法方法__str__雅采，用來定制對象的打印樣式
def __str__(self):
# return '<%s.%s object at 0x%x>' % (self.__module__, self.__class__.__name__, id(self))
# return 'Student: %s %d %d' % (self.name, self.age, self.score)
return str(self.__dict__)[1:-1]
#'name': '小明', 'age': 18, 'score': 90
class Schoolchild(Student):
def __add__(self, other):
return self.age + other.age
stu1 = Student('小明', 18, 90)
stu2 = Student('老王', 29, 84)
stu3 = Student('小花', 20, 78)
print(stu1)
all_students = [stu1, stu2, stu3]
all_students.sort(reverse=True)
for stu in all_students:
print(stu.name, stu.age, stu.score)
#老王 29 84
#小花 20 78
#小明 18 90
# 父類重載了運(yùn)算符爵憎，子類也能用
c1 = Schoolchild('小明明', 8, 70)
c2 = Schoolchild('小花花', 10, 67)
print(c1+c2)
#18
