python基础-面向对象编程

一、三大编程范式

编程范式即编程的方法论，标识一种编程风格

三大编程范式：

1.面向过程编程

2.函数式编程

3.面向对象编程

二、编程进化论

1.编程最开始就是无组织无结构，从简单控制流中按步写指令

2.从上述的指令中提取重复的代码块或逻辑，组织到一起(比方说，你定义了一个函数)，便实现了代码重用，且代码由无结构走向了结构化，创建程序的过程变得更具逻辑性

3.我们定义函数都是独立于函数外定义变量，然后作为参数传递给函数，这意味着：数据与动作是分离的

4.如果我们把数据和动作内嵌到一个结构(函数或类)里面，那么我们就有了一个‘对象系统’（对象就是数据与函数整合到一起的产物）。

 假设你是一条狗，我们用结构化的数据来描述你
 1：数据与动作分离
 2：数据与动作结合

 导向：
 1.面向对象设计
 2.什么是类什么是对象

三、面向对象设计与面向对象编程

def定义函数是面向对象

class定义类是面向对象

1、面向对象设计

面向对象设计(Object oriented design)：将一类具体事物的数据和动作整合到一起，即面向对象设计

示例1：

 #相当于：类
 def dog(name,gender,type):
     #狗的动作
     def jiao(dog):
         print('一条狗[%s],汪汪汪' % dog['name'])
     def chi_shi(dog):
         print('一条[%s] 正在吃肉' % dog['type'])
     #狗的属性
     def init(name,gender,type):
         dog1 = {
             'name':name,
             'gender':gender,
             'type':type,
             'jiao':jiao,    #动作
             'chi_shi':chi_shi,   #动作
         }
         return dog1
     return init(name,gender,type)

 d1=dog('元吴','母','中华犬')
 d2=dog('alex','母','藏敖')
 print(d1)
 print(d2)
 d1['jiao'](d1)
 d2['chi_shi'](d2)

什么是类？

类：把一类事物的相同的特征和动作整合到一起就是类，类是一个抽象的概念。

什么是对象？

对象：就是基于类而创建的一个具体的事物（指具体存在的），也是特征和动作整合到一起。

示例2：

学校类：
特征：name,addr,type
动作：考试，招生，开除学生

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author: nulige

 def school(name,addr,type):
     def init(name, addr, type):
         sch = {
             'name': name,
             'addr': addr,
             'type': type,
             'kao_shi': kao_shi,
             'zhao_sheng': zhao_sheng,
         }
         return sch
     def kao_shi(school):
         print('%s 学校正在考试' %school['name'])
     def zhao_sheng(school):
         print('%s %s 正在招生' %(school['type'],school['name']))
     return  init(name,addr,type)

 s1=school('oldboy','沙河','私立学校')
 print(s1)
 print(s1['name'])

 s1['zhao_sheng'](s1)

 s2=school('清华','北京','公立学校')

 print(s2)
 print(s2['name'],s2['addr'],s2['type'])
 s2['zhao_sheng'](s2)

2、面向对象编程

面向对象编程(object-oriented programming):用定义类+实例/对象的方式去实现面向对象的设计

 #用面向对象编程独有的语法class去实现面向对象设计
 class Dog:
     def __init__(self,name,gender,type):   #实例化的过程，就是运行__init__
         self.name=name
         self.gender=gender
         self.type=type

     def bark(self):
         print('一条名字为[%s]的[%s],狂吠不止' %(self.name,self.type))

     def yao_ren(self):
         print('[%s]正在咬人' %(self.name))

     def chi_shi(self):
         print('[%s]正在吃屎' %(self.type))

 dog1=Dog('alex','female','京巴')
 dog2=Dog('wupeiqi','female','腊肠')
 dog3=Dog('yuanhao','female','藏獒')

 dog1.bark()
 dog2.yao_ren()
 dog3.chi_shi()

小结：

　在Python中，类和 OOP 都不是日常编程所必需的。尽管它从一开始设计就是面向对象的,并且结构上支持 OOP,但 Python 没有限定或要求你在你的应用中写 OOP 的代码。

用面向对象语言写程序和一个程序的设计是面向对象的，两者就是两码事。

四、类和对象  

1.什么叫类：类是一种数据结构，就好比一个模型，该模型用来表述一类事物(事物即数据和动作的结合体)，用它来生产真实的物体(实例)。

2.什么叫对象：睁开眼，你看到的一切的事物都是一个个的对象，你可以把对象理解为一个具体的事物(事物即数据和动作的结合体)

(铅笔是对象，人是对象，房子是对象，狗是对象，alex是对象，配齐是对象，元昊是对象)

3.类与对象的关系：对象都是由类产生的，上帝造人，上帝首先有一个造人的模板，这个模板即人的类，然后上帝根据类的定义来生产一个个的人

4.什么叫实例化：由类生产对象的过程叫实例化，类实例化的结果就是一个对象，或者叫做一个实例（实例=对象）

五、类的相关知识

1、初识类

在python中声明函数与声明类很相似。

声明函数

1 def functionName(args):
2      '函数文档字符串'
3       函数体

声明类

 '''
 class 类名:
     '类的文档字符串'
     类体
 '''

 #我们创建一个类
 class Data:
     pass

 #用类Data实例化出一个对象d1
 d1=Data()

经典类与新式类

 大前提：
 1.只有在python2中才分新式类和经典类，python3中统一都是新式类
 2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类
 3.所有类甭管是否显式声明父类，都有一个默认继承object父类（讲继承时会讲，先记住）
 在python2中的区分
 经典类：
 class 类名:
     pass

 经典类：
 class 类名(父类):
     pass

 在python3中，上述两种定义方式全都是新式类

