027class_part1

因為有基礎，我直接簡單寫了
##定義類，創建對象，調用對象方法，返回值

class  person:
    def  speak(self,x):
    print('love',x)
    return  x + '*********'

xia = person()
s = xia.speak('theonewholoveme')
print(s)

##添加屬性，和Java有區別

class  B:
    def  func(self,x = '**'):
        print(self.name,x)

z = B()
z.name = 'xia'
z.func('21')

##構造方法

def  __init__(self):
    print('123')

def  __init__(self,name,age):
　　print('3',name,age)

python構造方法只有一個或者沒有，和Java不同

###繼承

 1 class  Father:
 2     def  f(self):
 3         print('father')
 4     def  smoke(self):
 5         print('f_吐煙')
 6 
 7 class  Son(Father):
 8     def  s(self):
 9         print('son')
10     def  smoke(self):
11         super(Son,self).smoke()  # super(當前類名，self).父類方法，第一種調用父類方法
12         print('s_吐煙')
13         Father.smoke(self)  # 第二種調用父類方法，推薦使用super
14         
15 s=Son()
16 s.smoke()

#多繼承
類外部調用方法順序

 1 class  GF:
 2     def  a1(self):
 3         print('grand.a1')
 4 
 5 class  F1:
 6     def a(self):
 7         print('F1.a')
 8 
 9 class  F2(GF):
10     def a(self):
11         print('F2.a')
12 
13 class S(F1,F2):
14     pass
15 
16 son = S()
17 son.a()         # F1.a,那個在前就調用哪個的，這裡F1在前面，如果是S(F2,F1),這樣就是F2.a了
18 son.a1()        # grand.a1,從F1往上找找不到就會從右邊F2這邊找

類方法內部調用對象方法

 1 class  BaseRequest:
 2     def  __init__(self):
 3         print('BaseRequest.__init__')
 4     
 5 class  RequestHandler(BaseRequest):
 6     def  __init__(self):
 7         print('RequestHandler.__init__')
 8     def  server_forever(self):
 9         print('RequestHandler.server_forever')
10         self.process_request()   # self還是Son創建的對象，所以還是從Minx開始找
11 
12 def  process_request(self):
13     print('RequestHandler.process_request')
14 
15 class  Minx:
16     def  process_request(self):
17         print('Minx.process_request')
18 
19 class  Son(Minx,RequestHandler):
20     pass
21 
22 o = Son()                       #RequestHandler.__init__
23 o.server_forever()   # RequestHandler.server_forever#Minx.process_request

###多態（瞭解）
不過，在python裡面忽略多態，支持多態，所以我就不寫了

###類的成員之欄位
普通欄位    self.***
靜態欄位    直接在類裡面

class  Province:
    country = '中國'
    def __init__(self,name):
        self.name = name
guangdong = Province('廣東')
print(Province.country)              # 中國    # 靜態欄位，在類裡面，可以通過對象訪問也可以通過類訪問
print(guangdong.name)                  # 廣東    # 普通欄位，在對象裡面

###類的方法
普通方法 1、對象調用；

2、通過類調用普通方法（不使用）

class  P:
    def  f(self):
        print('ffff')
obj = P()
P.f(obj)   # 這樣調用，蠻無聊的。不會使用

靜態方法：加@staticmethod

class  P:
    @staticmethod
    def  sta():
        print('statics')
P.sta()

類方法：和靜態方法差不多，參數問題，這個不重要（不會使用）

@classmethod
def  classmd(cls):
    print(cls)

P.classmd()

#類成員之屬性

class  P:
    @property
    def  per(self):
        print('property')
        return  1 
        
    @per.setter
    def  per(self,val):
        print(val)
    
    @per.deleter
    def  per(self):
        print('deleter')
    
x = P()            
r = x.per             # property， 有類似x.per的就執行  @property下函數 ，需要有返回值
print(r)             #  1
x.per = 123        # 自動顯示123     有類似 x.per = *** 的就執行 @per.setter 下函數
del   x.per          # 顯示deleter    有類似del  x.per 的就執行@per.deleter 下函數

property實現的功能相當於Java的get，.setter相當於實現set，deleter相當於delete

eg：利用屬性實現分頁

 1 #__author:_nbloser
 2 #date:2018/1/19
 3 
 4 class  Pergination:
 5     def  __init__(self,current_page):
 6         try:
 7             p = int(current_page)
 8         except:
 9             p = 1
10         self.page = p
11 
12     @property
13     def  start(self):
14         val = (self.page-1)*10
15         return  val
16 
17     @property
18     def  end(self):
19         val = self.page*10
20         return  val
21 
22 li = []
23 for  i  in  range(1000):
24     li.append(i)
25 
26 while  True:
27     p = input('頁碼：')
28     obj = Pergination(p)
29 
30 print(li[obj.start:obj.end])