一、面向对象
什么是面向对象？
面向对象是一门编程思想！
面向过程编程思想与面向对象编程思想对比：
- 面向过程编程思想：
核心是 “过程 ”二字，过程是指解决问题的步骤 ，即先干什么再干什么！
基于该编程思想编写程序 ，就好比在设计一条工厂流水线，一种机械式的思维方式
优点：
将复杂的问题流程化，进而简单化
缺点：
牵一发而动全身 ，程序的可扩展性差
- 面向对象编程思想：
核心是 “对象 ” 二字 ，对象指的是“特征与技能”的结合体。
基于该编程思想编写程序，就好比把自己当做一个上帝在创造世界 ，一种“上帝式”的思维方式
优点：
可扩展性高
缺点：
面向对象编写程序的复杂程度比面向过程高
注意：编程思想仅仅是一门思想 ，与任何技术无关
二 、类
1 、什么是类？
类指的是类型、类别 。
在两种角度去看待类：
- 现实世界中：
- 先有一个个对象，经过社会的文明发展 ，随之总结出类 ，对象是实际存在的，而类是抽象产生的
- python程序中：
- 必须先由类 ，再通过调用类产生对象
对象指的是“特征与技能 ”的结合体 ， 类指的是一系列“对象之间相同的特征与技能 ”的结合体
2、如何定义类？
如何写类并产生对象：
- 先从现实世界中通过一个个对象总结出类
- 然后再定义类，后调用产生对象 。
比如 “选课系统”：
选课系统 - 学生类：
- 学生对象1：
特征：
- 姓名：tank
- 性别：female
- 年龄：95
- 学校：家里蹲
技能：
- 技术：python
- 学习：learn
- 选课：course
- 学生对象2
特征：
- 姓名：jason
- 性别：female
- 年龄：99
- 学校：家里蹲
技能：
- 技术：python
- 学习：learn
- 选课：course
3 、定义类的语法
语法：
class 关键字：帮你产生类
class 类名：
- 对象之间相同的特征
- 学校
school = "家里蹲"
- 对象之间相同的技能
- python
def Python():
pass
- learn
def Learn():
pass
- course
def Course():
pass
类名的规范：
- 驼峰命名法（推荐）
定义一个学生类并对属性进行增删查改：
# 定义一个家里蹲学生类 class JldStudent: # 类名指向的是类的内存地址 # 学生相同的特征 # 在类中的特征(即变量)称之为“属性 ” school = "OldBoy" # 注意：在类内部定义函数 ，会默认产生一个参数self # 学生相同的技能(即函数)称之为“方法 ” def learn(self): # self此处当做一个形参 print("learning...") # 查看类的名称空间 print(JldStudent.__dict__) print(JldStudent.__dict__["school"]) # 可调用属性 print(JldStudent.__dict__["learn"]) # 获取learn方法对象 JldStudent.__dict__["learn"](123) # 方法对象+() ，相当于执行learn函数(方法) # 类提供了一种特殊获取名字的方式 “类名.名字”的方式 # 查 print(JldStudent.school) JldStudent.learn(12) # 改 JldStudent.school = "Cld" print(JldStudent.school) # 删 del JldStudent.school # print(JldStudent.school) # AttributeError: type object 'JldStudent' has no attribute 'school' # 增 JldStudent.age = 18 print(JldStudent.age)执行结果：
{'__module__': '__main__', 'school': 'OldBoy', 'learn':
4 、类的名称空间
- 类的名称空间：
在定义阶段时产生，会将类中所有的名字，扔进类的名称空间
- 函数的名称空间：
在调用函数时产生 ，函数调用结束后销毁
三、对象
1 、对象的产生
对象名=类名() ---> 调用类产生对象
类的名称空间在定义时产生 ，对象的名称空间在调用类时产生
调用类产生对象的过程称之为类的实例化，对象称之为一个类的实例
定义一个类：
class Student: # 学校 ---> 属性 school = "Jld" # 技能 ---> 方法 def learn(self): print(self) # 打印输出为 <__main__.Student object at 0x00000000021B6248> ，是一个对象 print("learning...") # 获取对象 ，产生对象 obj = Student() print(obj) # 打印输出为 <__main__.Student object at 0x00000000021B6248>，也是一个对象 # 对象调用类内部的名字(属性) print(obj.school) # 对象调用类内部的函数(方法) ，无需传入参数：会将对象当做第一个参数传给该函数(方法) obj.learn() # 对象的绑定方法 ，无需传参执行结果：
<__main__.Student object at 0x000001BE191C6908> Jld <__main__.Student object at 0x000001BE191C6908> learning...
由对象来调用类内部的函数，称之为对象的绑定方法。
对象的绑定方法特殊之处：会将对象当做第一个参数自动传给该函数(方法) ，所以对象调用类内部的函数时无需传参
2 、为对象添加独有的属性
定义一个类：
class Student: # 学校 --> 属性 school = "Jld" def __init__(self, name, sex, age): # 参数：obj1, "张三", "female", 84 print(self.__dict__) # 给对象添加新的属性 self.name = name # stu1.name = "张三" self.sex = sex # stu1.sex = "female" self.age = age # stu1.age = 84 print(self.__dict__) # 技能 ---> 方法 def learn(self): print("learning...") # obj1 = Student() # Student(obj1) ---> __init__(self) ---> self==obj1 # obj2 = Student() # Student(obj2) ---> __init__(self) ---> self==obj2 # obj3 = Student() # Student(obj3) ---> __init__(self) ---> self==obj3# 给对象添加独有的属性： # 第一种方法（很麻烦）：调用类后 ，为对象传入对象独有的特征(属性) obj1.name = "张三" obj1.sex = "female" obj1.age = 84 # 第二种方法：调用类时，为对象传入对象独有的特征(属性) # __init__(self, name, sex, age)：obj1 --> self "张三" --> name "female" --> sex 84 --> age # 调用类时：会将对象当做第一个参数 ，并与括号内所有的参数一并传给__init__() obj1 = Student("张三", "female", 84)
执行结果：
{} {'name': '张三', 'sex': 'female', 'age': 84}
注意：凡是在类内部定义的.__或者__结尾的方法都有特殊意义
__init__()：在类内部定义的方法 ，在调用类时触发，会自动将对象当做第一个参数自动传入并执行
3、对象名字的查找顺序
对象名字的查找顺序：
① 对象.属性，会先找对象自己的
② 若对象没有 ，会去找类的
③ 对象没有 ，类也没有，就会报错
定义一个类：
class people: country = "China" name = "李四" def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age def run(self): print("running...") obj1 = people("张三", "female", 95) print(obj1.name) # 张三 找对象自己的name属性 print(obj1.country) # China 对象没有 ，找类中的属性 # 报错：AttributeError: 'people' object has no attribute 'json' print(obj1.json) # 对象没有 ，类也没有，就报错
4 、一切皆对象
在python中一切皆对象
""" 在python中一切皆对象 """ class foo: def __init__(self, x, y, z): self.x = x self.y = y self.z = z # 产生对象 # 调用类产生对象的过程称之为类的实例化 ，对象称之为一个类的实例 foo_obj = foo(10, 20, 30) print(foo_obj) # 查看 字符串 类型 print(type(str)) #执行结果：
<__main__.foo object at 0x0000014471D71C88> <class 'type'> <class 'type'> <class 'type'> <class 'type'> <class 'type'> <class 'type'> <class 'type'>