示例：

 #经典类（python2.7)
 class Chinese:
     '这是一个中国人的类'
     pass

 print(Chinese)

 #新式类(python3.0)

 #实例化到底干了什么？
 p1=Chinese() #实例化
 print(p1)

2、属性

类是用来描述一类事物，类的对象指的是这一类事物中的一个个体

是事物就要有属性，属性分为

1：数据属性：就是变量

2：函数属性：就是函数，在面向对象里通常称为方法

注意：类和对象均用点来访问自己的属性

类的属性

理论：数据属性即变量，类的定义与函数又极其类似，其实可以用函数的作用域来理解类的属性调用。

类的数据属性

 #定义一个中文人的类,然后在类中定义一个类的属性,政府是共产堂,这样，只要是中文人他们的党永远都是共产堂
 #类属性又称为静态变量,或者是静态数据。这些数据是与它们所属的类对象绑定的,不依赖于任何类实例。
 #如果你是一位Java或C++程序员,这种类型的数据相当于在一个变量声明前加上static关键字。

 class Chinese:
     government='共产堂'

 print(Chinese.government)

类的函数属性(又称为方法)

 class Chinese:
     government='共产_党'
     def sui_di_tu_tan():
         print('90%的中国人都喜欢随地吐痰')

     def cha_dui(self):
         print('一个中国人-->%s<--插到了前面' %self)

 Chinese.sui_di_tu_tan()

 person1_obj='alex'
 Chinese.cha_dui(person1_obj) #带参函数，所以调用时需要传入参数，将'alex'传给self

查看类属性

我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表

类名.__dict__:查出的是一个字典，key为属性名，value为属性值

 #共有属性，动作（方法）
 class Chinese:
     '这是一个中国人的类'
     dang='共产堂'             #数据属性
     def sui_di_tu_tan():     #函数属性
         print('朝着墙上就是一口痰')
     def cha_dui(self):       #加了self的就必须传一个参数，否则会报错
         print('插到了前面')

 print(Chinese.dang)
 Chinese.sui_di_tu_tan()
 Chinese.cha_dui('元昊')

 # print(dir(Chinese))            #查看系统内置属性
 # print(Chinese.__dict__)        #查看属性字典
 print(Chinese.__dict__['dang'])  #调用数据属性，本身就是在数据属性中找东西
 Chinese.__dict__['sui_di_tu_tan']()  #调用函数属性，有了函数的内存地址，加（），就可以运行
 Chinese.__dict__['cha_dui'](1)       #调用函数属性

执行结果：

 共产堂
 在地上就是一口痰
 插到了前面
 共产堂
 在地上就是一口痰
 插到了前面

特殊的类属性

 class Chinese:
     '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
     government='共产堂'
     def sui_di_tu_tan():
         print('90%的中国人都喜欢随地吐痰')

     def cha_dui(self):
         print('一个中国人-->%s<--插到了前面' %self)

 print(Chinese.__name__)  #类C的名字(字符串)
 print(Chinese.__doc__)   #类C的文档字符串
 print(Chinese.__base__)  #类C的第一个父类(在讲继承时会讲)
 print(Chinese.__bases__) #类C的所有父类构成的元组(在讲继承时会讲)
 print(Chinese.__dict__)  #类C的属性
 print(Chinese.__module__)#类C定义所在的模块
 print(Chinese.__class__) #实例C对应的类(仅新式类中)

六、对象相关知识

　　对象是由类实例化而来，类实例化的结果称为一个实例或者称作一个对象

1.1、实例化

　　什么是实例化？

　　由类生产对象的过程就叫实例化

 class Chinese:
     '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
     government='共产_党'
     def sui_di_tu_tan():
         print('90%的中国人都喜欢随地吐痰')

     def cha_dui(self):
         print('一个中国人-->%s<--插到了前面' %self)

 person1=Chinese() #类名加上括号就是实例化(可以理解为函数的运行,返回值就是一个实例)

 #这就是实例化，只不过你得到的person1实例，没有做任何事情

1.2、构造函数

类是数据属性和函数属性的结合，描述的是一类事物

这类事物的一个具体表现就是一个实例/对象，比方说中国人是一个类，而你就是这个类的一个实例

你除了有中国人这个数据属性外，还应该有名字，年龄，性别等数据属性

如何为实例定制数据属性，可以使用类的一个内置方法__init__()该方法，在类()实例化是会自动执行

 class Chinese:
     '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
     government='共产_党'
     def __init__(self,name,age,gender): #实例化的过程可以简单理解为执行该函数的过程，实例本身会当作参数传递给self（这是默认的步骤）
         self.name=name
         self.age=age
         self.gender=gender

     def sui_di_tu_tan():
         print('90%的中国人都喜欢随地吐痰')

     def cha_dui(self):
         print('一个中国人-->%s<--插到了前面' %self)

 # person1=Chinese() #会报错
                         #自动执行__init__方法,而这个方法需要参数,
                         # 这些参数应该写在类名后面的括号里,然后由类传
                         #给__init__函数,也就说,传给类的参数就是传给__init__的参数

 person1=Chinese('alex',1000,'female')
 person2=Chinese('wupeiqi',10000,'female')
 person3=Chinese('yuanhao',9000,'female')

 print(person1.__dict__)

注意：在说实例化的时候说过，执行类()会自动返回一值，这个值就是实例，而类()会自动执行__init__，所以一定不要在该函数内定义返回值，会冲突。

1.3、实例属性

理论：

1.实例只有数据属性（实例的函数属性严格来说是类的函数属性）

2.del 实例/对象，只是回收了实例的数据属性，函数属性是属于类的，是不会回收。

