一，面向?qū)ο?/h1>

面向過程：
優(yōu)點(diǎn)：復(fù)雜的過程流程化构拳，簡單化
缺點(diǎn)：可擴(kuò)展性差
舉例：linux中shell編譯安裝咆爽，這種固定的流程，面向過程方式堆積命令即可


面向?qū)ο螅簩ο笫翘卣髋c技能的合體
優(yōu)點(diǎn)：可擴(kuò)展性強(qiáng)
缺點(diǎn)：編程復(fù)雜難度高置森，容易出現(xiàn)過度設(shè)計(jì)

二斗埂，類

1，類的定義

在程序中：一定先有類再有對象
對象可以訪問到類中共有的數(shù)據(jù)與功能凫海，所以類中的內(nèi)容仍然是屬于對象的蜜笤；
類只不過是一種節(jié)省空間、減少代碼冗余的機(jī)制盐碱，面向?qū)ο缶幊套罱K的核心仍然是去使用對象把兔。



class Student:
    beauty='mzz'
    def learning(self):
        print('mzz like to study')
    print('----->running')

# ----->running會在"類"定義階段執(zhí)行

# 查看類的內(nèi)存空間
print(Student.__dict__)
# {'__module__': '__main__', 'beauty': 'mzz', 'learning': <function Student.learning at 0x102c43e50>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}




print(Student.beauty)    # 數(shù)據(jù)類型（變量）
# mzz
print(Student.learning)     # 函數(shù)屬性
# <function Student.learning at 0x103063e50>
# 類調(diào)用的learning是一個(gè)函數(shù)，所以要按照函數(shù)的調(diào)用方式瓮顽，即要加上self這個(gè)參數(shù)

Student.learning('mzz')
# ----->running
# mzz like to study








# 增加
Student.counry="China"
print(Student.counry)
# China


# 修改
Student.beauty="Egg"
print(Student.beauty)
# Egg


# 刪除
del Student.counry
#print(Student.counry) # 會報(bào)錯(cuò)县好，已經(jīng)刪除

# 查看類的內(nèi)存空間驗(yàn)證,沒有country
print(Student.__dict__)

2，類的實(shí)例化過程

# 調(diào)用類的過程又稱實(shí)例化
#1）得到一個(gè)返回值暖混，即對象缕贡，該對象是一個(gè)空對象
#2） Student.__init__,把類當(dāng)作第一個(gè)參數(shù)傳進(jìn)去
class Student:
    beauty='mzz'

    def __init__(self,name,age,sex):  # 在調(diào)用時(shí)自動(dòng)觸發(fā)
        self.Name=name
        self.Age=age
        self.Sex=sex

    def learning(self):
        print('mzz like to study')


s1=Student('mz',13,'female')
print(s1.__dict__)
# {'Name': 'mz', 'Age': 13, 'Sex': 'female'}

print(s1.Sex)
# female


s2=Student('egon',22,'male')
print(s2.Name)
# egon

3，屬性查找與綁定方法

#1, 查找一個(gè)對象的屬性拣播，先找自己的__dict__,再找類的__dict__
class Student:
    school='Asia'

    def __init__(self,name,age,sex):  # 在調(diào)用時(shí)自動(dòng)觸發(fā)
        self.Name=name
        self.Age=age
        self.Sex=sex

    def learning(self):
        print('%s like to study' %self.Name)

s1=Student('mz',13,'female')
s2=Student('egon',22,'male')





#2, 類的數(shù)據(jù)屬性是所有對象共享晾咪，所有對象都指向同一個(gè)內(nèi)存地址
print(Student.school,id(s1.school))
# Asia 4303951152
print(Student.school,id(s2.school))
# Asia 4303951152



Student.school='India'
print(Student.school,id(s1.school))
# India 4383185008
print(Student.school,id(s2.school))
# India 4383185008









#3, 類中定義的函數(shù)是綁定給對象使用,類也可以使用（用起來會很復(fù)雜）
# 不同對象就是不同綁定方法
# 綁定給誰，就應(yīng)該給誰調(diào)用

print(Student.learning)
# <function Student.learning at 0x10029f790>
print(s1.learning)
# <bound method Student.learning of <__main__.Student object at 0x10025dfa0>>
print(s2.learning)
# <bound method Student.learning of <__main__.Student object at 0x1002962b0>>


s1.learning()
# mz like to study
s2.learning()
# egon like to study






# 接上驗(yàn)證贮配，函數(shù)屬性的綁定方法
class Student:
    school='Asia'

    def __init__(self,name,age,sex):  # 在調(diào)用時(shí)自動(dòng)觸發(fā)
        self.Name=name
        self.Age=age
        self.Sex=sex

    def learning(self,x,y):
        print('%s like to study' %self.Name)
        print(x,y)


