标签: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): pass def f2(host,port,pwd,arg,arg2): pass def 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 ): pass obj1 = 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() #输出 F3a2 F2a1 |
上面代码访问的顺序如下:
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