面向对象
面对对象
什么是面对对象
在学习面对对象之前需先明确面向过程
在学习面向对象之前我们写的任何代码都是面向过程的
什么是面向过程？面向过程是一种编程思想
即面向 朝向过程去编写代码，在编写代码是要时刻想着过程
过程是什么？解决问题的步骤 流程，即第一步干什么
其目的是将一个复杂的问题，拆分为若干的小问题，按步骤一一解决
也可以说将一个复杂性的问题，流程化（为其制定一个固定的实现流程）
面向过程编程的优缺点
优点：复杂的问题简单化
缺点：由于其实现流程是固定的，一但中间某一个步骤发生了修改，将导致整体都需要修改，牵一发而动全身
实现某个功能固定流程，再在原来的基础上增加新功能，就需要重新设计一遍，扩展性差，维护性差
由于面向过程所存在的缺点，才催生了新的编程思想
面向对象
是一中编程思想，即编写代码的方法
oop ，object—oriented programming的简称，就是面向对象的英文缩写
将程序看做是一堆对象的集合，实现功能的方式就是对象之间交互来实现
什么是对象
一切皆对象
对象指的是具备某些特征与进的结合体，是实实在在存在的具体物体（描述完就能找到）
什么是类
类就是类型，类别，分类
类是一个抽象概念，不是实际存在的，是根据一些具备相同特征和技能的对象 抽取到的
类与对象之间的关系
类事包含一系列相同特征和技能的对象
对象是属于某个类的实例
先有类还是先有对象
在生活中是先有对象再根据对象特征和技能划分类
在程序中是先有类还是先有对象
程序员在程序中相当于上帝 需要什么就创造什么
在程序中先有类，才能通过类来产生对象，要先确定对象具备什么特征和行为才能产生对象
面向对象的优缺点
优点：
1、不用考虑繁琐的实现步骤，从一个操作工变成了指挥者。
2、扩展性高，当需要一个新功能时，加一个具备新功能的对象，命令它去完成任务
3、各个对象之间耦合度低，当一个一个对象出现了问题，不会对其他对象产生影响
4、可维护性高
缺点：
1、面对对象的复杂度比面向过程高
2、无法预知执行结果，就象lol的游戏过程，一定不能把过程写死，每个英雄的行为是不固定的
使用场景：需要较高的扩展性时，（直接与用户发生交互的程序，例如qq，微信）
对于不需要扩展性的程序而言，使用面对对象反而增加了复杂度
为什么要使用面对对象，因为在目前情况下，很多程序与用户直接打交道而用户的需求千变万化，所以对扩展性要求非常高
面对对象编程的本质就是使用使用不同的对象来完成
类和对象
在计算机创建一个人类对象
要得到对象必须要先告诉计算机，这个对象具备是吗特征和行为，所以需要先定义类
注：类名要按照大驼峰的方式来书写ThisIsPerson 每个单词的首字母都大写
class Person：
pass
class就是定义一个类
在类中面向对象的特征和行为
class Person:
#用变量来描述特征
name = "李四"
sex = "man"
age = 20
#得到对象 通过调用类也称之实例化 或创建对象
obj = Person()
print(obj)
#输出结果<__main__.Person object at 0x00000279452B7C50>
#使用对象的实现（说的就是特征）
print(obj.name)
print(obj.age)
print(obj.sex)
表示模块名为main 其包括一个Person类 通过Person类产生了一个对象地址为0x00000279452B7C50
这是一个Person类的对象，其地址为0x00000279452B7C50
class Student:
number = "007"
name = "嘉文"
sex = "man"
age = 20
# 学生的学校 由于每个学生的学校都是相同 所以将其放到类中
school = "Tsinghua"
# 创建了两个学生对象
stu1 = Student()
stu2 = Student()
print(stu1)
print(stu2)
# 每个对象内存地址都是不同的 , 在创建对象时,计算机会申请一个新的内存空间,并将对象中的内容存进去
print(id(stu1.name))
print(id(stu2.name))
# 由于name的值时声明在类中的,所以每个对象使用的都是同一份
print(stu1.name)
print(stu2.name)
# 为对象单独制定属性
stu1.name = "韩信"
stu2.name = "陈大炮"
print(stu1.name)
print(stu2.name)
# 每个对象的name属性都不同,则意味需要给每个对象单独指定name
存储属性的位置有两个 一个是类中，还有一个是对象中
当每个对象的某个特征都相同时则放到类中
当每个对象的某个特征多不同时则放到对象中
通过_ dict _ 可以获取一个对象中包含的内容
stu1.age = 30
print(stu1.__dict__)
print(stu2.__dict__)
#获取类中包含的内容
print（Student.__dict__）
属性的访问顺序
class Car:
c_type = "破鞋"
color = "red"
price = 400000
c1 = Car()
c2 = Car()
print(c1.__dict__)
print(c2.__dict__)
print(c1.c_type)
# 当对象中不存在是会到类中去找
c1.c_type = "法拉利"
print(c1.__dict__)
print(c2.__dict__)
print(c1.c_type)
print(c2.c_type)
# 如果对象中存在这个属性,优先访问对象中的属性
print(Car.__dict__)
查找顺序 先查对象 再查类
当创建一个类的时候 会产生名称空间,存储类中名称和值的绑定关系
当创建一个对象的时候 会产生名称空间,存储对象中名称和值的绑定关系
类还有另一个作用 就是 作为对象的模板,所有属于同一个类的对象,都具备类中的公共内容
即使我们什么都不写 类中也存在一些自带的属性,是从父类得到的(继承会详细讨论)
初始化函数
class Student:
# 定义一个函数 用于为对象设置属性
def set_attr(obj, name, sex, age):
obj.name = name
obj.sex = sex
obj.age = age
pass
stu1 = Student()
# 指定属性
stu1.name = "张无忌"
stu1.sex = "man"
stu1.age = 18
stu2 =Student()
stu2.name = "周芷若"
stu2.sex = "woman"
stu2.age = 78
# stu3 = Student()
# stu4 = Student()
# set_attr(stu3,"灭绝","woman",88)
# set_attr(stu4,"金毛狮王","man",20)
# print(stu3.__dict__)
# print(stu4.__dict__)
# set_attr这个函数目的是用于设置对象的属性 ,如果没有对象则该函数没有存在的意义,也就是初始化函数与类应该是一个整体
# 应该讲这个函数放到类中
stu3 = Student()
stu4 = Student()
Student.set_attr(stu3,"金毛狮王","man",80)
print(stu3.__dict__)
Student.set_attr(stu4,"张全蛋","man",28)
print(stu4.__dict__)
# 现在已经简化了代码 但是对象的创建和初始化步骤是分开的, 通常对象一旦创建 就应该进行初始化,所以最好时将创建与初始化进绑定
stu5 = Student()
print(stu5)
# 作为一个人 一旦出生 性别必须要指定
# 带有__开头__结尾的函数 是一些特殊内置函数,会在某个时间点自动触发执行
class Person:
# 初始化函数名称是固定 该函数会在调用类是时自动执行,self参数必须有,表示要进行初始化的对象,系统会自动传值
def __init__(self,name,age):
print("执行了 __init__")
print(self)
self.name = name
self.age =age
p1 = Person("张三丰",80)
print(p1.__dict__)
p2 = Person("李狗蛋",20)
print(p2.__dict__)
# init 函数用于初始化对象,它会在创建对象时,自动执行,并传入调用类时传递的参数,第一个参数表示要初始化的对象本身,
# self(第一个)参数不需要手动传递
# self表示对象自己 是一个形式参数,名字可以随便取,但是不建议修改
绑定方法
绑定方法
什么是绑定 把两个东西捆绑在一起
什么是方法 方法 就是 函数
函数是专业术语,不好理解,面向对象编程思想,是要我们模仿现实生活中的抽象概念,为了方便理解就把函数称之为方法
绑定方法就是 把对象与函数进行绑定
为什么要把把对象与函数进行绑定
调用函数 就变成了调用对象的方法
对象本质上就是一种存放数据的容器
函数是用于处理数据的代码
绑定方法就是将数据与处理数据的函数绑定在一起
最终问题是 为什么要把数据与处理数据的函数绑定在一起?
如何使用绑定方法
class Student:
school = "BeiJing"
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
def learning(self):
print("正在学习..")
def sayHI(self):
print("hello my name is %s my age:%s my sex:%s" % (self.name,self.age,self.sex))
# 默认情况下 在类中定义的函数都是绑定方法,共同点是,都会讲对象作为第一个参数self
stu1 = Student("一个学生","man",18)
stu1.sayHI()
Student.sayHI(stu1)
# 当用用对象来调用类中的方法时,默认把对象传入方法中
# 而用类名来调用时,则需要手动传入对象
print(stu1.sayHI)
#<bound method Student.sayHI of <__main__.Student object at 0x000001784F889C50>>
# 这是一个绑定方法,本质上是Student类中的sayHI函数 现在把这个函数绑定给了地址为0x000001784F889C50的对象
stu2 = Student("李四","女",19)
stu2.sayHI()
print(stu2.sayHI)
# 只要拿到对象 就同时拿到了数据和处理数据的方法
为设么要有绑定
第一个问题传递参数,必须手动传递,很有可能传参顺序而发生错误
第二个问题每次处理数据 都需要手动传参数
第三个问题 当要处理的数据特别的多 就不能再定义为变量了 你可以使用列表出来存储要处理的数据
但是 每次处理 都需要先获取数据 在传递给处理数据的函数
所以将 要处理的数据与 处理数据的函数进行绑定
如何绑定? 就得用对象了
绑定给类方法
class Student:
school = "beijing"
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
# 绑定方法分为两种 一种是绑定给对象的,一种绑定给类的
# @classmethod
# def print_school_name():
# print("学校名为:%s" % Student.school)
# 绑定给类的方法 使用一个装饰器叫classmethod,必须有一个参数,表示当前类,参数名也可以自己定义,建议不要修改
@classmethod
def print_school(cls): # 输出类里面叫school的属性
print(cls.school)
# def print_school2(self): # 输出类里面叫school的属性
# print(self.school)
# 这是绑定给对象的方法
def sayHello(self):
print(self.name, " 说: 你好")
# Student.print_school_name()
Student.print_school()
Student.print_school()
stu1 = Student("印度阿三","woman",20)
stu1.print_school()
stu10 = Student("赵六","男",20)
Student.print_school2(stu10)
对象绑定方法 可以使用对象来调用 也可以使用类名来调用
在对象调用时会自动传入对象自己
类调用时不会自动传参
类的绑定方法,对象和类都能调用,并且都会自动传入这个类
一个方法到底应该绑定给对象还是帮对给类?
当要处理的数据包含在类中时,就应该绑定给类
当要处理的数据包含在对象中时,就应该绑定给对象
# 有一个Dog类 每一个Dog对象都应该会叫 会跑 请用面向对象来完成
class Dog:
def __init__(self,nikename,gender,age):
self.nikename = nikename
self.gender = gender
self.age = age
def run(self):
print("不好了 ",self.nikename,"跑了 ")
def bark(self):
print("听",self.nikename,"在瞎叫...")
d1 = Dog("大金毛","母的",2)
d2 = Dog("大黄","公的",3)
d1.run()
d2.bark()
类的绑定方法和对象的绑定方法的相同与不同
相同点:
1.都会自动传值
2.都可以被类和对象调用
不同点:
1.对象绑定方法再对象调用时 传的是对象自己 而类绑定方法字自动传的是类自己
2.第一个参数 个cls 一个叫self
非绑定方法
class Teacher:
def __init__(self,name,sex):
self.name = name
self.sex = sex
# @staticmethod 用于定义个非绑定方法
@staticmethod
def test_func(num):
print("test_func run!")
print(num)
Teacher.test_func(1)
t1 = Teacher("矮根","男")
t1.test_func(100)
print(t1.test_func)
什么是非绑定方法 在类中 即不绑定给类 也不绑定给对象
特点:没有自动传参数的效果 ,类和对象向都能调用,就是一个普通函数
当你的这个功能不需要访问类的数据 也不需要访问对象的数据,就可以作为一个非绑定方法
使用场景较少
练习
1.创建Student类
2.拥有以下属性: 姓名 性别 年龄 学校 班级
3.拥有以下方法
save(name) 其作用是将这个对象序列化到文件中
get_obj(name) 其作用是根据name从文件中反序列化为得到一个对象
分析save方法和get_obj 应该作为绑定给对象还是绑定给类
import json
class Student:
school = "beijing"
def __init__(self,name,sex,age,classes):
self.name = name
self.age = age
self.sex = sex
self.classes = classes
def save(self):
dic = {"name":self.name,"sex":self.sex,
"age":self.age,"classes":self.classes}
with open(self.name,"wt",encoding="utf-8") as f:
json.dump(dic,f)
@classmethod
def get_obj(cls,name):
with open(name,"rt",encoding="utf-8") as f:
dic = json.load(f)
obj = cls(dic["name"],dic["sex"],dic["age"],dic["classes"])
return obj
# stu1 = Student("阿尔法","man",20,"py5期")
# stu2 = Student("张三","woman",20,"py5期")
# stu1.save()
# stu2.save()
stu = Student.get_obj("阿尔法")
print(stu)
print(stu.name)
继承
1、什么是继承
继承是一种关系，必须存两个对象才可能产生这种关系，在现实生活中的继承，儿子继承父亲的就叫继承
被继承的称之为父，继承的一方称之为子
在程序中继承指的是类与类之间的关系
2、为什么要使用继承
在生活中，通过继承，子可以直接享受父提供的内容，例如财产
在程序中，通过继承可以直接使用父类已有的代码
3、继承的使用
缺定继承关系：在子类中类名后面加上括号，括号内加上父类名称即可
在python中一个子类可以有多个父类，多个父类在括号中用逗号隔开
子类可以使用父类中的属性
子类也可以使用父类中的函数
抽象：相同属性抽象出来放到共同的父类中
class Father：
pass
class GanDie：
pass
class Son(Father，Gandie)# 继承的方法
pass
class Person:：
def __init__(self, name age, sex)
self.name = name
self.age = age
self.sex = sex
def eat(self):
print("正在吃饭")
def student(self)
print("正在学习")
class Teacher(person):
def terching(self):
print("老师正在上课")
t1 = Teacher("blex",30,"woman")
t1.eat()
t1.study()
class Student(Person):
pass
stu1 = Student
stu1.eat()
stu1.study()
#通过继承 避免了重复代码的编写
#通过抽象 避免了继承到一些不应该有的内容
#应该先抽象再继承
#在抽取过程中 可能会有一些跟业务需求无关的类，这是正常的 这些称之为公共父类
#公共父类的作用是存储多个自乐相同属性和技能
4、派生与覆盖
什么是派生
派生指的是 子类继承某个父类 并且拥有自己独特的属性或技能 该子类称之为派生类
子类出现了与父类重复的名字，称之为覆盖
子类出现与父类不同的名字称之为派生
class Person:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def sayHI(self):
prtit('hello 我是%S 今年%s岁 性别：%s'%(self.name, self.age, self.sex))
class Test(Person): #该类不能称之为派生类，因为没有与任何独特的内容与父类完全一致
pass
class Student(Person): #Student类就称之为派生类（有自己独特的属性与内容）
def __init__(self,name,age,sex,number):
self.name = name
self.age = age
self.sex = sex
self.number = number
# 上课
def up_class(self):
print("%s 正在上课....."）
5、子类访问父类父方法
子类访问父类有两种方法
1、指名道姓的方法访问
2、使用super的方法访问
class Person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
print(self)
def sayHI(self):
print("hello 我是%s 今年%s岁 性别:%s" % (self.name,self.age,self.sex))
class Student(Person):
def __init__(self,name,age,sex,number):
# self.name = name
# self.age = age
# self.sex = sex
#上述代码与父类中完全相同
Person.__init__(self,name,age,sex)
self.number = number
# 上课
def up_class(self):
print("%s 正在上课.....")
def sayHI(self):
# print("hello 我是%s 今年%s岁 性别:%s" % (self.name,self.age,self.sex))
# 访问父类中的方法来简化代码
# 指名道姓
# Person.sayHI(self)
super.sayHI()
print("学号:",self.number)
stu1 = Student("阿三",20,"woman","9527")
# print(stu1)
# print(stu1.name,stu1.age,stu1.sex)
stu1.sayHI()
class Student(Person):
def __init__(self,name,age,sex,number):
super(Student,self).__init__(name,age,sex)
self.number = number
# 上课
def up_class(self):
print("%s 正在上课.....")
stu1 = Student("阿三",20,"woman","9527")
print(stu1)
print(stu1.name,stu1.age,stu1.sex)
7、存在继承关系后的属性查找顺序
对象——》类——》父类——》父类的父类。。。。
优先找对象，如果没有对象，则找类，如果类没有，会沿着继承关系一直找到最顶层的父类
无论属性还是方法 查找方法都是一样的
存在多个继承的话就按照继承的顺序，先继承谁就找谁
8、经典类与新式类
所有直接继承或间接继承object的类 都是新式类
object 称之为 根类 意思是所有类 都源自于object类
为什么这么设计
例如：创建对象时，需要申请内存空间，创建新的名称空间将对象的属性放入名称空间，这一系列复杂的基础操作，都由object来完成
简单地说object提供了一下常用的基础操作
即所有类都属于新式类（在python3中）
在python3中默认所有类都是新式类
而python2中默认的是经典类（不会自动基础object）
——bases——用于查看父类
显示属性的查找顺序类别，继承查找属性就是按照mro来查找的
super访问父类内容时 按照mro列表属性查找
组合
什么叫组合
一个对象将另一个（或多个）对象作为属性
组合的目的
降低冗余，降低耦合度
class Person:
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
class Student(Person):
def __init__(self,name,sex,age,number):
super().__init__(name, sex, age)
self.number = number
def show_info(self):
print(self.__dict__)
def select_cursor(self):
print("%s 正在选课...." % self.name)
class Teacher(Person):
def __init__(self,name,sex,age,salary,level):
super().__init__(name,sex,age)
self.salary = salary
self.level = level
def set_score(self):
print("%s 正在为学生打分..." % self.name)
# 上述代码通过继承减少了代码冗余
# # 需要给学生添加手机这个属性,(手机号码,运营商,归属地,可以打电话)
# stu = Student("李寻欢","女",20,"飞刀一班")
# print(stu.name)
# print(stu.phonenumber)
stu = Student("李寻欢","女",20,"飞刀一班")
stu.show_info()
学生会增加各种各样的新的属性 比如手机 比如电脑, 这样Student中会增加大量的属性和方法
后期的维护成本非常高
这时就需要使用组合 来完成减少代码冗余
class Phone:
def __init__(self,phonenumber,operator,address):
self.phonenumber = phonenumber
self.operator = operator
self.address = address
def call(self):
print("%s 正在拨号" % self.phonenumber)
class Person:
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
class Student(Person):
def __init__(self,name,sex,age,number):
super().__init__(name, sex, age)
self.number = number
def show_info(self):
# print("name:%s sex:%s, age:%")
print(self.__dict__)
def select_cursor(self):
print("%s 正在选课...." % self.name)
class Teacher(Person):
def __init__(self,name,sex,age,salary,level):
super().__init__(name,sex,age)
self.salary = salary
self.level = level
def set_score(self):
print("%s 正在为学生打分..." % self.name)
stu = Student("乔峰","男",38,"007")
# 学生买了一台手机 所以增加一个手机属性
p1 = Phone("1999999999","中国小米移动","上海浦东")
stu.phone = p1
# 学生要打电话
stu.phone.call()
# 通过将手机对象和学生对象进行组合 完成了需求,并且相比较继承而言
# 耦合度低 手机和学生在修改的时候 互不影响
# 同时也减少了代码冗余
# 继承是一种关系 什么是什么 学生是人类 老师是人类 (如果把手机相关内容插入到人类中,相当于学生是手机???)
# 组合是 对象之间的关系 学生对象拥有手机对象
封装
1、什么是封装
生活中的封装类似工厂，将一堆产品装入纸箱，拿胶带封起来
在程序中，封装指的是将内容隐藏起来，在面向对象中有什么内容可以被隐藏？就是属性和方法
2、为什么要封装
1、提高安全性（例如：cup频率 缓冲区大小，电脑，手机汽车等）
对于封装属性而言，是通过给范围和修改增加额外的逻辑判断来实现的
2、封装是为了明确区分内部和外部
3、如何使用封装
在属性或方法名称前 加上两个下划线，就可以将其设置为私有
另外补充：python中权限只有两种，公开（谁都能访问）的和私有的（只有自己能访问）
属性的封装，通过需要提供相应的设置器和访问器
4、什么时候用
5、封装的实现原理
6、封装的特点
被隐藏的内容 在内部是可以直接访问的，外部无法访问
封装的方法：
class Student:
def __init__(self,name,sex,age,idCard):
self.name = name
self.age = age
self.sex = sex
self.__idCard = idCard
def say_hi(self):
print("hello i am %s age is : %s sex is %s" %
(self.name,self.age,self.sex))
def test(self):
print(self.__idCard)
# 可以使用方法 将内部封装的内容返回出去
def get_idCard(self):
return self.__idCard
# 如果直接返回的话 就没必要设置隐藏了 ,谁都可以通过调用方法来获取,我们再方法中加上自己的判断逻辑
def get_idCard2(self,pwd): # 如果密码正确我就给你身份证号码
if pwd == "1111":
return self.__idCard
else:
print("滚 你没有资格知道我的身份证...")
def set_idCard(self,pwd,new_idCard): # 如果密码正确就允许修改
if pwd == "1111":
self.__idCard = new_idCard
else:
print("滚 你没有资格修改我的身份证...")
stu = Student("步惊云","男",20,"3206661998445132")
stu.say_hi()
# print(stu.__idCard) # 加上__也访问不了
# stu.test() # 但在内部是可以访问的
# idcard = stu.get_idCard()
# print(idcard)
# 即实现了隐藏 又提供了访问的接口 这就是封装的用法
# idcard = stu.get_idCard2("1111")
# print(idcard)
# 身份证填错了 要修改
# stu.__idCard = "123" # 这样是无法修改原来的身份证信息的 而是添加了新的属性
#
# print(stu.__idCard)
# print(stu.get_idCard2("1111"))
# 调用方法来修改隐藏的属性
stu.set_idCard("1111","xxxxxxxxxxxxxxxxxx")
print(stu.get_idCard2("1111"))
# 总结:对于被隐藏的属性 访问和修改都需要通过方法 get用于获取 set用于设置(也称之为设置器和访问器)
class A:
def __f1(self):
print("f1 run")
def run_f1(self):
self.__f1()
a = A()
a.run_f1()
# ATM 的取款功能
# 1.插入银行卡 2.输入密码 3.选择取款金额 4.取款
class ATM:
def __insert_card(self):
print("插入银行卡...")
def __input_pwd(self):
print("输入密码...")
def __select_money(self):
print("选择取款金额...")
def withdraw(self):
self.__insert_card()
self.__input_pwd()
self.__select_money()
print("取款成功!....")
atm = ATM()
atm.withdraw() # 外部调用这个简单的接口 就能完成一系列复杂的操作
# atm.select_money() #直接调用内部的方法 是没有意义的无法完成整个功能
# 当然用户按照流程一一调用也可以完成功能 但是太麻烦
# atm.insert_card()
# atm.input_pwd()
# atm.select_money()
# 封装方法 如何封装 给方法名字前面加上双下划线
# 封装方法的好处:
# 1.提高安全性
# 2.隔离复杂度 (将复杂的内容隔离到内部 外部只留下简单的接口 对于使用者 难度降低)
封装的实现原理
class Person:
def __init__(self,name,sex,age,idCard):
self.name = name
self.sex = sex
self.__age = age
self.__idCard = idCard
def get_idCard(self):
return self.__idCard
def __test(self):
pass
print("aaaaaaaaaa")
# p = Person("比尔盖茨","男",20,"322323232332332")
#
# # print(p.__idCard)
# p.__idCard = "XXXXXX"
# print(p.__idCard)
#
# print(p.get_idCard())
#
# print(p.__dict__)
# print(Person.__dict__)
#
#
# p.__xxxxxxxxxxxx = 1
#
# print(p.__dict__)
# 通过__dict__ 可以发现
# 1.私有的属性和方法名称 前自动加上了_类名 python就是通过这样的转换方式来实现封装
# 2.只有在类的内部的双下划线才会被自动转换,并且这个转换过程只执行一次,在类定义完成后 后续添加的双下划线开头的名称是不会自动转换的
# 3.父类中私有的方法 子类中无法使用
#在父类中定义的私有方法 能不能被子类所覆盖?
总结
封装指的是隐藏内部的实现细节，对外提供访问的接口
封装是隐藏，但是不是单纯的隐藏
能封装的内容：属性和方法
如何封装：名字前加__双下划线
对于被隐藏的属性访问和修改都需要通过方法 一般get用于获取，set用于设置（也称之为设置器和访问器）
property
当一些属性的值，不是固定的而是通过计算得来的时候，我们必须为这个属性增加方法才能完成计算
但是一旦使用方法后，该属性的范围的就成了方法的调用，很明显与其他属性访问方式不同，这个给使用者造成迷惑
所有需要将这个方法伪装成普通属性，这就用到了Property
property可以将方法伪装成属性，利用这个特点我们也可以将其使用到封装中
之前没有这个装饰器我们需要为私有的属性提供两个方法，但是这样一来访问私有属性的方法就发生了变化
这时候就可以使用property来进行伪装，使的访问访问私有属性与访问普通属性的方式一致
另外property还提供了setter（用于修改属性的值）和deleter（删除属性的值）
# BIM案例:
class Person:
def __init__(self,name,weight,height):
self.name = name
self.weight = weight
self.height = height
# self.bmi = weight/(height*height)
# def bmi(self):
# return self.weight / (self.height * self.height)
@property
def bmi(self):
return self.weight / (self.height * self.height)
p = Person("尔晴",50,1.5)
# print(p.bmi)
# p.weight = 90
# print(p.bmi)
# 现在 虽然可以实现需求 但是我们把一个属性变成了一个行为 这是不合理的
# print(p.bmi())
# p.weight = 90
# print(p.bmi())
# 使用property装饰器 可以将一个方法伪装成一个属性
print(p.bmi)
p.height += 0.2
print(p.bmi)
class Student:
def __init__(self,name,sex,idCard):
self.name = name
self.sex = sex
self.__idCard = idCard
def get_idCard(self):
return self.__idCard
def set_idCard(self,new_id):
self.__idCard = new_id
@property # 需要掌握
def idCard(self):
return self.__idCard
@idCard.setter #了解的
def idCard(self,new_id):
self.__idCard = new_id
@idCard.deleter # 了解的
def idCard(self):
print("身份证属性被删除了.....")
del self.__idCard
stu = Student("尔康","男","323254554554")
# print(stu.get_idCard())
# stu.set_idCard("xxxx")
print(stu.get_idCard()) # 使用装饰器前
print(stu.name) # 普通属性的访问
print(stu.idCard) # 使用装饰器后
stu.idCard = "aaaaaaa" # 使用装饰器后的修改操作
print(stu.idCard)
del stu.idCard
print(stu.__dict__)
print(Student.__dict__)
多态
什么是多态
多种状态 形态
生活中具备多种形态的事物 水（水蒸气 冰 液态水）
一种事物具备多种形态或状态 就称之为多态
官方解释：不同对象 可以响应同一方法，并作出不同的行为，产生不同结果
如何实现多态？
让几个不同类拥有相同的父类，这样一来他们就具备了形态的方法，每个子类要覆盖父类的方法
程序中的多态 例如动物
class Animal:
def eat(self):
print("动物在吃东西...")
def sleep(self):
print("动物在睡觉...")
def drink(self):
print("动物需要水.....")
class Person(Animal):
def eat(self):
print("人吃粮食...")
class Pig(Animal):
def eat(self):
print("猪吃饲料...")
class Dog(Animal):
def eat(self):
print("狗吃骨头...")
person = Person()
pig = Pig()
dog = Dog()
person.eat()
pig.eat()
dog.eat()
#假设你学习了C1驾照 意味着 所有C1类的汽车都能开 因为每种C1汽车的驾驶方式相同
# 当使用了多态之后 对象的使用者不需要关心这个对象具体的实现,只需要知道该对象属于哪个基类,就能直接使用它
# 如此扩展性变高了
class Phone:
def call(self):
print("手机就能打电话..")
def send_msg(self):
print("手机能发短信..")
class WindowsPhone(Phone):
def call(self):
print("拨号打电话..")
def send_msg(self):
print("输入号码发短信..")
class IPhone(Phone):
def call(self):
print("拨号打电话..")
def send_msg(self):
print("输入号码发短信..")
# 可以定义一个方法接受一个手机为参数 无论是是类型的手机 都可以被使用
def CALL(phone):
phone.call()
wp = WindowsPhone()
ipx = IPhone()
CALL(wp)
CALL(ipx)
# 系统内置的方法有很多都体现了多态
print(len("abc"))
print(len([1,2,3,4,]))
print(len({"name":"123","sex":"man"}))
print("abc".__len__())
print([1,2,3,4,].__len__())
print({"name":"123","sex":"man"}.__len__())
print(len({1,23,4,5}))
多态之ABC模块
多态是多个对象拥有相同的方法，但是我们没有从严格要求说必须要提供这些方法，子类完全可以不提供这些方法
现在要做的就是，严格要求 子类必须实现父类声明的方法
import abc
# abstract class 是抽象类的缩写 抽象的意思是 不清晰 不具体 看不懂
#使用ABC模块来限制子类 的步骤
#1.为类中指定元类为abc.ABCMeta
#2.在相应的方法上加上abc.abstractmethod装饰器
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod
def eat(self):
pass
@abc.abstractmethod
def drink(self):
pass
class Cat(Animal):
def eat(self):
print("猫爱吃鱼肉...")
def drink(self):
print("用舌头舔..")
class Dog(Animal):
def eat(self):
print("狗爱吃骨头...")
def drink(self):
print("用舌头舔..")
class Pig(Animal):
def eat(self):
print("猪 爱吃草...")
def drink(self):
print("用嘴吸的..")
p = Pig()
# p.eat()
c = Cat()
# c.eat()
# 多态的好处 完全不需要考虑得到的对象时声明类型 只要知道了其基类中的内容就能使用
def feeding(animal):
animal.eat()
animal.drink()
鸭子类型
python推崇简单的编程方法
鸭子类型 如果一个对象叫声象鸭子 走路也象鸭子 那就把它当成鸭子
对应到代码中就是：只要你的行为一样 那就把你当成同一个类型来看待
class Duck:
def bark(self):
print("鸭子嘎嘎叫...")
def run(self):
print("摇摇晃晃走....")
class Chicken:
def bark(self):
print("鸡咯咯叫...")
def run(self):
print("摇摇晃晃走....")
def test(obj):
obj.bark()
obj.run()
duck = Duck()
c = Chicken()
test(duck)
test(c)
# 如果你足够自觉 你可以不使用abc模块 也不需要基类 自觉地将方法名字都写成一样 同样可以实现多态
# 这种方式称之为鸭子类型
isinstance和issubclass
class Person：
pass
class Student：
pass
stu = Student():
print(type(1) == type(1)) # 判断两对象是不是同一个类型
print(isinstance(stu,Student)) # 判断stu对象是不是S图dent类的实例
print(issubclass(Student,Person)) # 判断一个类是不是另一个类的子类（所有类都是object的子类或子子类）
反射
反射 其实说的就是反省
简单的说 就是对象具备一种修正错误的能力
hasattr 是否存在某个属性
getattr 获取某个属性的值
setattr 设置摸个属性的值
delattr 删除某个属性的值
这几方法有一个共同点 都是通过字符串来操作属性
可以理解为，通过字符串来操作属性，就叫反省
class Student(object):
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
def study(self):
print("学生正在学习")
stu = Student("egon","woman")
#当你获取到一个对象时，但是并不清楚这个对象内部细节是，就需要使用反射了
def test(obj):
if hasattr(obj,"name")
print(getattr(obj,"name","没有name属性"))
test(stu)
setattr(stu,"school","beijing")
delattr(stu,"shchool")
print(getattr(stu,"school",,"没有学校属性"))
delattr(stu,"age")
print(stu.age)
总结：
如果在编码期间 就能明确知道我要访问的属性，就没有必要使用反射
如果在编码期间，无法明确知道我要访问的属性，就应该使用反射
class Student:
def study(self):
print("学习中....")
stu = Student()
res = getattr(stu,"study",None)
print(res)
def eat(self):
print("正在吃饭...")
# 可以通过反射的方式为对象增加一个方法 但是注意 这样增加的方法就是一个普通函数 不会自动传值
setattr(stu,"eat",eat)
print(getattr(stu,"eat",None))
练习：
# 需要编写一个CMD工具 这个工具可以支持两个命令 dir ,tasklist
class CMD:
def dir(self):
print("列出当前文件夹目录....")
def tasklist(self):
print("查看任务列表.....")
cmd = CMD()
res = input("请输入指令:").strip()
if hasattr(cmd,res):
func = getattr(cmd,res)
print(func)
func()
else:
print("输入的指令不正确....")
类中的特殊的内置函数
前后带双下滑线的都是特殊的内置函数 会在莫些时机自动执行，一般不情况下我们不应该直接调用
——str——
当我们需要自定义打印显示内容时，就需要实现——str——方法
该方法必须返回一个字符串，返回的是什么，打印出来就是什么
class Test:
def __init__(self,name):
self.name = name
def __str__(self):
print("str run....")
return self.name
t = Test("安米")
print(int(1).__str__())
# print([1,2,3,5])
# print(t)
# 在讲一个对象转换字符串时 本质就是在调用这个对象 __str__方法
print(str(t))
——del——
当对象被从内存中删除时，会自动执行
另一种情况时 程序员手动删除了这个对象也会自动执行
什么时候使用它
在Python中有自动内存管理机制，所有python自己创建的数据不需要我们做任何操作
但是有一种情况，我们使用python打开了一个不属于python管理的数据时
比如打开一个文件，这个文件一定是操作系统在打开的，会占用系统内存，而python解释器无法操作系统内存的
所以当你python解释器运行结束后，文件依然处于打开状态，这时候就需要使用——del——来关闭操作文件
简单的说，当程序运行结束时，需要做一些清理操作 就使用——del——
——del——也称之为析构函数：分析构造，并拆除对象
class Student:
def __del__(self):
print("对象被删除了....")
stu = Student()
# 手动删除 立即执行__del__
del stu
import time
time.sleep(5)
class TextFile:
def __init__(self,filepath,mode="rt",encoding="utf-8"):
self.file = open(filepath,mode=mode,encoding=encoding)
def read(self):
return self.file.read()
def write(self,text):
self.file.write(text)
# 该方法其实就是一个通知性质 仅仅是告诉程序员 对象即将被删除
def __del__(self):
# 在这里关闭系统的文件 妥妥的
self.file.close()
tf = TextFile("2.今日内容.txt")
print(tf.read())
# tf.file.close() 不需要手动关闭了 在对象删除时会自动关闭
tf.read()
exec
execute的缩写
表示执行的意思
其作用，是帮你解析python代码，并且将得到的名称存储到指定的名称空间，解释器内部也是调用它来执行代码的
exec需要三个参数
1、需要一个字符串对象，表示需要执行的python语句
2、是一个字典，表示全局名称空间
3、也是一个字典，表示局部名称空间
# 如果同时制定了 全局和局部 则 会字符串中包含名称 解析后存到局部中
# print(globalsdic)
print(localsdic)
localsdic["func1"]()
# # 如果只传了一个传参数 则 将字符串中包含名称 解析后存到全局中
exec("""
aaaaaaaaaaaaaaaaaaaa = 1
bbbbbbbbbbbbbbbbbbbbbbbbbbbb = 2
""",localsdic)
元类
元类是指 用于产生类的类，type就是元类
所有的自定义都是通过type实例化得来
创建模块的过程
1、创建一个空的名称空间
2、执行内部的代码
3、将得到的名字放到名称空间中
# class也是一个对象
class Student(object):
school = "北京大学!"
def study(self):
print("学习中...")
# 使用type可以发现 类其实是type类型的实例(对象)
print(type(Student))
# 我们可以自己调用type来实例化产生一个类
# myclass 包含的代码
code = """
name = "张三"
age = 18
def hello(self):
print("hello %s" % self.name)
"""
#类的名字
class_name = "MyClass"
#类的的父类们
base_classes = (object,)
#类的名称空间
namespace = {}
exec(code,{},namespace)
res = type(class_name,base_classes,namespace)
print(Student)
print(res.name)
print(res.age)
print(res.hello)
# 1.类是由type实例化产生的
# 2.我们可以使用type来产生一个类
# 3.一个类是由 类名字 类的父类元祖 类的名称空间 三个部分组成
class Test(object): #Test = type("Test",(object,),{})
pass
——call——
调用的意思
在对象呗调用时执行（函数，类）
自定义元类的目的
1、可以通过——call——来控制对象的创建过程
2、可用控制类的创建过程
# 自定义一个元类 元类也是一个类 但是需要继承type
class MyMeta(type):
# self 表示要创建对象的那个类(Person) *args是调用Person类时传入的参数
def __call__(self, *args, **kwargs):
print("MyMte中的 call run'")
print(self,*args,**kwargs)
# 下面的三步是固定写法 一个模板 只要你需要控制对象的创建过程 就应该先把模板写出来
# 1.创建空对象
obj = object.__new__(self)
# 2.调用初始化方法
self.__init__(obj,*args,**kwargs)
# self.__init__(obj)
# 3.得到一个完整的对象
return obj
# 修改Person类的元类为MyMeta
class Person(metaclass=MyMeta):
def __init__(self,name,age):
self.name = name
self.age = age
def __call__(self, *args, **kwargs):
print("call run...")
#调用Person这个对象时 执行的是 Person的类(type)中__call__ 方法
p = Person("张三疯",80)
print(p)
# 当调用对象时 会执行该对象所属类中的__call__方法
# p()
print(p.name)
print(p.age)
——init——和——doc——
要控制类的创建过程，只要找到类所属中的——init——即可
——doc——代表的是文档注释
def __init__(self,class_name,bases,namespace):
print("============================")
#print(self.__dict__)
# 我要控制 类的名字 必须 是大写开头
if not class_name.istitle():
print("类名 必须大写开头...... ")
# 该代码是主动抛出异常
raise TypeError("类名 必须大写开头...... ")
#要空类的创建 必须包含__doc__这个属性
if not self.__doc__:
raise TypeError("类中必须有文档注释.....")
pass
class Student(metaclass=MyMeta): # Student = MyMeta("Student",(object,),{})
"""
这是文档注释 可以通过__doc__来获取
这是一个学生类
"""
# 在类的__init__中可以控制该类对象的创建过程
def __init__(self,name):
print("-----------------------")
print(self.__dict__)
self.name = name
print(Student.__doc__)
元类总结：
元类是用于创建类的类
学习元类是为了能控制类的创建过程以及类实例化对象的过程
一、控制类创造的过程
1、创建一个元类（需要继承type）、
2、覆盖——init——方法，该方法会将新建的类对象，类名、父类名，名称空间都传进来，可以利用这些信息再做处理
3、对于需要 被控制的类，需要指定metaclass为上面的元类
二、控制类实例化对象的过程
1、创建一个元类（需要继承type）
2、覆盖——call——方法会将正在实例化对象的类，调用类是传入的参数都传进来
3、在——call——方法中，必须先编写模板代码
3.1、创建空对象
3.2、调用类的——init——方法来初始化这个空对象
3.3返回该对象
4、加入你需要控制的逻辑
类的三个组成部分
类名，父类们，名称空间
元类——》实例化产生——》类——》实例化产生——》对象
单例模式
一种设计模式（套路）
单个实例
一个类如果只有一个实例，那么该类就称之为单例
class MyMeta(type):
obj = None
def __call__(self, *args, **kwargs):
if not MyMeta.obj:
obj = object.__new__(self)
self.__init__(obj,*args,**kwargs)
MyMeta.obj = obj
return MyMeta.obj
#打印机类
class Printer(metaclass=MyMeta):
"""
这是一个单例类 请不要直接实例化 使用get方法来获取实例
"""
obj = None
def __init__(self,name,brand,type):
self.name = name
self.brand = brand
self.type = type
def printing(self,text):
print("正在打印 %s" % text)
# 通过该方法来获取对象 可以保证只有一个对象
# 但是这还不够 因为 还是可以通过调用类产生新对象
# 就应该使用元类 来控制实例化的过程 __call__
# 在__call__ 中编写代码 保证每次调用call 都返回同一个实例 即可
@classmethod
def get_printer(cls):
if not cls.obj:
obj = cls("ES005","爱普生","彩色打印机")
cls.obj = obj
print("创建了新的对象")
return cls.obj
# 以下三个对象 的数据完全相同 但是却 占用三分内存空间
# p1 = Printer("ES005","爱普生","彩色打印机")
# p2 = Printer("ES005","爱普生","彩色打印机")
# p3 = Printer("ES005","爱普生","彩色打印机")
# 现在要处理问题就是 如何能够限制该类 只能实例化一个对象
p = Printer.get_printer()
print(p)
p = Printer.get_printer()
print(p)
p = Printer.get_printer()
print(p)
p = Printer.get_printer()
print(p)
p1 = Printer("ES005","爱普生","彩色打印机")
p2 = Printer("ES005","爱普生","彩色打印机")
print(p1)
print(p2)
# print(p1,p2,p3)
