铁乐学python_day18-19_面向对象编程1

以下笔记绝大部分（百分之80或以上）摘自我的授课老师之一：老男孩教育中的景老师。

她上课讲的知识点由浅入深，引人入胜，听她的课完全不会感觉到困阿，而且不知不觉中就感觉掌握了。

她的博客是：

http://www.cnblogs.com/Eva-J/

由于面向对象编程是一门思想，目前的我还并没有能力直接转化成自已的语言去组织浅显地讲述出来，而且学习的时间也紧迫，

并不允许过多的去研究。故有鉴于此，后面的学习笔记大多会以整理转摘为主！

面向过程 VS 面向对象

面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，

面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：

极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

缺点是：

一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

应用场景：

一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象的程序设计的核心是对象（上帝式思维），

要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。

面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的属性和方法），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙互相缠斗着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

面向对象的程序设计的

优点：

解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：

可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

应用场景：

需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

在python 中面向对象的程序设计并不是全部。

面向对象编程可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，

另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

了解一些名词：类、对象、实例、实例化

类：具有相同特征的一类事物

对象（实例）：具体的某一个事物

实例化：类——>对象的过程

在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，

对象是则是这一类事物中具体的一个。

面向对象编程

类的概念 ： 具有相同属性和技能的一类事物

例：人类 抽象

对象 ： 就是对一个类的具体的描述

例：具体的人 具体

使用面向对象的好处：

1 使得代码之间的角色关系更加明确

2 增强了代码的可扩展性

3 规范了对象的属性和技能

面向对象的特点：结局的不确定性

创建一个类：

类名的作用：
1:引用静态变量（静态属性）
        1）类名.__dict__['静态变量名'] 可以查看，但是不能删改
        2）类名.静态变量名 直接就可以访问,可以删改.删除一个静态变量 del 类名.静态变量名

接上例：
# 引用静态变量（静态属性）
print(Preson.role)
print(Preson.__dict__['role'])
# 类名.静态属性名 等同于 类名.__dict__['静态属性名'］
# 且前者使用起来比后者优雅简单多了，所以以后要用到的时候统一使用前者的格式。
print(Preson.money)
Preson.money = 1000  # 类名.静态变量名，直接可以修改和进行删除
print(Preson.money)

person
person
0
1000

2:引用动态变量（动态属性）
        1）类名.方法名  查看这个方法的内存地址
        2）类名.方法名(实参)  调用了这个方法，必须传一个实参，这个实参传给了self

关于self
self：在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字，但是正常人都不会这么做。因为你瞎改别人就不认识。

接上例：
# 实例化给人与狗各创造一个对象
tiele = Person('tiele', '男', 31, 10, )
xiaobai = Dog('小白', '金毛寻回犬', 38, 15)

# 类名.方法名，查看内存地址
print(Person.attack)

# 类名.方法名(实参),调用此方法
Person.attack(tiele, xiaobai)

#　ｐｒｉｎｔ输出
<function Person.attack at 0x0000000000DD5510>
tiele 对 小白 发起了一次攻击
造成了 10 点伤害
小白 还余 28 HP

实例化的过程：
    1.创造一个实例,此实例将会作为一个实际参数。
    2.自动触发一个__init__的方法，并且把实例以参数的形式传递给__init__方法中的self形参。
    3.执行完__init__方法之后，会将self自动返回给你定义的对象名。

# __init__方法 ：初始化方法，给一个对象添加一些基础属性的方法，一般情况下是针对self的赋值。

对象
    在类的内部 self是本类的一个对象。
    在类的外部，每一个对象都对应着一个名字，这个对象指向一个对象的内存空间。
对象是关于类而实际存在的一个例子，即实例
对象/实例只有一种作用：属性引用
当然了，你也可以引用一个方法，因为方法也是一个属性，只不过是一个类似函数的属性，我们也管它叫动态属性。
引用动态属性并不是执行这个方法，要想调用方法和调用函数是一样的，都需要在后面加上括号。

属性的调用：
对象名.属性名               第一种调用方法
对象名.__dict__['属性名']   第二种调用方法
接上例：
print(tiele.name)  # 输出 tiele
print(tiele.__dict__['sex'])  #输出 男

方法的调用 ：
类名.方法名(对象名)  # 那么方法中的self参数就指向这个对象
对象名.方法名()      # 这样写 相当于方法中的self参数直接指向这个对象

接上例：
# 类名.方法名(对象名)
Person.attack(tiele, xiaobai)
# 对象名.方法名()
tiele.attack(xiaobai)

# 显示如下：
tiele 对 小白 发起了一次攻击
造成了 10 点伤害
小白 还余 28 HP
tiele 对 小白 发起了一次攻击
造成了 10 点伤害
小白 还余 18 HP

对象的内存空间里: 只存储对象的属性，而不存储方法和静态属性。
方法和静态属性都存储在类的内存空间中,为了节省内存，让多个对象去共享类中的资源。

对象属性是独有的，静态属性和方法是共享的。
对象使用名字：先找自己内存空间中的，再找类的内存空间中的。

类名.静态变量名 ：对于静态属性的修改，应该使用类名直接修改。
接上例：
print(Person.money)
Person.money = 1000
print(Person.money)

# 显示
0
1000

程序的解耦
    1） 当计算的规模足够大的时候 我们应该在编码的过程当中让操作尽量原子化。
    2） 尽量用返回值来代替print。

类属性的补充：
一：我们定义的类的属性到底存到哪里了？
有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

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

类命名空间与对象、实例的命名空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性。

而类有两种属性：静态属性和动态属性

静态属性就是直接在类中定义的变量

动态属性就是定义在类中的方法

其中类的数据属性是共享给所有对象的，而类的动态属性是绑定到所有对象的。

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性。

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常。

后面的内容请接着看面向对象编程2的博文笔记

【end】