一、什么事面向對象，以及面向對象的優點？

面向過程優缺點:

我們知道面向過程是流水線式的編程，過程就是解決問題的步驟，把大的問題化解成小的模塊

面向過程優點: 極大的降低了程序的復雜度

面向過程缺點: 牽一發而動全身, 所以完成一個模塊很少改動，否則改動的地方比較多

面向對象優缺點:

面向對象編程的核心是對象，由屬性和函數構成

面向對象優點: 解決程序的擴展性，對某個類的修改能反映到整個體系中

類的語法結構:

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学习之面向对象学习的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。