一：面向对象
【1】基础概念：
（1）面向过程：
概念：面向过程是一种编程思想
优点：
（1）复杂的问题简单化 流程化
（2）代码逻辑清晰
缺点：
（1）代码扩展性比较差 例如：当想添加新的功能的时候 需要修改大量的代码
（2）代码维护性比较差 例如：如果一个环节出现问题 会影响别的环节正常运行
（2）面向对象：
概念：
（1）面向对象是一种编程思想，核心是对象
（2）程序员 指挥对象帮我们进行工作
案例一:
# 大象装冰箱 ''' #面向过程 1:首先打开冰箱 2:将大象装入冰箱 3:关上冰箱门 ''' ''' # 面向过程 找一个帮忙将大象装入冰箱 '''
PS：其通过创造对象 帮我们解决问题
案例二：
# 西游记 ''' 1:如来找唐僧四人去帮忙传经 2:不同的人有不同的特征技能 3:假如某人挂了不会影响其余人 4:为了增加战斗力给孙悟空三根毫毛 '''
PS:
（1）通过对象帮忙工作 扩展性比较高
（2）某一对象挂了 不会影响其余环节可维护性比较强
（3）面向对象的优缺
优点：
（1）代码扩展性 可维护性都很高
（2）对象都是单独存在的不会互相影响
（3）某些对象可以被重复使用
缺点：
（1）不能向面向过程 准确知道结果
（2）要设计对象之前 需要考虑对象的特征属性等 开发难度增加
（4）使用场景
（1）：如果对于扩展性高的软件 使用面向对象编程 例如：qq V信 游戏
（3）：扩展性比较低的建议使用面向过程 例如：操作系统
【2】类和对象：
（1）类：
概念：一组具有相同特征或属性的集合体
例如：电子产品 ，食物，汽车等
（2）对象：
概念：
（1）具体存在的事物 具备自己的行为和特征
（2）其是特征和技能的结合体
（3）类和对象的关系
（1）对象属于某一个类
（2）类是一系列对象的集合体
PS:
（1）在生活中先有对象 才能有类 例如：因为先有的人 人多了慢慢被定义成人类
（2）在程序中必须先有类 才能有对象 因为计算机不知道对象拥有什么样的特征属性
总结：在使用面向对象的时候 我们首先需要考虑 需要什么样的对象 该对象有什么特征 从而归纳总结这些特征 汇总成类
（4）类和对象的创建：
（1）类：
# PS:类名尽量做到见面知意 使用大驼峰式 即第一个字母大写 class Student: ''' 1 类中的属性 技能 2 属性用变量定义 3 技能哟函数定义 ''' print(Student) # <class '__main__.Student'>
（2）对象：
例如：
stu = Student() stu = Student() # <__main__.Student object at 0x00000000027F84A8>
PS：
（1）创建对象也是序列化的过程
（2）序列化即类调用对象里传参的过程 传参个数必须相等
例如：
class Teacher: def __init__(self,name,age,gender): self.name = name self.age = age self.gender = gender stu1 = Teacher('SR',18,'male') print(stu1) # <__main__.Teacher object at 0x00000000025E7518> print(stu1.name) # SR print(stu1.age) # 18
（5）类在定义及被调用的过程：
（1）定义阶段：
（1）首先类在定义的时候会产生类的名称空间
（2）执行类内部体代码 将类内部的产生的名字 放入类的名称空间
（2）对象调用阶段：
（1）首先会产生自己的名称空间
（2）执行类内部的代码 将内部产生的名字放入自己的名称空间中
（3）将类名称存入自己的名称空间中
（6）属性的写法
（1）类中的属性是公共的
例如：
class Person: name = 'SR' p1 = Person() print(p1.name) # SR p2 = Person() print(p2.name) # SR
# p1 与 p2 都能继承类中的属性
（2）对象中的属性是自己独有的
例如：
class Person: name = 'SR' p1 = Person() p1.name = '张三' print(p1.name) # 张三 p2 = Person() p2.name = '李四' print(p2.name) # 李四
# 类中虽然有公有属性，但是都是继承自己独有的
（7）类的访问顺序：
（1）首先先访问自己独有的
（2）访问公有的
（3）独有的公有的都不存在 会报错
例如：
class Person: name = 'SR' p1 = Person() print(p1.name) # SR p2 = Person() p2.name = '李四' print(p2.name) # 李四 # 将公有的注释 p1 = Person() print(p1.name) # IndentationError: expected an indented block
图解过程：
（8）属性的增删改查
（1）增加
方法：对象变量名称.属性名称 = 属性值
例如：
class User: age = 18 user = User() user.age = 20 print(user.age)
（2）删除
方法 ：del 对象的变量名称.属性名称
例如：
class User: age = 18 user = User() del user.age
（3）修改
方法：对象.属性 = 新的值
例如：
class User: age = 18 user = User() user.age = 20 print(user.age) # user.age = 20
（4）查看
方法：print(对象.__dict__)
例如：
class User: age = 18 user = User() user.age = 20 print(user.__dict__) # {'age': 20}
# 其只能查看对象内部的属性 不能查看类
（9）初始化方法：
（1）作用：为对象初始化赋值
例如：
class User_info: # 为对象赋值 名称 年龄 def __init__(self,name,age): self.name = name self.age = age user = User_info('SR',18) print(user.age) # 18 print(user.name) # SR print(user.__dict__) # {'name': 'SR', 'age': 18}
（2）特点：
（1）实例初始化会自动调用__init__方法
（2）会将对象作为第一个参数传给self，self可以修改 但是不建议修改
（3）其返回值为None 且不能修改 修改就会报错
例如：
class User_info: # 为对象赋值 名称 年龄 def __init__(self,name,age): self.name = name self.age = age return 1 # __init__() should return None, not 'int' user = User_info('SR',18) print(user.age) # 18 print(user.name) # SR print(user.__dict__) # {'name': 'SR', 'age': 18}
PS：对象的精髓在于将数据与处理属于的函数绑定在一起 只要拿到对象就同时拿到需要被处理的数据以及处理数据的函数
（10）绑定方法：
（1）对象绑定方法
作用：类内部函数可以访问对象内部的属性
例如：
class User_info: # 为对象赋值 名称 年龄 def __init__(self,name,age): self.name = name self.age = age def say_hello(self): print(self) # <__main__.User_info object at 0x0000000002807390> print('hello i am a student') stu = User_info('SR',18) # 调用类内部函数 stu.say_hello() # hello i am a student print(stu) # <__main__.User_info object at 0x0000000002807390>
PS：
（1）虽然我能调用内部函数 但是想进行格式化输出 即想调用对象内部的数据
（2）函数内部添加self 就是与那个对象进行数据交互 哪个对象调用函数 即self就为那个对象
（3）既然self可以与对象进行数据交互 那么可以通过调用对象内部的数据 进行格式化输出
例如：
class User_info: # 为对象赋值 名称 年龄 def __init__(self,name,age): self.name = name self.age = age def say_hello(self): #调用对象 print('hello i am a student %s'%self.name) stu = User_info('SR',18) # 调用类内部函数 stu.say_hello() # hello i am a student SR
PS：在使用调用函数的时候 其会将对象本身作为第一个参数 传入函数内部
类调用：
例如：
class User_info: # 为对象赋值 名称 年龄 def __init__(self,name,age): self.name = name self.age = age def say_hello(self): #调用对象 print('hello i am a student %s'%self.name) user = User_info('SR',18) User_info.say_hello() # 报错 需要传入一个参数 User_info.say_hello(1) # 报错 1这个对象中没有包含name参数 User_info.say_hello(user) # hello i am a student SR
PS：当使用类调用函数的时候 函数内部需要几个参数 就需要上传几个参数
（2）类绑定方法：
（1）作用：当类内部函数不需要对象内部数据 而需要类内部数据的时候需要用到该方法
例如：
class OldBoyStudent: school = "oldboy" def __init__(self,name): self.name = name def show_school(self): print(self.school) OldBoyStudent.show_school() # 报错 需要传个参数 user = OldBoyStudent('SR') OldBoyStudent.show_school(user) # 正确
PS：
（1）此时对象都有一个共同点school 不需要再调用对象了
（2）但是其需要我们上传对象 而我们不需要调用对象 直接调用函数内部的数据就行了
解决办法：
通过类绑定
例如：
class OldBoyStudent: school = "oldboy" def __init__(self,name): self.name = name # 开启类绑定 @classmethod def show_school(cls): print(cls) # <class '__main__.OldBoyStudent'> print(cls.school) OldBoyStudent.show_school() # oldboy print(OldBoyStudent) # <class '__main__.OldBoyStudent'>
（3）静态绑定方法
作用：即不需要对象中的数据 也不需要类中的数据
例如：
class OldBoyStudent: school = "oldboy" def __init__(self,name): self.name = name # 开启非绑定方法 @staticmethod def show_school(): print('hello world') OldBoyStudent.show_school() # hello world print(OldBoyStudent) # # <class '__main__.OldBoyStudent'>