類和對象
1.什么是類览露，什么是對象
類就是擁有相同功能和相同屬性的對象的集合 - 抽象的
對象就是類的實例 - 具體
如果人是類，余婷和駱昊就是對象
如果車是類丽惶，具體某一輛車才是對象
2.類的聲明 - 用代碼描述清楚這個類是哪些相同功能和相同屬性的集合
"""
1)語法:
class 類名:
類的說明文檔
類的內(nèi)容
2)說明
class - 聲明類的關(guān)鍵字
類名 - 標識符炫七，不能關(guān)鍵字夫凸，見名知義纠亚，采用駝峰式;首字母大寫
類的說明文檔 - 用""""""引起來的說明性文字
類的內(nèi)容 - 用來描述共同的功能和屬性
主要包含方法(聲明在類中的函數(shù))和屬性(聲明在類中的變量)
"""
class Person:
"""人類"""
def eat(self):
print('人類吃飯')
def sleep(self):
print('人類睡覺')
def thinking(self):
print('人類思考')
3.創(chuàng)建對象
"""
語法:
類() - 創(chuàng)建類的對象并返回
"""
p1 = Person()
p2 = Person()
print(id(p1), id(p2))
對象方法
1.類中的方法 - 就是類中共同的功能
方法 - 聲明在類中的函數(shù)
類中的方法分為三種:對象方法偷拔、類方法抖仅、靜態(tài)方法
2.對象方法
"""
1)怎么聲明 - 直接聲明在類中的函數(shù)就是對象方法
2)怎么調(diào)用：需要對象來調(diào)用;以'對象.對象方法()'的形式來調(diào)用
3)特點:有個自帶參數(shù)self,參數(shù)self在通過對象調(diào)用的時候不用傳參
系統(tǒng)會自動將當(dāng)前對象給self傳參
當(dāng)前對象 - 當(dāng)前調(diào)用這個方法的對象
當(dāng)前類的對象能做的事情躲雅，self都可以做
"""
class Dod:
# eat就是對象方法
def eat(self, food='骨頭'):
print('self:', self)
print('狗吃' + food)
dog1 = Dod() # dog1就是Dog的對象
print('dog1:', dog1)
dog1.eat()
init的方法和構(gòu)造方法
1.init的方法和構(gòu)造方法
"""
1)構(gòu)造函數(shù) - python中聲明類的時候,系統(tǒng)會自動聲明一個和類同名的函數(shù)
這個函數(shù)就是構(gòu)造函數(shù)大溜，用來創(chuàng)建當(dāng)前類的對象
當(dāng)我們調(diào)用構(gòu)造函數(shù)創(chuàng)建對象的時候呵燕，
系統(tǒng)會自動調(diào)用類中的__init__方法來初始化對象
2)__init__方法 - 魔法方法;也是一個對象方法驶冒。聲明的時候函數(shù)名必須是__init__
并且保證這個方法是對象方法
聲明后不用去調(diào)用儒士，系統(tǒng)會自動調(diào)用
記住:a.創(chuàng)建對象的時候系統(tǒng)自動調(diào)用__init__方法
b.創(chuàng)建對象的時候的止，構(gòu)造函數(shù)需不需要參數(shù)，需要幾個參數(shù)看__init__除了self以外
需要幾個參數(shù)
"""
class Person:
def __init__(self):
print('init方法')
p1 = Person()
p2 = Person()
class Student:
def __init__(self, name, age=10):
print('學(xué)生類的init', name, age)
stu1 = Student('小明', 18)
stu2 = Student(age=20, name='小花')
類中的屬性
1.類中的屬性 - 就是類中保存數(shù)據(jù)的變量
類中的屬性分為兩種:字段着撩、對象屬性
2.字段
1)怎么聲明:直接聲明在類里面函數(shù)外面中的變量就是字段
2)怎么使用:通過類使用:以'類.字段'的形式去使用
3)什么時候用:不會因為對象不同而不同的屬性就聲名成對象屬性
3.對象屬性
1)怎么聲明:
聲明在init方法中;以'self.屬性名=值'的形式來聲明
2)怎么使用:通過對象來使用;以'對象.屬性'的形式來使用
3)什么時候用:會因為對象不同而不同的屬性就聲名成對象屬性
class Person:
# a就是字段
a = 10
# name和age就是對象屬性
def __init__(self):
self.name = '小明'
self.age = 18
print(Person.a)
p1 = Person()
print(p1.name, p1.age)
p2 = Person()
print(p2.name, p2.age)
print('===================================================')
class Student:
def __init__(self, name, score=100):
self.name = name
self.age = 18
self.score = score
stu1 = Student('小明')
print(stu1.name, stu1.age, stu1.score)
stu2 = Student('小花', 60)
print(stu2.name, stu2.age, stu2.score)
print('==================================================')
# 聲明一個狗類诅福，擁有屬性:品種、名字拖叙、顏色氓润、年齡、性別;吃(XXX吃XXX)
class Dog:
def __init__(self, name, pz='土狗', color='黃色', age=1, sex='公'):
self.pz = pz
self.name = name
self.color = color
self.age = age
self.sex = sex
def eat(self, food):
print('%s吃%s' % (self.name, food))
dog1 = Dog('旺財', age=3)
dog2 = Dog('小強', '二哈', '黑白')
print(dog1.pz, dog1.name, dog1.color, dog1.age, dog1.sex)
print(dog2.pz, dog2.name, dog2.color, dog2.age, dog2.sex)
dog1.eat('屎')
dog2.eat('骨頭')
類中的方法
1.類中的方法
類中的方法有三種:對象方法憋沿、類方法旺芽、靜態(tài)方法
1)對象方法
a.怎么聲明:直接聲明在類中的函數(shù)
b.怎么調(diào)用:通過對象來調(diào)用
c.特點:自帶一個參數(shù)self;self在調(diào)用的時候不用傳參，指向當(dāng)前對象
self -> 當(dāng)前對象
d.什么時候用:如果實現(xiàn)函數(shù)的功能需要用到對象屬性辐啄，這個函數(shù)就聲名成對象方法
2)類方法
a.怎么聲明:在函數(shù)聲明前加@classmethod
b.怎么調(diào)用:通過類來調(diào)用
c.特點:自帶參數(shù)cls, cls調(diào)用時不用傳參采章，系統(tǒng)會自動將當(dāng)前類傳給cls
cls -> 當(dāng)前類(當(dāng)前類能做的事情cls都可以做)
d.什么時候用:實現(xiàn)函數(shù)的功能不需要對象屬性的前提下，需要類的時候用類方法
2)靜態(tài)方法
a.怎么聲明:在函數(shù)聲明前加@staticmethod
b.怎么調(diào)用:通過類來調(diào)用
c.特點:沒有自帶的參數(shù)
d.什么時候用:實現(xiàn)函數(shù)的功能不需要對象屬性的前提下壶辜，也不需要類的時候用靜態(tài)方法
class Student:
num = 100
def __init__(self, name, tel, age=18):
self.name = name
self.age = age
self.tel = tel
# study是對象方法
def study(self):
print('%s在學(xué)習(xí)' % self.name)
@classmethod
def func1(cls):
print('cls:', cls)
print('類方法func1')
# cls可以創(chuàng)建對象
stu2 = cls('小花', 112, 20)
print('stu2:', stu2)
print(cls.num)
@staticmethod
def fun2():
print('靜態(tài)方法fun2')
stu = Student('小明', '110')
stu.study()
print('Student:', Student)
Student.func1()
Student.fun2()
class Math:
pi = 3.141592653
@classmethod
def circle_area(cls, r):
return cls.pi * r ** 2
@staticmethod
def sum(num1, num2):
return num1 + num2
class Keng:
num = 100
def func1(self):
print('坑中的對象方法')
@classmethod
def func2(cls):
print('坑中的類方法')
@staticmethod
def func3():
print('坑中的靜態(tài)方法')
# 注意:類中的所有方法都可以通過對象或者類調(diào)用
# 類調(diào)用對象方法
Keng.func1(1) # 用類調(diào)用對象方法self會失去意義
k = Keng()
k.func2() # 用對象調(diào)用類方法多此一舉悯舟，cls還是當(dāng)前類
k.func3() # 同上
對象屬性的增刪改查
class Person:
def __init__(self, name, age=18, gender='女'):
self.name = name
self.age = age
self.gender = gender
p1 = Person('小明', gender='男')
p2 = Person('小紅', 20)
# 1.獲取屬性的值
# 屬性的增刪改查只針對指定的對象有效，不會影響別的對象
"""
1)對象.屬性 - 獲取對象指定屬性的值
2)getattr(對象,屬性名:str) - 獲取對象指定屬性的值
3)getattr(對象,屬性名:str,默認值) - 獲取對象指定屬性的值
"""
print(p1.name)
print(getattr(p1, 'name'))
print(getattr(p1, 'aaa', '無名氏'))
# attr = input('輸入需要獲取的屬性:')
# print(getattr(p1, attr))
# 2.修改屬性和增加屬性
"""
1)對象.屬性 = 值 - 當(dāng)屬性存在的時候就是修改砸民，不存在就是增加
2)setattr(對象,屬性名,值) - 當(dāng)屬性存在的時候就是修改抵怎，不存在就是增加
"""
# 改
p1.age = 28
print(p1.age)
setattr(p1, 'age', 30)
print(p1.age)
# 增
p1.height = 180
print(p1.height, getattr(p1, 'height'))
setattr(p1, 'weight', 70)
print(p1.weight)
# 3.刪除對象屬性
"""
1)del 對象.屬性 - 刪除對象中指定的屬性
2)delattr(對象,屬性名) - 刪除對象中指定的屬性
"""
# del p1.name
# print(p1.name)
#
# delattr(p1, 'age')
# print(p1.age)
內(nèi)置屬性
# 內(nèi)置類屬性 - 聲明類的時候系統(tǒng)提供的屬性
class Dog:
"""狗類！"""
num = 100
# 約束對象屬性
# __slots__ = ('name', 'age', 'gender', 'height', 'weight')
def __init__(self, name, age=3, gender='公狗'):
self.name = name
self.age = age
self.gender = gender
def func1(self):
print('對象方法', self.name)
@classmethod
def func2(cls):
print('類方法')
@staticmethod
def func3():
print('靜態(tài)方法')
dog1 = Dog('大黃')
# 1. 類.__name__ - 獲取類的名字
print(Dog)
print(Dog.__name__)
# 2. 對象.__class__ - 獲取對象對應(yīng)的類(和type(對象)功能一樣)
print(type(dog1))
print(dog1.__class__)
# 3. 類.__doc__ - 獲取類的說明文檔
print(Dog.__doc__)
# 4. __dict__
# 類.__dict__ - 獲取類中所有字段和字段對應(yīng)的值岭参，以字典的形式返回
print(Dog.__dict__)
# 5.(掌握!) 對象.__dict__ - 獲取對象所有的屬性和對應(yīng)的值反惕，以字典形式返回
print(dog1.__dict__)
# 6.__slots__ - 用來約束當(dāng)前類最多能夠擁有的對象屬性
# 注意 __dict__和__slots__只能存在一個，不可兼得
# 7.類.__module__ - 獲取當(dāng)前這個類實在哪個模塊中聲明的,返回模塊名
print(Dog.__module__)
print(int.__module__)
# 8. 類.__bases__ - 獲取當(dāng)前類的父類
# object是python的基類
print(Dog.__bases__)