实例化的过程实际就是执行__init__的过程，这个函数内部只是为实例本身即self设定了一堆数据(变量)，所以实例只有数据属性。

 class Chinese:
     '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
     government='共产_党'
     def __init__(self,name,age,gender):
         self.name=name
         self.age=age
         self.gender=gender

     def sui_di_tu_tan():
         print('90%的中国人都喜欢随地吐痰')

     def cha_dui(self):
         print('一个中国人-->%s<--插到了前面' %self)

 person1=Chinese('alex',1000,'female')
 print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
 print(person1.name,person1.age,person1.gender) #访问实例的数据属性

那么我们想访问实例的函数属性（其实是类的函数属性），如何实现

 class Chinese:
     '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
     government='共产_党'
     def __init__(self,name,age,gender):
         self.name=name
         self.age=age
         self.gender=gender

     def sui_di_tu_tan():
         print('90%的中国人都喜欢随地吐痰')

     def cha_dui(self):
         print('一个中国人-->%s<--插到了前面' %self)

 person1=Chinese('alex',1000,'female')
 print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
 print(Chinese.__dict__)#函数属性只存在于类中
 Chinese.cha_dui(person1)#我们只能通过类去调用类的函数属性,然后把实例当做变量传递给self

改进版本

 class Chinese:
     '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
     government='共产_党'
     def __init__(self,name,age,gender):
         self.name=name
         self.age=age
         self.gender=gender

     def sui_di_tu_tan():
         print('90%的中国人都喜欢随地吐痰')

     # def cha_dui(self):
     #     print('一个中国人-->%s<--插到了前面' %self)

     def cha_dui(self):
         print('一个中国人-->姓名:%s 年龄:%s 性别:%s<--插到了前面' %(self.name,self.age,self.gender))

     def eat_food(self,food):
         print('%s 正在吃 %s' %(self.name,food))

 person1=Chinese('alex',1000,'female')
 print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
 print(Chinese.__dict__)#函数属性只存在于类中
 Chinese.cha_dui(person1)#我们只能通过类去调用类的函数属性,然后把实例当做变量传递给self
 Chinese.eat_food(person1,'韭菜馅饼')

 person1.cha_dui()#其实就是Chinese.cha_dui(person1)
 person1.eat_food('飞禽走兽') #本质就是Chinese.eat_food(person1,'飞禽走兽')

3、实例属性和查看实例属性的方法如下：

同样是dir和内置__dict__两种方式

原理图

示例：

 class Chinese:
     '这是一个中国人的类'

     dang='共产堂'

     def __init__(self,name,age,gender):
         print('我是初始化函数，我开始运行了')
         self.mingz=name     #name,age,gender都封装在self里面
         self.nianji=age     #p1.nianji=age
         self.xingbin=gender #p1.xingbin=gender
         print('我结束啦')

     def sui_di_tu_tan():
         print('在地上就是一口痰')
     def cha_dui(self):
         print(self)
         print('%s 插到了前面' %self)
     #return None (系统默认就是return None,这里不要加return)

 #数据属性
 p1=Chinese('元昊','','female')   #实例化的过程，就是调用__init__
 print(p1.__dict__)       #查看字典属性  #==>{'nianji': '18', 'mingz': '元昊', 'xingbin': 'female'}
 print(p1.mingz)          #p1.nianji=age, 直接调用__init__里面的属性,
 print(p1.dang)           #类的作用域概念，如果__init__里面没有，就去外面那层找，外层找到Class Chinese类字典

 #实例属性没有函数属性，函数属性属于类
 print(Chinese.__dict__)
 Chinese.sui_di_tu_tan()
 Chinese.cha_dui(p1)

 #p1.sui_di_tu_tan()  #class把p1作为参数自动加到sui_di_tu_tan(p1)括号里面，所以会报错。因为是python底层自动加上的。
 p1.cha_dui()         #p1里面没有，但是类里面有，所以能找到

执行结果：

 我是初始化函数，我开始运行了
 我结束啦
 {'mingz': '元昊', 'xingbin': 'female', 'nianji': ''}
 元昊
 共产堂
 {'__init__': <function Chinese.__init__ at 0x0121F0C0>, '__doc__': '这是一个中国人的类', '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, 'sui_di_tu_tan': <function Chinese.sui_di_tu_tan at 0x0121F270>, 'dang': '共产堂', 'cha_dui': <function Chinese.cha_dui at 0x0121F228>, '__dict__': <attribute '__dict__' of 'Chinese' objects>}
 在地上就是一口痰
 <__main__.Chinese object at 0x01681210>
 <__main__.Chinese object at 0x01681210> 插到了前面
 <__main__.Chinese object at 0x01681210>
 <__main__.Chinese object at 0x01681210> 插到了前面
 China
 Japan
 {'name': 'alex'}
 {'__init__': <function Chinese.__init__ at 0x0121F108>, 'dang': '共产堂', '__module__': '__main__', 'play_ball': <function Chinese.play_ball at 0x0121F198>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, 'country': 'Japan', '__doc__': None, '__dict__': <attribute '__dict__' of 'Chinese' objects>}
 共产堂
 {'__init__': <function Chinese.__init__ at 0x0121F108>, '__module__': '__main__', 'play_ball': <function Chinese.play_ball at 0x0121F198>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None, '__dict__': <attribute '__dict__' of 'Chinese' objects>}
 {'__init__': <function Chinese.__init__ at 0x0121F108>, '__module__': '__main__', 'play_ball': <function Chinese.play_ball at 0x0121F198>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None, 'eat': <function eat_food at 0x011F2F60>, '__dict__': <attribute '__dict__' of 'Chinese' objects>}
 alex 正在吃虾
 test

1.4、特殊实例属性

__class__

__dict__

 class Chinese:
     '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
     government='共产_党'
     def __init__(self,name,age,gender):
         self.name=name
         self.age=age
         self.gender=gender

     def sui_di_tu_tan():
         print('90%的中国人都喜欢随地吐痰')

     # def cha_dui(self):
     #     print('一个中国人-->%s<--插到了前面' %self)

     def cha_dui(self):
         print('一个中国人-->姓名:%s 年龄:%s 性别:%s<--插到了前面' %(self.name,self.age,self.gender))

     def eat_food(self,food):
         print('%s 正在吃 %s' %(self.name,food))

 person1=Chinese('alex',1000,'female')

 print(person1.__class__)
 print(Chinese)

 person2=person1.__class__('xiaobai',900,'male')
 print(person2.name,person2.age,person2.gender)

警告：类和对象虽然调用__dict__返回的是一个字典结构，但是千万不要直接修改该字典，会导致你的oop不稳定。

1.5、类属性与对象(实例)属性

1、类属性的增、删、改、查

 class Chinese:
     country='China'
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name))

 #查看
 print(Chinese.country)

 #修改
 Chinese.country='Japan'
 print(Chinese.country)

 p1=Chinese('alex')
 print(p1.__dict__)   #从类的字典里面去找，上面已经修改过了，所以是Japan

 #增加
 Chinese.dang='共产堂'

 #printChinese.dang)
 #print(p1.dang)

 #删除
 del Chinese.dang
 del Chinese.country

 print(Chinese.__dict__)
 #print(Chinese.country)

 #给类增加一个函数属性
 def eat_food(self,food):   #定义了一个函数，
     print('%s 正在吃%s' %(self.name,food))

 Chinese.eat=eat_food

 print(Chinese.__dict__)
 p1.eat('虾')    #给函数属性传参数

 #增加
 def test(self):
     print('test')

 Chinese.play_ball=test
 p1.play_ball()  #Chinese.play_ball(p1)

