1、面向对象概述（ObjectOriented，OO）
- OOP思想
- 接触到任意一个任务，首先想到的是任务这个世界的构成，是有模型构成的
- 几个名词
- OO：面向对象
- OOA：面向对象的分析
- OOD：面向对象的设计
- OOI：面向对象的实现
- OOP：面向对象的编程
- OOA->OOD->OOI：面向对象的实现过程
- 类和对象的概念
- 类：抽象名词，代表一个集合，共性的事物
- 对象：具象的事物，单个个体
- 类和对象的关系
- 一个具象，代表一类事物的某一个个体
- 一个抽象，代表的是一大类事物
-类中的内容，应该具有两个内容
- 表明事物的特征，叫做属性（变量）
- 表明事物的功能或动作，称为成员方法（函数）
2、类的基本实现
-
类的命名
- 遵守变量命名的规范
- 大驼峰（由一个或者多个单词构成，每个单词首字母大写，单词跟单词直接相连）
- 尽量避开跟系统命名相似的命名
-
如何声明一个类
- 必须使用class关键字
- 类由属性和方法构成，其他不允许出现
- 成员属性定义可以直接使用变量赋值，如果没有，只许使用None
- 案例 01.py
-
实例化类
变量 = 类名（）# 实例化一个对象 -
访问对象成员
-
使用点操作符
obj.成员属性名称 obj.成员方法
-
-
可以通过默认内置变量检查类和对象的所有成员
-
对象所有成员检查
# dict前后各有两个下划线 obj.__dict__ -
类所有的成员
class_name.__dict__
-
3、anaconda基本使用
- anaconda主要是一个虚拟环境管理器
- 还是一个安装包管理器
- conda list：显示anaconda安装的包
- conda env list：显示anaconda的虚拟环境列表
- conda create -n xxx python=3.6：创建Python版本为3.6的虚拟环境，名称为xxx
- windows平台的使用
4、类和对象的成员分析
- 类和对象都可以存储成员，成员可以归类所有，也可以归对象所有
- 类存储成员时，使用的是与类关联的一个对象
- 对象存储成员是存储在当前对象中
- 当对象访问一个成员时，如果对象中没有该成员，就尝试访问类中的同名成员；如果对象中有此成员，一定使用对象中的成员
- 创建对象的时候，类中的成员不会放入到对象中，而是得到一个空对象，没有成员，但是可以借用
- 通过对象对类中成员重新赋值或者通过对象添加成员时，对应的成员会保存在对象中，而不会修改类成员
5、关于self
- self在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入到当前方法的第一个参数中
- self并不是关键字，只是一个用于接受对象的普通参数，理论上可以用任何一个普通变量名代替
- 方法中有self形参的方法，称为非绑定类的方法，可以通过对象访问；没有self的是绑定类的方法，只能通过类访问
- 调用绑定类函数，使用类名调用Teacher.sayAgain()
- 使用类访问绑定类的方法时，如果类方法中需要访问当前类的成员，可以通过__class__.成员名 来访问
class A():
name = "liuying"
age = 18
def __init__(self):
self.name = "aaaa"
self.age = 200
def say(self):
print(self.name)
print(self.age)
class B():
name = "bbbb"
age = "90"
a = A()
a.say()
A.say(a)
A.say(A)
A.say(B) # 以上代码，利用了鸭子模型
6、面向对象的三大特性
- 封装
- 继承
- 多态
6.1封装
- 封装就是对对象的成员进行访问限制
- 封装的三个级别
- 公开的，public
- 受保护的，protected
- 私有的，private
- public，protected，private不是关键字，俗称3P
- 判别对象的位置
- 对象内部
- 对象外部
- 子类中
- 私有
-
私有成员是最高级别的封装，只能在当前类或对象中访问
-
在成员前面添加两个下划线即可
class Person(): name = "liuying" # name是公有的成员 __age = 18 # __age就是私有成员 p = Person() print(p.name) print(p.__age) # 注意报错信息 print(Person.__dict__) # 查看类的所有成员 print(p._Person__age) # 访问私有成员 -
Python的私有不是真私有，是一种称为name mangling的改名策略，可以使用对象._classname__attributename访问
-
- 受保护的封装 protected
- 受保护的封装是将对象成员进行一定级别的封装，然后，在类中或者子类中都可以进行访问，但在外部不可以
- 封装方法：在成员名称前添加一个下划线即可
- 公开的，公共的 public
- 公共的封装实际对成员没有任何操作，任何地方都可以访问
6.2继承
- 继承就是一个类可以获得另外一个类中的成员属性和方法
- 继承的作用：减少代码，增加代码的复用功能，同时可以设置类与类之间的关系
- 继承与被继承的概念：
- 被继承的类叫父类，基类，超类
- 用于继承的类，叫子类，派生类
- 继承与被继承一定存在一个is-a关系
# 继承的语法
# 在Python中，任何类都有一个共同的的父类叫object
class Person():
name = "Noname"
age = 0
def sleep(self):
print("sleep......")
# 父类写在括号里
class Teacher(Person):
def make_test(self):
pass
t = Teacher()
print(t.name)
print(Teacher.name)
- 继承的特征
- 所有类都继承自object类，即所有类都是object的子类
- 子类一旦继承父类，则可以使用父类中除私有成员外的所有内容
- 子类继承父类后，并没有将父类成员完全赋值到子类，而是通过引用关系访问调用
- 子类中可以定义独有的成员属性和方法
- 子类中定义的成员和父类成员如果相同，则优先使用子类成员
- 子类如果想扩充父类的方法，可以在定义新方法的同时访问父类成员来进行代码重用，
可以使用[父类名.父类成员] 的格式来调用父类成员，也可以使用[super().父类成员]的格式来调用
class Person():
name = "Noname"
age = 18
__score = 0 # 考试成绩，只要自己知道
_petname = "sec" # 小名，受保护的，不是谁都可以叫的
def sleep(self):
print("sleep......")
def work(self):
print("make some money")
# 父类写在括号里
class Teacher(Person):
teacher_id = "9527"
name = "DaNa"
def make_test(self):
print("attention")
def work(self):
# 扩充父类的功能只需要调用父类相应的函数
# Person.work(self) # 这里的self就是Teacher自己的一个实例，把他当做父类的一个实例传进去作参数。子类可以冒充父类，但是父类一般不能冒充子类
# 扩充父类的另一种方法,super代表得到父类
super().work() # 这里不需要self？
self.make_test()
t = Teacher()
print(t.name)
print(t._petname)
# print(t.__score) # 公开访问私有变量，报错
t.sleep()
print(t.teacher_id)
t.make_test()
print(t.name) # 子类和父类定义同一名称变量，则优先使用子类本身
t.work()
- 继承变量函数的查找顺序问题
- 优先查找自己的变量
- 没有则查找父类
- 构造函数中如果本类没有定义，则自动查找调用父类构造函数
- 如果本类有定义，则不再继续向上查找
- 构造函数
- 是一类特殊的函数，在类进行实例化之前进行调用
- 如果定义了构造函数，则实例化时使用构造函数，不查找父类构造函数
- 如果没定义，则自动查找父类构造函数
- 如果没定义，父类的构造函数带参数，则实例化对象时的参数应该按父类的构造函数参数构造
- 在对象进行实例化的时候，系统自动调用的一个函数叫构造函数，通常用此函数来对实例对象进行初始化，顾名思义
- 构造函数如果没有，则自动向上查找，按照MRO顺序，直到找到为止
# 构造函数的概念
class Dog():
# __init__就是构造函数，每次实例化的时候第一个被自动调用，主要工作是初始化，所以得名
def __init__(self): # 必须有参数
print("i am init dog")
kaka = Dog() # 实例化的时候，括号内的参数需要跟构造函数参数匹配
# 继承中的构造函数 -1
class Animal():
def __init__(self):
print("Animal")
class PaxingAni(Animal):
def __init__(self):
print("Paxing Dongwu")
class Dog(PaxingAni):
def __init__(self):
print("i am init dog")
class Cat(PaxingAni):
pass
kaka = Dog()
c = Cat() # 此时应该自动调用构造函数，因为Cat没有构造函数，所以查找父类构造函数，找到了就停止向上查找
# 继承中的构造函数 -2
class Animal():
def __init__(self):
print("Animal")
class PaxingAni(Animal):
def __init__(self, name):
print("Paxing Dongwu {0}".format(name))
class Dog(PaxingAni):
def __init__(self):
print("i am init dog")
class Cat(PaxingAni):
pass
d = Dog()
c = Cat() # 缺参数，报错
# 构造函数的调用
class A():
def __init__(self):
print("A")
class B():
def __init__(self, name):
print("B")
print(name)
class C():
# C中想扩展B的构造函数，即调用B的构造函数后再添加一些功能
# 有两种方法实现
# 第一种是通过父类名调用
def __init__(self, name):
B.__init__(self, name) # 首先调用父类的构造函数
print("这是C中附加的功能") # 然后再添加自己的功能
# 第二中是使用super调用
# super(C, self).__init__(name) # 首先调用父类的构造函数
c = C("我是C")
- super
- super 不是一个关键字，而是一个类
- 作用是获取MRO（MethodResolustionOrder）列表中除本身的第一个类（基本就是它的父类）
- super与父类之间没有任何实质性关系，但通过super()可以调用到父类
- super使用的两个方法，参见在构造函数中调用父类的构造函数
- 单继承和多继承
- 单继承：每个类只能继承一个类
- 多继承：每个类允许继承多个类
- 单继承和多继承的优缺点
- 单继承：
- 优点：传承有序，逻辑清晰，语法简单，隐患少
- 缺点：功能不能无线扩展，只能在当前唯一的继承链中扩展
- 多继承：
- 优点：类的功能扩展方便
- 缺点：继承关系混乱
- 单继承：
# 多继承的例子
# 子类可以直接拥有父类的属性和方法，私有属性和方法除外
class Fish() :
def __init__(self, name):
self.name = name
def swim(self):
print("I am swimming")
class Bird():
def __init__(self, name):
self.name = name
def fly(self):
print("I am flying")
class Person():
def __init__(self, name):
self.name = name
def work(self):
print("Working......")
class SuperMan(Person, Bird, Fish): # 有顺序，不推荐这么弄，多类继承按书写顺序存放
def __init__(self, name):
self.name = name
s = SuperMan("yueyue")
s.fly()
s.swim()
- 菱形继承/钻石继承问题
- 多个子类继承自同一个父类，这些子类又被同一个类继承，于是继承关系图形成一个菱形图谱
- MRO
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eCM9fD0Q-1587025767776)(D:/python pycharm/2020-04-16_132455.jpg)]
- 关于多继承的MRO
- MRO就是多继承中，用于保存继承顺序的一个列表
- python本身采用C3算法来对多继承的菱形继承进行计算的结果
- MRO列表的计算原则：
- 子类永远在父类前面
- 如果多个父类，则根据继承语法中括号内类的书写顺序存放
- 如果多个类继承了同一个父类，孙子类中只会选取继承语法括号中第一个父类的父类
6.3 多态
- 多态就是同一个对象在不同情况下有不同的状态出现
- 多态不是语法，是一种设计思想
- 多态性：一种调用方式，不同的执行效果
- 多态：同一事物的多种形态，动物分为人类，狗类，猪类
- 多态和多态性
- Mixin（掺入）设计模式
- 主要采用多继承的方式对类的功能进行扩展
- 物理变化与化学变化的区别
- 我们使用多继承语法来实现Mixin
- 使用Mixin实现多继承的时候要非常小心
- 首先他必须表示某一单一功能，而不是某个物品
- 职责必须单一，如果有多个功能，则写多个Mixin
- Mixin不能依赖于子类的实现，就是自己就实现了
- 子类即使没有继承这个Mixin类，也能继续工作，只是缺少了某个功能
- 优点
- 使用Mixin可以在不对类进行任何修改的情况下，扩充功能，枪支的瞄准镜
- 可以方便的组织和维护不同功能组件的划分
- 可以根据需要任意调整功能类的组合
- 可以避免创建很多的新类，避免导致类的继承混乱
# Mixin案例
class Person():
name = "liuying"
age = 18
def eat(self):
print("EAT......")
def drink(self):
print("DRINK......")
def sleep(self):
print("SLEEP......")
class Teacher(Person):
def work(self):
print("Work")
class Student(Person):
def study(self):
print("Study")
class Tutor(Teacher, Student): # Tutor 助教
pass
t = Tutor()
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)
print("*" * 50)
# Mixin的写法
class TeacherMixin():
def work(self):
print("Work")
class StudentMixin():
def study(self):
print("Study")
class TutorM(Person,TeacherMixin, StudentMixin):
pass
tt = TutorM()
print(TutorM.__mro__)
print(tt.__dict__)
print(TutorM.__dict__)
7、类相关函数
- issubclass:检测一个类是否是另一个类的子类
- isinstance:检测一个对象是否是一个类的实例
- hasattr:检测一个对象是否有成员xxx
- getattr:get attribute
- setattr:set attribute
- delattr:delete attribute
- dir:获取对象的成员列表
# issubclass
class A():
pass
class B(A):
pass
class C():
pass
print(issubclass(B, A)) # 判断B是不是A的子类 返回True
print(issubclass(C, A))
print(issubclass(B, object))
# isinstance
a = A()
print(isinstance(a, A)) # 判断是不是一个类的实例
print(isinstance(A, A))
# hasattr
class A():
name = "NoName"
a = A()
print(hasattr(a, "name"))
print(hasattr(a, "age"))
print(dir(A))
print(dir(a))
665
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
