【Python 高级】Python全栈体系（七）
Python 高级
第一章 Python 基础强化
一、面向对象强化
"""
创建员工管理器：
1. 记录所有员工
2. 计算总薪资
岗位：
1. 程序员:底薪 + 项目分红
2. 测试员：底薪 + Bug数 * 5
...
要求：
增加新员工,管理器代码不变.
体会：三大特征，四大原则
"""
class EmployeeManager:
def __init__(self):
self.__employees = []
def add_employee(self, emp):
self.__employees.append(emp)
def calculate_total_salary(self):
total_salary = 0
for item in self.__employees:
total_salary += item.get_salary()
return total_salary
class Employee:
def __init__(self, base_salary=0):
self.base_salary = base_salary
def get_salary(self):
return self.base_salary
# ------------------
class Programmer(Employee):
def __init__(self, base_salary=0, bonus=0):
super().__init__(base_salary)
self.bonus = bonus
def get_salary(self):
# return self.base_salary + self.bonus
return super().get_salary() + self.bonus
class Tester(Employee):
def __init__(self, base_salary=0, bug_count=0):
super().__init__(base_salary)
self.bug_count = bug_count
def get_salary(self):
return super().get_salary() + self.bug_count * 5
manager = EmployeeManager()
manager.add_employee(Programmer(10000, 50000))
manager.add_employee(Tester(8000, 200))
print(manager.calculate_total_salary())
"""
风清扬使用独孤九剑攻击
任我行使用吸星大法攻击
令狐冲既使用独孤九剑又使用吸星大法攻击
...
可能还有很多人,很多技能。
"""
class Person:
def __init__(self, name=""):
self.name = name
self.__skills = []
def add_skill(self, skill):
self.__skills.append(skill)
def release_skill(self):
print(self.name, "释放技能")
for item in self.__skills:
item.attack()
class Skill:
def attack(self):
pass
class DuGuJiuJian(Skill):
def attack(self):
super().attack()
print("独孤九剑攻击")
class XiXinDaFa(Skill):
def attack(self):
super().attack()
print("吸心大法攻击")
fqy = Person("风清扬")
fqy.add_skill(DuGuJiuJian())
fqy.release_skill()
lhc = Person("令狐冲")
lhc.add_skill(DuGuJiuJian())
lhc.add_skill(XiXinDaFa())
lhc.release_skill()
二、技能系统
"""
技能系统
"""
class ImpactEffect:
"""
影响效果
"""
def impact(self):
pass
class DamageEffect(ImpactEffect):
def __init__(self, value=0):
self.value = value
def impact(self):
super().impact()
print("伤害%d生命"%self.value)
class CostSPEffect(ImpactEffect):
def __init__(self, value=0):
self.value = value
def impact(self):
super().impact()
print("消耗%d法力"%self.value)
class LowerDeffenseEffect(ImpactEffect):
def __init__(self, value=0,time = 0):
self.value = value
self.time = time
def impact(self):
super().impact()
print("降低%.1f防御力,持续%.1f"%(self.value,self.time))
class SkillBaseData:
def __init__(self, name="", level=0):
self.name = name
self.level = level
class SkillDeployer:
"""
技能释放器
"""
def __init__(self, base_data=None):
self.base_data = base_data
self.__config_file = self.__load_config_file()
self.__effect_objects = self.__create_effect_objects()
def __load_config_file(self):
return {
"降龙十八掌":["DamageEffect(260)","CostSPEffect(100)"],
"六脉神剑":["DamageEffect(100)","LowerDeffenseEffect(0.7,5)"],
}
def __create_effect_objects(self):
# 根据当前技能名称,获取影响效果名称
# ["DamageEffect(260)","CostSPEffect(100)"]
effect_names = self.__config_file[ self.base_data.name ]
# effect_objects = []
# for item in effect_names:
# obj = eval(item)
# effect_objects.append(obj)
# return effect_objects
return [eval(item) for item in effect_names]
def generate_skill(self):
for item in self.__effect_objects:
item.impact()
# 测试
xlsbz = SkillDeployer(SkillBaseData("降龙十八掌",1))
xlsbz.generate_skill()
lmsj = SkillDeployer(SkillBaseData("六脉神剑",1))
lmsj.generate_skill()
三、多继承
"""
多继承
继承：统一概念/隔离变化
同名方法解析顺序 mro
"""
class A:
def func(self):
print("A")
class B(A):
def func(self):
print("B")
class C(A):
def func(self):
print("C")
class D(B, C):
def func(self):
print("D")
super().func()# ?
C.func(self)# 调用指定名称的父类同名方法
d01 = D()
d01.func()
print(D.mro())
第二章 程序结构
一、模块 Module
1. 定义
- 包含一系列数据、函数、类的文件，通常以.py结尾。
2. 作用
- 让一些相关的数据，函数，类有逻辑的组织在一起，使逻辑结构更加清晰。
- 有利于多人合作开发。
3. 导入
3.1 import
- 语法：
import 模块名
import 模块名 as 别名 - 作用：将某模块整体导入到当前模块中
- 使用：模块名.成员
3.2 from import
- 语法：
from 模块名 import 成员名[ as 别名1] - 作用：将模块内的一个或多个成员导入到当前模块的作用域中。
- 使用：直接使用成员名
3.3 from import *
- 语法：from 模块名 import *
- 作用：将某模块的所有成员导入到当前模块。
- 模块中以下划线(_)开头的属性，不会被导入，通常称这些成员为隐藏成员。
"""
模块
"""
# 导入方式1： import 模块名
# 使用: 模块名.成员
# 本质：创建变量模块地址
# 适用性：面向过程的函数、全局变量
# import module01
#
# print(module01.g01)
# module01.func01()
# module01.MyClass.func03()
# c01 = module01.MyClass()
# c01.func02()
# 导入方式2： from 模块名 import 成员
# 使用: 直接使用成员
# 本质：将其他模块成员导入到当前作用域中（小心命名冲突）
# 适用性：面向对象的类
# from module01 import g01
# from module01 import func01
# from module01 import MyClass
#
# func01()
#
# def func01():
# print("demo02 -- func01")
#
# print(g01)
# func01()
# MyClass.func03()
# c01 = MyClass()
# c01.func02()
# 导入方式3： from 模块名 import 成员
# 使用: 直接使用成员
# 本质：将其他模块成员导入到当前作用域中（小心命名冲突）
from module01 import *
print(g01)
func01()
MyClass.func03()
c01 = MyClass()
c01.func02()
4. 模块变量
- __all__变量：定义可导出成员，仅对from xx import *语句有效。
- __doc__变量：文档字符串。
- __file__变量：模块对应的文件路径名。
- __name__变量：模块自身名字，可以判断是否为主模块。
当此模块作为主模块(第一个运行的模块)运行时，__name__绑定’main’，不是主模块，而是被其它模块导入时,存储模块名。
"""
模块相关概念
"""
# __all__变量：定义可导出成员，仅对from xx import *语句有效。
from my_project.skill_system import *
skill_manager.SkillManager().generate()
# __doc__变量：文档字符串。
print(skill_manager.__doc__)
# __file__变量：模块对应的文件路径名。
print(__file__)
# __name__变量：模块自身名字，可以判断是否为主模块。
print(__name__)# __main__
5. 加载过程
- 在模块导入时，模块的所有语句会执行。
- 如果一个模块已经导入，则再次导入时不会重新执行模块内的语句。
6. 分类
- 内置模块(builtins)，在解析器的内部可以直接使用。
- 标准库模块，安装Python时已安装且可直接使用。
- 第三方模块（通常为开源），需要自己安装。
- 用户自己编写的模块（可以作为其他人的第三方模块）
二、包 package
1. 定义
- 将模块以文件夹的形式进行分组管理。
2. 作用
- 让一些相关的模块组织在一起，使逻辑结构更加清晰。
3. 导入
import 包名.模块名 [as 模块新名]
import 包名.子包名.模块名 [as 模块新名]
from 包名 import 模块名 [as 模块新名]
from 包名.子包名 import 模块名 [as 模块新名]
from 包名.子包名.模块名 import 成员名 [as 属性新名]
# 导入包内的所有子包和模块
from 包名 import *
from 包名.模块名 import *
"""
包
导入是否成功的条件：
系统路径 + 导入路径 == 真实路径
"""
# 导入方式1：import 路径.模块名 as 别名
# 使用：别名.成员
import package01.m01 as m
m.func01()
# 导入方式2：from 路径.模块名 import 成员
# 使用：直接使用成员
from package01.package02.m02 import func02
func02()
# 导入方式3：from 路径.模块名 import *
# 使用：直接使用成员
from package01.package02.m02 import *
func02()
4. _init_.py 文件
是包内必须存在的文件
会在包加载时被自动调用
5. _all_
记录from 包 import * 语句需要导入的模块
6. 搜索顺序
内置模块
sys.path 提供的路径
import sys
sys.path.append("/home/alex/my_project")
print(sys.path)
from common.list_helper import ListHelper
class SkillDeployer:
def deploy(self):
print("释放技能")
ListHelper.get_elements()
"""
时间处理
"""
import time
# 1. 获取当前时间戳:从1970年1月1日到现在经过的秒数
print(time.time())# 1576595536.5944133
# 2. 获取当前时间元组（年、月、日、时、分、秒、星期、年的第几天、夏令时）
time_tuple = time.localtime()
print(time_tuple)
# 3. 时间戳--->时间元组
print(time.localtime(1576595536.5944133))
# 4. 时间元组--->时间戳
print(time.mktime(time_tuple))
# 5. 时间元组--->字符串
print(time.strftime("%y/%m/%d %H:%M:%S",time_tuple))# 19/12/17 23:17:23
print(time.strftime("%Y/%m/%d %H:%M:%S",time_tuple))# 19/12/17 23:17:23
# 6. 字符串--->时间元组
print(time.strptime("19/12/17 23:17:23","%y/%m/%d %H:%M:%S"))
"""
定义函数,根据年月日计算星期数
星期一
星期二
...
"""
import time
def get_week(year, month, day):
tuple_time = time.strptime("%d/%d/%d" % (year, month, day), "%Y/%m/%d")
tuple_weeks = ("星期一","星期二","星期三","星期四","星期五","星期六","星期日",)
return tuple_weeks[tuple_time[6]]
print(get_week(2022,5,30))
"""
定义函数,根据年出生日期，计算活了多少天
"""
import time
def life_days(year,month,day):
tuple_time = time.strptime("%d/%d/%d" % (year, month, day), "%Y/%m/%d")
life_second = time.time() - time.mktime(tuple_time)
return int(life_second / 60 / 60 / 24)
print(life_days(2022,5,30))
第三章 异常处理 Error
一、异常
- 定义：运行时检测到的错误。
- 现象：当异常发生时，程序不会再向下执行，而转到函数的调用语句。
- 常见异常类型：
– 名称异常(NameError)：变量未定义。
– 类型异常(TypeError)：不同类型数据进行运算。
– 索引异常(IndexError)：超出索引范围。
– 属性异常(AttributeError)：对象没有对应名称的属性。
– 键异常(KeyError)：没有对应名称的键。
– 为实现异常(NotImplementedError)：尚未实现的方法。
– 异常基类Exception。
二、处理
- 语法：
try:
可能触发异常的语句
except 错误类型1 [as 变量1]：
处理语句1
except 错误类型2 [as 变量2]：
处理语句2
except Exception [as 变量3]：
不是以上错误类型的处理语句
else:
未发生异常的语句
finally:
无论是否发生异常的语句
- 作用：将程序由异常状态转为正常流程。
- 说明：
as 子句是用于绑定错误对象的变量，可以省略
except子句可以有一个或多个，用来捕获某种类型的错误。
else子句最多只能有一个。
finally子句最多只能有一个，如果没有except子句，必须存在。
如果异常没有被捕获到，会向上层(调用处)继续传递，直到程序终止运行。
"""
异常处理
"""
def div_apple(apple_count):
person_count = int(input("请输入人数："))# ValueError
result = apple_count / person_count# ZeroDivisionError
print("每个人分%d个苹果" % result)
# 写法1：根据不同的错误,做出不同的逻辑处理
try:
div_apple(10)
except ValueError:
print("输入的必须是整数")
except ZeroDivisionError:
print("输入的不能是零")
# 写法2：不同的错误,相同的处理逻辑
# try:
# div_apple(10)
# # except Exception:
# except:
# print("出错喽")
# # 写法3：如果没有出错,可以单独定义逻辑.
# try:
# div_apple(10)
# except:
# print("出错喽")
# else:
# print("没有错误")
# 写法4：如果没有出错,可以单独定义逻辑.
try:
div_apple(10)
finally:
print("无论是否错误,一定执行的逻辑")
"""
定义函数,正确返回成绩(0 -- 100)
"""
def get_score():
while True:
try:
score = int(input("请输入成绩："))
except:
print("输入的不是整数")
continue
if 0 <= score <=100:
return score
else:
print("成绩输入超过范围")
score = get_score()
print(score)
三、raise 语句
- 作用：抛出一个错误，让程序进入异常状态。
- 目的：在程序调用层数较深时，向主调函数传递错误信息要层层return 比较麻烦，所以人为抛出异常，可以直接传递错误信息。
四、自定义异常
- 定义：
class 类名Error(Exception):
def __init__(self,参数):
super().__init__(参数)
self.数据 = 参数
- 调用：
try:
….
raise 自定义异常类名(参数)
….
except 定义异常类 as 变量名:
变量名.数据
- 作用：封装错误信息
"""
异常处理
主动抛出异常
"""
class AgeRangeError(Exception):
def __init__(self, name="", error_id=0, error_code=""):
self.name = name
self.error_id = error_id
self.error_code = error_code
class Wife:
def __init__(self, age=0):
self.age = age
@property
def age(self):
return self.__age
@age.setter
def age(self, value):
if 20 <= value <= 30:
self.__age = value
else:
# 多个错误信息(错误名称,错误编号,错误代码...)
raise AgeRangeError("年龄超过范围错误", 1324, "if 20 <= value <= 30")
# raise Exception("我不要")
try:
shuanger = Wife(40)
except AgeRangeError as e:
print(e)
print(e.error_id)
print(e.error_code)
"""
创建敌人类,限制攻击力在1--100之间
"""
class AtkRangeError(Exception):
def __init__(self, name="", error_id=0, error_code=""):
self.name = name
self.error_id = error_id
self.error_code = error_code
class Enemy:
def __init__(self, atk=0):
self.atk = atk
@property
def atk(self):
return self.__atk
@atk.setter
def atk(self, value):
if 1 <= value <= 100:
self.__atk = value
else:
# 多个错误信息(错误名称,错误编号,错误代码...)
# raise AtkRangeError("年龄超过范围错误", 1324, "1 <= value <= 100")
raise Exception("攻击力超过范围错误", 1324, "1 <= value <= 100")
try:
mieba = Enemy(400)
# except AtkRangeError as e:
# print(e.name)
# print(e.error_id)
# print(e.error_code)
except Exception as e:
print(e.args)