python之路---面向对象编程思想及类

编程思想：

    1：面向机器编程

          机器语言以及汇编语言都是面向机器编程，以最原始的二进制以及英文字符去直接操作计算机硬件，虽然执行效率极高，但是开发效率低下，且出错率高

    2：面向过程编程：

          从解决问题的步骤角度出发，先干什么，后干什么，好似一条流水线生产，将复杂的问题流程化，从而简单化，但是面条式的程序，扩展性不高

    3：结构化程序设计：采用子程序，代码块，for循环，while循环来代替面向过程语言中的goto，以避免面条式的代码出现

    4:面向对象编程：核心是对象二字，是一种上帝式的思维方式，就好比在创造世界(一切皆是对象)，扩展性高，但是编程复杂度要高于面向过程

 什么是对象：对象是特征和功能的结合体，如桌子这个对象，特征是四四方方(当然也可能是圆的...)，功能是吃饭的时候放菜等等...

 什么是类：类是一系列对象相同特征与技能的结合体，如人是对象，而人类即类

  注意：在现实世界中是现有对象才有类这个概念的，而在python中先有类，才有对象

   定义类：

 class Information:    #使用骆驼峰风格
     name = 'bob'

     def func(self):
         print('python')

在定义类的过程中就开始执行类体代码(与函数不同)，并创建了类的名称空间，将执行类体代码过程中产生的名字存放于该空间(这里是name:指向‘bob’的内存地址，func：指向函数体的内存地址)，可以说类的本质就是名称空间，用于存放类的属性(可以将其分为：数据属性和函数属性---来源于egon老师)

我们可以通过类名.__dict__查看类下的属性

我们可以对类的名字(属性)进行增/删/改/查：

# print(Information.name) --->查

# Information.name='tom'
# print(Information.name) --->改

# Information.job = 'PHP'
# print(Information.job)  --->增

# del Information.name
# print(Information.name) --->删

 在类内定义的函数是类的属性，类可以调用(就是调用普通函数，所以得遵循函数的调用原则，没有自动传值一说)

#--->是function

调用类的过程叫做类的实例化，实例化的结果是产生类的对象/类的实例

a = Information()
b = Information()
c = Information()
print(a)
print(b)
print(c)

#<__main__.Information object at 0x031936D0>
#<__main__.Information object at 0x031937B0>
#<__main__.Information object at 0x031937D0>

 产生三个不同的对象，其本质仍然是名称空间，这三个对象拥有相同的特征与功能（这些共有属性存放在类这个名称空间中），而自己独有的属性存放在自己的名称空间中

class Information:    #使用骆驼峰风格
    name = 'bob'

    def func(self):
        print('python')

a = Information()
b = Information()
c = Information()
print(a.__dict__)
a.job = 'python'
b.job = 'JAVA'
print(a.name,b.name,c.name)
print(a.job,b.job)
--->
{}
bob bob bob
python JAVA

 上述是在对象产生后为对象添加属性的方法(在刚刚产生时是没有自己独有属性的，结果为{})，那么如何在对象产生的过程中(类的实例化阶段)为其添加独有的属性？

class Information:    #使用骆驼峰风格
    name = 'bob'
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def func(self):
        print('python')


a = Information('bob','python')
b = Information('tom','JAVA')
print(a.__dict__)
print(b.__dict__)
--->
{'x': 'bob', 'y': 'python'}
{'x': 'tom', 'y': 'JAVA'}

 上述代码实际上是发生了两件事情：

  1:调用类的时候产生了空对象，2：自动触发__init__(构造方法),将对象(通过self)以及括号内的参数传入

  对象属性的查找顺序是：自身的内存空间--->类的内存空间---->报错

 类中定义的属性(数据属性和函数属性)是对象共享的，而对象只有数据属性，且是独有的

 类内定义的函数，对象是可以使用的，但是是通过绑定的方法(不同于函数调用)，绑定的效果是：绑定给谁，就给谁调用， 并且将调用的对象作为第一个参数传入

class Information:    #使用骆驼峰风格
    name = 'bob'
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def func(self):
        print('python')

a=Information(1,2)
print(Information.func)
print(a.func)
--->
#
#>

   注：

        1:在类内定义的函数，类是可以调用的，但是大多数情况下是给对象使用的，所以在类内定义的函数应该自带一个 self(用于将对象这个名称空间传入，对于以往直接传参数这是个很神奇的方法)

        2：类调用类内的函数就是在调用一个普通的函数，但是对象更应该称之为在调用绑定方法

python3统一了类与类型的概念--->类即类型，一切皆对象

 对于我们创建一个列表L=[1,2,3],实际上是完成了L=list([1,2,3])过程，那么类即类型，对于list这个类来说，L=list([1,2,3])实际上是完成了类的实例化过程，而L.append()这些方法本质上是在调用list类内定义的函数(即在调用绑定方法)

L = [1,2,3]
l=[1]
L.append(4)
list.append(L,5)
print(L,l)
--->
[1, 2, 3, 4, 5] [1]
#这个结果说明了：
#1.L.append(4)与list.append（L,5）的效果一致
#L.append(4)并没有为l添加属性说明，绑定给谁，就由谁调用，并且把谁作为参数传入，4是L独有的属性

L = [1,2,3]
print(type(L))
print(L.append)
--->
#
#
说明：其实就是一个实例对象，调用append就是在调用类的绑定方法

 所以对象是高度整合的产物：整合了数据和专门处理数据的方法

python中一切皆对象的思想---类的实例(对象)的精髓：

python用变量来记录值(变量可以反应一系列状态的变化)，而流程控制(for....while....if 等)帮助我们进行变量的控制，当我们仅仅使用循环，条件判断等写程序这是最初的程序模式(最直白的面条式，各种代码冗余,功能与特征夹杂在一起)，然后出现了函数，虽然和前者一样都是面向过程，但是函数是功能的集合，他不仅帮我们解决了一部分的代码冗余问题，还将数据和功能分开，提高了可读性，易于维护(相比之前也易于扩展一些),然后到了面向对象，在python中一切都是对象，我们创建了一个列表l=[1,2,3]，实际上是调用了list这个类，而我们通常使用l.append(4)，实际就是调用了类的绑定方法(绑定给谁就由谁调用，并将谁自动传入，所以也不会改变其它的列表对象)，python的一切皆对象的思想，在你实例化一个对象的时候，将对象的数据属性以及与他绑定的方法一同传给你(你无需再去挨个定义功能)--->这是将函数与变量的一次整合