類的成員,組合

一.成員

　　1.變量

  　　實例變量(字段)
      　　公有實例變量(字段)

      　　私有實例變量(字段)

 　　 類變量(靜態字段)
      　　公有類變量(靜態字段)

      　　私有類變量(靜態字段)

 1 class Foo:  2 
 3     country='中國'  #  4     # 類變量,靜態字段(如下的方法均可以調用公共的變量能夠拿出來放到類變量中)
 5 
 6     # 方法
 7     def __ini__(self,name):  8         self.name=name  9         # 實例變量,對象變量,字段
10 
11     # 方法
12     def fnc(self): 13         pass
14 
15 obj=Foo('lisa') 16 # Foo類的對象
17 # Foo類的實例

class Foo: country='中國'
    # 類變量,靜態字段(如下的方法均可以調用公共的變量能夠拿出來放到類變量中)

    # 方法
    def __init__(self,name): self.name=name # 實例變量,對象變量,字段

    # 方法
    def func(self): pass obj1=Foo('lisa') obj2=Foo('sushan') print(obj1.country) print(obj2.country)

類變量,靜態字段(如下的方法均可以調用公共的變量能夠拿出來放到類變量中)

 1 class Foo:  2 
 3     country='中國'
 4 
 5     def __init__(self,name):  6         self.name=name  7 
 8     def func(self):  9         pass
10 
11 obj1=Foo('lisa') 12 obj2=Foo('sushan') 13 
14 能夠經過類名訪問類變量,也能夠經過類的對象訪問 15 obj1.country='美國'   #此時只有obj1裏的country改爲了美國
16 Foo.country='美國'   #此時Foo裏的全部country改爲了美國
17 
18 print(obj1.country) 19 print(obj2.country)

類變量,靜態字段的改變

準則:
　　實例變量(字段)訪問時,使用對象訪問,即:obj.name
　　類變量(靜態字段)訪問時,使用類方法,即:Foo.country(實在不方便時,採用對象)

 1 class Foo:  2 
 3     country='中國'
 4 
 5     def __init__(self,name):  6         self.name=name  7 
 8     def func(self):  9         pass
10 obj1=Foo('lisa') 11 obj2=Foo('sushan') 12 
13 練習一: 14 obj1.name='amy'
15 print(obj1.name)  #amy
16 print(obj2.name)  #sushan
17 
18 練習二: 19 obj1.country='美國'
20 print(obj1.country)  #美國
21 print(obj2.country)  #中國
22 
23 練習三: 24 Foo.country='美國'
25 print(obj1.country)  #美國
26 print(obj2.country)  ##美國

易錯點:

何時用類變量
　　全部對象中有共同的字段且要改都改要刪都刪時,將實例變量提取成靜態字段

字段成員修飾符:

 1 class Foo:  2     def __init__(self,name):  3         self.name=name  4         self.age=123
 5         #此時的self.name,self.age是共有的,內部能調用,外部也能調用
 6 
 7     def func(self):  8         print(self.name)  #內部能調用
 9 
10 obj=Foo('lisa') 11 print(obj.name)  #外部也能調用
12 print(obj.age) 13 obj.func()

實例變量(字段)公有

 1 class Foo:  2 # def __init__(self,name):
 3 # #私有的實例變量
 4 # self.__name=name
 5 # self.age=123
 6 #  7 # def func(self):
 8 # print(self.__name) #內部能夠調用
 9 # 10 # obj=Foo('Lisa')
11 # print(obj.age)
12 # print(obj.__name) # 'Foo' object has no attribute '__name' Foo裏沒有這個屬性 外部不能調用
13 # obj.func() #間接訪問

實例變量(字段)私有

 1 公有:  2 class Foo:  3     country='中國'
 4     def __init__(self):  5         pass
 6 
 7     def func(self):  8         print(self.country)  #內部調用
 9         print(Foo.country) 10 
11 obj=Foo() 12 print(obj.country)  #外部調用
13 obj.func()

類變量(靜態字段)公有:

 1 class Foo:  2     __country='中國'
 3     def __init__(self):  4         pass
 5 
 6     def func(self):  7         print(self.__country)  #內部能夠執行
 8 
 9 obj=Foo() 10 print(obj.__country)   #外部沒法調用私有變量
11 obj.func()

類變量(靜態字段)私有:

1 class Foo: 2     def __init__(self,name): 3         #私有的實例變量
4         self.__name=name 5 obj=Foo('Lisa') 6 print(obj._Foo__name)  #硬上也能夠出來 可是不建議

特殊狀況:

python 中建立一個類,將自動繼承object,能夠幫助咱們開闢內存

 1 class Base(object):  2     __secret='受賄'
 3     def __init__(self):  4 
 5 class Foo(Base):  6     def func(self):  7         print(self.__secret)   #找不到
 8         print(Foo.__secret)  9 
10 print(Foo.__secret)  #找不到
11 
12 
13 class Base(object): 14     __secret='受賄'
15     def zt(self): 16         print('Base.__secret') 17 
18 class Foo(Base): 19     def func(self): 20         print(self.__secret) 21         print(Foo.__secret) 22 
23 obj=Foo() 24 obj.zt()  #子類訪問父類的函數是能夠訪問的

思考題:如何驗證子類都不知道私有字段的存在

2.方法:

  實例方法
  靜態方法
  類方法
不必寫實例化方法,能夠用靜態方法

1 class Foo(object): 2     def __init__(self,name): 3         self.name=name 4 
5     def func(self): 6         print('實例方法') 7 obj=Foo() 8 obj.func()

有必要寫實例方法