s1=Student('mz',13,'female')
s2=Student('egon',22,'male')

s1.learning(1,2)
# mz like to study
# 1 2


s2.learning(1,2)
# egon like to study
# 1 2


#類也可以使用（用起來會很復(fù)雜）
Student.learning(s1,1,2)
# mz like to study
# 1 2



類的函數(shù)屬性調(diào)用默認(rèn)必須要有一個(gè)參數(shù)

示例

# 示例：任何一個(gè)老師都可以看到老師的個(gè)數(shù)
class Teacher:
    school='Asia'
    count=0

    def __init__(self,name,sex,age,level,salary):
        self.name=name
        self.age=age
        self.level=level
        self.salary=salary
        Teacher.count+=1

    def teach(self):
        print('%s is teaching' %self.name)


t1=Teacher('小艾','male',20,1,3000)
t2=Teacher('小林','male',21,2,4000)
t3=Teacher('小狗','female',23,3,5000)


# 查看Teacher數(shù)量
print(t1.count)
print(t2.count)
print(t3.count)
# 3   都是3

4谍倦，類和對象

a1=list([1,2,3,4])
a2=list([1,2,3,4])
print(id(a1))
# 4343027392

print(id(a2))
# 4343027456

a1.append('a')
a2.append('b')

print(a1)
# [1, 2, 3, 4, 'a']

print(a2)
# [1, 2, 3, 4, 'b']

python中，一切皆對象泪勒，類型本質(zhì)都是類昼蛀。
數(shù)據(jù)類型都是一個(gè)個(gè)類創(chuàng)造的對象

-- 游戲中生命值攻擊力示例

class Dog:
    camp='A' #所有類里面的（xiaohua）都屬于A組
    def __init__(self,name,life_value=200,attack_value=10):
    # 初始生命值200，初始攻擊力10
        self.name=name
        # 賦值圆存，前面的name可以任意起名
        self.life_value=life_value
        self.attack_value=attack_value
    def attack(self,enemy):   # 攻擊技能
        enemy.life_value-=self.attack_value
        # 敵人的生命力=敵人的生命力減去自己的攻擊力

class Cat:
    camp='B'
    def __init__(self,name,life_value=100,attack_value=80):
        self.name=name
        self.life_value=life_value
        self.attack_value=attack_value
    def attack(self,enemy):
        enemy.life_value-=self.attack_value

xiaohua=Dog('xiaohua')
mimi=Cat('mimi')


print(xiaohua.life_value)
# 200

mimi.attack(xiaohua)
print(xiaohua.life_value)
# 120

5叼旋，代碼級別看面向?qū)ο?/h3>

# 偽代碼示例

#1、在沒有學(xué)習(xí)類這個(gè)概念時(shí)沦辙，數(shù)據(jù)與功能是分離的
def exc1(host,port,db,charset):
    conn=connect(host,port,db,charset)
    conn.execute(sql)
    return xxx


def exc2(host,port,db,charset,proc_name):
    conn=connect(host,port,db,charset)
    conn.call_proc(sql)
    return xxx

#每次調(diào)用都需要重復(fù)傳入一堆參數(shù)
exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
exc2('127.0.0.1',3306,'db1','utf8','存儲過程的名字')



#2夫植、我們能想到的解決方法是，把這些變量都定義成全局變量
HOST=‘127.0.0.1’
PORT=3306
DB=‘db1’
CHARSET=‘utf8’

def exc1(host,port,db,charset):
    conn=connect(host,port,db,charset)
    conn.execute(sql)
    return xxx


def exc2(host,port,db,charset,proc_name)
    conn=connect(host,port,db,charset)
    conn.call_proc(sql)
    return xxx

exc1(HOST,PORT,DB,CHARSET,'select * from tb1;')
exc2(HOST,PORT,DB,CHARSET,'存儲過程的名字')





#3油讯、但是2的解決方法也是有問題的详民，按照2的思路，我們將會定義一大堆全局變量撞羽，這些全局變量并沒有做任何區(qū)分阐斜，即能夠被所有功能使用，然而事實(shí)上只有HOST诀紊，PORT谒出，DB，CHARSET是給exc1和exc2這兩個(gè)功能用的邻奠。言外之意：我們必須找出一種能夠?qū)?shù)據(jù)與操作數(shù)據(jù)的方法組合到一起的解決方法笤喳，這就是我們說的類了

class MySQLHandler:
    def __init__(self,host,port,db,charset='utf8'):
        self.host=host
        self.port=port
        self.db=db
        self.charset=charset
    def exc1(self,sql):
        conn=connect(self.host,self.port,self.db,self.charset)
        res=conn.execute(sql)
        return res


    def exc2(self,sql):
        conn=connect(self.host,self.port,self.db,self.charset)
        res=conn.call_proc(sql)
        return res

