初学Python：面向对象总结

2019-04-16　　Python 3x

一、 面向对象的含义和特性
　　面向对象是将世界中的具体事物进行抽象，从而能够更好的帮助我们归纳总结，解决复杂问题的一种解决问题的思路。
　　面向对象的三个特性——封装、继承、多态。
　　类和对象是面向对象中的两个重要概念。
　　类：是对事物的抽象，比如汽车模型。
　　对象：是类的一个实例，比如：大卡车。
　　二者之间的联系：类是把对象抽象化，对象是把类实例化。这个有点像哲学上上的个体和整体。当然个体还可以继续细分，这种就是一种分而治之和分类思想。

二、类
类：是对事物的抽象，比如汽车模型。

1. Python中类的定义、结构、创建

1 使用class关键字定义一个类，并且类名首字母要大写；
2 创建的类型不能用简单类型表示时就需要创建类；
3 类把需要的变量和函数组合，这种包含也称之为“封装”

2. Python类的结构

1 Class 类名:
2     成员变量（属性）
3     成员函数（方法）

3. 类的创建

1 class MyClass():
2     def fun(self): # self 是必须的
3         print('I am fuction") 

 

4.   类的属性

 

类由属性和方法组成，类的属性是对数据的封装，类的方法则是对类的行为的封装。类的属性按使用范围分为公有属性和私有属性，类的属性范围取决于属性的名称。
公有属性：类中和类外都可以调用的属性
私有属性：不能被类以外的函数调用，只能通过类的内部方法调用。（其实也可以通过instance.classname__attribute方式访问，但只用于调试程序）。定义方式：以"–"双下划线开始的成员变量就是私有属性，否则是共有属性。
内置属性：由系统在定义类的时候默认添加的，由前后两个下划线构成

 1 #!/usr/bin/python
 2 #coding:utf-8
 3 
 4 name ='Jock' # 定义全局变量
 5 class Ren(object): # 定义类，class Ren或者class Ren()都可以
 6     name = '人' # 定义公有属性
 7     __money = '我有十块钱' # 定义私有属性
 8 
 9     def run(self): # 定义方法（函数），必须要有一个形参，通常用self
10         print('跑步')
11         print(name) # 调用全局变量name='Jock'
12         print(self.name) # 调用类属性name='人'
13 
14     def say(self):
15         lie = "我很欣赏你" # 定义局部变量，注意这个不是类的公有属性
16         print(self.__money) # 内部调用私有属性
17         print(lie) # 调用局部变量
18 
19 if __name__ == '__main__': # 直接调用则执行，被调用则不执行 
20     zhangsan = Ren() # 实例化类，创建对象
21     print(zhangsan.name) # 调用类的公有属性name='人’
22     zhangsan.name='张三' # 对实例zhangsan的name属性重新赋值为'张三'
23     print(zhangsan.name) # 输出>>>张三
24     zhangsan.run() # 调用成员函数fun()
25     zhangsan.say() # 调用成员函数say()
26     print(zhangsan._Ren__money) # 另外一种访问私有属性的方式，仅在测试时使用
27     print('#'*50)
28     print(Ren.__dict__) # 调用内置属性'__dict__'

 

 1 #!/usr/bin/python
 2 #coding:utf-8
 3 
 4 class Name():
 5     var1 = '类属性，公有属性'
 6     __var2 = '类的私有属性'
 7 
 8     def fun(self):
 9         self.var2 = '对象的公有属性var2'
10         self.__var3 = '对象的私有属性__var3'
11         var4 = '函数fun的局部变量var4'
12 
13 
14 tan = Name()
15 
16 print(tan.var1)
17 print(Name.var1)
18 qi = Name()
19 tan.fun()
20 print(tan.var2)
21 
22 #print(qi.var2) # 会报错，因为qi这个实例还没有调用fun()函数
23 #print(tan.var4) # 会报错，因为var4是局部变量只能在函数内部使用。

5. 类的方法

和函数定义一样，但需要self作为第一个参数。
类的方法也分为：公有方法和私有方法。
公有方法：只有实例化之后才能被调用。
私有方法：不能被外部的类和方法调用，私有方法的定义和私有属性定义都是一样的，在方法前面加上’__'双下划线就可以了；
类方法：被classmethod()函数处理过的函数，能被类所直接调用，也能被对象所调用（是继承关系）
静态方法：相当于"全局函数"，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义静态方法没有"self"语句；
self参数：用于区分函数和类的方法（必须有一个self)，self参数表示指向对象本身。

 1 #!/usr/bin/python
 2 #coding:utf-8
 3 
 4 class Name():
 5     name = 'Jock'
 6     __money = '我有十块钱' # 定义私有属性
 7     __age = 24 # 定义私有属性
 8 
 9     def fun1(self): # 定义公有方法
