第七色在线视频,2021少妇久久久久久久久久,亚洲欧洲精品成人久久av18,亚洲国产精品特色大片观看完整版,孙宇晨将参加特朗普的晚宴

對于Python的內(nèi)建對象，比如int、dict、list等，通過str()方法，可以把這些對象轉(zhuǎn)換為字符串對象輸出。

對于自定義對象，通過str()方法，同樣可以得到對象所對應(yīng)的字符串結(jié)果。 例如<__main__.Person object at 0x7fc77b859c50>這個結(jié)果其實是自定義類的1個實例在內(nèi)存中的地址。

通過str()打印的數(shù)據(jù)，是怎么來的呢？這其實是對象的內(nèi)建方法__str__返回的。

如果我們的類也想把容易理解的字符串輸出的話，那么我們也需要實現(xiàn)類的__str__()方法。

Python 定義了__str()__和__repr__()兩種方法，__str()__用于顯示給用戶，而__repr__()用于顯示給開發(fā)人員，當使用str()時，實際調(diào)用的是__str__()方法，而直接輸入變量，調(diào)用的是__repr__()方法。

任務(wù)

請給Student 類定義__str__和__repr__方法，使得能打印出'Student: name, gender, score'。

#?coding=utf-8
class?Person(object):
????def?__init__(self,?name,?gender):
????????self.name?=?name
????????self.gender?=?gender
class?Student(Person):
????def?__init__(self,?name,?gender,?score):
????????super(Student,?self).__init__(name,?gender)
????????self.score?=?score
????def?__str__(self):
????????return?'Student(name:{},?gender:{},?score:{})'.format(self.name,?self.gender,?self.score)
????def?__repr__(self):
????????return?'Student(name:{},?gender:{},?score:{})'.format(self.name,?self.gender,?self.score)
s1?=?Student('立里',?'男',?100)
s2?=?Student('信興',?'男',?99)
print(s1)
print(s2)

通過isinstance()方法，可以判斷一個對象是否是某個類型，從某種意義上來講，通過isinstance()方法，我們獲取到了一個對象的一些信息，那有沒有別的方法可以獲取到對象更多的信息呢？
答：（1）通過type()函數(shù)，可以獲得變量的類型。

????? ?（2）通過dir()方法，可以獲取變量的所有屬性。

????????dir列出的屬性中，有很多是以下劃線開頭和結(jié)尾的，這些都是特殊的方法，稱為內(nèi)建方法，在后面，我們還會學(xué)習(xí)這些方法。

????????對于自定義對象的實例變量，dir()返回所有實例屬性，包括__class__這類有特殊意義的屬性。注意到方法who也是p的一個屬性。

????????dir()返回的屬性是字符串列表，如果已知一個屬性名稱，要獲取或者設(shè)置對象的屬性，就需要用 getattr() 和 setattr( )函數(shù)了。

getattr(p,?'name')?#?獲取name屬性
setattr(p,?'name',?'Adam')?#?設(shè)置新的name屬性
#?但是屬性不存在，報錯：AttributeError:?'Person'?object?has?no?attribute?'age'
getattr(s,?'age',?20)?#?獲取age屬性，如果屬性不存在，就返回默認值20

#任務(wù)：
#?coding=utf-8
#?希望除了name和gender外，可以提供任意額外的關(guān)鍵字參數(shù)，并綁定到實例，請修改?Person?的__init__()定義，完成該功能。
#?**kwargs?可變關(guān)鍵字參數(shù)，字典形式（k-v）
class?Person(object):
????def?__init__(self,?name,?gender,?**kwargs):
????????self.name?=?name
????????self.gender?=?gender
????????for?k,?v?in?kwargs.items():
????????????setattr(self,?k,?v)
????????????
#?實例1：??????
p1?=?Person('蓮華',?'男',?age?=?24,?work?=?'巫師')
tamplate1?=?'我叫{n}，性別{g}，{a}歲，任職{w}'
str1?=?tamplate1.format(n?=?p1.name,?g?=?p1.gender,?a?=?p1.age,?w?=?p1.work)
print(str1)
#?實例2：
p2?=?Person('裘葵',?'女',?blood?=?30000,?work?=?'戰(zhàn)士')
tamplate2?=?'我叫{n}，性別{g}，任職{w}，血量'
str2?=?tamplate2.format(n?=?p2.name,?g?=?p2.gender,?b?=?p2.blood,?w?=?p2.work)
print(str2)

