目录
- 面向对象
- 1. 面向过程编程的优缺点
- 2. 面向对象编程的优缺点
- 3. 类
- 类和函数的区别
- 什么是类
- 现实世界中先有对象，后有类
- python中先有类，再有对象
- 对象
- 如何实例化一个对象
- 对象属性查找顺序
- 类与对象的绑定方法
- 类与数据类型
- ==如何证明类中函数的参数self是实例对象本身==
- 对象的高度整合
面向对象
1. 面向过程编程的优缺点
优点：逻辑清晰
缺点：扩展性差（上一个函数的输出是下一个函数的输入）
2. 面向对象编程的优缺点
对象就是特征和技能的结合体
面向对象编程：一个个对象进行交互
优点：扩展性强
缺点：逻辑复杂
3. 类
类和函数的区别
- 函数在定义阶段，只检查语法，不执行代码
- 类在定义阶段，会运行代码
什么是类
类（类别）：一系列==具有相同特征和技能==的==集合==
现实世界中先有对象，后有类
# 定义学生
# 姓名: 猪瑞星
# 学号: 222222
# 学校: wuda
# 技能: 选课,三十六变
# 姓名: 孔悟空
# 学号: 111111
# 学校: wuda
# 技能: 选课,七十二变
# 姓名: 雷公
# 学号: 666666
# 学校: wuda
# 技能: 选课,电闪雷鸣,开车
# 定义老师
# 姓名：tank
# 学校：wuda
# 技能：教课，piao
# 姓名：nick
# 学校：wuda
# 技能：教课，看书
# 定义学生
# 姓名: 猪瑞星
# 学号: 222222
# 学校: wuda
# 技能: 选课,三十六变
# 姓名: 孔悟空
# 学号: 111111
# 学校: wuda
# 技能: 选课,七十二变
# 姓名: 雷公
# 学号: 666666
# 学校: wuda
# 技能: 选课,电闪雷鸣,开车
# 定义老师
# 姓名：tank
# 学校：wuda
# 技能：教课，piao
# 姓名：nick
# 学校：wuda
# 技能：教课，看书python中先有类，再有对象
class 类名(驼峰体): # 定义类,会直接运行类体代码
# 定义一系列特征
# 定义一系列方法
对象1 = 类名() # 实例化出对象
class 类名(驼峰体): # 定义类,会直接运行类体代码
# 定义一系列特征
# 定义一系列方法
对象1 = 类名() # 实例化出对象对象
如何实例化一个对象
class student(object):
count = 0
def __init__(self,name,Student_ID,school_name):
self.name = name
self.Student_ID = Student_ID
self.school_name = school_name
def xuanke(self):
print(f'{self.name} 正在选课')
print(student.__dict__) # 会显示student类的所有属性
a_stu = student('plf','11111','北大') # 实例化时，第一个调用__init__方法
a_stu.xuanke() # 调用选课系统
'''
{'__module__': '__main__', 'count': 0, '__init__': <function student.__init__ at 0x00000110AA7F0A60>, 'xuanke': <function student.xuanke at 0x00000110AA7F0AE8>, '__dict__': <attribute '__dict__' of 'student' objects>, '__weakref__': <attribute '__weakref__' of 'student' objects>, '__doc__': None}
plf 正在选课
'''
class student(object):
count = 0
def __init__(self,name,Student_ID,school_name):
self.name = name
self.Student_ID = Student_ID
self.school_name = school_name
def xuanke(self):
print(f'{self.name} 正在选课')
print(student.__dict__) # 会显示student类的所有属性
a_stu = student('plf','11111','北大') # 实例化时，第一个调用__init__方法
a_stu.xuanke() # 调用选课系统
'''
{'__module__': '__main__', 'count': 0, '__init__': <function student.__init__ at 0x00000110AA7F0A60>, 'xuanke': <function student.xuanke at 0x00000110AA7F0AE8>, '__dict__': <attribute '__dict__' of 'student' objects>, '__weakref__': <attribute '__weakref__' of 'student' objects>, '__doc__': None}
plf 正在选课
'''对象属性查找顺序
class OldBoyStudent:
school = 'oldboy'
name = 'c'
def __init__(self, name ,age):
self.name = name
self.age = age
def choose_course(self):
print('is choosing course')
stu1 = OldBoyStudent('a',1)
print(stu1.school)
stu2 = OldBoyStudent('b',2)
print(stu2.scool)
class OldBoyStudent:
school = 'oldboy'
name = 'c'
def __init__(self, name ,age):
self.name = name
self.age = age
def choose_course(self):
print('is choosing course')
stu1 = OldBoyStudent('a',1)
print(stu1.school)
stu2 = OldBoyStudent('b',2)
print(stu2.scool)先在实例对象本身的名称空间中查找，如果没有就会去类中查找，类中没有找到就会报错
类与对象的绑定方法
class OldBoyStudent:
school = 'oldboy'
def __init__(self, name ,age):
self.name = name
self.age = age
def choose_course(self):
print(id(self)) # 10000
print(self.school)
print(f'{self.name} is choosing course')
stu1 = OldBoyStudent('a',1)
stu1.choose_course() # self是对象本身
print(id(stu1)) # 10000
OldBoyStudent.choose_course(stu1)
class OldBoyStudent:
school = 'oldboy'
def __init__(self, name ,age):
self.name = name
self.age = age
def choose_course(self):
print(id(self)) # 10000
print(self.school)
print(f'{self.name} is choosing course')
stu1 = OldBoyStudent('a',1)
stu1.choose_course() # self是对象本身
print(id(stu1)) # 10000
OldBoyStudent.choose_course(stu1)类与数据类型
lis = list([1,2,3])
lis2 = list([1,2,3])
# 增加一个元素
lis.append(4)
# 换一种写法
list.append(lis,5)
# 总结：数据类型其实都是对象。数据类型的内置方法，都是对象的方法
lis = list([1,2,3])
lis2 = list([1,2,3])
# 增加一个元素
lis.append(4)
# 换一种写法
list.append(lis,5)
# 总结：数据类型其实都是对象。数据类型的内置方法，都是对象的方法==如何证明类中函数的参数self是实例对象本身==
分两种情况：1. 类的情况，2.实例本身
当实例去调用 "jiaoxue"函数时
class teacher():
count = 0
def __init__(self,name,school,age,sex):
self.name = name
self.school = school
self.age = age
self.sex = sex
teacher.count += 1
def jiaoxue(self):
print(self)
print(f'类中函数的self的内存地址为：{id(self)}')
one = teacher('plf','武大','23','男')
print(f"初始化对象的内存地址为：{id(one)}")
one.jiaoxue()
teacher.jiaoxue(111)
'''
初始化对象的内存地址为：1171091425992
<__main__.teacher object at 0x00000110AA7D0AC8>
类中函数的self的内存地址为：1171091425992
'''
class teacher():
count = 0
def __init__(self,name,school,age,sex):
self.name = name
self.school = school
self.age = age
self.sex = sex
teacher.count += 1
def jiaoxue(self):
print(self)
print(f'类中函数的self的内存地址为：{id(self)}')
one = teacher('plf','武大','23','男')
print(f"初始化对象的内存地址为：{id(one)}")
one.jiaoxue()
teacher.jiaoxue(111)
'''
初始化对象的内存地址为：1171091425992
<__main__.teacher object at 0x00000110AA7D0AC8>
类中函数的self的内存地址为：1171091425992
'''当类去调用“jiaoxue” 函数时
class teacher():
count = 0
def __init__(self,name,school,age,sex):
self.name = name
self.school = school
self.age = age
self.sex = sex
teacher.count += 1
def jiaoxue(self):
print(self)
print(f'类中函数的self的内存地址为：{id(self)}')
teacher.jiaoxue(111) # 随意传入一个数据，正常情况下我们可以传入teacher类的对象
'''
111
类中函数的self的内存地址为：1345944480
'''
class teacher():
count = 0
def __init__(self,name,school,age,sex):
self.name = name
self.school = school
self.age = age
self.sex = sex
teacher.count += 1
def jiaoxue(self):
print(self)
print(f'类中函数的self的内存地址为：{id(self)}')
teacher.jiaoxue(111) # 随意传入一个数据，正常情况下我们可以传入teacher类的对象
'''
111
类中函数的self的内存地址为：1345944480
'''总结：
- 类中的函数self形参，当类调用时，self即表示传入的参数
- 类中的函数self形参，当实例化对象调用时，self即表示实例化对象本身
对象的高度整合
对象有一大堆属性/数据，还会有一大堆方法来操作这些属性。然后对于不同的对象，这些属性又不同。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
