一.初识面向对象
1.类与对象的关系: 类是对事物的总结. 抽象的概念. 类用来描述对象. 对象是类的实例化的结果. 对象能执行哪些方法. 都由类来决定. 类中定义了什么. 对象就拥有什么
class 类名:
方法
类() #对象
class Car:
pass
Car()
- 注意:类名的首字母大写,严格遵守驼峰命名规范
1.1python中我们可以是用__init__(self)函数给对象进行初始化操作. 这个函数(方法)被称为构造函数(方法)或初始化方法
- 在创建对象的时候会自动的调用 __init__()
- self是你创建出来的那个对象
class Car: #创建类
def __init__(self,color)
self.color=color#属性
c = Car() #创建对象
1.2 方法 ->在类中的函数
class Phone: #创建类
def __init__(self,color,price): #初始化方法(构造方法) 自动调用
self.color=color #属性
self.price=price #属性
def call(self,man): #方法
print(f'用我{self.color}手机给{man}打电话')
def play(self): #方法
print('我%s的手机可以打游戏' % self.price)
p = Phone('红色',5000)
p.call('马云')
p.play()
2.面向对象和面向过程的对比
2.1⾯向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤,即, 先干什么, 后干什么.
- 优点: 负责的问题流程化, 编写相对简单
- 缺点: 可扩展性差
2.2面向对象: 一切以对象为中心.
- 优点: 可扩展性强
- 缺点: 编程的复杂度高于⾯面向过程
3.面向对象的三个特征
- ⾯向对象三大特征: 封装, 继承, 多态. 只要是面向对象编程语言. 都有这三个特征.
3.1. 封装: 把很多数据封装到一个对象中. 把固定功能的代码封装到一个代码块, 函数, 对象, 打包成模块. 这都属于封装的思想.
3.2. 继承: 子类可以自动拥有父类中除了私有属性外的其他所有内容. 在python中实现继承非常简单. 在声明类的时候, 在类名后面添加一个小括号,就可以完成继承关系. 那么什么情况可以使用继承呢? 两个类具有相同的功能或者特征的时候. 可以采用继承的形式. 提取一个父类, 这个父类中编写着两个类相同的部分. 然后两个类分别取继承这个类就可以了了.
- 这样写的好处是我们可以避免写很多重复的功能和代码. 如果从语义中去分析的话. 会简单很多. 如果语境中出现了x是一种y. 这时, y是⼀一种泛化的概念. x比y更加具体. 那这时x就是y的子类.
3.3. 多态: 同一个对象, 多种形态.
- 多态的好处: 程序具有超⾼高的可扩展性. ⾯面向对象思想的核⼼心与灵魂.
二.类的成员
什么是类的成员? 你能在类中写什么? 写的内容就是成员.
class 类名:
# 方法
def __init__(self, 参数1, 参数2....):
# 属性变量
self.属性1 = 参数1
self.属性2 = 参数2
....
# 方法
def method(self):
pass
1.类的成员------变量
1.1.实例变量,类变量(静态变量)
- 实例变量是给对象用的,
- 类变量对多个对象共享,最好用类名来访问
class Person:
country = "中国" # 类变量, 表示所有的该类的对象都共享这个变量.
def __init__(self, name, num, birthday):
# 实例变量(字段) 表示你创建的每⼀个人都有这三个变量量
self.name = name
self.num = num
self.birthday = birthday
p1 = Person("alex", 18, "1840年年06⽉月01⽇日")
print(p1.name)
print(p1.country) #中国
p2 = Person("wusir", 28, "1894年年07⽉月25⽇日")
print(p2.name)
print(p2.country) #中国
2.类的成员------方法
2.1.实例方法(成员方法) 对象直接访问的方法叫实例方法
class Computer:
def play(self): #实例方法 参数为self
print('电脑可以玩')
c = Computer()
c.play() #对象直接调用实例方法
2.2.类方法 @classmethod
类方法需要在参数列表中的第一个位置预留一个位置, 通常我们给第一个参数起名字叫cls. 类方法在被调用的时候也不需要传递实例对象.但是. 系统会自动的把类传递给第一个参数. 类方法在编写的时候, 需要在类方法上面添加@classmethod
class Phone:
@classmethod
def play(cls): #类方法 参数必须是cls
print('我的手机可以打游戏')
2.3.静态方法 @staticmethod
- 静态方法不需要我们给方法传递self. 也就是说. 当出现一个方法不需要使用到成员变量的时候. 就可以选择使用静态方法. 静态方法需要我们在方法上面添加一个@staticmethod
- 静态方法和静态变量一样. 一般都是使用类名直接访问和调⽤用的.
class Phone:
@staticmethod
def func(): #静态方法 没有参数
print('我的电话可以打电话')
3.类的成员------属性
属性其实就是通过方法改造过来的一种变量的写法, 在方法上添加⼀个@property就可以了
注意:
1. ⽅法参数只能有⼀个self
2. ⽅法上⽅要写@property
3. 调用的时候, 我们不需要写括号. 直接当成属性变量来用就可以了.
4. 这种套路只能取值. 不能设置值
class Person:
def __init__(self):
pass
@property
def age(self):
return 1
p = Person()
age = p.age
print(age)
4.私有方法和私有变量
在python中使用__作为⽅法或者变量的前缀. 那么这个方法或者变量就是一个私有的.
class Person:
def __init__(self, mimi):# 私有变量
self.__mimi = mimi
def __age(self):#私有方法
print("不告诉你")`
三.类与类之间的关系
1.依赖关系
class Elphant:
def __init__(self, name):
self.name = name
def open(self):
'''
开门
:return:
'''
pass
def close(self):
'''
关门
:return:
'''
pass
class Refrigerator:
def open_door(self):
print("冰箱门被打开了")
def close_door(self):
print("冰箱门被关上了")
#大象和冰箱之间就是依赖关系. 我用着你. 但是你不属于我. 这种关系是最弱的.
2.关联关系,组合关系,聚合关系
其实这三个在代码上写法是一样的. 但是, 从含义上是不一样的.
-
关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.
-
聚合关系. 属于关联关系中的一种特例. 侧重点是xxx和xxx聚合成xxx. 各自有各自的声明周期. 比如电脑. 电脑⾥里里有CPU, 硬盘, 内存等等. 电脑挂了了. CPU还是好的. 还是完整的个体
-
组合关系. 属于关联关系中的一种特例例. 写法上差不多. 组合关系比聚合还要紧密. 比如人的大脑, 心脏, 各个器官. 这些器官组合成一个人. 这时. 人如果挂了. 其他的东西也跟着挂了
3.继承关系
在面向对象的世界中存在着继承关系. 我们现实中也存在着这样的关系. 比如. x是一种y, 那x就可以继承y. 这是理解层面上的. 如果上升到代码层面. 我们可以这样认为. 子类在不影响父类的程序运行的基础上对父类进行的扩充和扩展. 这里.我们可以把父类被称为超类或者基类. 子类被称为派生类
class Base:
def __init__(self, num):
self.num = num
def func1(self):
print(self.num)
class Foo(Base):
def func1(self):
print("Foo. func1", self.num)
obj = Foo(123)
obj.func1() # Foo. func1 123 运行的是Foo中的func1
四.特殊成员
1. 类名() 会自动执行__init__()
2. 对象() 会自动执行__call__()
3. 对象[key] 会自动执行__getitem__()
4. 对象[key] = value 会自动执行__setitem__()
5. del 对象[key] 会自动执行 __delitem__()
6. 对象+对象 会自动执行 __add__()
7. with 对象 as 变量 会自动执行__enter__ 和__exit__
8. 打印对象的时候 会自动执行 __str__
9. 干掉可哈希 __hash__ == None 对象就不可哈希了.
- 创建对象的真正步骤:
首先, 在执行类名()的时候. 系统会自动先执行__new__()来开辟内存. 此时新开辟出来的内存区域是空的. 紧随其后, 系统自动调用__init__()来完成对象的初始化工作. 按照时间轴来算.
1. 加载类
2. 开辟内存(__new__)
3. 初始化(__init__)
4. 使用对象干xxxxxxxxx
五.反射
1.isinstance type和issubclass的应用
- issubclass() 这个内置函数可以帮我们判断xxx类是否是yyy类型的子类.
class Base:
pass
class Foo(Base):
pass
class Bar(Foo):
pass
print(issubclass(Bar, Foo)) # True
print(issubclass(Foo, Bar)) # False
print(issubclass(Bar, Base)) # True
-
type(obj) 表示查看obj是由哪个类创建的.
class Foo:
pass
obj = Foo()
print(obj, type(obj)) # 查看obj的类
-
isinstance也可以判断xxx是yyy类型的数据.但是isinstance没有type那么精准.
-
isinstance可以判断该对象是否是xxx家族体系中的(只能往上判断)
class Base:
pass
class Foo(Base):
pass
class Bar(Foo):
pass
print(isinstance(Foo(), Foo)) # True
print(isinstance(Foo(), Base)) # True
print(isinstance(Foo(), Bar)) # False
2.函数和方法的区分
- 函数在打印的时候. 显示的是function. 而方法在打印的时候是method.
class Foo:
def chi(self):
print("我是吃")
@staticmethod
def static_method():
pass
@classmethod
def class_method(cls):
pass
f = Foo()
print(f.chi) # <bound method Foo.chi of <__main__.Foo object at 0x10f688550>>
print(Foo.chi) # <function Foo.chi at 0x10e24a488>
print(Foo.static_method) # <function Foo.static_method at 0x10b5fe620>
print(Foo.class_method) # bound method Foo.class_method of <class '__main__.Foo'>>
print(f.static_method) # <function Foo.static_method at 0x10e1c0620>
print(f.class_method) #<bound method Foo.class_method of <class '__main__.Foo'>>
仔细观察, 我们能得到以下结论:
- 1. 类方法. 不论任何情况, 都是方法.
- 2. 静态方法, 不论任何情况. 都是函数
- 3. 实例方法, 如果是实例访问. 就是方法. 如果是类名访问就是函数.
3.反射
关于反射, 其实一共有4个函数:
- 1. hasattr(obj, str) 判断obj中是否包含str成员
- 2. getattr(obj,str) 从obj中获取str成员
- 3. setattr(obj, str, value) 把obj中的str成员设置成value. 注意. 这里的value可以是值, 也可以是函数或者方法
- 4. delattr(obj, str) 把obj中的str成员删除掉
六.约束,异常抛出,异常处理,MD5和日志的处理
1.约束
2.异常抛出
3.日常处理
4.MD5加密算法
5.日志
import logging
# 配置好日志的处理, 默认就是GBK
logging.basicConfig(filename='x1.txt', # 把日志信息写入的文件名
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S', # 时间的格式
level=10) # 当前配置表示 10以上的分数会被写入日件
# 向日志文件写入内容
logging.critical("最高的") # 50, 几乎是最高的
logging.error("最多的") # 40 平时使用最多的就是它
logging.warn("警告") # 30 警告
logging.warning("警告")
logging.info("提示") # 20 级
logging.debug("最低的") # 10
logging.log(999, "自己定义一个等级") #自己定义一个等级
# 再创建⼀个操作⽇志的对象logger（依赖FileHandler）
file_handler2 = logging.FileHandler('l2.log', 'a', encoding='utf-8')
file_handler2.setFormatter(logging.Formatter(
fmt="%(asctime)s - %(name)s -%(levelname)s -%(module)s: %(message)s"))
logger2 = logging.Logger('百度贴吧', level=logging.DEBUG)
logger2.addHandler(file_handler2)
logger2.error("我才不去呢. 我们在北京. 离你那么远")
import traceback
class GenderException(Exception):
pass
class Person:
def __init__(self, name, gender):
self.name = name
self.gender = gender
logger1.info(f"这个人的名字是{self.name}, 这个人的性别是:{self.gender}")
def xizao(self):
print(f"{self.name}在洗澡")
class ZaoTang:
def nan(self, ren):
if ren.gender == "男":
ren.xizao()
else:
raise GenderException("我这里要的是男人")
def nv(self, ren):
if ren.gender == "女":
ren.xizao()
else:
raise GenderException("我这里要的是女人")
try:
p1 = Person("赵亚磊", "男")
p2 = Person("林志玲", "女")
zaotang = ZaoTang()
zaotang.nan(p2)
zaotang.nv(p1)
except GenderException:
print("走错屋里了")
logger1.error("走错屋了.. ")
logger1.error(traceback.format_exc()) # 把堆栈信息记录在日志文件中
七.MRO C3算法