面向对象
1.什么是面向对象？ 面向对象是一门编程思想! - 面向过程编程思想: 核心是 “过程” 二字，过程指的是解决问题的步骤，即先干什么再干什么！ 基于该编程思想编写程序，就好比在设计一条工厂流水线，一种机械式的思维方式。 优点: 将复杂的问题流程化，进而简单化 缺点: 牵一发而动全身，程序的可扩展性差。 注意: 编程思想仅仅是一门思想，与任何的技术无关。 - 面向对象编程思想: 注意: 要将自己当做一个上帝！！！ 核心是 “对象” 二字，对象指的是 “特征与技能” 的结合体。 基于该编程思想编写程序，就好比在创造世界，一种 “上帝式” 的思维方式。 优点: 可扩展性高。 缺点: 编写程序的复杂程度比面向过程高。 2.如何产生对象: 1) 什么是类？ 类指的是类型、类别。 - 在两种角度去看待: - 现实世界中: - 先有一个个的对象，经过社会的文明发展，随之总结出类。 对象是实际存在的，而类抽象产生的。 - 在程序中: - 必须先有类，再通过“调用类，产生对象”。 对象指的是 “特征与技能” 的结合体， 类指的是一系列 “对象之间相同的特征与技能” 的结合体。 2) 如何定义类: - 如何写类并产生对象: - 先从现实世界中通过一个个对象总结出类。 - 然后再定义类，后调用类产生对象。 - 比如: 选课系统: - 选课系统学生类: - 学生对象1: 特征: - 姓名: 胡晨阳 - 性别: female - 年龄: 95 - 学校: oldboy - 技能: - 技术: python - 学习: learn - 选课: course - 学生对象2: 特征: - 姓名: 高弟 - 性别: female - 年龄: 98 - 学校: oldboy - 技能: - 技术: python - 学习: learn - 选课: course 3) 定义类语法: class 关键字: 帮你产生类的。 class 类的名字: - 对象之间相同的特征 - 学校 school = 'oldboy' - 对象之间相同的技能 - python def python(): pass - learn def learn(): pass - course def course(): pass
类
class 类名:
特征
技能
定义类名的规范:
- 驼峰命名法
# 定义老男孩学生类 class OldboyStudent: # 类名指向的是类的内存地址 # 学生相同的特征 # 在类中的特征 也称之为 “属性” attribute school = 'oldboy' # 学生相同的技能 # 注意: 在类内部定义函数，会默认有一个参数self def learn(self): # self此时当做一个形参 print('learning....') print(OldboyStudent) # <class '__main__.OldboyStudent'> # 查看类的名称空间 类.__dict__ 对象.__dict__ print(OldboyStudent.__dict__) print(OldboyStudent.__dict__['school']) print(OldboyStudent.__dict__['learn']) OldboyStudent.__dict__['learn'](123) # 类提供一种特殊获取名字的方式 “类名.名字” 的方式 # 查 print(OldboyStudent.school) OldboyStudent.learn('tank') # 改 OldboyStudent.school = 'OldGirl' print(OldboyStudent.school) # 删 del OldboyStudent.school # 增 OldboyStudent.school = 'Oldboy' print(OldboyStudent.school) OldboyStudent.old_student = 'HuChenYang' print(OldboyStudent.old_student) ''' - 函数的名称空间： 在调用函数时产生，函数调用结束后销毁。 - 类的名称空间: 在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。 '''
对象
对象的产生:
- 调用类产生对象
类名 + () 调用类产生对象
类的名称空间在定义时产生，对象的名称空间在调用类时产生。
调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。
class Student: # 学校 school = 'oldboy' # 学习技能 ----> method ---》 方法 def learn(self): print(self) # 注意：看到self就应该知道是对象本身 print('learning...') stu1 = Student() stu2 = Student() stu3 = Student() # print(Student) # # print(Student.school, 'Student...') print(Student.learn, 'Student...') #<function Student.learn at 0x00000000025789D8> Student... Student.learn(123) #123 print('=' * 100) print(stu1) # <__main__.Student object at 0x0000017BFF8A5898> # print(stu1.school, 'stu1...') print(stu1.learn, 'stu1...') # learning... # print(stu1) # 对象调用方法时: 会将对象当做第一个参数传入方法中。 stu1.learn() # print('=' * 100) print(stu2) # <__main__.Student object at 0x0000017BFF8A5898> # print(stu2.school, 'stu2...') print(stu2.learn, 'stu2...') stu2.learn() print('=' * 100) print(stu3) # <__main__.Student object at 0x0000017BFF8A5898> # print(stu3.school, 'stu3...') print(stu3.learn, 'stu3...') stu3.learn()
由对象来调用类内部的函数，称之为对象的绑定方法。
对象的绑定方法特殊之处: 会将对象当做第一个参数传给该方法。
class Student: # 学校 school = 'oldboy' def __init__(self, name, sex, age): # stu1, 'tank', 'male', 17 print(self.__dict__) # 给对象添加新的属性 self.name = name # stu1.x = 'tank' self.sex = sex # stu1.y = 'male' self.age = age # stu1.z = 17 # 查看当前对象的名称空间 print(self.__dict__) # 学习技能 ----> method ---》 方法 def learn(self): print(self) # 注意看到self就知道是对象本身 print('learning...') '''结果 {'__module__': '__main__', 'school': 'oldboy', '__init__': <function Student.__init__ at 0x00000000025989D8>, 'learn': <function Student.learn at 0x0000000009BD1730>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None} {} {'name': 'ldc', 'sex': 'female', 'age': 18} 江鹏 female 84 '''
# **** 想要在调用类时，为对象传入对象独有 特征 # ***** __init__(self, name, sex, age): # name---> tank , sex---> male, age----> 17 # 调用类时: 会将对象当做第一个参数，与括号内所有的参数一并传给__init__() # stu1 = Student('tank', 'male', 17) # 注意: 凡是在类内部定义的，__开头或者__结尾的方法都有特殊的意义。 # 在类内部定义的方法，在调用类时触发，会自动将对象本身当做第一个参数自动传入, 与括号内所有的参数一并传给__init__()。 # __init__(self):
对象名字的查找顺序： *******
1.对象.属性，会先找对象自己的。
2.若对象没有，会去找类的。
3.若类没有，则会报错。
class People: country = 'China' name = 'jason' def __init__(self,name,age,sex): self.name = name self.age=age self.sex=sex def fun(self): print('running...') obj1 = People('tank',17,'male') print(obj1.name) # tank 找对象自己的name属性 print(obj1.country) # China 对象没有，找类中的属性 # print(obj1.jason) # AttributeError: 'People' object has no attribute 'jason' print(obj1.__dict__) #{'name': 'tank', 'age': 17, 'sex': 'male'} # 给对象的名称空间添加 country='中国' 属性 obj1.country = '中国' print(obj1.__dict__) # {'name': 'tank', 'age': 17, 'sex': 'male', 'country': '中国'} print(People.__dict__) # {'__module__': '__main__', 'country': 'China', 'name': 'jason', '__init__': <function People.__init__ at 0x00000000025989D8>, 'fun': <function People.fun at 0x0000000009BD1730>, # '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None} print(obj1.country) # 中国
在python中一切皆对象。
number = 10 # int(10) ----> __init__(number, 10) int(10) # l1 ---> list对象 l1 = list([1, 2, 3]) dict() tuple((1, 2, 3)) float str set bool enumerate bytes filter
人狗大作战
# 人类 class People: def __init__(self, name, life, arg): self.name = name self.life = life self.arg = arg # 人调用bite时，传入狗对象 def bite(self, dog_obj): print(f'人：[{self.name}] 开始 咬 狗:[{dog_obj.name}]!') # 减掉狗对象中的生命值 值为人的攻击力 dog_obj.life -= self.arg print(f'狗的生命值减掉: [{self.arg}], 还剩狗的血量: [{dog_obj.life}]') if dog_obj.life <= 0: print(f'狗[{dog_obj.name}]已经挂了') return True # 狗类 class Dog: def __init__(self, name, life, dog_type, arg): self.name = name self.dog_type = dog_type self.life = life self.arg = arg # 狗对象调用bite时，传入人对象 def bite(self, p_obj): print(f'狗：[{self.name}] 开始 咬人:[{p_obj.name}]!') # 减掉人对象中的生命值 值为狗的攻击力 p_obj.life -= self.arg print(f'人的生命值减掉: [{self.arg}], 还剩人的血量: [{p_obj.life}]') if p_obj.life <= 0: print(f'人[{p_obj.name}]已经挂了') return True p1 = People('高弟', 2000, 500) d1 = Dog('HCY', 250, '哈士奇', 2500) p2 = People('高弟2', 5000, 50) import time while True: # 开始人狗互咬 # if p1.life or d1.life: res1 = d1.bite(p2) if res1: break time.sleep(1) res2 = p1.bite(d1) if res2: break time.sleep(1)
总结：
面向对象编程:
核心是 “对象”， 对象指的是 特征与技能 结合体。
基于该编程思想编写程序，就好比在创造世界，一种上帝式思维方式。
优点:
可扩展性强。
缺点:
编写复杂难度较面向过程高。
1.类的实例化: 调用类的过程称之为类的实例化，产生的对象也可以称之为类的一个实例
调用类产生对象发生的事情:
1.会产生一个空对象的名称空间
2.会自动触发__init__，并且会将对象当做第一个参数传入。
3.会将调用类括号内的参数一并传给__init__().
2.查看类与对象的名称空间 类.__dict__ 对象.__dict__
3.类或对象的属性操作: 查、增、改、删
4.类中数据属性（类中的变量）: 类中属性是给对象使用的，对象引用类中的属性，指向的都是类中同一个内存地址。
5.类中的方法（类中的函数）: 类中的方法是给对象使用的，
由不同的对象来调用就会将方法绑定给不同的对象, 并且会将对象当做第一个参数传入。
6.对象属性的查找顺序: 先从对象自己名称空间中查找 ---》 类的名称空间中查找
7.对象绑定方法的特殊之处:
1.会将对象当做第一个参数传入。******
2.若对象的绑定方法中还有其他参数，会一并传入。
8.一切皆对象: 在python3中，类即类型。