面向过程编程 和 面向对象编程

1. 什么是面向过程变成？

首先，在编程中，面向过程和面向对象是编程的两大编程思想，分别是：面向过程和面向对象，二不是一门新的技术栈.

面向过程中核心是过程二字，过程就是先干什么、在干什么、最后干什么，就是机械式的思维方式

优点：复杂的问题简单化、进而流程化
缺点：扩展性差，牵一发而动全身
应用场景: 一般用在对扩展性要求比较差的情况

使用面向过程写一个注册的案例来体会面向过程的优缺点、
1. 先让用户输入用户名和密码
2. 验证参数
3. 直接把数据写入文件中

2. 面向对象编程

面向对象它也是一种编程的思想，不是一门新的技术栈

面向对象中对象是核心，必须搞明白什么是对象
    """在Python中一切皆对象!"""

对象是什么?
    在生活中:
        对象就是'特征'与'技能'的集合体
     在程序中：
        对象就是盛放'数据属性'和'功能'的容器
        
优点：扩展性强
缺点：简单的问题复杂化了

3. 类的定义和对象产生

"""
1. 关键字使用class来声明
2. class后面写的是类名，类名的命名：一般情况下遵循变量的命名规范即可，类名一般首字母都要大写，（小写也行，但是不推荐）
3. 如果你的类名比较长，推荐使用驼峰法，并且是大驼峰
4. 类名后面的小括号不能省略
"""

# 类名
class Student():

    school = 'ShangHai'  # 这是属性 类的属性

    def __init__(self,name,age,gender): # 这是初始化方法 self是调用的对象 会把调用的对象直接传过来
        self.name = name                # self.name 是一个字典的 key值 后面的name是传进来的values值
        self.age = age
        self.gender = gender


    def choose_course(self, course):   # 这个是自定义的方法
        print("%s选课成功:%s" % (self.name,course))

# 如何查看类的名称空间?
print(Student.__dict__)

# 如何查看对象的名称空间
print(stu.__dict__) # {} 默认情况下调用类会得到一个空对象，其实就是一个空字典

"""调用类的过程也是实例化的过程，得到的对象也称为是一个实例"""

stu = Student('huang','18','male',)  # 调用类产生一个对象 是一个字典 可以产生多个对象
stu.choose_course('python')         # 对象再调用类里面的方法

"""
定义类发生了哪些事情?
1. 类一旦定义完成，会立马执行类体代码
2. 会产生类的名称空间，其实就是一个大字典，然后把类中得名字都丢到类的名称空间去
3. 把类的名称空间绑定给 类名.__dict__中
"""

class Student():
    school = 'SH'  # 类属性，其实就是变量吗?

    """它有特殊的含义, 在类里面必须叫__init__，然后调用类的时候才会自动触发执行"""

    ## 类里面一定要有这个方法吗? 不一定，也就是说，你如果需要提前定制对象的属性，你就写这个方法， 如果不需要，就不用写
    def __init__(self, name, age, gender, course=None):
        if course is None:
            course = []
        self.name = name  # stu.__dict__['name'] = 'kevin'
        self.age = age  # stu.__dict__['age'] = 18
        self.gender = gender  # stu.__dict__['gender'] = 'male'
        self.courses = course  # stu.__dict__['courses'] = []

    ## 函数写在类里面就称为是方法
    def choose_course(stu_dict, course):
        stu_dict.__dict__['courses'].append(course)
        print("%s选课成功:%s" % (stu_dict.__dict__['name'], stu_dict.__dict__['courses']))

### 版本2
"""在调用类的时候，会自定调用类里面的__init__方法"""

"""调用类的时候有特殊的功能，它会把对象自己当成第一个参数传给__init__方法"""
stu = Student('kevin', 19, 'male',) # stu = Student(stu， 'kevin', 19, 'male')
stu.choose_course('python')
stu.choose_course('linux')

4. 属性的查找顺序

# 类只能从类中查找 而不能从方法中查找
class Student():
    school = 'ShangHai'

print(Student.school)   # 查属性 查不到会报错
# print(Student.schoolsdadas)   # 查不到会报错
Student.school = 'qinghua'  # 修改属性
print(Student.__dict__)

Student.xxx = 'xxx'  # 如果有属性名字就修改 没有就增加

del Student.school   # 删除属性

# 方法的属性查找
class Student():
    school = 'ShangHai'

　　def __init__(self, school_name, school_add):
    　　self.school_name = school_name
    　　self.school_add = school_add

　　def student(self, class_name, stu_name, age, uid, gender):
    　　self.class_name = class_name
    　　self.stu_name = stu_name
    　　self.age = age
    　　self.uid = uid
    　　self.gender = gender

obj = Student('上海校区','上海')  # 生成一个对象
obj.student('13级','huang','18',3344,'male')
print(obj.class_name) # 先从方法中找 找不到去类的名称空间找 再找不到就报错

print(obj.name) # 方法的 查 
print(obj.school) # 先从方法里面找 找不到去类中查找 只限定于 . 方法  
print(obj.__dict__['school']) # 字典的方式查找只能找到自己的名称空间 而查不到类的名称空间 每个对象都有自己的名称空间  
obj.name = 'aaa' # 修改原有的 obj.name = 'huang'  
obj.hobby = [] # 增加一个方法属性 del obj.hobby # 删除一个方法属性

5. 练习题 对类名称空间的掌控

# 定义一个类，产生一堆对象，然后定义一个计数器，记录产生了多少个对象

class Student():
    cshool = 'ShangHai'

    count = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age
        Student.count += 1  # 必须要用类来调用 不然只能统计调用方法的那个对象
        
obj = Student('huang',18)
obj1 = Student('huang1',18)
obj2 = Student('huang2',18)
obj3 = Student('huang3',18)

print(Student.count)