执行结果：

 China

 Japan

 {'name': 'alex'}

 {'play_ball': <function Chinese.play_ball at 0x01558108>, '__init__': <function Chinese.__init__ at 0x01085660>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Chinese' objects>}

 {'play_ball': <function Chinese.play_ball at 0x01558108>, '__init__': <function Chinese.__init__ at 0x01085660>, '__doc__': None, 'eat': <function eat_food at 0x01532F60>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Chinese' objects>}

 alex 正在吃虾

 test

2、实例属性的增、删、改、查

 class Chinese:
     country='China'
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))
 p1=Chinese('alex')
 print(p1.__dict__)

 #查看
 # print(p1.name)
 # print(p1.play_ball)

 #增加
 p1.age=18
 print(p1.__dict__)
 print(p1.age)

 #不要修改底层的属性字典
 # p1.__dict__['sex']='male'
 # print(p1.__dict__)
 # print(p1.sex)

 #修改
 p1.age=19
 print(p1.__dict__)
 print(p1.age)

 #删除
 del p1.age
 print(p1.__dict__)

执行结果：

 {'name': 'alex'}

 {'age': 18, 'name': 'alex'}
 18

 {'age': 19, 'name': 'alex'}
 19

 {'name': 'alex'}

1.其实你会发现，实例化就是 类名()，然后返回的结果是一个对象，加上括号是不是跟函数运行很像，函数运行完了有返回值，是不是很像，没错，就是一样的。

2.函数又作用域的概念，其实类也有作用域的概念，二者一样

3.你可以把class当做最外层的函数，是一个作用域

 #定义一个类，只当一个作用域去用，类似于c语言中的结构体
 class MyData:
     pass

 x=10
 y=20
 MyData.x=1
 MyData.y=2

 print(x,y)
 print(MyData.x,MyData.y)
 print(MyData.x+MyData.y)

4.实例化会自动触发init函数的运行，最后返回一个值即实例，我们要找的实例属性就存放在init函数的局部作用域里

5.类有类的属性字典，就是类的作用域，实例有实例的属性字典，即实例的作用域

6.综上，一个点代表一层作用域，obj.x先从自己的作用域找，自己找不到去外层的类的字典中找，都找不到，就会报错

7.在类中没有使用点的调用，代表调用全局变量。

上面知识应用：

示例1：

 class Chinese:
     country='China'
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))

 p1=Chinese('alex')
 print(p1.country)                 #访问的是类的
 p1.country='日本'                  #把country改成日本
 print('类的--->',Chinese.country)  #类的---> China
 print('实例的',p1.country)         #在类的字典里，新增了一个p1.country='日本'。所以发果是：实例的 日本

示例2：

 country='中国'
 class Chinese:
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))

 p1=Chinese('alex')
 # print(p1.country)   #p1.country就是在类里面找，找不到就报错。

示例3：

 country='中国'
 class Chinese:
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))

 #另外定义一个函数，接收输入
 def shi_li_hua():
     name=input('>>: ')
     p1=Chinese(name)
     # print(p1.country)
     print(p1.name)
 shi_li_hua()

示例4：

 country='中华人民共和国'
 class Chinese:
     country='中国'

     def __init__(self,name):
         self.name=name
         print('--->',country)  #即不是类的属性，也不是实例的属性。所以他就是变量的直接赋值

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))

 p1=Chinese('alex')             #打印出来的值是变量， ---> 中华人民共和国

示例5：

 country='中国'        #从外面去找
 class Chinese:
     country='中国'
     def __init__(self,name):
         self.name=name
         print('--->',country)  #即不是类的属性，也不是实例的属性。所以他就是变量

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))

 #调用实例数据属性的两种方法如下：

 #用.的方式调用：
 print(Chinese.__dict__)
 print(Chinese.country)

 结果：
 ---> 中国

 #通过实例调用
 p1=Chinese('alex')
 print('实例--------》',p1.country)

 结果：
 实例--------》 中国

