标签：x11 init 语言 回顾 关系 orm 小结 ati 不能
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
class Animal: def __init__(self,name): self.name = name def talk(self): print("animal {0} is talk".format(self.name))class Cat(Animal): def talk(self): return "Meow!"class Dog(Animal): def talk(self): return "Woof!Woof!"def animal_talk(obj): #定义一个调用类的talk方法 print(obj.talk())all_animal = [Dog("d1"),Cat("c1")] #把对象存入列表中for animal in all_animal: #循环传入对象 animal_talk(animal) # 实现类似于Animal.talk(Dog("d1"))这种效果#输出Woof!Woof!Meow! |
之前我们学了面向对象知识，那我们在什么时候用呢？不可能什么时候都需要用面向对象吧，除非你是纯的面向对象语言，好的，我们下面就来谈谈
在学面向对象之前我们都是用：函数
面向对象编程其实就是：类 + 对象
|
1
2
3
4
5
6
7
8
9
10
11
|
class 类名： def 函数1(): pass def 函数2(): pass# obj是对象，是一个实例化的obj = 类名()obj.函数1() |
说明：我们把一些公共的功能，可以提取出来，并且在公共的功能中创建属于这个对象的属性，然后其他的方法就可以使用这个对象的属性了
我们举一个远程上传，执行命令的例子，例子代码如下：
|
1
2
3
4
5
6
7
8
9
|
def upload(): #连接服务器 #上传文件 #关闭def cmd(): #连接服务器 #执行命令 #关闭 |
从上面可以看出，连接服务器和关闭服务时属于公共的功能，我们用面向对象实现如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
class SSH: def __init__(self,host,port,pwd,username): self.host = host .... def connection(self): #去创建连接 self.conn = #和服务器创建的连接对象() def close(self): #关闭 self.conn.关闭 def upload(self): self.conn #使用连接上传文件 def cmd(self): self.conn #使用连接执行命令obj = SSH(...)obj = connection()obj.upload()obj.close() |
说明：我们用面向对象，其实就是建立一个模板，比如说见一个person类，通过这个person类去实例化很多对象，子类继承它的时候，也可以重用一些属性和方法，这里就不多说了
说明：当很多的函数需要有公共的参数时，可以吧参数提取出来，封装到对象中，便于以后方便使用
比如说，我们有很多的函数，需要用公共的参数，代码如下：
|
1
2
3
4
5
6
7
8
|
def f1(host,port,pwd,arg): passdef f2(host,port,pwd,arg,arg2): passdef f3(host,port,pwd,arg,arg2): pass |
上面三个函数都用到了host、port、pwd、arg这四个参数，那我们就可以封装到对象中，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class f: def __init__(self,host,port,pwd,arg): self.host = host self.port = port self.pwd = pwd self.arg = arg def f2(self): self.host .... def f2(self,args2): self.host .... def f3(self,args2): self.host .... |
作用：调用当前方法的对象
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Foo: #静态字段或者公有属性 country = "中国" def __init__(self,name,count): self.name = name self.count = count def bar(self): passobj1 = Foo("江苏"，100000)obj1.bar |
注意：country = "中国" 属于公有字段，它的作用是:每个对象中保存相同的东西时，可以使用静态字段
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class F1: def __init__(self,n): self.N = n print("F1") class F2: def __init__(self,arg1): self.a = arg1 print("F2")class F3: def __init__(self,arg2): self.b = arg2 print("F3")o1 = F1("alex")o2 = F2(o1)o3 =F3(o2)######输出alex##### o3 =F3(o2)o3 ====> o2# o2 = F2(o1)o3.b.a# o1 = F1("alex")o1.b.a.N |
说明：子类继承父类，对象调用方法时，先从自己的类中去找，找不到，就会去找父类中的方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
class F1: def __init__(self): print(‘F1‘) def a1(self): print("F1a1") def a2(self): print("F1a2")class F2(F1): def __init__(self): print("F1") def a1(self): print("F2a1") def a2(self): self.a2() print("F2a2")class F3(F2): def __init__(self): print("F3") def a2(self): print("F3a2")obj = F3()obj.a1()#输出F3a2F2a1 |
上面代码访问的顺序如下：
|
1
2
3
4
5
6
7
|
class F1: age = 18 #静态字段 def __init__(self,name): self.name = name #普通字段 def a1(self): #普通方法 print(‘F1a1‘) |
特点：
|
1
2
3
4
5
6
7
8
|
class F1: @staticmethod #声明是静态方法 def a1(n1,n2): #无需传入对象，但是可以声明多个值 print(‘xiaogao‘)F1.a1(1,2) #类名.方法名 方式调用 |
作用：当对象不需要传入参数时，去创建对象有些浪费，占着资源，所以还不如直接用类名直接去调用，这个类似于函数。
面向对象【day07】：多态-面向对象使用场景--知识点回顾
标签：x11 init 语言 回顾 关系 orm 小结 ati 不能
原文地址：http://www.cnblogs.com/luoahong/p/7208341.html
