面向对象和面向过程编程

一、面向过程编程

面向过程：核心“过程”，实质是将需要实现的功能分成多个功能段，然后在按照特定的顺序去执行这些功能段，从而实现要求功能
优点：复杂问题流程化，将简单的问题简单化
缺点：可扩展性差，维护难度会高
用途：用于那些功能一旦实现之后就很少需要改变的场景，如，写一些简单的脚本程序

二、、面向对象编程

对象：特征和技能集合的个体
面向对象的核心是‘对象’；
优点：使程序更加容易扩展和易更改，使开发效率变的更高；基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。
缺点：过程复杂，极容易出现过度设计的问题
用途：应用于客户需求经常变更，互联网应用，游戏等

三、面向对象名词解释

1、类
用有相似特征，属性和功能所有个体的集合。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法。在程序中药先定义类，在产生个体对象。

2、属性
人类包含很多特征，把这些特征用程序来描述的话，叫做属性，比如年龄、身高、性别、姓名等都叫做属性，一个类中，可以有多个属性

3、方法
人类不止有身高、年龄、性别这些属性，还能做好多事情，比如说话、走路、吃饭等，相比较于属性是名词，说话、走路是动词，这些动词用程序来描述就叫做方法。

4、实例(对象)
一个对象即是一个类的实例化后的实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

5、实例化
把一个类转变为一个对象的过程就叫实例化

四、面向对象3大特性

1、Encapsulation 封装

2、Inheritance 继承

3、Polymorphism 多态

五、类的定义及使用

# 定义一个类，定义类的关键字：class
class LuffyStudents:
    school = '路飞学城'                            # 类的数据属性
    def learn(self):                              # 类的函数属性
        print('is learning')
    def eat(self):                                # 类的函数属性
        print('is eatting')
    def sleep(self):                              # 类的函数属性
        print('is sleeping')
        
print(LuffyStudents.__dict__)                     # 查看定义类后的名称空间
print(LuffyStudents.__dict__['school'])           # 打印定义类后的名称空间

# 查看类里面定义的属性
print(LuffyStudents.school)
print(LuffyStudents.eat)
print(LuffyStudents.learn)
print(LuffyStudents.sleep)



# 向类里面增加属性

LuffyStudents.country = 'China'
print(LuffyStudents.__dict__)

# 修改类里面的属性

LuffyStudents.school = '罗高'
print(LuffyStudents.school)

# 删除类里面的属性

del LuffyStudents.learn
print(LuffyStudents.__dict__)

# 调用类（实例化）
stdu1 = LuffyStudents()
stdu2 = LuffyStudents()
stdu3 = LuffyStudents()
stdu1 = LuffyStudents()
print(stdu1)
print(stdu2)
print(stdu3)

注意：

1、类中可以有任意python代码，这些代码在类定义阶段便会执行，因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过 LuffyStudents.__dict__查看。
2、类中定义的名字，都是类的属性，点是访问属性的语法。
3、对于经典类来说我们可以通过该字典操作类名称空间的名字，但新式类有限制。
4、类与函数区别：函数在定义时不会执行，名词空间在调用时产生；类在定义的时候就执行了，从而产生名称空间

六、对象使用

class LuffyStudents:
    school = '路飞学城'              # 类的数据属性

    def __init__(self,name,sex,age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self):                # 类的函数属性
        print('is learning')

    def eat(self):                  # 类的函数属性
        print('is eatting')

    def sleep(self):                # 类的函数属性
        print('is sleeping')

__init__方法后实例化步骤
1、先产生一个空对象
2、然后将产生的实例化对象，和对象的三个属性特征，共四个参数传给__init__

stdu1 = LuffyStudents('李二','男',20)
stdu2 = LuffyStudents('何芳华','女',23)

# 查看对象定制属性

print(stdu1.__dict__)     # 查看名称空间
print(stdu2.__dict__)

print(stdu1.Name)
print(stdu1.__dict__['Name'])
输出结果：
{'Name': '李二', 'Sex': '男', 'Age': 20}
{'Name': '何芳华', 'Sex': '女', 'Age': 23}
李二
李二

# 增加属性

stdu2.Course = 'python全栈开发'
print(stdu2.__dict__)

输出结果：
{'Name': '何芳华', 'Sex': '女', 'Age': 23, 'Course': 'python全栈开发'}

# 修改属性

stdu1.Name = '夏天'
print(stdu1.__dict__['Name'])

输出结果：
夏天

# 删除属性

del stdu2.Course
print(stdu2.__dict__)

输出结果：
{'Name': '何芳华', 'Sex': '女', 'Age': 23}

七、属性查找和绑定方法

1、属性查找

# 定义一个类，定义类的关键字：class

class LuffyStudents:
    school = '路飞学城'                # 类的数据属性

    def __init__(self,name,sex,age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self,x):                # 类的函数属性
        print('%s is learning %s'%(self.Name,x))

    def eat(self,x):                  # 类的函数属性
        print('%s is eatting %s'%(self.Name,x))

    def sleep(self,x):                # 类的函数属性
        print('%s is sleeping %s'%(self.Name,x))

stu2 = LuffyStudents('刘三','女',24)
stu3 = LuffyStudents('夏天','男',26)

print(LuffyStudents.school,id(LuffyStudents.school))
print(stu2.school,id(stu1.school))
print(stu3.school,id(stu1.school))

打印结果：
路飞学城 3088686421576
路飞学城 3088686421576
路飞学城 3088686421576
由打印结果看：类中的数据属性是所有对象共享的，在同一个内存地址取数据属性的数据


print(LuffyStudents.learn)   
print(stu2.learn)
print(stu3.learn)


打印结果：
<function LuffyStudents.learn at 0x0000023E5D2B5840>
<bound method LuffyStudents.learn of <__main__.LuffyStudents object at 0x0000023E5D2C0518>>
<bound method LuffyStudents.learn of <__main__.LuffyStudents object at 0x0000023E5D2C0550>>
由结果看，类的函数属性中每个对象绑定的函数属性的内存地址是不同的

类中名称空间访问顺序

在stu2的名称空间内添加变量x
stu2.x = 'from stu2'
在类的名称空间内添加变量x
LuffyStudents.x = 'from LuffyStudents'

查看两个名称空间内的变量
print(stu2.__dict__)
print(LuffyStudents.__dict__)


print(stu2.x)
打印结果：from stu2
类中名称空间访问顺序是先从对象本身名称空间查找，找不到就到类内部的名称空间查找，查找不到就到父类中查找，在查找不到就会报错，不会到全局名称空间查找

2、绑定方法

class LuffyStudents:
    school = '路飞学城'                # 类的数据属性

    def __init__(self,name,sex,age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self,x):                # 类的函数属性
        print('%s is learning %s'%(self.Name,x))

    def eat(self,x):                  # 类的函数属性
        print('%s is eatting %s'%(self.Name,x))

    def sleep(self,x):                # 类的函数属性
        print('%s is sleeping %s'%(self.Name,x))
        
类中定义的函数（没有被任何装饰器装饰的）,其实主要是给对象使用的，而且是绑定到对象的，称为绑定到对象的方法。虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法。
stu2 = LuffyStudents('刘三','女',24)
stu3 = LuffyStudents('夏天','男',26)

LuffyStudents.learn(stu2,'hard')
LuffyStudents.eat(stu2,'happy')
LuffyStudents.sleep(stu2,'well')
打印结果：
刘三 is learning hard
刘三 is eatting happy
刘三 is sleeping well

绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值（方法__init__也是一样的道理）
注意：绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self。