总结：

.的方式调用的是属性，要么跟类有关，要么跟实例有关

不加.就跟类没关，跟实例没关。

示例1：

 class Chinese:
     country='China'
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))
 p1=Chinese('alex')

 print(p1.country)    #打印的就是country本身
 p1.country='Japan'   #增加了一个实例，类本身不会更改
 print(Chinese.country)

示例2：

 class Chinese:
     country='China'
     l=['a','b']
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))

 p1=Chinese('alex')
 print(p1.l)        #p1本身自己没有，找的就是类，所以打印出来的值就是：['a', 'b']

 p1.l=[1,2,3]
 print(Chinese.l)   #l 的值不会变，因为他是在1里面加入了一个新的字典。结果：['a', 'b']
 print(p1.__dict__) #因为他是在1里面加入了一个新的字典。结果：{'l': [1, 2, 3], 'name': 'alex'}

示例3：

 class Chinese:
     country='China'
     l=['a','b']
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print('%s 正在打 %s' %(self.name,ball))

 p1=Chinese('alex')
 print(p1.l)          #p1本身自己没有，找的就是类，所以打印出来的值就是：['a', 'b']

 p1.l.append('c')     #这不是在赋值和给实例新增属性。执行结果：['a', 'b']
 print(p1.__dict__)   #执行结果：{'name': 'alex'}
 print(Chinese.l)     #改的就是类里面的东西，所以直接增加进去了。执行结果：['a', 'b', 'c']

理论 ：类的作用域即函数作用域

七、静态属性、类方法、静态方法

1、静态属性

作用就是：封装逻辑，把函数属性封装成数据属性

 class Room:
     def __init__(self,name,owner,width,length,heigh):
         self.name=name
         self.owner=owner
         self.width=width
         self.length=length
         self.heigh=heigh

     @property     #静态属性
     def cal_area(self):     #计算面积
         return self.width * self.length

     @property
     def cal_volume(self):    #计算体积
         return self.width * self.length * self.heigh

 r1=Room('厕所','alex',1000,100,100000)
 r2=Room('公共厕所','yuanhao',1,1,1)
 r3=Room('主人房','nulige',10,10,10)

 print(r1.cal_area)
 print(r2.cal_area)
 print(r3.cal_volume)
 print(r1.name)
 print(r2.name)
 print(r3.name)

执行结果：

 100000
 1
 1000
 厕所
 公共厕所
 主人房

2、类方法

类方法作用：专门给类使用与实例无关，类方法只能访问类相关属性，不能访问实例属性（跟实例没有任何关系）

 class Room:
     tag=1
     def __init__(self, name, owner, width, length, heigh):
         self.name = name
         self.owner = owner
         self.width = width
         self.length = length
         self.heigh = heigh

     @property
     def cal_area(self):
         return self.width * self.length

     @classmethod     #classmethod类方法只是给类使用(不管是否存在实例)，只能访问实例变量

 def tell_info(cls,x):  print(cls)  print('---->',cls.tag)   Room.tell_info(1)

执行结果:

 <class '__main__.Room'>
 ----> 1

3、静态方法

 '''
 staticmethod静态方法只是名义上的归属类管理，不能使用类变量和实例变量,是类的工具包
 '''

 class Room:
     def __init__(self,name,owner,width,length):
         self.name=name
         self.owner=owner
         self.width=width
         self.length=length

     @property
     def cal_area(self):
         return self.width * self.length

     @staticmethod    #类的工具包，不跟类绑定，也不跟实例绑定（无法调用实例的东西）

 def wash_body():  print('洗刷刷,洗刷刷')   def test():  print('这可不是静态方法,用类调用没问题,你用一个实例调用看看')   Room.wash_body()   r1=Room('厕所','alex',10,10)  r1.wash_body()     #------  Room.test()  r1.test() #会报错,因为如果test不是静态方法,那么r1会吧自己传给test的第一个参数self,test无参所以报错   静态方法

八、组合

一、组合的组成部分

定义一个人的类，人有头，驱赶，手，脚等数据属性，这几个属性又可以是通过一个类实例化的对象，这就是组合

简单理解：就是大类包含小类，就是组合。

用途：

1：做关联

2：小的组成大的

 class Hand:
     pass

 class Foot:
     pass

 class Trunk:
     pass

 class Head:
     pass

 class Person:
     def __init__(self,id_num,name):
         self.id_num=id_num  #身份证号码
         self.name=name
         self.hand=Hand()
         self.foot=Foot()
         self.trunk=Trunk()
         self.head=Head()

 p1=Person('','alex')  #给实例传值
 print(p1.__dict__)          #查看实例的属性字典

执行结果：

 {'foot': <__main__.Foot object at 0x011B4130>, 'trunk': <__main__.Trunk object at 0x011B4170>, 'id_num': '', 'hand': <__main__.Hand object at 0x011B40D0>, 'name': 'alex', 'head': <__main__.Head object at 0x011B4190>}

二、选课系统

示例1：

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author: nulige

 #选课系统

 #一种很LOW的关联方法:
 class School:
     def __init__(self,name,addr):
         self.name=name
         self.addr=addr
         self.course_list=[]

     def zhao_sheng(self):
         print('%s 正在招生' %self.name)

 class Course:
     def __init__(self,name,price,period):
         self.name=name
         self.price=price
         self.period=period

 s1=School('oldboy','北京')
 s2=School('oldboy','上海')
 s3=School('oldboy','天津')

 c1=Course('linux',5800,'1h')
 c2=Course('python',9800,'1h')

 s1.course_list.append(c1)
 s1.course_list.append(c2)
 print(s1.__dict__)    #打印字典属性

 for course_obj in s1.course_list:
     print(course_obj.name,course_obj.price)

