一、定義

面向對象是一種編程方式，此編程方式的實現是基於對 類 和 對象 的使用

類：一個種類，一個模型。
對象：指具體的東西，模型造出來的東西叫做對象。
實例：實例和對象是一樣的。
實例化：實例化就是造東西的這個過程。
屬性：就是變量
方法：就是類裏面的函數

類的定義：

class Person:  #類
    def __init__(self):#構造函數
        self.name = ‘zhang‘
        self.nose = 2 #  #公有屬性

    def driver(self):#方法
        print(‘
 
老司機，開車非常穩‘)

p=Person()#實例化，p就是實例即對象
print(p.name)#實例化對象可調用類的公共屬性
p.driver()#實例化對象可調用類的公共方法

二、構造函數：

__init__(self) 這個是構造函數。可寫可不寫。當類實例化的時候，最先執行構造函數。構造函數也可帶參數。如果構造函數帶參數，則在實例化的時候，就要帶參數

class Person:  #類
    def __init__(self，age):#帶參數的構造函數
        self.name = ‘zhang‘
        self.nose = 2 #  #公有屬性
        self.age=age
p
 
=person(18)#實例化，必須將age的值帶過去
print(p.age)#打印18

三、self

self代表的是本類對象。因為函數裏面的變量都是局部變量，出了函數就不能用了。
用self給對象綁定了之後，就可以self.xx隨便用了

class Person:  #類
    def __init__(self，age):#帶參數的構造函數
        self.name = ‘zhang‘
        self.nose = 2 #  #公有屬性
        self.age=age  
    def haha(self):
        print(self.nose)#
 
可直接用self.nose使用構造函數中的變量，會打印出2
        
p=Person(18)

四、私有屬性和方法

私有屬性和方法的定義，在前面加上兩個橫。私有屬性和方法只能在類內部調用。出了類體就不能再調用

class Person:  #類
    def __init__(self):#構造函數
        self.name = ‘zhang‘
        self.nose = 2 #  #公有屬性
        self.__ear=2#私有屬性，變量前加__  

    def driver(self):#方法
        print(‘老司機，開車非常穩‘)
    def __eat(self):#私有方法
        print(‘吃。。。。。。。。。‘)

p=Person()#實例化，p就是實例即對象
print(p.__ear)#報錯
p.__ear()#報錯，私有方法只在類內有效，出了類就無法調用

五、屬性方法

看起來像屬性的方法。跟普通方法的區別：在方法前加上@property。調用的時候像調用屬性一樣，不用加括號

class Baby():
    #沒有構造函數
    def my(self):
        self.name = ‘aaa‘
    def cry(self):#實例方法
        print(‘哇哇哇‘)

    @property#屬性方法
    def hhh(self):
        return 198
b=Baby()
b.cry()
print(b.hhh)#屬性方法的調用跟調用屬性一樣，方法名後不加括號

六、類變量

可以直接通過類名來引用並操作的變量。實例也可引用操作，但是實例並不是實際改變類變量的值

類變量直接在類內部定義（不要定義到函數體中）

class Baby():
    country = ‘China‘ #類變量，公共的變量,每個實例都可以用
    def my(self):
        self.name = ‘aaa‘
    def cry(self):#實例方法
        print(‘哇哇哇‘)
        print(self.country)#函數調用類變量時，要用self.xxx
b=Baby()
b.country=‘zhongguo‘#實例對象修改類變量的值
print(b.coutry)#打印出zhongguo
print(Baby.country)#類直接調用類標量，仍舊是原值china,並沒有改變
Baby.country=‘japan‘#類變量可通過 類.xxx=xx修改
print(Baby.country)#打印出japan

七、類方法

類方法不僅可以直接用實例調用，也可以直接用類名調用。類方法的定義需要在普通方法前加上@classmethod

class Baby():
    country=‘china‘#類變量，公共變量，所有實例化對象都可用
    # def __init__(self):#構造函數不是必須寫的
    #     print(id(self))
    #     self.name=name
    def cry(self):#帶self的方法，叫實例方法.必須先實例化後才能調用
        print(‘哇哇啊啊‘)
        print(self.xiaoming())#調用類方法時，必須用self.xxx

    @property#加上這句，將函數定義為屬性方法，當做變量用。不能加入參
    def hhh(self):
        return 198

    @classmethod
    def xiaoming(cls):#cls代表本類,這個是類方法
        print(cls.country)
        print(‘我是類方法‘)

b=Baby()
b.xiaoming()#實例對象調用類方法
Baby.xiaoming()#類名直接調用類方法

八、靜態方法

#靜態方法就是一個普通的函數，只不過就是寫在類中，不能用類變量，類方法，也用不了實例方法，實例變量。。靜態方法的定義在普通方法前加上@staticmethod

class Byby():
    @staticmethod
    def xiaohei():
        print(‘這個是靜態方法，它和一個沒卸載類裏面的函數一樣‘)

九、析構函數

析構函數在實例銷毀時執行，一般用作最後的善尾工作。比如在數據庫操作中，可以將關閉操作都放在析構函數中，當程序全部執行的時候，會自動地執行析構函數，將數據庫連接關閉

析構函數也是非必寫

import pymysql
class MyDb(object):
    def __del__(self):#析構函數不是必寫的
        #析構函數
        self.cur.close()#將數據庫關閉操作放在析構函數。在程序執行完畢後，會執行析構函數
        self.conn.close()#
        print(‘over....‘)

    def __init__(self,host,user,password,db,port=3306,charset=‘utf8‘):
        try:
            self.conn=pymysql.connect(host=host,user=user,password=password,port=port,charset=charset,db=db,autocommit=True)
            #autocommit  在執行insert,update,delete語句時可以自動提交commit
        except Exception as e:
            print(‘數據庫連接失敗%s‘%e)
        else:
            self.cur=self.conn.cursor(cursor=pymysql.cursors.DictCursor)

    def ex_sql(self,sql):
        try:
            self.cur.execute(sql)
        except Exception as e:
            print(‘sql語句有問題%s‘%sql)
        else:
            self.res=self.cur.fetchall()
            return self.res

my=MyDb(‘127.0.0.1‘,‘root‘,‘123456‘,‘db‘)
my.ex_sql(‘select * from stu;‘)
print(‘最後一行......‘)#程序自上向下執行，這一行代碼執行完畢後，程序結束，此時就會執行析構函數

#所以最終會看到打印結果中顯示：
最後一行......
over......

十、if __name__ == ‘__main__‘:

作用：

1、判斷這個python文件是在別的地方導入的，還是直接運行這個python文件

2、這句話一般是做測試的時候用的，直接執行該句話所在的文件，加與不加沒有任何區別

3、但是如果在別的文件import該文件，則main下的所有代碼不會被執行

假設文件aa.py中代碼如下：

print(__name__)#直接執行該文件，會打印出__main__。但是如果在別的文件import該文件，這句話回打印出當前文件的文件名
if __name__ == ‘__main__‘:#  直接運行當前python文件，main 寫這裏並沒有什麽用。寫與不寫一樣#但是如果在別的python中導入當前python文件，那麽main下的代碼不會被執行
    print(‘測試。。。。。。。。‘）

以上代碼，如果直接運行所在py文件，則會打印出：

__main__

測試。。。。。。

如果在文件b.py中import aa.py,執行結果：

aa #直接打印出aa.py的文件名。同時不會執行if__name__==‘__main__‘ 下的代碼

python基礎：面向對象