python学习面向对象_python学习之面向对象学习
一、什么事面向對象，以及面向對象的優點？
面向過程優缺點:
我們知道面向過程是流水線式的編程，過程就是解決問題的步驟，把大的問題化解成小的模塊
面向過程優點: 極大的降低了程序的復雜度
面向過程缺點: 牽一發而動全身, 所以完成一個模塊很少改動，否則改動的地方比較多
面向對象優缺點:
面向對象編程的核心是對象，由屬性和函數構成
面向對象優點: 解決程序的擴展性，對某個類的修改能反映到整個體系中
類的語法結構:
class 類名:
類體
例子:
class People:
language = ‘Chinese‘
def func(self): #self把對象自身傳進去
pass
p1 = People
p2 = People
print(p1.language)
print(p2.language)
p1.language = ‘english‘
print(p1.language) #輸出english
print(p2.language) #輸出english
注: 所有對象共用類的屬性，所以p2也輸出english
初始化類__init__
例子:
class Garen:
camp=‘Demacia‘
def __init__(self,nickname, aggressivity=58,life_value=456):
self.nickname = nickname
self.aggressivity = aggressivity
self.life_value = life_value
def attack(self,enemy):
enemy.life_value -= self.aggressivity
hero = Garen(‘garen‘, 100, 600) #加括號初始化類對象
print(isinstance(hero, Garen)) #isinstance判斷hero是否是類Garen的實例,是則返回True，否則返回False
print(Garen.__name__) #類的名稱
print(Garen.__doc__) #類的文檔字符串
print(Garen.__base__) #類的第一個父類
print(Garen.__bases__) #類的所有父類構成的元組
print(Garen.__dict__) #類的字典屬性
print(Garen.__module__) #類定義所在的模塊
print(Garen.__class__) #實例對應的類
將函數綁定到對象上叫做對象的方法，并且會把自身傳遞給函數作為第一個參數
對象的交互:
class Riven:
camp = ‘Noxus‘
def __init__(self, nickname, aggressivity=54,life_value=300):
self.nickname = nickname
self.aggressivity = aggressivity
self.life_value = life_value
def attack(self,enemy):
enemy.life_value -= self.aggressivity
r1 = Riven(‘瑞問問‘)
print(hero.life_value)
r1.attack(hero)
print(hero.life_value)
print(id(r1.attack)) #id打印函數位置
print(id(Riven.attack))
類有兩種屬性:數據屬性和函數屬性，數據屬性共享給所有對象。
方法是綁定到所有對象上的，并且對象會傳遞給函數
創建對象就是創建了一個命名空間，對象會先找自己的命名空間，再找類的命名空間
二、繼承
繼承是一種創建新類的方式
繼承的好處，減少代碼冗余，
子類覆蓋父類的方法叫做派生
例子:
class ParentClass1:
pass
class ParentClass2:
pass
class SubClass1(ParentClass1):
pass
class SubClass2(ParentClass1,ParentClass2):
pass
print(SubClass1.__bases__) #打印父類
print(SubClass2.__bases__) #打印父類
繼承關系如圖:
F->A->E-B->D->C
F->D->B-E->C->H->A派生類
例子:
class Animal:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print(‘eating‘)
def talk(self):
print(‘%s 正在叫‘ %self.name)
class People(Animal):
def __init__(self,name,age,sex,education):
Animal.__init__(self,name,age,sex)
self.education = education
def talk(self):
Animal.talk(self)
print(‘%s say hello‘ %self.name)
class Pig(Animal):
pass
class Dog(Animal):
pass
peo1 = People(‘hyh‘,20,‘male‘,‘小學畢業‘)
pig1 = Pig(‘zhangsan‘, 16, ‘male‘)
dog1 = Dog(‘lisi‘, 16, ‘female‘)
peo1.talk()
pig1.talk()
dog1.talk()
print(isinstance(peo1, People)) #判斷peo1是否是People類，返回True或False
print(isinstance(pig1, Pig)) #繼承反映的什么是什么的關系
print(isinstance(dog1, Dog))
通過__dict__獲取屬性
class Sub:
def __init__(self):
self.bar = 123
def bar(self):
print(‘Sub.bar‘)
s = Sub()
print(s.__dict__)
print(s.__dict__[‘bar‘])
組合: 在一個類中，以另外一個類的對象作為數據屬性，稱為類的組合，組合反映的是什么有什么的關系,
例子:
class People:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Date:
def __init__(self,year,mon,day):
self.year = year
self.mon = mon
self.day = day
def tell(self):
print(‘%s-%s-%s‘ %(self.year,self.mon,self.day))
class Teacher(People):
def __init__(self,name,age,sex,salary,year,mon,day):
self.name = name
self.age = age
self.sex = sex
self.salary = salary
self.birth = Date(year,mon,day)
class Student(People):
def __init__(self,name,age,sex,year,mon,day):
self.name=name
self.age=age
self.sex=sex
self.birth=Date(year,mon,day)
t=Teacher(‘egon‘,18,‘male‘,3000,1995,12,31)
t.birth.tell()
定義類模擬接口
例子:
class File:
def read(self):
raise TypeError(‘類型錯誤‘)
def write(self):
raise TypeError(‘類型錯誤‘)
class Txt(File):
def read(self):
print(‘文本數據的讀取方法‘)
def write(self):
print(‘文本數據的讀取方法‘)
class Sata(File):
def read(self):
print(‘硬盤數據的讀取方法‘)
def wirte(self):
print(‘硬盤數據的讀取方法‘)
class Process(File):
def read(self):
print(‘進程數據的讀取方法‘)
def write(self):
print(‘進程數據的讀取方法‘)
p = Process()
p.read()
t = Txt()
d = Sata()
print(isinstance(p, Process))
print(isinstance(t, Txt))
print(isinstance(d, Sata))
注: File類定義功能函數，Txt,Sata,Process分別定義實現函數的方法
調用父類用super方法
例子:
class Foo1:
def test(self):
print("from foo1.test")
class Foo2:
def test(self):
print(‘from foo2.test‘)
class Bar(Foo1,Foo2):
def test(self):
super().test()
print(‘Bar‘)
b = Bar()
b.test()三、封裝封裝：主要為了保護數據的隱私，而把數據隱藏起來，只能通過接口去訪問
類中通過__雙下劃線來隱藏數據屬性和函數屬性，含有__x的屬性都會變成_類名__x的形式：Foo:
__x = __test(): ()
(Foo.)封裝實例:
class People:
__country = ‘China‘
def __init__(self,name,age,sex):
self.__name = name
#self._People__name = name
self.__age = age
self.__sex = sex
def tell_info(self):
print(‘人的名字是：%s， 人的年齡是: %s, 人的性別是: %s‘ %(self.__name, self.__age, self.__sex))
p = People(‘alex‘, 29, ‘male‘)
print(p.__dict__)
p.tell_info()
注: 封裝只在定義時檢查語法
p.__x = 1
print(p.__x) #打印1
修改屬性接口
class People:
def __init__(self,name,age):
self.__name = name
self.__age = age
def tell_info(self):
print(‘人的名字是: %s, 人的年齡是: %s‘ %(self.__name, self.__age))
def set_info(self,x, y):
if not isinstance(x, str):
raise TypeError(‘名字必須是字符串‘)
if not isinstance(y, int):
raise TypeError(‘年齡必須是整數‘)
self.__name = x
self.__age = y
p = People(‘alex‘, 20)
p.tell_info()
p.set_info(‘hyh‘, 18)
p.tell_info()
四、類裝飾器
原文：http://haoyonghui.blog.51cto.com/4278020/1934677
總結
以上是生活随笔為你收集整理的python学习面向对象_python学习之面向对象学习的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python显示外部命令_Python
- 下一篇： golang 切片 接口_Golang简