Python——面向对象

一、创建类

语法格式：

class 类名:
    pass

创建方法：

1 构造方法

1 class Person:
2 
3     def __init__(self, name,age):
4 
5         #构造方法，构造方法的特性， 类名() 自动执行构造方法
6 
7         self.n = name
8         self.a = age

　执行构造方法：

1 obj = Person('李欢', 18)

 

2 普通方法：

1 class Person:
2 
3     def show(self):
4         pass

执行普通方法：

1 obj = Person（）
2 obj.show()

 

二、封装

self代指obj，指调用方法的调用者

1 class Bar:
2         def __init__(self, n,a):
3             self.name = n
4             self.age = a
5             self.xue = 'o'
6             
7 obj1 = Bar('alex', 123)
8     
9 obj2 = Bar('eric', 456)

 

三、继承

继承格式：

1 class 父类：　　　　#基类
2   pass
3             
4 class 子类(父类):　　#派生类
5   pass

 

重写父类方法后，希望执行父类方法和重写后的方法。

方法一： super(子类, self).父类中的方法(...)
方法二： 父类名.父类中的方法(self,...)
 1 class f:
 2     def eat(self):
 3         print('Eating')
 4 
 5     def sleep(self):
 6         print('f is sleeping')
 7 
 8 class s(f): 　　#在括号中加入要继承的父类
 9     def sleep(self):　　　　#重写父类方法
10         super(s,self).sleep()   #方法一
11         print('s is sleeping')
12         f.sleep(self)           #方法二
13 
14 obj = s()
15 obj.sleep()
16 obj.eat()

 

支持多继承

多继承特点：

a. 左侧优先
b. 一条道走到黑
c. 同一个根时，根最后执行
 1 class BaseReuqest:
 2 
 3     def __init__(self):
 4         print('BaseReuqest.init')
 5 
 6 
 7 class RequestHandler(BaseReuqest):
 8     def __init__(self):
 9         print('RequestHandler.init')
10         BaseReuqest.__init__(self)
11 
12     def serve_forever(self):
13         # self,是obj
14         print('RequestHandler.serve_forever')
15         self.process_request()
16 
17     def process_request(self):
18         print('RequestHandler.process_request')
19 
20 class Minx:
21 
22     def process_request(self):
23         print('minx.process_request')
24 
25 
26 class Son(Minx, RequestHandler): #按照从左到右，一条线走到底，如果有相同的根，则根最后执行
27     pass
28 
29 
30 obj = Son() # init
31 obj.serve_forever()

obj = Son进行实例化时，先自动执行init方法，Son类中没有init，则在第一个父类中找init方法，Minx中没有init，去第二个父类中找init方法，以此执行完init方法之后，再去调用server_forever()普通方法。

四、类成员

字段

  • 静态字段

    静态字段保存在类，可以通过对象访问，也可以通过类访问。

  • 普通字段

    普通字段保存在对象中，只能通过对象访问。

例：

1 class Province:
2     country = 'China'       #静态字段
3     def __init__(self,name):
4         self.name = name        #普通字段
5 
6 obj = Province('beijing')
7 print(obj.name)
8 print(Province.country)

 

方法

  • 普通方法

    普通方法保存在类中，由对象来调用。self表示对象

  • 静态方法

    静态方法保存在类中，由类直接调用

  • 类方法

    类方法保存在类中，由类直接调用，cls代指当前类

例：

 1 class foo:
 2 
 3     def bar(self):          #普通方法，self是对象
 4         print('ok')
 5 
 6     @staticmethod           #静态方法
 7     def sta():
 8         print('123')
 9 
10     @staticmethod           #静态方法
11     def stat(a,b):
12         print(a,b)
13 
14     @classmethod            #类方法
15     def aaa(cls):　　　　　　#cls是类名
16         print('class method')
17 
18 obj = foo()
19 obj.bar()
20 foo.sta()
21 foo.stat(1,2)
22 foo.aaa()

 

不伦不类——属性

通过加装饰器，以另一种形式访问对应的方法。

 1 class foo:
 2     @property　　　　#用于执行obj.bar
 3     def bar(self):
 4         print('1213')
 5         return 666
 6 
 7     @bar.setter　　　　#用于执行obj.bar = 123
 8     def bar(self,val):
 9         print(val)
10 
11     @bar.deleter　　　　#通过del obj.bar可以定位并访问下面的方法
12     def bar(self):
13         print(999)
14 
15 obj = foo()
16 obj.bar
17 obj.bar = 123
18 del obj.bar

 

实例：

实现分页

 1 class Pagenation:
 2 
 3     def __init__(self,current_page):
 4 
 5         try:
 6             p = int(current_page)
 7         except Exception as e:
 8             p = 1
 9 
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(5000):
24     li.append(i)
25 
26 while True:
27     page = input('>>>')
28     obj = Pagenation(page)
29     # print(li[obj.start() : obj.end()])
30     print(li[obj.start:obj.end])    #在方法前加装饰器后，可以直接用 对象名.方法名 访问方法。

 

posted on 2016-09-22 11:31  oliver.lee  阅读(203)  评论(0)  编辑  收藏  举报

导航