10         print(self.name)
11         print('我是公有方法')
12         #__fun2() # 直接调用__fun2会报错，提示NameError: name '_Name__fun2' is not defined
13         self.__fun2() # 调用私有方法
14 
15     def __fun2(self): # 定义私有方法，只能在类定义里面被调用
16         print(self.name)
17         print('我是私有方法')
18 
19     def get(self,x): # 获取私有属性的值
20         if x == 'money':
21             return self.__money
22         else:
23             return self.__age
24 
25     def set(self,x): # 改变私有属性
26         self.__age = x
27     
28 
29     @classmethod # 装饰器，声明下面这个函数是动态方法，可以直接被类调用,这种方法最好
30     def classFun(self): # 定义动态方法
31         print(self.name)
32         print('我是类方法')
33     # 另外一种解决办法，使用classmethod()函数
34     # classNewFun = classmethod(classFun)
35 
36     @staticmethod # 装饰器，声明下面这个函数是静态方法，可以直接被类调用，这种方法最好
37     def staticFun(): # 不能有self，定义静态方法
38         print(Name.name) # 需要通过Name.name调用类的name属性
39         print('我是静态方法')
40     # 另一种解决办法，使用staticmethod()函数
41     # staticNewFun = staticmethod(staticFun)
42 """
43 二者实际原理
44 动态方法是动态加载内部的属性和方法，现加载，节省空间，不过执行速度不如静态方法
45 静态方法是在执行前先加载静态方法的所有属性和方法，然后再执行，执行速度快，不过占用空间多
46 一般大数据才需要考虑资源空间效率问题
47 """
48 print('#'*80)
49 tan = Name()
50 tan.fun1()
51 print('#'*80)
52 # Name.fun1 # 报错，因为公有方法必须实例化调用才行。类本身无法直接调用类自身的公有方法 
53 Name.classFun()
54 print('#'*80)
55 Name.staticFun()
56 print('#'*80)
57 print(tan.get('age')) 获取类的私有属性
58 print('#'*80)
59 tan.set(20) # 设置类的私有属性
60 print(tan._Name__age) # 测试，访问私有属性

三、对象
对象：是类的一个实例，比如：大卡车。类是把对象抽象化，对象是把类实例化。这个有点像哲学上上的个体和整体。当然个体还可以继续细分，这种就是一种分而治之和分类思想。

1. 对象的创建
创建对象的过程称之为实例化；当一个对象被创建后，包含三个方面的特性：对象的句柄、属性、方法。
1）句柄用于区分不同对象；
2）对象对象的属性和方法与类中的成员变量和成员函数对应。
注：还有继承、多态、析构函数、构造函数没有总结进去。

四、设计一个三维向量类，实现向量的加减法以及向量与标量的乘法和除法。

源代码如下：

1、定义三维向量运算类：Three_arithmetic

 

 1 class Three_arithmetic:
 2     def add(self,a,b):　　　　　　
 3         c=a[0]+b[0],a[1]+b[1],a[2]+b[2]
 4         return c
 5     def subtr(self,a,b):
 6         c=c=a[0]-b[0],a[1]-b[1],a[2]-b[2]
 7         return c
 8     def num_mult(self,a,k):
 9         c=k*a[0],k*a[1],k*a[2]
10         return c
11     def num_divi(self,a,k):
12         c=a[0]/k,a[1]/k,a[2]/k
13         return c

 

2、运行上述程序后，代码运算示例如下：

1 a=(1,1,1)　　　　　　    //输入向量a，a为元组
2 b=(2,2,2)                     //输入向量b，b为元组
3 k=Three_arithmetic()    //实例化
4 k.add(a,b)                    //引用类函数add，将两个向量相加    
5 k.subtr(a,b)                  //引用类函数subtr，将两个向量相减    
6 k.num_mult(a,2)          //引用类函数num_mult,将向量a乘以2 
7 k.num_divi(a,2)            //引用类函数num_divi,将向量a除以2

3、执行结果如下：

Python 3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 22:20:52) [MSC v.1916 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> 
================== RESTART: C:/Users/Benny/Desktop/temp.py ==================
>>> a=(1,1,1)
>>> b=(2,2,2)
>>> k=Three_arithmetic()
>>> k.add(a,b)
(3, 3, 3)
>>> k.subtr(a,b)
(-1, -1, -1)
>>> k.num_mult(a,2)
(2, 2, 2)
>>> k.num_divi(a,2)
(0.5, 0.5, 0.5)
>>> 

 

转载于:https://www.cnblogs.com/shuxincheng/p/10719088.html