三，封裝

1碌宴，隱藏屬性

# 正常情況下杀狡，x可以通過調(diào)用Foo正常訪問
class Foo:
    x=1

    def __init__(self,name,age):
        self.name=name
        self.age=age

print(Foo.x)
# 1

abc=Foo('dog',3)
print(abc.age)
# 3





# 隱藏屬性，在需要隱藏屬性的前面加上__（兩個(gè)下劃線）
# 隱藏屬性是在調(diào)用階段生成贰镣，所以在類內(nèi)部是可以直接訪問雙下滑線開頭的屬性的
class Foo:
    __x=1

    def __init__(self,name,age):
        self.name=name
        self.age=age


#print(Foo.x)  會報(bào)錯(cuò)

obj=Foo('mzz',18)
print(obj.name,obj.age)
# mzz 18



class Foo:
    __x=1

    def __init__(self,name,age):
        self._name=name
        self._age=age

print(Foo.__dict__)
# {'__module__': '__main__', '_Foo__x': 1, '__init__': <function Foo.__init__ at 0x10304f790>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}

# 根據(jù)屬性的變形呜象，通過以下方式可以得到隱藏的屬性的值
print(Foo._Foo__x)
# 1

2膳凝，為什么使用隱藏屬性

class People:
    def __init__(self,name):
        self.__name=name



#People.get_name('mmm')   # 會報(bào)錯(cuò)

obj=People('muzz')
#print(obj.set_name())   # 會報(bào)錯(cuò)


class People:
    def __init__(self,name):
        self.__name=name

    def get_name(self):
        # 類似于開個(gè)接口，可以賦予其他的東西
        print('誰是小可愛')
        print(self.__name)

obj=People('muzz')
obj.get_name()
# 誰是小可愛
# muzz


# 類的創(chuàng)造者恭陡，可以嚴(yán)格控制使用者對屬性的操作
class People:
    def __init__(self,name):
        self.__name=name

    def get_name(self):
        # 類似于開個(gè)接口蹬音，可以賦予其他的東西
        print('不給看')

obj=People('muzz')
obj.get_name()
# 不給看



# 如果更改名字，如下
class People:
    def __init__(self,name):
        self.__name=name

    def get_name(self):
        print(self.__name)

    def set_name(self,val):
        self.__name=val

obj=People('muzz')
obj.set_name('egon')
obj.get_name()
# egon





# 增加條件
class People:
    def __init__(self,name):
        self.__name=name

    def get_name(self):
        print(self.__name)

    def set_name(self,val):
        if type(val) is not str:
            print('必須字符串類型')
            return
        self.__name=val

obj=People('muzz')
obj.set_name(12235)
obj.get_name()
# 必須字符串類型
# muzz

3休玩，property裝飾器

1）用法一

"""
成人的BMI數(shù)值：
過輕：低于18.5
正常：18.5-23.9
過重：24-27
肥胖：28-32
非常肥胖, 高于32
　　體質(zhì)指數(shù)（BMI）=體重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86
"""


# 例1：傳值給People著淆，得到ami的值需要obj.ami()拴疤，即調(diào)用函數(shù)的方式
class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

    def ami(self):
        print(self.weight / (self.height **2))

obj=People('mzz',55,1.70)
print(obj.ami())
# 19.031141868512112
# None

obj.ami()
# 19.031141868512112






# 例2：加上@property 可以正常以obj.ami方式調(diào)用
class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

    @property
    def ami(self):
        print(self.weight / (self.height **2))

obj=People('mz',55,1.70)
obj.ami
# 19.031141868512112

2）用法2

# property用法2
class People:
    def __init__(self, name):
        self.__name = name

    def get_name(self): # obj1.name
        return self.__name

    def set_name(self, val): # obj1.name='EGON'
        if type(val) is not str:
            print('必須傳入str類型')
            return
        self.__name = val

    def del_name(self): # del obj1.name
        del self.__name

    name=property(get_name,set_name,del_name)

obj=People('eggg')
print(obj.name)

obj.set_name('EGGG')
print(obj.name)
#EGGG

obj.del_name()
print(obj.name) # 會報(bào)錯(cuò)

3） 用法3 (建議)

# property用法3
class People:
    def __init__(self, name):
        self.__name = name

    @property
    def name(self): # obj1.name
        return self.__name

    @name.setter
    def name(self, val): # obj1.name='EGON'
        if type(val) is not str:
            print('必須傳入str類型')
            return
        self.__name = val

    @name.deleter
    def name(self): # del obj1.name
        print('不讓刪除')
obj=People('mz')
print(obj.name)
# mz

obj.name=12
# 必須傳入str類型

obj.name='xiaohua'
print(obj.name)
# xiaohua

del obj.name
# 不讓刪除




注意def name的name要統(tǒng)一