python31 面向对象

面向过程

　　支持面向对象的语言中，都有两大范式：

　　　　1. 面向过程

　　　　2. 面向对象

　　这两大范式不是新的技术，而是一种编程思想

　　面向过程：核心就是过程二字，首先，然后，最后的一种固定思维方式

　　代码案列：

　　　　已注册为例

　　　　首先接受代码

　　　　做逻辑处理，然后验证参数

　　　　把数据写进文件里

　　面向过程优点：复杂问题简单化，进而流程化

　　面向过程缺点：拓展性差

　　使用场景：对拓展性要求不高的地方，一般使用面向过程

面向对象

　　面向对象的核心就是对象二字

　　　　1.在生活中

　　　　　　对象就是特征与技能的结合体

　　　　2.在程序中

　　　　　　对象就是盛放数据属性和方法的结合体

　　面向对象优点：拓展性好

　　缺点：编程复杂度变高

　　使用场景：一般用在对拓展性要求较高的地方

类的定义和对象的产生

　　站在不同角度，分类结果不一样

　　类：就是一系列相似的特征和相似的技能的结合体

　　问题;

　　　　到底先有类还是先有对象？

　　　　　　1.在生活中

　　　　　　　　现有对象，再有类

　　　　　　2.在程序中

　　　　　　　　必须先定义类，然后在调用类产生的对象

class Student（）：
    shcool=‘清华大学’
     def choose_course(stu_dict, course, ):
        stu_dict["courses"].append(course)
        print("%s选择了%s成功，%s" % (stu_dict["name"], course, stu_dict["courses"]))

属性就是变量，函数就是方法

　　定义类发生几件事：

　　　　1.类一旦被定义，会立马执行类体代码

　　　　2.类一旦定义完成，会产生类的名称空间，它会把类中的名字都丢到类的名称空间去

　　　　3. 会把类的名称空间绑定给__dict__属性, 如何查看: 类名.__dict__

产生对象：

　　定义好类，然后调用类就产生对象

　　stu=Student（）调用类，得到的结果就是对象

对象的名称空间

　　stu.——dict——，得到的是一个空对象

　　每调用一次类，都会产生一个对象，并且产生的对象之间是相互独立的，互补影响的

　　调用类的过程也是实例化的过程，得到的结果就是一个实例

定制对象自己独有的属性

class Student():
    school = 'SH'  # 属性就是变量
    def __init__(stu_obj, name, age, gender, salary):
        stu_obj.name = name  # stu.__dict__['name'] = 'kevin'
        stu_obj.age = age  # stu.__dict__['age'] = '18'
        stu_obj.gender = gender  # stu.__dict__['gender'] = 'male'
        stu_obj.salary = salary  # stu.__dict__['salary'] = '1800'
    def choose_course(stu_dict, course, ):
        stu_dict["courses"].append(course)
        print("%s选择了%s成功，%s" % (stu_dict["name"], course, stu_dict["courses"]))

_init__这个函数名不能改名字，必须叫这个名字，一点都不能差

调用类会自动的触发类里面的__init__方法，然后会把得到的对象本身当成第一个参数自动传递

__dict__开头的属性或者方法都有他自己的特殊含义，一般不建议使用

名字查找顺序

属性的查找顺序分两大类：

　　类属性：在类里面定义的属性就是类属性

　　对象属性：就是对象自己独有的属性

增删改查

　　类属性：　　

#增
Student.x = 'a'
#删
del Student.school
#改
Student.x = 10
#查
print(Student.school)

　　对象属性：

#增
Stu.x = 'a'
#删
del Stu.school
#改
Stu.x = 10
#查
print(Stu.school)

对象属性查找顺序：现在自己的对象属性里面查找，找不到就到类属性中查找，找到就取出，找不到就报错

课堂练习

"""
    1. 定义一个类，产生一堆对象
    2. 定义一个计数器，记录产生了多少个对象
"""

class Student():
    school = 'Sh'
    count = 0
    def __init__(self, name, age, gender):
        """面向对象中，必须搞清楚self是谁"""
        self.name = name
        self.age = age
        self.gender = gender
        Student.count += 1


stu = Student("kevin", 18, 'male')
stu1 = Student("kevin1", 18, 'male')
stu2 = Student("kevin2", 18, 'male')
stu3 = Student("kevin3", 18, 'male')
print(stu.__dict__)  # {'name': 'kevin', 'age': 18, 'gender': 'male'}
print(stu.count)
print(stu1.count)
print(stu2.count)
print(Student.count)

类中定义的变量是类的数据属性，是共享给所有对象用的，指向相同的内存地址

# id都一样
print(id(Student.school)) # 4301108704

print(id(stu1.school)) # 4301108704
print(id(stu2.school)) # 4301108704
print(id(stu3.school)) # 4301108704