久久er66,伊人久操网站

Python面向?qū)ο缶幊蹋ㄒ唬?/h1>

更新時間：2022年05月30日 09:16:36 作者：springsnow

本文詳細(xì)講解了Python的面向?qū)ο缶幊?，文中通過示例代碼介紹的非常詳細(xì)。對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下

一、程序中定義類和對象

1、定義類

定義函數(shù)時，函數(shù)只檢測語法，不執(zhí)行代碼，但是定義類的時候，類體代碼會在類定義階段就立刻執(zhí)行，并且會產(chǎn)生一個類的名稱空間，也就是說類的本身其實(shí)就是一個容器/名稱空間（__dict__），是用來存放名字的，這是類的用途之一。

語法格式如下：

class ClassName:
    
    .
    .
    .

類實(shí)例化后，可以使用其屬性，實(shí)際上，創(chuàng)建一個類之后，可以通過類名訪問其屬性。

使用類名訪問其屬性：

# 注意類中定義變量使用駝峰體
class OldboyStudent():
    school = 'oldboy'

    def choose_course(self):
        print('is choosing course')


print(OldboyStudent.__dict__)
# {'__module__': '__main__', 'school': 'oldboy', 'choose_course': , '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None}

print(OldboyStudent.__dict__['school'])
# oldboy


print(OldboyStudent.__dict__['choose_course'])
#


try:
    OldboyStudent.__dict__['choose_course']()
except Exception as e:
    print('error:', e)
# error: choose_course() missing 1 required positional argument: 'self'


print(OldboyStudent.school)
# oldboy


print(OldboyStudent.choose_course(111))
# is choosing course


print(OldboyStudent.choose_course)
#


OldboyStudent.country = 'China'
print(OldboyStudent.__dict__['country'])
# 'China'
delOldboyStudent.school
print(OldboyStudent.__dict__)
# {'__module__': '__main__', 'choose_course': , '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None, 'country': 'CHINA'}

2、定義對象

調(diào)用類即可產(chǎn)生對象，調(diào)用類的過程，又稱為類的實(shí)例化，實(shí)例化的結(jié)果稱為類的對象/實(shí)例。

stu1 = OldboyStudent()  # 調(diào)用類會得到一個返回值，該返回值就是類的一個具體存在的對象/實(shí)例
print(stu1.school)  # oldboy

stu2 = OldboyStudent()  # 調(diào)用類會得到一個返回值，該返回值就是類的一個具體存在的對象/實(shí)例
print(stu2.school)  # oldboy

stu3 = OldboyStudent()  # 調(diào)用類會得到一個返回值，該返回值就是類的一個具體存在的對象/實(shí)例
stu3.choose_course()  # is choosing course

二、定制對象獨(dú)有特征

1、引入

對于上述的學(xué)生類，如果類的屬性改了，則其他對象的屬性也會隨之改變

class OldboyStudent():
    school = 'oldboy'

    def choose_course(self):
        print('is choosing course')


stu1 = OldboyStudent()
stu2 = OldboyStudent()

<strong>OldboyStudent.school</strong> = 'OLDBOY'
print(stu1.school)  # <strong>OLDBOY</strong>

print(stu2.school)  # OLDBOY

2、定制對象獨(dú)有特征

對象本質(zhì)類似于類，也是一個名稱空間，但是對象的名稱空間存放對象獨(dú)有的名字，而類中存放的是對象們共有的名字。

因此我們可以直接為對象單獨(dú)定制名字。

print(stu1.__dict__)  # {}
print(stu2.__dict__)  # {}

stu1.name = 'tank'
stu1.age = 18
stu1.gender = 'male'

print(stu1.name, stu1.age, stu1.gender)
# tank 18 male

try:
    print(stu2.name, stu2.age, stu2.gender)
except Exception as e:
    print(e)
# 'OldboyStudent' object has no attribute 'name'

stu2.name = 'sean'
stu2.age = 19
stu2.gender = 'female'

print(stu2.name, stu2.age, stu2.gender)
# sean 19 female

3、對象屬性查找順序

首先從自身查找，沒找到往類中找，類中沒有則會報錯。即對象的屬性查找順序?yàn)椋鹤陨?mdash;>類—>父類—>報錯。

class OldboyStudent:
    school = 'oldboy'
    count = 0
    aa = 10 #類的的公共變量aa


    def __init__(self, x, y, z):  # 會在調(diào)用類時自動觸發(fā)
        self.name = x  # stu1.name='耗哥'
        self.age = y  # stu1.age=18
        self.sex = z  # stu1.sex='male'
        OldboyStudent.count += 1
        # self.count += 1
        self.aa = 1 #對象的私有變量aa

    def choose_course(self):
        print('is choosing course')


print(OldboyStudent.count)  # 0

stu1 = OldboyStudent('nick', 18, 'male')
print(stu1.count)  # 1

stu2 = OldboyStudent('sean', 17, 'male')
print(stu2.count)  # 2

stu3 = OldboyStudent('tank', 19, 'female')
print(stu3.count)  # 3

print(OldboyStudent.count)  # 3


# 由于上述修改的是類屬性，類屬性的count已經(jīng)被修改為3，所以其他實(shí)例的count都為3
print(stu1.count)  # 3
print(stu2.count)  # 3
print(stu3.count)  # 3