执行结果：

 {'course_list': [<__main__.Course object at 0x01984190>, <__main__.Course object at 0x019841B0>], 'name': 'oldboy', 'addr': '北京'}

 linux 5800
 python 9800

示例2：

用组合的方式实现

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author: nulige

 class School:
     def __init__(self,name,addr):
         self.name=name
         self.addr=addr

     #招生
     def zhao_sheng(self):
         print('%s 正在招生' %self.name)

 class Course:
     def __init__(self,name,price,period,school):
         self.name=name
         self.price=price
         self.period=period
         self.school=school

 s1=School('oldboy','北京')
 s2=School('oldboy','上海')
 s3=School('oldboy','天津')

 # c1=Course('linux',5800,'1h','oldboy北京')
 # c1=Course('python',9800,'1h',s1 )

 msg='''
 1 老男孩 北京校区
 2 老男孩 上海校区
 3 老男孩 天津校区
 '''
 while True:
     print(msg)
     menu={
         '':s1,
         '':s2,
         '':s3,
     }

     choice=input('请选择学校：')
     school_obj=menu[choice]
     name=input('课程名: ')
     price=input('课程费用: ')
     period=input('课程周期: ')
     new_course=Course(name,price,period,school_obj)
     print('课程[%s] 属于[%s] 学校' %(new_course.name,new_course.school.name))

执行结果：

 1 老男孩 北京校区
 2 老男孩 上海校区
 3 老男孩 天津校区

 请选择学校：1
 课程名: python
 课程费用: 9800
 课程周期: 1h
 课程[python] 属于[oldboy] 学校

 1 老男孩 北京校区
 2 老男孩 上海校区
 3 老男孩 天津校区

 请选择学校：

九、面向对象三大特性

什么是类的继承？

类的继承跟现实生活中的父、子、孙子、重孙子、继承关系一样，父类又称为基类。

python中类的继承分为：单继承和多继承

1、继承

 class ParentClass1:
     pass

 class ParentClass2:
     pass

 class SubClass(ParentClass1): #单继承
     pass

 class SubClass(ParentClass1,ParentClass2): #多继承
     pass

2、子继承到底继承了父类的什么属性？

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author: nulige

 #继承
 class Dad:
     '这个是爸爸类'
     money=10
     def __init__(self,name):
         print('爸爸')
         self.name=name

     def hit_son(self):
         print('%s 正在打儿子' %self.name)

     '这个是儿子类'
 class Son(Dad):
     money = 10000000000000

 s1=Son('alex')  #继承父类的属性

 print(s1.money) 
 print(Dad.money)
 # print(Dad.__dict__) 
 # print(Son.__dict__)

执行结果：

 爸爸
 10000000000000
 10

3、什么时候用继承？

1.当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

例如：描述一个机器人类，机器人这个大类是由很多互不相关的小类组成，如机械胳膊类、腿类、身体类、电池类

2.当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好

例如

　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，如下所示：

 class 猫：

     def 喵喵叫(self):
         print '喵喵叫'

     def 吃(self):
         # do something

     def 喝(self):
         # do something

     def 拉(self):
         # do something

     def 撒(self):
         # do something

 class 狗：

     def 汪汪叫(self):
         print '汪汪叫'

     def 吃(self):
         # do something

     def 喝(self):
         # do something

     def 拉(self):
         # do something

     def 撒(self):
         # do something

上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝、拉、撒

　　   猫：喵喵叫（猫继承动物的功能）

　　   狗：汪汪叫（狗继承动物的功能）

伪代码方式实现示例：

 class 动物:

     def 吃(self):
         # do something

     def 喝(self):
         # do something

     def 拉(self):
         # do something

     def 撒(self):
         # do something

 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
 class 猫(动物)：

     def 喵喵叫(self):
         print '喵喵叫'

 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
 class 狗(动物)：

     def 汪汪叫(self):
         print '汪汪叫'

用继承的方式实现示例：

 class Animal:

     def eat(self):
         print("%s 吃 " %self.name)

     def drink(self):
         print ("%s 喝 " %self.name)

     def shit(self):
         print ("%s 拉 " %self.name)

     def pee(self):
         print ("%s 撒 " %self.name)

 class Cat(Animal):

     def __init__(self, name):
         self.name = name
         self.breed = '猫'

     def cry(self):
         print('喵喵叫')

 class Dog(Animal):

     def __init__(self, name):
         self.name = name
         self.breed='狗'

     def cry(self):
         print('汪汪叫')

 # ######### 执行 #########

 c1 = Cat('小白家的小黑猫')
 c1.eat()

 c2 = Cat('小黑的小白猫')
 c2.drink()

 d1 = Dog('胖子家的小瘦狗')
 d1.eat()

3、继承同时具有两种含义

含义一.继承基类的方法，并且做出自己的改变或者扩展（代码重用）

含义二.声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法

归一化式继承方式实现示例：

 #接口继承

 import abc
 class All_file(metaclass=abc.ABCMeta):
     @abc.abstractmethod  #就是一种规范
     def read(self):
         pass

     @abc.abstractmethod   #装饰器
     def write(self):
         pass

 class Disk(All_file):
     def read(self):
         print('disk read')

     def write(self):
         print('disk write')

 class Cdrom(All_file):
     def read(self):
         print('cdrom read')

     def write(self):
         print('cdrom write')

 class Mem(All_file):
     def read(self):
         print('mem read')

     def write(self):
         print('mem write')

 m1=Mem()
 m1.read()
 m1.write()

执行结果：

 mem read
 mem write

1、实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

2、继承的第二种含义非常重要。它又叫“接口继承”。

接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

3、归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合，就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

4、继承顺序

继承在Python不同版本中是有区别的。

