Python第七天

Posted 2020-07-29 浮光掠影转瞬间

Python

　

　　面向对象：　　　　

　　　　面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

一. 如何定义一个类

　　在进行python面向对象编程之前，先来了解几个术语：类，类对象，实例对象，属性，函数和方法。

　　类是对现实世界中一些事物的封装，定义一个类可以采用下面的方式来定义：

class className:
    block

　　注意类名后面有个冒号，在block块里面就可以定义属性和方法了。当一个类定义完之后，就产生了一个类对象。类对象支持两种操作：引用和实例化。引用操作是通过类对象去调用类中的属性或者方法，而实例化是产生出一个类对象的实例，称作实例对象。比如定义了一个people类：

class people:
    name = \'jack\'       #定义了一个属性
    #定义了一个方法
    def printName(self):
        print self.name

　　people类定义完成之后就产生了一个全局的类对象，可以通过类对象来访问类中的属性和方法了。当通过people.name（至于为什么可以直接这样访问属性后面再解释，这里只要理解类对象这个概念就行了）来访问时，people.name中的people称为类对象，这点和C++中的有所不同。当然还可以进行实例化操作，p=people( )，这样就产生了一个people的实例对象，此时也可以通过实例对象p来访问属性或者方法了(p.name).

　　理解了类、类对象和实例对象的区别之后，我们来了解一下Python中属性、方法和函数的区别。

　　在上面代码中注释的很清楚了，name是一个属性，printName( )是一个方法，与某个对象进行绑定的函数称作为方法。一般在类里面定义的函数与类对象或者实例对象绑定了，所以称作为方法；而在类外定义的函数一般没有同对象进行绑定，就称为函数。

 

二.属性

　　在类中我们可以定义一些属性，比如：

class people:
    name = \'jack\'
    age = 12

p = people()
print p.name,p.age

　　定义了一个people类，里面定义了name和age属性，默认值分别为\'jack\'和12。在定义了类之后，就可以用来产生实例化对象了，这句p = people( )实例化了一个对象p，然后就可以通过p来读取属性了。

 

三.方法

　　在类中可以根据需要定义一些方法，定义方法采用def关键字，在类中定义的方法至少会有一个参数，，一般以名为\'self\'的变量作为该参数（用其他名称也可以），而且需要作为第一个参数。下面看个例子：

class people:
    __name = \'jack\'
    __age = 12

    def getName(self):
        return self.__name
    def getAge(self):
        return self.__age

p = people()
print(p.getName(),p.getAge())

注意：　   

　　self是一个Python自动会给传值得参数