class Foo(object): def __init__(self, name): self.name = name def func(self): print(self.name) obj = Foo() obj.func()

靜態方法

 1 class Foo():  2     def __init__(self, name):  3         self.name = name  4 
 5     @staticmethod   #靜態方法 :若是方法中不用對象中的封裝的值,就能夠用靜態方法
 6     def func():   #不用寫self
 7         print('222')  8 
 9 obj = Foo('更好') 10 obj.func() 11 Foo.func()

靜態方法

靜態方法能夠經過類調用,也能夠經過對象調用 可是推薦使用類調用
總結:
  1.編寫時
    編寫是方法上方寫@staticmethod
    方法參數無關緊要
  2.調用時
      類.方法名()   推薦
      對象.方法名()

 1 class Foo():  2     def __init__(self, name):  3         self.name = name  4 
 5  @staticmethod  6     def func():  7         print('222')  8     # 類方法(用當前類的時候就用類方法)
 9  @classmethod 10     def show(cls,x1,x2):  #cls,自動傳遞當前類
11         print(cls,x1,x2)

類方法

1 執行類方法 2 Foo.show(1,8)  #<class '__main__.Foo'> 1 8

View Code

總結:
    1.定義時
        在方法上方寫:@classmethod
        參數:至少有一個cls參數
    2.執行時
        類名.方法名()   默認會將當前類傳到參數中
    3.何時用
        若是在方法中會使用到當前類,就可使用(看代碼的時候用,原碼)

靜態方法/類方法和實例方法的區別
　　方法中沒有用到封裝的對象中的內容時,就能夠用靜態方法或類方法,不然用實例方法
　　靜態方法或類方法的選擇,方法中用到了當前類就用類方法
　　定義時:靜態方法上要寫@staticmethod;類方法上要寫@classmethod
　　執行時:前者是類名.方法名 後者是對象.方法名

★以上方法想要變成私有的前面要加上下劃線

1 class Foo: 2     def __init__(self): 3         pass
4     def __display(self): 5         print('666') 6     def func(self): 7         self.__display() 8 obj=Foo() 9 obj.func()

私有成員沒法再外部直接訪問,可是能夠在外部間接訪問(私有的實例方法)

 1 class Foo:  2     def __init__(self):  3         pass
 4  @staticmethod  5     def __display():  6         print('666')  7     def func(self):  8         Foo.__display()  9 obj=Foo() 10 obj.func()

私有成員沒法再外部直接訪問,可是能夠在外部間接訪問(私有的靜態方法)

 1 class Foo:  2     def __init__(self):  3         pass
 4  @classmethod  5     def __display(cls):  6         print('666')  7     def func(self):  8         Foo.__display()  9 obj=Foo() 10 obj.func()

私有成員沒法再外部直接訪問,可是能夠在外部間接訪問(私有的類方法)

3.屬性(經過方法改造出來的)

class Foo: def __init__(self): pass @property #在方法上加上property
    def start(self):  #括號裏不能夠加其餘參數
        return 1 @property def end(self): return 10 obj=Foo() print(obj.start)  #調用的時候不加括號
print(obj.end)

總結:
  1.編寫時
      方法的上方寫property
      方法的參數只有一個self
  2.調用時:不用加括號   對象.方法
  3.對於簡單的方法,無序傳參且有返回值時可使用@property
  屬性也有公有私有之分,與上面相同

 1 while 1:  2     data_list=[]  3     for i in range(1,901):  4         data_list.append('num_%s' % i)  5     page=int(input('請輸入要查看的頁碼'))  6     # per_page_num=10
 7     start=(page-1)*10
 8     end=page*10
 9     num_list=data_list[start:end] 10     for item in num_list: 11         print(item)

練習題(翻頁)從前

 1 class Pagenation():  2     def __init__(self,num_list,page,per_page_num=10):  3         '''
 4  初始化  5  :param num_list: 全部的數據  6  :param page: 要看的頁數  7  :param per_page_num: 每頁有幾個  8         '''
 9         self.num_list=num_list 10         self.page=page 11         self.per_page_num=per_page_num 12  @property 13     def start(self): 14         '''
15  每頁的開始 16  :return: 17         '''
18         return (page-1)*self.per_page_num 19 
20  @property 21     def end(self): 22         '''
23  每頁的結束 24  :return: 25         '''
26         return page*10
27     def show(self): 28         '''
29  主函數 30  :return: 31         '''
32         result=self.num_list[self.start:self.end] 33         for el in result: 34             print(el) 35 
36 num_list=[] 37 for i in range(0,901): 38     res='num-%s' % i 39  num_list.append(res) 40 
41 page=int(input('請輸入要查看的頁碼:')) 42 
43 obj=Pagenation(num_list,page) 44 obj.show()

練習題(翻頁)如今

二.組合(嵌套)(建模)

 1 class ch:  2     def __init__(self,name,address):  3         self.name=name  4         self.address=address  5     def speech(self):  6         pass
 7 obj1=ch('北京','沙河')  8 obj2=ch('上海','浦東')  9 obj3=ch('深圳','南山') 10 class Teacher: 11     def __init__(self,name,age,salary): 12         self.name=name 13         self.age=age 14         self.salary=salary 15         self.school=None 16 obj4=Teacher('王華','25','10000') 17 obj5=Teacher('劉敏','26','12000') 18 obj6=Teacher('李青','27','14000') 19 
20 obj4.school=obj1 21 obj5.school=obj2 22 obj6.school=obj1 23 
24 print(obj4.school.name) 25 print(obj5.school.name) 26 print(obj6.school.name)

建立三個學校