從定義上來講，Student和Teacher都擁有來自父類Person繼承的who()方法，以及自己定義的who()方法。但是在實際調(diào)用的時候，會首先查找自身的定義，如果自身有定義，則優(yōu)先使用自己定義的函數(shù)；如果沒有定義，則順著繼承鏈向上找。

在Boss的定義類，沒有定義who方法，所以會順著繼承鏈向上找到父類的who方法并且調(diào)用。

除了從一個父類繼承外，Python允許從多個父類繼承，稱為多重繼承。多重繼承和單繼承沒有特別大的差異，只是在括號內(nèi)加入多個需要繼承的類的名字即可。

在多重繼承里，A雖然被繼承了兩次，但是__init__()的方法只調(diào)用一次。

多重繼承的目的是從兩種繼承樹中分別選擇并繼承出子類，以便組合功能使用。

Python的網(wǎng)絡(luò)服務(wù)器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服務(wù)器運行模式有 多進程ForkingMixin 和 多線程ThreadingMixin兩種。

要創(chuàng)建多進程模式的 TCPServer：

class?MyTCPServer(TCPServer,?ForkingMixin)
????pass

要創(chuàng)建多線程模式的 UDPServer：

class?MyUDPServer(UDPServer,?ThreadingMixin):
????pass

如果沒有多重繼承，要實現(xiàn)上述所有可能的組合需要 4x2=8 個子類。

為了操作實例對象的私有屬性，我們定義了實例方法；同樣的，如果需要需要操作類的私有屬性，則應(yīng)該定義類的方法。
默認的，在class中定義的全部是實例方法，實例方法第一個參數(shù) self 是實例本身。

和實例方法不同的是，這里有兩點需要特別注意：

????1.??類方法需要使用@classmethod來標記為類方法，否則定義的還是實例方法。

????2. 類方法的第一個參數(shù)將傳入類本身，通常將參數(shù)名命名為 cls，上面的 cls.__localtion 實際上相當于Animal.__localtion。

?因為是在類上調(diào)用，而非實例上調(diào)用，因此類方法無法獲得任何實例變量，只能獲得類的引用。

通過函數(shù)isinstance()可以判斷一個變量的類型。
在繼承鏈上，一個父類的實例不能是子類類型，因為子類比父類多了一些屬性和方法。
在一條繼承鏈上，一個實例可以看成它本身的類型，也可以看成它父類的類型。isinstance也可以用于Python自有數(shù)據(jù)類型的判斷。

任務(wù)
請根據(jù)繼承鏈的類型轉(zhuǎn)換，依次思考 t 是否是 Person，Student，Teacher，object 類型，并使用isinstance()判斷來驗證您的答案。

isinstance(t, Person)? # True
isinstance(t, Student) #False
isinstance(t, Teacher)? # True
isinstance(t, object)??? #True

定義Student類的時候，由于繼承了Person類，所以Student類自動擁有name、gender屬性，因此，在定義Student類的時候，只需要把額外的屬性加上即可。
class Student(Person):
??? def __init__(self, name, gender, score):
??????? super(Student, self).__init__(name, gender)
??????? self.score = score

student = Student('Alice', 'girl', 100)
print(student.name) # ==> Alice
print(student.gender) # ==> girl
print(student.score) # ==> 100

注意：

????1.?class Student()定義的時候，需要在括號內(nèi)寫明繼承的類Person。

????2. 在__init__()方法，需要調(diào)用super(Student, self).__init__(name, gender)，來初始化從父類繼承過來的屬性。
任務(wù)
請參考Student類，編寫Teacher類，老師擁有任教某個科目的屬性。

class Teacher(Person):
??? def __init__(self, name, gender, course)
??????? super(Teacher, self).__init__(name, gender)
??????? self.course = course
???????
teacher = Teacher('Eliot', 'boy', 'Chinese')
print(teacher.name)
print(teacher.gender)
print(teacher.course)

再通過把原先未私有化對象私有時，對象因為改變了私有屬性而不被外部訪問?。?/p>

再通過在對象前加__ 從而使得對象變成私有，這樣既不能改變對象的量，即不能從外部修改對象

1.實例化對象跟類對象只有名字是相同，其他修改不相關(guān)

2.修改實例化不影響類對象，同理修改類對象不影響實例化對象

3.在實例化對象和類對象不要使用相同的名字?。?！

私有屬性沒有辦法從外部訪問，只能在類的內(nèi)部操作；那如果外部需要操作私有屬性怎么辦？這個時候可以通過定義類或者實例的方法來操作私有屬性。
實例的方法指的就是在類中定義的函數(shù)，實例方法的第一個參數(shù)永遠都是self，self是一個引用，指向調(diào)用該方法的實例對象本身，除此以外，其他參數(shù)和普通函數(shù)是完全一樣的。
__init__(self, name)其實也可看做是一個特殊的實例方法。
在外部調(diào)用實例方法時，是不需要顯式傳遞self參數(shù)的。
name是實例的私有屬性，從外部是無法訪問的，而get_name(self) 就是一個實例方法，在實例方法里面是可以操作私有屬性的，注意，它的第一個參數(shù)是self。__init__(self, name)其實也可看做是一個特殊的實例方法。

任務(wù)
把Animal類的age、name、localtion定義成私有屬性，并定義對應(yīng)的方法修改和獲取他們的值。

class?Animal(object):
????def?__init__(self,?name,?age,?localtion):
????????self.__name?=?name
????????self.__age?=?age
????????self.__localtion?=?localtion
????def?get_info(self):
????????return?'name?=?{},?age?=?{},?localtion?=?{}'.format(self.__name,?self.__age,?self.__localtion)

dog?=?Animal('wangwang',?1,?'GuangDong')
print(dog.get_info())

并不是所有的屬性都可以被外部訪問的，這種不能被外部訪問的屬性稱為私有屬性。私有屬性是以雙下劃線'__'開頭的屬性。

#?類私有屬性
class?Animal(object):
????__localtion?=?'Asia'

#?實例私有屬性
class?Animal(object):
????def?__init__(self,?name,?age,?localtion):
????????self.name?=?name
????????self.age?=?age
????????self.__localtion?=?localtion

外部訪問私有屬性將會拋出異常，提示沒有這個屬性。
雖然私有屬性無法從外部訪問，但是，從類的內(nèi)部是可以訪問的。私有屬性是為了保護類或?qū)嵗龑傩圆槐煌獠课廴径O(shè)計的。

任務(wù)：

# 請給Animal類的__init__方法中添加name和age參數(shù)，并把age綁定到__age屬性上，看看外部是否能訪問到。

#?Enter?a?code
class?Animal:
????def?__init__(self,?name,?age,?location):
????????self.name?=?name
????????self.__age?=?age
????????self.__location?=?location
cat?=?Animal('neko',?3,?'Home')
dog?=?Animal('YY',?3,?'Zoom')
print(dog.age)
#?報錯：AttributeError:?Animal?instance?has?no?attribute?'age'

屬性可以分為類屬性和實例屬性。

在類屬性和實例屬性同時存在的情況下，實例屬性的優(yōu)先級是要高于類屬性的，在操作實例的時候，優(yōu)先是操作實例的屬性。

當實例沒有和類同名的時候，通過實例對象，依然可以訪問到類屬性。

通過實例是無法修改類的屬性的，事實上，通過實例方法修改類屬性，只是給實例綁定了一個對應(yīng)的實例屬性。

需要特別注意，盡量不要通過實例來修改類屬性，否則很容易引發(fā)意想不到的錯誤。

任務(wù)：

# 請把上節(jié)的 Animal類屬性 count 改為 __count，再試試能否從實例和類訪問該屬性。

#?coding=utf-8
class?Animal:
????__count?=?0
????def?__init__(self,?name,?age):
????????Animal.__count?+=?1
????????self.name?=?name
????????self.age?=?age
cat?=?Animal('neko',?3)
dog?=?Animal('kk',?2)
print(Animal.__count)
print(cat.__count)
print(dog.__count)
#?以上三中方式都無法訪問__count（前置雙下劃線），會報錯：AttributeError:?class?Animal?has?no?attribute?'__count'

class?Animal(object):
????localtion?=?'asia'
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age

類是抽象，是模板，而實例則是根據(jù)類創(chuàng)建的對象，比如類：動物，只是一個抽象，并沒有動物的詳細信息，而貓、狗等，則是具體的動物，是類的對象。

實例對象綁定的屬性只屬于這個實例，綁定在一個實例上的屬性不會影響其它實例。

類也可以綁定屬性，但是類的屬性不屬于任何一個對象，而是屬于這個類。

如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，并且，所有實例訪問的類屬性都是同一個。也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份。

localtion就是屬于Animal這個類的類屬性，此后，通過Animal()實例化的所有對象，都可以訪問到localtion，并且得到唯一的結(jié)果。

類屬性也是可以動態(tài)添加和修改的，需要注意的是，因為類屬性只有一份，所以改變了，所有實例可以訪問到的類屬性都會變更。

任務(wù)

請給 Animal類添加一個類屬性 count，每創(chuàng)建一個實例，count 屬性就加 1，這樣就可以統(tǒng)計出一共創(chuàng)建了多少個 Animal的實例。

#?coding=utf-8
class?Animal:
????count?=?0
????def?__init__(self,?name,?age):
????????Animal.count?+=?1
????????self.name?=?name
????????self.age?=?age
????????
cat?=?Animal('neko',?3)
dog?=?Animal('saki',?2)
print(dog.count)
print(cat.count)

類是抽象，是模板，而實例則是根據(jù)類創(chuàng)建的對象，比如類：動物，只是一個抽象，并沒有動物的詳細信息，而貓、狗等，則是具體的動物，是類的對象。

實例對象綁定的屬性只屬于這個實例，綁定在一個實例上的屬性不會影響其它實例。

類也可以綁定屬性，但是類的屬性不屬于任何一個對象，而是屬于這個類。

如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，并且，所有實例訪問的類屬性都是同一個。也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份。

定義類屬性可以直接在 class 中定義：

class?Animal(object):
????localtion?=?'asia'
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age

#?coding=utf-8
class?Animal:
????count?=?0
????def?__init__(self,?name,?age):
????????Animal.count?+=?1
????????self.name?=?name
????????self.age?=?age
????????
cat?=?Animal('neko',?3)
dog?=?Animal('saki',?2)
print(dog.count)
print(cat.count)

類是抽象，是模板，而實例則是根據(jù)類創(chuàng)建的對象，比如類：動物，只是一個抽象，并沒有動物的詳細信息，而貓、狗等，則是具體的動物，是類的對象。

實例對象綁定的屬性只屬于這個實例，綁定在一個實例上的屬性不會影響其它實例。

類也可以綁定屬性，但是類的屬性不屬于任何一個對象，而是屬于這個類。

如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，并且，所有實例訪問的類屬性都是同一個。也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份。

定義類屬性可以直接在 class 中定義：

class?Animal(object):
????localtion?=?'asia'
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age

localtion就是屬于Animal這個類的類屬性，此后，通過Animal()實例化的所有對象，都可以訪問到localtion，并且得到唯一的結(jié)果。

類屬性也是可以動態(tài)添加和修改的，需要注意的是，因為類屬性只有一份，所以改變了，所有實例可以訪問到的類屬性都會變更。

任務(wù)

請給 Animal類添加一個類屬性 count，每創(chuàng)建一個實例，count 屬性就加 1，這樣就可以統(tǒng)計出一共創(chuàng)建了多少個 Animal的實例。

類是抽象，是模板，而實例則是根據(jù)類創(chuàng)建的對象，比如類：動物，只是一個抽象，并沒有動物的詳細信息，而貓、狗等，則是具體的動物，是類的對象。

實例對象綁定的屬性只屬于這個實例，綁定在一個實例上的屬性不會影響其它實例。

類也可以綁定屬性，但是類的屬性不屬于任何一個對象，而是屬于這個類。

如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，并且，所有實例訪問的類屬性都是同一個。也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份。

定義類屬性可以直接在 class 中定義：

class?Animal(object):
????localtion?=?'asia'
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age

localtion就是屬于Animal這個類的類屬性，此后，通過Animal()實例化的所有對象，都可以訪問到localtion，并且得到唯一的結(jié)果。

類屬性也是可以動態(tài)添加和修改的，需要注意的是，因為類屬性只有一份，所以改變了，所有實例可以訪問到的類屬性都會變更。

任務(wù)

請給 Animal類添加一個類屬性 count，每創(chuàng)建一個實例，count 屬性就加 1，這樣就可以統(tǒng)計出一共創(chuàng)建了多少個 Animal的實例。

#?coding=utf-8
class?Animal:
????count?=?0
????def?__init__(self,?name,?age):
????????Animal.count?+=?1
????????self.name?=?name
????????self.age?=?age
????????
cat?=?Animal('neko',?3)
dog?=?Animal('saki',?2)
print(dog.count)
print(cat.count)

類是抽象，是模板，而實例則是根據(jù)類創(chuàng)建的對象，比如類：動物，只是一個抽象，并沒有動物的詳細信息，而貓、狗等，則是具體的動物，是類的對象。

實例對象綁定的屬性只屬于這個實例，綁定在一個實例上的屬性不會影響其它實例。

類也可以綁定屬性，但是類的屬性不屬于任何一個對象，而是屬于這個類。

如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，并且，所有實例訪問的類屬性都是同一個。也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份。

定義類屬性可以直接在 class 中定義：

class?Animal(object):
????localtion?=?'Asia'
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age

localtion就是屬于Animal這個類的類屬性，此后，通過Animal()實例化的所有對象，都可以訪問到localtion，并且得到唯一的結(jié)果。

類屬性也是可以動態(tài)添加和修改的，需要注意的是，因為類屬性只有一份，所以改變了，所有實例可以訪問到的類屬性都會變更。

任務(wù)

請給 Animal類添加一個類屬性 count，每創(chuàng)建一個實例，count 屬性就加 1，這樣就可以統(tǒng)計出一共創(chuàng)建了多少個 Animal的實例。

#?coding=utf-8
class?Animal:
????count?=?0
????def?__init__(self,?name,?age):
????????Animal.count?+=?1
????????self.name?=?name
????????self.age?=?age
????????
cat?=?Animal('neko',?3)
dog?=?Animal('saki',?2)
print(dog.count)
print(cat.count)

類是抽象，是模板，而實例則是根據(jù)類創(chuàng)建的對象，比如類：動物，只是一個抽象，并沒有動物的詳細信息，而貓、狗等，則是具體的動物，是類的對象。

實例對象綁定的屬性只屬于這個實例，綁定在一個實例上的屬性不會影響其它實例。

類也可以綁定屬性，但是類的屬性不屬于任何一個對象，而是屬于這個類。

如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，并且，所有實例訪問的類屬性都是同一個。也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份。

定義類屬性可以直接在 class 中定義：

class?Animal(object):
????localtion?=?'Asia'
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age

localtion就是屬于Animal這個類的類屬性，此后，通過Animal()實例化的所有對象，都可以訪問到localtion，并且得到唯一的結(jié)果。

類屬性也是可以動態(tài)添加和修改的，需要注意的是，因為類屬性只有一份，所以改變了，所有實例可以訪問到的類屬性都會變更。

任務(wù)

請給 Animal類添加一個類屬性 count，每創(chuàng)建一個實例，count 屬性就加 1，這樣就可以統(tǒng)計出一共創(chuàng)建了多少個 Animal的實例。

#?coding=utf-8
class?Animal:
????count?=?0
????def?__init__(self,?name,?age):
????????Animal.count?+=?1
????????self.name?=?name
????????self.age?=?age
????????
cat?=?Animal('Neko',?3)
dog?=?Animal('Saki',?2)
print(dog.count)
print(cat.count)

類是抽象，是模板，而實例則是根據(jù)類創(chuàng)建的對象，比如類：動物，只是一個抽象，并沒有動物的詳細信息，而貓、狗等，則是具體的動物，是類的對象。

實例對象綁定的屬性只屬于這個實例，綁定在一個實例上的屬性不會影響其它實例。

類也可以綁定屬性，但是類的屬性不屬于任何一個對象，而是屬于這個類。

如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，并且，所有實例訪問的類屬性都是同一個。也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份。

定義類屬性可以直接在 class 中定義：

class?Animal(object):
????localtion?=?'Asia'
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age

localtion就是屬于Animal這個類的類屬性，此后，通過Animal()實例化的所有對象，都可以訪問到localtion，并且得到唯一的結(jié)果。

類屬性也是可以動態(tài)添加和修改的，需要注意的是，因為類屬性只有一份，所以改變了，所有實例可以訪問到的類屬性都會變更。

任務(wù)

請給 Animal類添加一個類屬性 count，每創(chuàng)建一個實例，count 屬性就加 1，這樣就可以統(tǒng)計出一共創(chuàng)建了多少個 Animal的實例。

#?coding=utf-8
class?Animal:
????count?=?0
????def?__init__(self,?name,?age):
????????Animal.count?+=?1
????????self.name?=?name
????????self.age?=?age
????????
cat?=?Animal('Neko',?3)
dog?=?Animal('Saki',?2)
print(dog.count)
print(cat.count)

類是抽象，是模板，而實例則是根據(jù)類創(chuàng)建的對象，比如類：動物，只是一個抽象，并沒有動物的詳細信息，而貓、狗等，則是具體的動物，是類的對象。

實例對象綁定的屬性只屬于這個實例，綁定在一個實例上的屬性不會影響其它實例。

類也可以綁定屬性，但是類的屬性不屬于任何一個對象，而是屬于這個類。

如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，并且，所有實例訪問的類屬性都是同一個。也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份。

定義類屬性可以直接在 class 中定義：

class?Animal(object):
????localtion?=?'Asia'
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age

localtion就是屬于Animal這個類的類屬性，此后，通過Animal()實例化的所有對象，都可以訪問到localtion，并且得到唯一的結(jié)果。

類屬性也是可以動態(tài)添加和修改的，需要注意的是，因為類屬性只有一份，所以改變了，所有實例可以訪問到的類屬性都會變更。

任務(wù)

請給 Animal類添加一個類屬性 count，每創(chuàng)建一個實例，count 屬性就加 1，這樣就可以統(tǒng)計出一共創(chuàng)建了多少個 Animal的實例。

#?coding=utf-8
class?Animal:
????count?=?0
????def?__init__(self,?name,?age):
????????Animal.count?+=?1
????????self.name?=?name
????????self.age?=?age
????????
cat?=?Animal('Neko',?3)
dog?=?Animal('Saki',?2)
print(dog.count)
print(cat.count)

在定義 Person 類時，可以為Person類添加一個特殊的__init__()方法，當創(chuàng)建實例時，__init__()方法被自動調(diào)用，我們就能在此為每個實例都統(tǒng)一加上以下屬性：

class?Person(object):
????def?__init__(self,?name,?sex,?age):
????????self.name?=?name
????????self.sex?=?sex
????????self.age?=?age

__init__() 方法的第一個參數(shù)必須是 self（也可以用別的名字，但建議使用習(xí)慣用法），后續(xù)參數(shù)則可以自由指定，和定義函數(shù)沒有任何區(qū)別。
定義類后，就可以相應(yīng)的實例化對象了，需要注意的是，在實例化的時候，需要提供除self以外的所有參數(shù)。

xiaoming?=?Person('Xiao?Ming',?'boy',?13)
xiaohong?=?Person('Xiao?Hong',?'girl',?14)

任務(wù)：

# 請定義一個動物類，抽象出名字、年齡兩個屬性，并實例化兩個實例dog,?cat。

#?coding=utf-8
class?Animal:
????def?__init__(self,?name,?age):
????????self.name?=?name
????????self.age?=?age
cat?=?Animal("neko",?2)
dog?=?Animal("yinu",?3)
template?=?'{n1}的名字叫：{n2}，年齡是：{a}歲。'
d?=?'dog'
c?=?'cat'
dn?=?dog.name
cn?=?cat.name
da?=?dog.age
ca?=?cat.age
str1?=?template.format(n1?=?d,?n2?=?dn,?a?=?da)
str2?=?template.format(n1?=?c,?n2?=?cn,?a?=?ca)
print(str1)
print(str2)

通過以下的方式賦予實例這些屬性，并且把這些屬性打印出來。

xiaohong.name?=?'xiaohong'
xiaohong.sex?=?'girl'
xiaohong.age?=?13
print(xiaohong.name)
print(xiaohong.sex)
print(xiaohong.age)

這些屬性也可以和普通變量一樣進行運算。

xiaohong.age?=?xiaohong.age?+?1

任務(wù):

# 請定義一個動物類，并創(chuàng)建出兩個實例dog,?cat，分別賦予不同的名字和年齡并打印出來。

#?coding=utf-8
class?Animal:
????pass
????
dog?=?Animal()
cat?=?Animal()
dog.name?=?'旺財'
cat.name?=?'Neko'
dog.age?=?2
cat.age?=?3

tamplate?=?'{n1}?的名字是：{n2}，年齡是：{a}歲'
d?=?'dog'
c?=?'cat'
dn?=?dog.name
cn?=?cat.name
da?=?dog.age
ca?=?cat.age
str1?=?tamplate.format(n1?=?d,?n2?=?dn,?a?=?da)
str2?=?tamplate.format(n1?=?c,?n2?=?cn,?a?=?ca)

print(str1)
print(str2)

#?結(jié)果如下：
#?dog?的名字是：旺財，年齡是：2歲
#?cat?的名字是：Neko，年齡是：3歲

Python中通過class關(guān)鍵字定義一個類。類名以大寫字母開頭。

class?Person:??pass

class?Person():?pass

class?Person(object):??pass

在Python3中，我們只需要知道這三種方式都可以定義一個類即可。

實例化是指，把抽象的類，賦予實物的過程。

創(chuàng)建實例使用類名+()，類似函數(shù)調(diào)用的形式創(chuàng)建：

class?Person(object):??pass?
xiaohong?=?Person()?
xiaoming?=?Person()

任務(wù)：

# 請練習(xí)定義一個動物類，并創(chuàng)建出兩個實例dog,?cat，打印實例，再比較兩個實例是否相等。

#?Enter?a?code
class?Animal:
????pass
dog?=?Animal()
cat?=?Animal()
print(cat)
print(dog)
print(cat?==?dog)
print(cat?is?dog)
#?結(jié)果如下?：
#?<__main__.Animal?instance?at?0x7f38e43873f8>
#?<__main__.Animal?instance?at?0x7f38e4383050>
#?False
#?False