obj1.fetch(\'selec...\') self = obj1
obj2.fetch(\'selec...\') self = obj1

 

四.类中内置的方法

　　在Python中有一些内置的方法，这些方法命名都有比较特殊的地方（其方法名以2个下划线开始然后以2个下划线结束）。类中最常用的就是构造方法和析构方法。

　　构造方法__init__(self,....)在生成对象时调用，可以用来进行一些初始化操作，不需要显示去调用，系统会默认去执行。构造方法支持重载，如果用户自己没有重新定义构造方法，系统就自动执行默认的构造方法。

　　析构方法__del__(self)在释放对象时调用，支持重载，可以在里面进行一些释放资源的操作，不需要显示调用。

 1 class Person:
 2     population=0
 3 
 4     def __init__(self,name):
 5         print("Person类正在实例化")
 6         self.name=name
 7         print("类名为",self.name)
 8         self.population += 1
 9 
10     def __del__(self):#析构函数
11         print("Person类正在析构",self.name)
12         self.population -= 1
13 
14         if self.population == 0:
15             print("I am the last One")
16         else:
17             print("There are still",self.population,"left")
18 
19     def sayHi(self):
20         print("Hello World",self.name)
21 
22     def howMany(self):
23         print("We have,",self.population,"Person Now")
24 
25 swaroop = Person("swaroop")
26 swaroop.sayHi()
27 swaroop.howMany()
28 
29 kalam = Person("kalam")
30 kalam.sayHi()
31 kalam.howMany()
32 
33 swaroop.sayHi()
34 #输出：
35 
36 Person类正在实例化
37 类名为 swaroop
38 Hello World swaroop
39 We have, 1 Person Now
40 Person类正在实例化
41 类名为 kalam
42 Hello World kalam
43 We have, 1 Person Now
44 Hello World swaroop
45 Person类正在析构 swaroop
46 I am the last One
47 Person类正在析构 kalam
48 I am the last One

面向对象三大特性(引用)

面向对象的三大特性是指：封装、继承和多态。

1 . 封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

第一步：将内容封装到某处

 self 是一个形式参数，当执行 obj1 = Foo(\'wupeiqi\', 18 ) 时，self 等于 obj1

                              当执行 obj2 = Foo(\'alex\', 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

• 通过对象直接调用
• 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名 1 class Foo:

 

 1 class Foo:
 2 
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6 
 7 obj1 = Foo(\'wupeiqi\', 18)
 8 print(obj1.name)    # 直接调用obj1对象的name属性
 9 print(obj1.age)    # 直接调用obj1对象的age属性
10 
11 obj2 = Foo(\'alex\', 73)
12 print(obj2.name)    # 直接调用obj2对象的name属性
13 print(obj2.age)     # 直接调用obj2对象的age属性
14 
15 wupeiqi
16 18
17 alex
18 73

 

 

 

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

 1 class Foo:
 2 
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6 
 7     def detail(self):
 8         print(self.name)
 9         print(self.age)
10 
11 obj1 = Foo(\'wupeiqi\', 18)
12 obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
13 
14 obj2 = Foo(\'alex\', 73)
15 obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78
16 
17 wupeiqi
18 18
19 alex
20 73

练习一：在终端输出如下信息

• 小明，10岁，男，上山去砍柴
• 小明，10岁，男，开车去东北
• 小明，10岁，男，最爱大保健
• 老李，90岁，男，上山去砍柴
• 老李，90岁，男，开车去东北
• 老李，90岁，男，最爱大保健

 1 class Foo:
 2     
 3     def __init__(self, name, age ,gender):
 4         self.name = name
 5         self.age = age
 6         self.gender = gender
 7 
 8     def kanchai(self):
 9         print "%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender)
10 
11     def qudongbei(self):
12         print "%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender)
13 
14     def dabaojian(self):
15         print "%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender)
16 
17 
18 xiaoming = Foo(\'小明\', 10, \'男\')
19 xiaoming.kanchai()
20 xiaoming.qudongbei()
21 xiaoming.dabaojian()
22 
23 laoli = Foo(\'老李\', 90, \'男\')
24 laoli.kanchai()
25 laoli.qudongbei()
26 laoli.dabaojian()
27 
28 面向对象

 

2 . 继承

         面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

　　

　在python中继承中的一些特点：

　　　(1)：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。有别于C#

　　　(2)：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

　　　(3)：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

 1 class F1:#父类，基类
 2 
 3     def show(self):
 4         print("show")
 5 
 6     def foo(self):
 7         print(self.name)
 8 
 9 class F2(F1): #子类，派生类
10     def __init__(self, name):
11         self.name = name
12 
13     def bar(self):
14         print("bar")
15     def show(self):
16         print("F2,show")
17 
18 obj = F2("hong")
19 obj.foo()
20 
21 hong

 1 class SchoolMember:  
 2     def __init__(self,name,age):  
 3         self.name=name  
 4         self.age=age  
 5         print(self.name,"正在实例化")  
 6           
 7     def tell(self):  
 8         print("Name is",self.name,"and Age is",self.age)  
 9           
10 class Teacher(SchoolMember):  
11     def __init__(self,name,age,salary):  
12         SchoolMember.__init__(self, name, age)  
13         self.salary=salary  
14         print("教师类正在实例化")  
15           
16     def tell(self):  
17         SchoolMember.tell(self)  
18         print("工资为",self.salary)  
19 t = Teacher("A",12,300)  
20 t.tell()  
21 #输出:
22 
23 A 正在实例化
24 教师类正在实例化
25 Name is A and Age is 12
26 工资为 300