# 由于aa是私有屬性，因此stu們都會用自己私有的aa，不會用類的aa。count也不屬于對象
print(stu1.__dict__)  # {'name': 'nick', 'age': 18, 'sex': 'male', 'aa': 1}
print(stu2.__dict__)  # {'name': 'sean', 'age': 17, 'sex': 'male', 'aa': 1}
print(stu3.__dict__)  # {'name': 'tank', 'age': 19, 'sex': 'female', 'aa': 1}

4、類定義階段定制屬性

類有一個名為 __init__() 的特殊方法（構(gòu)造方法），該方法在類實(shí)例化時會自動調(diào)用。

調(diào)用類時發(fā)生兩件事：

創(chuàng)造一個空對象
自動觸發(fā)類中__init__功能的執(zhí)行，將stu1以及調(diào)用類括號內(nèi)的參數(shù)一同傳入。

class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, gender):
        """調(diào)用類的時候自動觸發(fā)"""
        self.name = name
        self.age = age
        self.gender = gender
        print('*' * 50)

    def choose_course(self):
        print('is choosing course')


try:
    stu1 = OldboyStudent()
except Exception as e:
    print(e)
# __init__() missing 3 required positional arguments: 'name', 'age', and 'gender'

stu1 = OldboyStudent('nick', 18, 'male')
# **************************************************


print(stu1.__dict__) 
# {'name': 'nick', 'age': 18, 'gender': 'male'} #沒有school

三、對象的綁定方法

類名稱空間中定義的數(shù)據(jù)屬性和函數(shù)屬性都是共享給所有對象用的
對象名稱空間中定義的只有數(shù)據(jù)屬性，而且是對象所獨(dú)有的數(shù)據(jù)屬性。

1、類使用對象的綁定對象

類中定義的函數(shù)是類的函數(shù)屬性，類可以使用它，但使用的就是一個普通的函數(shù)而已，意味著需要完全遵循函數(shù)的參數(shù)規(guī)則，該傳幾個值就傳幾個

class OldboyStudent:
    school = 'oldboy'

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

    def choose_course(self):
        print(f'{self.name} choosing course')

    def func(self):
        print('from func')


print(OldboyStudent.choose_course)
# <function OldboyStudent.choose_course at 0x00000000023AEF70>

try:
    OldboyStudent.choose_course(123)
except Exception as e:
    print(e)
# 'int' object has no attribute 'name'

2、對象使用對象的綁定方法

類中定義的函數(shù)是共享給所有對象的，對象也可以使用，而且是綁定給對象用的，
綁定的效果：綁定給誰，就應(yīng)該由誰來調(diào)用，誰來調(diào)用就會將誰當(dāng)作第一個參數(shù)自動傳入。

類中定義的函數(shù)，類確實(shí)可以使用，但其實(shí)類定義的函數(shù)大多情況下都是綁定給對象用的，所以在類中定義的函數(shù)都應(yīng)該自帶一個參數(shù)self。

self代表類的實(shí)例，而非類

類的方法與普通的函數(shù)只有一個特別的區(qū)別——它們必須有一個額外的第一個參數(shù)名稱, 按照慣例它的名稱是 self，self 代表的是類的實(shí)例。

self 不是 python 關(guān)鍵字，我們把他換成 aaabbb也是可以正常執(zhí)行的:

class OldboyStudent:
    school = 'oldboy'

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

    def choose_course(self):
        print(f'{self.name} choosing course')

    def func(self):
        print('from func')


stu1 = OldboyStudent('nick', 18, 'male')
stu2 = OldboyStudent('sean', 17, 'male')
stu3 = OldboyStudent('tank', 19, 'female')

stu1.choose_course() #相當(dāng)于 OldboyStudent.choose_course(stul) 對象調(diào)對象綁定的方法,會自動傳參
# nick choosing course

stu2.choose_course()
# sean choosing course

stu3.choose_course()
# tank choosing course

stu1.func()
# from func
stu2.func()
# from func

四、類與數(shù)據(jù)類型

python3中統(tǒng)一了類與類型的概念，類就是類型

class Foo:
def __init__(self,name):
        self.name = name

f = Foo('name')

obj = Foo()
print(type(obj))
# <class '__main__.Foo'>


lis = [1, 2, 3] # 相當(dāng)于 lis = list([1,2,3])
print(type(lis))
# <class 'list'>
 
lis.append(4)  # 對象調(diào)對象綁定的方法,會自動傳參
list.append(lis,4)  # 類調(diào)用對象綁定的方法,必須得傳參

對象其實(shí)就是一個高度整合的產(chǎn)物，整合數(shù)據(jù)與專門操作該數(shù)據(jù)的方法（綁定方法）

import pymysql

class Foo:
    def __init__(self, host, port, db, chartset):
        self.host = host
        self.port = port
        self.db = db
        self.charset = chartset

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

    def exc2(self, proc_name):
        conn = pymysql.connect(self.host, self.port, self.db, self.charsett)
        conn.call_proc(proc_name)
        return xxx


obj1 = Foo('1.1.1.1', 3306, 'db1', 'utf-8')
obj1.exc1('select * from t1')
obj1.exc1('select * from t2')

obj2 = Foo('1.1.1.2', 3306, 'db1', 'utf-8')
obj2.exc1('select * from t4')

到此這篇關(guān)于Python面向?qū)ο缶幊痰奈恼戮徒榻B到這了。希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: