4.1 輕松看對象

1.面向?qū)ο?/h2>

關(guān)于面向?qū)ο蟮慕忉專?br> http://www.itdecent.cn/p/7a5b0043b035
如果你看完了上面的鏈接，也就會明白，我剛剛直接給你一個鏈接去理解面向?qū)ο?，本身就是一個面向?qū)ο蟮乃枷搿?br> 我一步一步給你解釋，這就是面向過程，而直接給你一個包含解釋面向?qū)ο蟮逆溄?封裝)，這就是面向?qū)ο蟆?/p>

2.類(Class)

類就是將物品的特征抽象到一個類別里面。如，人類、鳥類都是一個種類，類里面包含了物品的特征，如人類的的特征有年齡、姓名、眼耳鼻口等等。

Python中定義類：如，創(chuàng)建人類，特征是有(True)名字、姓名和性別

class People(object):
    Name = True
    Age = True
    Sex = True

人類的特征還有他們的行為，那么可以定義行為，如吃水果

class People(object):
    Name = True
    Age = True
    Sex = True
    def eatFruits(self,Fruit):  """self表示的是某一個人類，是確定的物，相當(dāng)Java的this"""
        print("吃" + Fruit)

類就是像一張?jiān)O(shè)計(jì)圖，把一類東西的共同特征和行為設(shè)計(jì)保存起來。

3.對象

類是一張?jiān)O(shè)計(jì)圖，而設(shè)計(jì)圖產(chǎn)出的物品就是對象。比如說，上帝創(chuàng)造了人類，以及人類的對象，亞當(dāng)和夏娃。

class People(object):
    Name = True
    Age = True
    Sex = True
    def eatFruits(self,Fruit):
       print("吃" + Fruit)

First_People = People()  """上帝創(chuàng)造了第一個人類——第一個對象"""
First_People.Name = "Adam"   """他的名字叫亞當(dāng)"""
First_People.Age = 930       """他的年齡930歲"""
First_People.Sex = "Man"     """他的性別為男"""
print(First_People)        """第一個人類的編號"""
print(First_People.Name)   """第一個人類的名字"""
print(First_People.Age)    """第一個人類的年齡"""
print(First_People.Sex)    """第一個人類的性別"""

結(jié)果:
<__main__.People object at 0x0000021A60B0E860>
Adam
930
Man

Second_People = People()   """上帝創(chuàng)造了第二個人類——第二個對象"""
Second_People.Name = "Eve"     """她的名字叫夏娃"""
Second_People.Age = 930        """她的年齡930歲"""
Second_People.Sex = "Woman"    """她的性別為女""" 
print(Second_People)       """第二個人類的編號"""
print(Second_People.Name)  """第二個人類的名字"""
print(Second_People.Age)   """第二個人類的名字"""
print(Second_People.Sex)   """第二個人類的名字"""

結(jié)果:
<__main__.People object at 0x0000021A60B28710>
Eve
930
Woman

"""亞當(dāng)和夏娃偷吃蘋果"""
First_People.eatFruits("apple")
Second_People.eatFruits("apple")

結(jié)果:
吃apple
吃apple

這就是對象的特征和行為。

4.魔法函數(shù)( __ FunctionName __ )

上面的代碼中，我們是用對象名調(diào)用對象的特征，并且賦值，這樣有時創(chuàng)建的對象多了，就比較麻煩，我們可以通過魔法函數(shù)，當(dāng)每次創(chuàng)建對象時就可以幫他們起名字，這樣就可以讓代碼更簡潔。

魔法函數(shù)的格式
class People(object):
  Name = True
  Age = True
  Sex = True
  def __init__(self,Name,Age,Sex): """魔法函數(shù)的格式:兩條下劃線+函數(shù)名+兩條下劃線(參數(shù))"""
        self.Name = Name
        self.Age = Age
        self.Sex = Sex
        print(Name,Age,Sex)
    
People1 = People("Adam",930,"Man")
People2 = People("Eve",930,"Woman")
People3 = People("小明",10,"Man")

結(jié)果:
Adam 930 Man
Eve 930 Woman
小明 10 Man

4.2 繼承者們

1.子類

類還可以細(xì)分為子類。比如，人類包括了亞洲人、歐洲人、美洲人。
我們把人類叫作父類，把亞洲人、歐洲人、美洲人叫做子類。
子類擁有父類的東西(特性、行為)，它們通過繼承(Inheritance)來連接。

繼承的格式
"""定義人類(父類)"""
class People(object):
  Name = True
  Age = True
  Sex = True

"""定義亞洲人類(子類)"""
class Asian(People):
    Etiquette = "鞠躬"  """禮儀是鞠躬"""
    
"""定義歐洲人類(子類)"""    
class European(People):
    Etiquette = "握手"

"""定義美洲人類(子類)"""    
class America(People):
    Etiquette = "親臉頰"

People1 = Asian()     """創(chuàng)建亞洲人"""
People2 = European()  """創(chuàng)建歐洲人"""
People3 = America()   """創(chuàng)建美洲人"""

print(People1.Etiquette , "------" , People1.Name)   """亞洲人擁有人類的特點(diǎn)"""
print(People2.Etiquette , "------" , People2.Name)   """歐洲人擁有人類的特點(diǎn)"""
print(People3.Etiquette , "------" , People3.Name)   """美洲人擁有人類的特點(diǎn)"""

結(jié)果:
鞠躬 ------ True
握手 ------ True
親臉頰 ------ True

2.屬性覆蓋

在繼承的過程中，子類可以增加父類沒有的東西，還可以替換父類中已經(jīng)存在的屬性。比如說，人類可以吃東西，而亞洲人可以改寫成吃粥。

"""定義人類(父類)"""
class People(object):
  Name = True
  Age = True
  Sex = True
  def eatFunction(self):
      print("吃東西")

"""定義亞洲人類(子類)"""
class Asian(People):
    Name = "亞洲人"
    Etiquette = "鞠躬"
    def eatFunction(self):
        print("吃粥")
    
"""定義歐洲人類(子類)""" 
class European(People):
    Name = "歐洲人"
    Etiquette = "握手"
    def eatFunction(self):
        print("吃面包")

"""定義美洲人類(子類)"""    
class America(People):
    Name = "美洲人"
    Etiquette = "親臉頰"
    def eatFunction(self):
        print("吃薯?xiàng)l")
    
People0 = People()
People1 = Asian()
People2 = European()
People3 = America()

print(People0.Name)
People0.eatFunction()
print()
print(People1.Name)
People1.eatFunction()
print()
print(People2.Name)
People2.eatFunction()
print()
print(People3.Name)
People3.eatFunction()

結(jié)果:
True
吃東西

亞洲人
吃粥

歐洲人
吃面包

美洲人
吃薯?xiàng)l

從上面例子可以看出，亞洲人類會調(diào)用自身定義的eatFunction()方法，而不是人類的eatFunction()。這就是父類中的同名屬性(方法)被子類的同名屬性(方法)覆蓋(override)

但有時我們不能將父類中的行為去除，需要父類中的行為，這是我們可以在覆蓋時利用super關(guān)鍵字。super關(guān)鍵字可按照需要放在子類方法中的任意位置

class People(object):
  Name = True
  Age = True
  Sex = True
  def eatFunction(self):
      print("吃東西")

class Asian(People):
    Name = "亞洲人"
    Etiquette = "鞠躬"
    def eatFunction(self):
        super().eatFunction()  """"super關(guān)鍵字:super().屬性或方法"""
        print("吃什么")
        print("吃粥")
    
    
People0 = People()
People1 = Asian()

print(People0.Name)
People0.eatFunction()
print()
print(People1.Name)
People1.eatFunction()

結(jié)果:
True
吃東西

亞洲人
吃東西
吃什么
吃粥

4.3 那些年，錯過的對象

其實(shí)在之前學(xué)過的知識當(dāng)中，已經(jīng)觸及過對象了，只不過這些對象已經(jīng)是定義好在Python中的。如 列表list，元組tuple，字符串str，詞典dict。
我們可以通過dir()、help()來查看它們的類。
如下

dir(list)
help(list)

dir(list)

help(list)

當(dāng)然我們也可以自己定義一個類，然后加入文檔注釋，查看類。如下

class People(object):
  """
      這是一個人類
  """
  Name = True
  Age = True
  Sex = True
  def eatFunction(self):
      print("吃東西")

dir(People)

help(People)

1.列表對象

list中的方法

• 插入功能
  1）在最后插入(append)

li = [1,2.2,3,3,"這是4",5]
print("插入前",li)
li.append("這是添加功能，只在最后添加")
print("插入后",li)

結(jié)果:
插入前 [1, 2.2, 3, 3, '這是4', 5]
插入后 [1, 2.2, 3, 3, '這是4', 5, '這是添加功能，只在最后添加']

2）在指定位置插入(insert)

li = [1,2,3,6,"這是4",5]
print("插入前",li)
li.insert(2,"這是插入功能，在指定位置后面插入")
print("插入后",li)

結(jié)果:
插入前 [1, 2, 3, 6, '這是4', 5]
插入后 [1, 2, '這是插入功能，在指定位置后面插入', 3, 6, '這是4', 5]

• 查找索引和計(jì)數(shù)功能
  1）查找索引功能(index)
  通過內(nèi)容查找索引

li = [1,2,3,6,3,"這是4",5]
print(li)
print("查找第一個元素為3的索引",li.index(3))

結(jié)果:
[1, 2, 3, 6, 3 , '這是4', 5]
查找第一個元素為3的索引 2

2）計(jì)數(shù)功能(count)

li = [1,2,3,6,3,"這是4",5]
print(li)
print("查找一共有多少個3:",li.count(3))

結(jié)果:
[1, 2, 3, 6, 3, '這是4', 5]
查找一共有多少個3: 2

• 刪除功能
  1）去除列表最后一個元素，并返回該元素(pop)

li = [1,2,3,6,3,"這是4",5]
print("刪除pop前",li)
li.pop()
print("刪除pop后,刪除掉最后一個元素",li)

結(jié)果:
刪除pop前 [1, 2, 3, 6, 3, '這是4', 5]
刪除pop后,刪除掉最后一個元素 [1, 2, 3, 6, 3, '這是4']

2）去除列表第一個出現(xiàn)的元素(remove)

li = [1,2,3,6,3,"這是4",5]
print("刪除remove前",li)
li.remove(3)
print("刪除remove后,刪除掉第一個元素3后",li)
li.remove(3)
print("刪除remove后,刪除掉第二個元素3后",li)

結(jié)果:
刪除remove前 [1, 2, 3, 6, 3, '這是4', 5]
刪除remove后,刪除掉第一個元素3后 [1, 2, 6, 3, '這是4', 5]
刪除remove后,刪除掉第二個元素3后 [1, 2, 6, '這是4', 5]

3）清空列表(clear)

li = [1,2,3,6,3,"這是4",5]
print("清空列表前",li)
li.clear()
print("清空列表后",li)

結(jié)果:
清空列表前 [1, 2, 3, 6, 3, '這是4', 5]
清空列表后 []

• 其他操作
  1）排序功能(sort)
  注意：如果列表里面有字符串和數(shù)字，無法進(jìn)行排序

li = [1,2,3,6,3,4,5]
print("排序之前",li)
li.sort()
print("排序之后",li)

結(jié)果:
排序之前 [1, 2, 3, 6, 3, 4, 5]
排序之后 [1, 2, 3, 3, 4, 5, 6]

"""按照某一排序標(biāo)準(zhǔn)排序，使用sort里面的key，
lambda是匿名函數(shù)，這里是按照字符串的索引為1的元素進(jìn)行排序"""
li = ['xaz','bxz','cd']
print("排序之前",li)
li.sort(key = lambda x:x[1])
print("排序之后",li)

結(jié)果:
排序之前 ['xaz', 'bxz', 'cd']
排序之后 ['xaz', 'cd', 'bxz']

sort的參數(shù)

2）顛倒次序(reverse)

li = [1,3,2,'xaz','bd',9,10]
print("顛倒之前",li)
li.reverse()
print("顛倒之后",li)

結(jié)果:
顛倒之前 [1, 3, 2, 'xaz', 'bd', 9, 10]
顛倒之后 [10, 9, 'bd', 'xaz', 2, 3, 1]

"""更簡便的顛倒"""
li = [1,3,2,6,4,10,9]
print("顛倒前",li)
print("顛倒后",li[::-1])

結(jié)果:
顛倒前 [1, 3, 2, 6, 4, 10, 9]
顛倒后 [9, 10, 4, 6, 2, 3, 1]

3）利用1）和2）可以進(jìn)行逆序排序

li = [1,3,2,6,4,10,9]
print("未逆序前",li)
li.sort()
print("先排好序",li)
li.reverse()
print("再將排序好的顛倒，逆序完畢",li)

結(jié)果:
未逆序前 [1, 3, 2, 6, 4, 10, 9]
先排好序 [1, 2, 3, 4, 6, 9, 10]
再將排序好的顛倒，逆序完畢 [10, 9, 6, 4, 3, 2, 1]

"""更簡易的逆序方式"""
li = [1,3,2,6,4,10,9]
print("逆序前",li)
li.sort()
print("進(jìn)行排序后,進(jìn)行顛倒",li[::-1])

結(jié)果:
逆序前 [1, 3, 2, 6, 4, 10, 9]
進(jìn)行排序后,進(jìn)行顛倒 [10, 9, 6, 4, 3, 2, 1]

2.元組與字符串對象

• 元組的操作
  由于元組的數(shù)據(jù)固定，因此它的操作比較少，只有兩個

tup = (1,3,4,4,3,2)
print(tup)
print('這是計(jì)數(shù)功能',tup.count(3))
print('這是按內(nèi)容查找索引功能',tup.index(2))

結(jié)果:
(1, 3, 4, 4, 3, 2)
這是計(jì)數(shù)功能 2
這是按內(nèi)容查找索引功能 5

• 字符串操作
  字符串是特殊的元組，因此可以進(jìn)行元組的操作，除此之外還有其他操作。
  1）計(jì)數(shù)和查找功能

str1 = 'HelloWorld HelloWorld'
str2 = "World"
print("str1:",str1)
print("str2:",str2)

print("str2在str1中出現(xiàn)的次數(shù)",str1.count(str2))

print("str1.find: 從左開始，查找str2在str1中第一次出現(xiàn)的次數(shù)",str1.find(str2))
print("str1.rfind: 從右開始，查找str2在str1中第一次出現(xiàn)的次數(shù)",str1.rfind(str2))

print("str1.index: 從左開始，查找str2在str1中第一次出現(xiàn)的索引",str1.index(str2))
print("str1.rindex: 從右開始，查找str2在str1中第一次出現(xiàn)的索引",str1.rindex(str2))

結(jié)果:
str1: HelloWorld HelloWorld
str2: World
str2在str1中出現(xiàn)的次數(shù) 2
str1.find從左開始，查找str2在str1中第一次出現(xiàn)的次數(shù) 5
str1.rfind從右開始，查找str2在str1中第一次出現(xiàn)的次數(shù) 16
str1.index從左開始，查找str2在str1中第一次出現(xiàn)的索引 5
str1.rindex從右開始，查找str2在str1中第一次出現(xiàn)的索引 16

2）判斷功能

str1 = 'HelloWorld HelloWorld'
print("str1:",str1)
print(".isalnum()如果所有字符都是數(shù)字或字母則放回True:",str1.isalnum())
print(".isalpha()如果所有字符都是字母則放回True:",str1.isalpha())
print(".isdigit()如果所有字符都是數(shù)字則放回True:",str1.isdigit())
print(".istitle()如果所有詞都是首字母大寫則放回True:",str1.istitle())
print(".isspace()如果所有字符都是空格則放回True:",str1.isspace())
print(".islower()如果所有字符都是小寫字母則放回True:",str1.islower())
print(".isupper()如果所有字符都是大寫字母則放回True:",str1.isupper())
結(jié)果:
str1: HelloWorld HelloWorld
.isalnum()如果所有字符都是數(shù)字或字母則放回True: False
.isalpha()如果所有字符都是字母則放回True: False
.isdigit()如果所有字符都是數(shù)字則放回True: False
.istitle()如果所有詞都是首字母大寫則放回True: False
.isspace()如果所有字符都是空格則放回True: False
.islower()如果所有字符都是小寫字母則放回True: False
.isupper()如果所有字符都是大寫字母則放回True: False

3）其他功能

"""分割功能"""
str1 = 'HelloWorld HelloWorld'
print("str1分割前:",str1)
print("默認(rèn)以空格為分隔符,str1分割后:",str1.split())

str2 = 'HelloWorld,HelloWorld'
print("str2分割前:",str2)
print("以,為分隔符,str2分割后:",str2.split(','))

結(jié)果:
str1分割前: HelloWorld HelloWorld
默認(rèn)以空格為分隔符,str1分割后: ['HelloWorld', 'HelloWorld']
str2分割前: HelloWorld,HelloWorld
以,為分隔符,str2分割后: ['HelloWorld', 'HelloWorld']

"""替換功能"""

"""將舊字符串替換為新字符串"""
str1 = 'HelloWorld1 HelloWorld2'
print('替換前',str1)
print('替換后',str1.replace('World1','Python1'))

結(jié)果:
替換前 HelloWorld1 HelloWorld2
替換后 HelloPython1 HelloWorld2

"""將字符串第一個字母替換為大寫"""
str1 = 'helloWorld1 helloWorld2'
print('替換前',str1)
print('替換后',str1.capitalize())

結(jié)果:
替換前 helloWorld1 helloWorld2
替換后 Helloworld1 helloworld2

"""將字符串的每個單詞的首字母大寫，以空格分開"""
str1 = 'helloWorld1 helloWorld2'
print('替換前',str1)
print('替換后',str1.title())

結(jié)果:
替換前 helloWorld1 helloWorld2
替換后 Helloworld1 Helloworld2

"""將字符串字母全部改為小寫"""
str1 = 'HelloWorld1 HELLOWORLD2'
print('替換前',str1)
print('替換后',str1.lower())

結(jié)果:
替換前 HelloWorld1 HELLOWORLD2
替換后 helloworld1 helloworld2

"""將字符串字母全部改為大寫"""
str1 = 'HelloWorld1 HelloWorld2'
print('替換前',str1)
print('替換后',str1.upper())

結(jié)果:
替換前 HelloWorld1 HelloWorld2
替換后 HELLOWORLD1 HELLOWORLD2

"""將字母大小寫互換"""
str1 = 'HelloWorld1 HelloWorld2'
print('替換前',str1)
print('替換后',str1.swapcase())

結(jié)果:
替換前 HelloWorld1 HelloWorld2
替換后 hELLOwORLD1 hELLOwORLD2

"""去除字符串兩邊空格"""
str1 = '   HelloWorld1 HelloWorld2   '
print("去除兩邊空格前:",str1)
print("去除兩邊空格后:",str1.strip())

結(jié)果:
去除兩邊空格前:    HelloWorld1 HelloWorld2   
去除兩邊空格后: HelloWorld1 HelloWorld2

"""以str為分隔符，將s中的元素合并成字符串"""
li = ['P','y','t','h','o','n']

str1 = ' '.join(li)  """以空格為分隔符"""
print(str1)

str1 = '-'.join(li)  """以-為分隔符"""
print(str1)

str1 = ','.join(li)  """以,為分隔符"""
print(str1)

str1 = '*'.join(li)  """以*為分隔符"""
print(str1)

結(jié)果:
P y t h o n
P-y-t-h-o-n
P,y,t,h,o,n
P*y*t*h*o*n

3.詞典對象

• 遍歷功能
  1）遍歷每一個鍵keys()方法

di = {"劍魂":93,"狂戰(zhàn)":97,"阿修羅":95,"鬼泣":94}
print('字典:',di)
print("遍歷字典的每一個鍵keys()方法")
for k in di.keys():
    print(k,end = ' ')

結(jié)果:
字典: {'劍魂': 93, '狂戰(zhàn)': 97, '阿修羅': 95, '鬼泣': 94}
遍歷字典的每一個鍵keys()方法
劍魂 狂戰(zhàn) 阿修羅 鬼泣 

2）遍歷每一個值values()方法

di = {"劍魂":93,"狂戰(zhàn)":97,"阿修羅":95,"鬼泣":94}
print('字典:',di)
print("遍歷字典的每一個值values()方法")
for v in di.values():
    print(v,end = ' ')

結(jié)果:
字典: {'劍魂': 93, '狂戰(zhàn)': 97, '阿修羅': 95, '鬼泣': 94}
遍歷字典的每一個值values()方法
93 97 95 94 

3）遍歷每一個鍵和每一個值items()方法

di = {"劍魂":93,"狂戰(zhàn)":97,"阿修羅":95,"鬼泣":94}
print('字典:',di)
print("遍歷字典的每一個鍵和值items()方法")
for k,v in di.items():
    print(k,v,end = ' ')

結(jié)果:
字典: {'劍魂': 93, '狂戰(zhàn)': 97, '阿修羅': 95, '鬼泣': 94}
遍歷字典的每一個鍵和值items()方法
劍魂 93 狂戰(zhàn) 97 阿修羅 95 鬼泣 94 

4）遍歷每一個鍵值對items()方法

di = {"劍魂":93,"狂戰(zhàn)":97,"阿修羅":95,"鬼泣":94}
print('字典:',di)
print("遍歷字典的每一個鍵值對items()方法")
for kv in di.items():
    print(kv,end = ' ')

結(jié)果:
字典: {'劍魂': 93, '狂戰(zhàn)': 97, '阿修羅': 95, '鬼泣': 94}
遍歷字典的每一個鍵值對items()方法
('劍魂', 93) ('狂戰(zhàn)', 97) ('阿修羅', 95) ('鬼泣', 94) 

• 刪除功能
  1）清空功能

di = {"劍魂":93,"狂戰(zhàn)":97,"阿修羅":95,"鬼泣":94}
print('清空字典前:',di)
di.clear()
print('清空字典后:',di)

結(jié)果:
清空字典前: {'劍魂': 93, '狂戰(zhàn)': 97, '阿修羅': 95, '鬼泣': 94}
清空字典后: {}

2）刪除功能

"""刪除最后一個鍵值對，并且放回該鍵值對popitem()"""
di = {"劍魂":93,"狂戰(zhàn)":97,"阿修羅":95,"鬼泣":94}
print('刪除前:',di)
print("刪除最后一個鍵值對，并返回該鍵值對",di.popitem())
print('刪除后',di)

結(jié)果:
刪除前: {'劍魂': 93, '狂戰(zhàn)': 97, '阿修羅': 95, '鬼泣': 94}
刪除最后一個鍵值對，并返回該鍵值對 ('鬼泣', 94)
刪除后 {'劍魂': 93, '狂戰(zhàn)': 97, '阿修羅': 95}

"""按照鍵刪除鍵值對，并返回該鍵對應(yīng)的值pop()"""
di = {"劍魂":93,"狂戰(zhàn)":97,"阿修羅":95,"鬼泣":94}
print('刪除前:',di)
print('刪除并返回對應(yīng)的值',di.pop("劍魂"))
print('刪除后',di)

結(jié)果:
刪除前: {'劍魂': 93, '狂戰(zhàn)': 97, '阿修羅': 95, '鬼泣': 94}
刪除并返回對應(yīng)的值 93
刪除后 {'狂戰(zhàn)': 97, '阿修羅': 95, '鬼泣': 94}

4.4 意想不到的對象

1.循環(huán)對象

循環(huán)對象：該對象包含了一個__ next __()方法，該方法用來生成下一次循環(huán)的結(jié)果。相當(dāng)于一個指針，指向下一個元素。每次循環(huán)時，都會調(diào)用該方法，直到拋出StopIteration異常。
如果學(xué)過Java的同學(xué)，可能知道，這就是Java中的迭代器Iterator，是專門用于遍歷元素的一個工具。

Python中內(nèi)置函數(shù)iter()能把一個容器型對象(元組、字典、字符串、字典)轉(zhuǎn)變?yōu)?strong>循環(huán)對象(迭代器)

Iterator = iter([3,4,1,2,7,"Python"])
print(Iterator.__next__())
print(Iterator.__next__())
print(Iterator.__next__())
print(Iterator.__next__())
print(Iterator.__next__())
print(Iterator.__next__())

結(jié)果:
3
4
1
2
7
Python

我們可以利用循環(huán)對象來改寫上面的代碼
for it in iter([3,4,1,2,7,"Python"]):
    print(it)

結(jié)果:
3
4
1
2
7
Python

循環(huán)對象的好處

我們也可能嘗試著自定義循環(huán)對象，這時我們需要生成器(generator)。
生成器的格式與定義函數(shù)相似，只是在return的地方改為yield。
生成器中可以有多個yield。當(dāng)生成器遇見一個yield時，就暫停運(yùn)行生成器，返回yield后面的值。當(dāng)再次調(diào)用生成器時，會從暫停的地方繼續(xù)運(yùn)行，知道遇見下一個yield。

定義生成器
def gen():
    a = 100
    yield a
    a = a*8
    yield a
    
    yield 1000
    
for i in gen():
    print(i)

結(jié)果:
100
800
1000

生成器的好處

def gen():
    i = 0
    while i < 10000000:
        i = i + 1
        yield i
"""
這個生成器能產(chǎn)生多個元素，如果實(shí)現(xiàn)創(chuàng)建序列保存10000000個元素，
那么會占用很大的空間，再進(jìn)行循環(huán)，造成極大浪費(fèi)。
而生成器會產(chǎn)生10000000個元素，但是在循環(huán)結(jié)束后就會釋放，提高了利用空間。
"""

Python中的range()函數(shù)返回的就是一個循環(huán)對象。

2.函數(shù)對象

函數(shù)(方法)也是一種對象。任何一個有__ call__()特殊方法的對象都被當(dāng)作是方法，即對象就是一個函數(shù)，對象就是一個方法。
如，

class ClassDemo(object):
    def __call__(self,x):
        print("我是__call__()方法,調(diào)用ClassDemo類的對象就能調(diào)用我")
        return x * 2
    
Class1 = ClassDemo()
print(Class1(3))

結(jié)果:
我是__call__()方法,調(diào)用ClassDemo類的對象就能調(diào)用我
6

Class1作為ClassDemo類的一個對象，當(dāng)被調(diào)用時，Class1執(zhí)行call()方法。

3.模塊對象

模塊也是對象。比如引入模塊time。

import time
dir(time)

可以看見time對象里面有很多個屬性和方法可以調(diào)用，比如sleep()。

之前，我們引入函數(shù)的第二種方式，如

引入time對象的sleep()屬性
from time import sleep

引入time對象的所有屬性
from time import *

這種引入方式實(shí)際上就是，引入模塊對象的屬性。

在引入模塊時，我們還可以給模塊換個名字，對模塊名進(jìn)行縮寫。

import time as t
t.sleep(10)  """程序停止10s"""

要注意，如果直接從模塊導(dǎo)入所有函數(shù)，當(dāng)導(dǎo)入多個模塊時，很可能發(fā)生屬性名沖突，而導(dǎo)致錯誤。比如mytime模塊里面也有一個sleep()函數(shù)時

import time
import mytime

sleep() """我們不清楚這個sleep()是來自time模塊還是mytime模塊"""
--------------------------------------------------------------------------------
對此我們可以這樣解決
import time  as  t
import mytime as mt

t.sleep()
mt.sleep()

上面就是通過對象名區(qū)分出了不同的屬性。

如果有多個模塊對象，它們的功能相似，我們可以將它們放在一個文件夾之中，構(gòu)成一個模塊包。比如放在this_dir種，需要時調(diào)用即可，比如文件夾中有time模塊

import this_dir.time

4.異常對象

異常對象