python3: 新式类

pyhon2: 新式类与经典类

新式类示例：

 #继承顺序就是mro列表定义的顺序

 class A:
     def test(self):
         print(' A')

 class B(A):
     def test(self):
         print(' B')

 class C(A):
     def test(self):
         print(' C')

 class D(B):
     def test(self):
         print(' D')

 class E(C):
     def test(self):
         print(' E')

 class F(D,E):
     # def test(self):
     #     print(' F')
     pass
 f1=F()
 f1.test()
 print(F.__mro__) #python2中没有这个属性

 #新式类继承顺序:F->D->B->E->C->A
 #经典类继承顺序:F->D->B->A->E->C

经典类示例

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author: nulige
 class A:
     def test(self):
         print('A')
     pass

 class B(A):
     def test(self):
         print('B')
     pass

 class C(A):
     def test(self):
         print('C')
     pass

 class D(B):
     def test(self):
         print('D')
     pass

 class E(C):
     def test(self):
         print('E')
     pass

 class F(D,E):
     def test(self):
         print('F')
     pass
 f1=F()
 f1.test()   #经典类：F->D->B->A-->E-->C

执行结果：

 F->D->B->A-->E-->C

总结：

1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

5、子类中调用父类方法

　　子类继承了父类的方法，然后想进行修改，注意了是基于原有的基础上修改，那么就需要在子类中调用父类的方法

方法一：父类名.父类方法()   ===>相当于在子类中调用父类的方法

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author: nulige
 #子类中调用父类的方法
 class Vehicle:
     Country='China'

     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('开动啦')
         print('开动啦')

 class Subway(Vehicle):
         def __init__(self,name,speed,load,power,line):
             Vehicle.__init__(self,name,speed,load,power)
             self.line=line

         def show_info(self):
             print(self.name,self.speed,self.load,self.power,self.line)

         def run(self):
             Vehicle.run(self)
             print('%s %s 线，开动啦' %(self.name,self.line))
 line13=Subway('北京地铁','100m/s',1000000,'电',13)

 line13.show_info()

 line13.run()

执行结果：

 北京地铁 100m/s 1000000 电 13
 开动啦
 开动啦
 北京地铁 13 线，开动啦

方法二：用super方法

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author: nulige

 class Vehicle:
     Country = 'China'

     def __init__(self, name, speed, load, power):
         self.name = name
         self.speed = speed
         self.load = load
         self.power = power

     def run(self):
         print('开动啦')
         print('开动啦')

 class Subway(Vehicle):
     def __init__(self, name, speed, load, power, line):
         #super用法，传参数和不传参数是一样的
         super().__init__(name, speed, load, power)              #这两个作用是一样的，一个不传参数
         #super(Subway,self).__init__(name, speed, load, power)  #这两个作用是一样的，一个传参数，
         self.line = line

     def show_info(self):
         print(self.name, self.speed, self.load, self.power, self.line)

     def run(self):
         super().run()   #用super的方法
         print('%s %s 线，开动啦' % (self.name, self.line))

 line13 = Subway('北京地铁', '100m/s', 1000000, '电', 13)
 line13.show_info()
 line13.run()

十、多态

多态：表明了动态绑定的存在，调用了不同的方法。才能展示出来。反映的是运行时候的状态。

什么是多态?

由不同的类实例化得到的对象，调用同一个方法，执行的逻辑不同。

示例1：

 s1='abc'
 l=[1,2]
 s1.__len__()
 l.__len__()

示例2：

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author: nulige

 class H2O:
     def __init__(self,name,temperature):  #名字，温度
         self.name=name
         self.temperature=temperature
     def turn_ice(self):
         if self.temperature < 0:
             print('[%s]温度太低结冰了' %self.name)
         elif self.temperature >0 and self.temperature < 100:
             print('[%s]液化成水' % self.name)
         elif self.temperature > 100:
             print('[%s]温度太高变成了水蒸气' % self.name)

 class Water(H2O):  #继承父类（H2O)
     pass

 class Ice(H2O):
     pass

 class Steam(H2O):
     pass

 w1 = Water('水', 25)
 i1 = Ice('冰', -20)
 s1 = Steam('蒸汽', 3000)

 def func(obj):
     obj.turn_ice()

 func(w1)   #---->w1.turn_ice()
 func(i1)   #---->i1.turn_ice()
 func(s1)   #---->s1.turn_ice()

执行结果：

 [水]液化成水
 [冰]温度太低结冰了
 [蒸汽]温度太高变成了水蒸气

面向对象三大特性，封装，多态，继承其实这种逻辑是错的，但很多人都这么说。

类的继承有两层意义：1.改变 2.扩展

1、多态就是类的这两层意义的一个具体的实现机制
3、调用不同的类实例化得对象下的相同的方法，实现的过程不一样。
4、python中的标准类型就是多态概念的一个很好的示范 。

十一、封装                                                                                                                                                                

封装是啥，抛开面向对象，你单去想什么是装，装就是拿来一个麻袋，把小猫，小狗，小王八，还有alex一起装进麻袋，什么是封，封就是把麻袋封上口子。

在面向对象中这个麻袋就是你的类或者对象，类或者对象这俩麻袋内部装了数据属性和函数属性，那么对于类和对象来说‘封’的概念从何而来，其实封的概念代表隐藏。

 

约定一:任何以单下划线开头的名字都应该是内部的,私有的。

示例1

 class People:
     _star='earth'   #以单_线开头的，就是隐藏属性（外部看不到他）
     __star='earth1111111111111111'  #python会自动重命名

     def __init__(self,id,name,age,salary):
         self.id=id
         self.name=name
         self._age=age
         self._salary=salary

     def _get_id(self):
         print('我是私有方法啊,我找到的id是[%s]' %self.id)

 # print(People.__dict__)

 #封装使用者，看不到里面使用的逻辑
 p1=People('','alex','',1000000000)
 print(p1._star)

执行结果：

 earth

　　python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的。

　　其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的，作为外部的你，仍然可以用。

约定二：双下划线开头的名字

 　　双下划线开头的属性在继承给子类时，子类是无法覆盖的（原理也是基于python自动做了双下滑线开头的名字的重命名工作）

示例2：

 class People:
     __star='earth1111111111111111'  #python会自动重命名
     def __init__(self,id,name,age,salary):
         self.id=id
         self.name=name
         self._age=age
         self._salary=salary

     def _get_id(self):
         print('我是私有方法啊,我找到的id是[%s]' %self.id)

 #封装使用者，看不到里面使用的逻辑
 p1=People('','alex','',1000000000)
 print(p1._People__star)

执行结果：

 earth1111111111111111

第三个层面的封装：明确区分内外，内部的实现逻辑，外部无法知晓，并且为封装到内部的逻辑提供一个访问接口给外部使用。（这才是真正的封装。）

 class People:
     __star='earth'
     def __init__(self,id,name,age,salary):
         self.id=id
         self.name=name
         self.__age=age
         self._salary=salary

     def _get_id(self):
         print('我是私有方法啊,我找到的id是[%s]' %self.id)

 class Korean(People):
     __star = '火星'
     pass

 print(People.__dict__)#__star存到类的属性字典中被重命名为_People__star
 print(Korean.__dict__)

 # print(Korean.__star)#傻逼,这么访问当然报错啦,__star被重命名了,忘记了?

 print(Korean._Korean__star)
 print(Korean._People__star)

 双下划线开头在继承中的应用

总结：

上面提到有两种不同的编码约定（单下划线和双下划线 ）来命名私有属性,那么问 题就来了:到底哪种方式好呢?大多数而言,你应该让你的非公共名称以单下划线开 头。但是,如果你清楚你的代码会涉及到子类,并且有些内部属性应该在子类中隐藏 起来,那么才考虑使用双下划线方案。 但是无论哪种方案，其实python都没有从根本上限制你的访问。

十二、面向对象的优点

从编程进化论我们得知，面向对象是一种更高等级的结构化编程方式，它的好处就两点

1：通过封装明确了内外，你作为类的缔造者，你是上帝，上帝造物的逻辑你无需知道（你知道了你tm也成上帝了），上帝想让你知道的你才能知道，这样就明确了划分了等级，物就是调用者，上帝就是物的创造者

2：通过继承+多态在语言层面支持了归一化设计

注意：不用面向对象语言（即不用class），一样可以做归一化（如老掉牙的泛文件概念、游戏行业的一切皆精灵），一样可以封装（通过定义模块和接口），只是用面向对象语言可以直接用语言元素显式声明这些而已；而用了面向对象语言，满篇都是class，并不等于就有了归一化的设计。甚至，因为被这些花哨的东西迷惑，反而更加不知道什么才是设计

十三、Python中关于常用的OOP术语  

抽象/实现

抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而实现这种模型。抽象不仅包括这种模型的数据属性,还定义了这些数据的接口。

对某种抽象的实现就是对此数据及与之相关接口的现实化(realization)。现实化这个过程对于客户 程序应当是透明而且无关的。

封装/接口

封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数。通过任何客户端直接对数据的访问,无视接口,与封装性都是背道而驰的,除非程序员允许这些操作。作为实现的 一部分,客户端根本就不需要知道在封装之后,数据属性是如何组织的。在Python中,所有的类属性都是公开的,但名字可能被“混淆”了,以阻止未经授权的访问,但仅此而已,再没有其他预防措施了。这就需要在设计时,对数据提供相应的接口,以免客户程序通过不规范的操作来存取封装的数据属性。

注意：封装绝不是等于“把不想让别人看到、以后可能修改的东西用private隐藏起来”

真正的封装是，经过深入的思考，做出良好的抽象，给出“完整且最小”的接口，并使得内部细节可以对外透明

（注意：对外透明的意思是，外部调用者可以顺利的得到自己想要的任何功能，完全意识不到内部细节的存在）

合成

合成扩充了对类的 述,使得多个不同的类合成为一个大的类,来解决现实问题。合成 述了 一个异常复杂的系统,比如一个类由其它类组成,更小的组件也可能是其它的类,数据属性及行为, 所有这些合在一起,彼此是“有一个”的关系。

派生/继承/继承结构

派生描述了子类衍生出新的特性,新类保留已存类类型中所有需要的数据和行为,但允许修改或者其它的自定义操作,都不会修改原类的定义。
继承描述了子类属性从祖先类继承这样一种方式
继承结构表示多“代”派生,可以述成一个“族谱”,连续的子类,与祖先类都有关系。

泛化/特化

基于继承
泛化表示所有子类与其父类及祖先类有一样的特点。
特化描述所有子类的自定义,也就是,什么属性让它与其祖先类不同。

多态

多态的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。

多态表明了动态(又名,运行时)绑定的存在,允计重载及运行时类型确定和验证。

举例：

水是一个类

不同温度，水被实例化成了不同的状态：冰，水蒸气，雾（然而很多人就理解到这一步就任务此乃多态，错，fuck！，多态是运行时绑定的存在）

(多态体现在由同一个类实例化出的多个对象，这些对象执行相同的方法时，执行的过程和结果是不一样的)

冰，水蒸气，雾，有一个共同的方法就是变成云，但是冰.变云(),与水蒸气.变云()是截然不同的两个过程，虽然调用的方法都一样

自省/反射

自省也称作反射，这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。还有那些特殊属性,像__dict__,__name__及__doc__