python_advanced

###############################################################################################
函数回顾
“”"
函数-功能
价值1：减少代码的重复
制作：
def 函数名称(): def全称define
函数体
使用
函数名称()
形式参数函数本身定义
实参数调用时（位置参数，关键字实参，序列实参:使用*号拆分，字典实参：使用**号拆分字典）

函数参数
实际参数：与形参进行对应
1.位置实参:按位置顺序格式：函数名(数据1，数据2，数据3)
2.关键字实参：按名称格式:函数名(参数名2=数据2)
3.序列实参：拆格式：函数名(*序列)
4.字典实参：拆
形式参数：约束实参
默认形参：实参可选
位置形参：实参必填
命名关键字形参：实参必须是关键字实参
不定长形参
星号元组形参：将实参合并为元组
是参数量无限

例：
def func02(p1,p2 =“”,*args,p3=0,**kwargs):
“”"
:param p1: 位置形参
:param p2: 位置形参+默认参数
:param args: 型号元组形参
:param p3: 命名关键字形参+默认形参
:param kwargs: 双星号字典形参
:return:
“”"
print(p1,p2=“”,*args)

“”"
#如果函数没有return ，相当于return None
#如果函数return 后面没有数据，也相当于return None

条件表达式
语法：变量 = 结果 1 if 条件 else 结果 2
例：

   def calculate_discount(account_type,money):if account_type =="vip"#if money<500:# return 0.85#else:#return 0.8return 0.85 if money <500 else 0.8  else:return 0.9 if money >800 else 1

函数返回容器
例 return return_1,return_2 /#返回是一个元组

作用域LEDB
Local 局部作用域：函数内部有效
Enclosed外部嵌套作用域：函数嵌套
Global 全局作用域: 模块(.py文件)内部整个文件有效
例：修改
a =100
def func01():
global a
a = 200 #修改全局
例：读取
list01 = [10]
def func02():
#读取全局变量
#修改列表第一个元素
list01[0] = 20

    Builtin 内置模块作用域: builtins.py文件

内容一 模块包异常处理
内容二 迭代生成器
内容三 lambda 表达式高级函数
内容四 闭包装饰器

##########################################################################################

python_高级进阶

分析
界面可能使用控制台, 也可能使用web等等
识别对象：界面视图类逻辑控制类数据模型类

基本的操作：增删改查

分配职责：
界面视图类View： 负责界面逻辑，比如显示器，获取输入，显示输出结果等。
逻辑控制类Controller：负责存储学生信息，处理业务逻辑，比如添加，删除等。
数据模型类Model：定义需要处理的数据类型。比如学生信息
例：
list01 = []
#增加
list01.append(10)
list01.append(20)

#修改
list01[0]=100

#查询
print(list01[0])

#删除
list01.remove(10)
del list01[0]

MVC 控制与显示分离
控制Controller ：负责业务逻辑
显示View ：负责界面逻辑
模型Model：封装数据
入口main：项目启动

案例：

学生信息管理系统MVC

“”"
学生信息管理系统MVC
“”"

数据模型

class StudentModel:"""学生数据模型对具体学生信息进行抽象"""def __init__(self, name="", age=0, score=0, sid=0):self.name = nameself.age = ageself.score = score# 学生编号：对数据进行唯一标识(全球唯一标识符)self.sid = sid  # 自增长1001   1002   1003# 对某个数据进行有效性验证@propertydef score(self):return self.__score@score.setterdef score(self, value):if value < 0:value = 0elif value > 100:value = 100self.__score = value

界面逻辑

class StudentView:"""学生视图：负责处理界面逻辑"""def __init__(self):self.__controller = StudentController()def __display_menu(self):print("1) 添加学生信息")print("2) 显示学生信息")print("3) 删除学生信息")# ...def __select_menu(self):item = input("请输入选项：")if item == "1":# 先写调用,再快捷键生成定义函数代码# atl + 回车self.__input_student()elif item == "2":self.__show_students()elif item == "3":self.__delete_student()def main(self):"""入口函数"""while True:self.__display_menu()self.__select_menu()def __input_student(self):stu = StudentModel()stu.name = input("请输入学生姓名：")stu.age = int(input("请输入学生年龄："))
**加粗样式**        stu.score = int(input("请输入学生成绩："))self.__controller.add_student(stu)def __show_students(self):for stu in self.__controller.list_students:print(f"{stu.name}的编号是{stu.sid}年龄是{stu.age}成绩是{stu.score}")def __delete_student(self):sid = int(input("请输入需要删除的学生编号："))if self.__controller.remove_student(sid):print("删除成功")else:print("删除失败")

业务逻辑

class StudentController:"""学生控制器负责处理业务逻辑"""def __init__(self):self.__list_students = []self.__start_sid = 1001# 只读属性@propertydef list_students(self):return self.__list_studentsdef add_student(self, stu):"""添加学生:param stu: 需要添加的学生对象"""stu.sid = self.__start_sidself.__start_sid += 1self.__list_students.append(stu)def remove_student(self, sid):"""删除学生:param sid: int类型的学生编号:return: bool类型,是否删除成功"""for student in self.__list_students:if student.sid == sid:self.__list_students.remove(student)return True  # 删除成功return False  # 删除失败

1.程序入口

view = StudentView()
view.main()

参照student_info_manager.py完成商品管理系统

实现添加商品信息功能
View – 录入商品信息
Controller – 添加商品信息
画出内存图
实现显示所有商品信息功能
实现删除商品信息功能

class CommodityModel:def __init__(self, cid=0, name="", price=0.0):self.cid = cidself.name = nameself.price = priceclass CommodityView:def __init__(self):self.__controller = CommodityController()def __display_menu(self):print("1) 添加商品信息")print("2) 显示商品信息")print("3) 删除商品信息")def __select_menu(self):item = input("请输入选项：")if item == "1":self.__input_commodity()elif item == "2":self.__show_commodity()elif item == "3":self.__delete_commodity()def main(self):"""入口函数"""while True:self.__display_menu()self.__select_menu()def __input_commodity(self):commodity = CommodityModel()commodity.name = input("请输入商品名称：")commodity.price = float(input("请输入商品单价："))self.__controller.add_commodity(commodity)def __show_commodity(self):for commodity in self.__controller.list_commoditys:print("%s商品编号是%d,单价是%.2f" % (commodity.name, commodity.cid, commodity.price))def __delete_commodity(self):cid = int(input("请输入商品编号："))if self.__controller.remove_commodity(cid):print("删除成功")else:print("删除失败")class CommodityController:def __init__(self):self.__list_commoditys = []self.__start_cid = 1001@propertydef list_commoditys(self):return self.__list_commoditysdef add_commodity(self, commodity):commodity.cid = self.__start_cidself.__start_cid += 1self.__list_commoditys.append(commodity)def remove_commodity(self, cid):for commodity in self.__list_commoditys:if commodity.cid == cid:self.__list_commoditys.remove(commodity)return Truereturn Falseview = CommodityView()
view.main()

函数导入 ：
导入方式1 ：创建变量module01 关联该模块
#适合：面向过程的技术(全局变量、函数)
例：
import module01
module01.func01

导入方式2：将该模块成员导入当前作用域中
语法：from 文件名 import 内容
#适合：面向对象的技术（类）
例：

 # from  module01  import  func01
from module import MyClass
m01 = MyClass()
m01.func01()

导入方式3 ：将该模块所有成员导入到当前作用域中
语法： from module01 import *

“”"
特殊导入方式
设置包的__init__.py 文件
“”"

导入包
方式1
设置

 import package01.package02.module01from package01.package02 as p p.module01.func01

方式二
from 包 import 包
设置

from package01.package02 import module01
from package01 import package02
package02.module01.func01

方式三
from 包 import *
设置 all = [“module01”]
from package01.package02 import *

**__all__变量 ** ：定义可导出成员，仅对from xx import
**__doc__变量 **：文档字符串
__file__变量 ：模块对应的文件路径名、
__name__变量：模块自身名字，可以判断是否为主模块。

当前模块作为主模块（第一个运行的模块运行时），name__绑定__main,不是主模块

import demo01
print(demo01.__doc__)   **#获取文档字符串**
print(dem01.__file__)  **#获取文件完整路径**
print(demo01.__name__) **#获取模块名称**
print(__name__)   **#只有当前模块是主模块时，才是__main__**#如果当前模块是主模块，则执行入口代码
#(当前模块被导入，不执行入口代码)
if __name__ == "__main__"

import time

人类世界2021年2月1日
世界元组：年/月/日/时/分/秒/星期/一年的第几天/夏时令
print(time.locatime())
计算机时间
#时间戳：从1970年1月1日 0时0分0秒到现在经过的秒数
print(time.time()) #1612685177.7564297

3.时间戳 --> 时间元组

print(time.localtime(1612685177.7564297))  #time.struct_time(tm_year=2021, tm_mon=2, tm_mday=7, tm_hour=16, tm_min=6, tm_sec=17, tm_wday=6, tm_yday=38, tm_isdst=0)

时间元组 —>时间戳

tuple_time = time.localtime(1612685177.7564297)print(time.mktime(tuple_time))

时间元组 -->字符串
#strptime #字符转为time

tuple_time = time.localtime(1612685177.7564297)print(time.strftime("%y/%m/%d %H:%M:%S",tuple_time))   #21/02/07 16:06:17     %Y 大写Y 为四位的年print(time.strftime("%Y/%m/%d %H:%M:%S",tuple_time))   #2021/02/07 16:06:17

字符串 -->变成时间元组
例 #2021/02/07 16:06:17

tuple_time = time.localtime(1612685177.7564297)   #得到时间元组 time.strftime("%Y/%m/%d %H:%M:%S",tuple_time)  #转为字符串time.strptime("2021/02/07 16:06:17","%Y/%m/%d %H:%M:%S")   转为元组

异常处理

常见： 名称异常NameError ：变量未定义
类型异常TypeError ：不同类型数据进行运算
索引异常IndexError ：超出索引范围
属性异常AttributeError ：对象没有对应名称的属性
键异常KeyError ：没有对应名称的键
变量错误ValueError
为实现异常NotlmplementedError ：尚未实现的方法
异常基类Exception ------->无论什么错误

报错：看最后一个链接

处理方法：
写法1 ：对症下药
#检查可能出错的代码

 try ：  代码逻辑except(ValueError,NameError ):  #错误执行 （官方建议）print("出错")

写法2：包治百病
#检查可能出错的代码
try ：
代码逻辑
except: #错误执行
print(“出错”)

写法3 ：
try ：
代码逻辑
finally: #无论执行是否错误都执行
print(“出错”)

例：

   def get_score():
while True:try:score = float(input("请输入成绩:"))return score     #退出函数出口except:print("成绩输入有误,请重新输入")

异常处理实例 ：

例：

def get_score():while True:try:score = float(input("请输入成绩:"))return scoreexcept:print("成绩输入有误,请重新输入")if __name__ == '__main__':print(get_score())

带有 iter 是可迭代对象
带有 next 是迭代器

迭代iter ：每一次对过程的重复称为一次"迭代"，而每一次迭代得到
可迭代对象 -------- iterable

定义：具有__iter__函数的对象，可以返回迭代器对象
语法 iterable
class 可迭代对象名称:
def init(self,聚合对象)：
self.聚合对象 = 聚合对象

def next(self):

例： message = “我是迭代器”
iterable = message.iter()

# for 循环原理
1.获取迭代器对象
iterable = message.iter()

2.获取下一个元素

while True：try：item = iterator__next__()print(item)except StopIteration:break

3.如果没有元素，则停止循环，

例：

while True：try：item = iterator__next__()print(item)except StopIteration:break

面试题：可以参与for循环的条件是？
能够获取迭代器对象（可迭代对象）
具有__iter__函数

元组迭代
例：

 tuple01   =（43,4,5,67,87，）iterator = tuple01.__iter__()while True:try:item = iterator.__next__()print(item)except StopIteration:break

字典迭代
例：

dict01 ={"a":"A","b":"B"}iterator  = dict01.__iter__()while True:try:key = itertor.__next__()value = dict01[key]print(key,value)except StopIteration:break

自定义迭代实例

 class SkillIterotor:def __init__(self,data):self.data = dataself.index = -1def __next__(self):self.index+=1if self.index < len(self.data):return self.data[self.index]else:raise StopIteration()                             class  SkillManger：def __init__(self):self.__skills = []def add_skill(self,skill):self.__skills.append(skill)def __iter__(self):return SkillIterator(self.__skills)manager = SkillManger()manager.add_skill("十八掌")manager.add_skill("六脉神剑")manager.add_skill("乾坤大挪移")#迭代自定义对象#for skill in manger:#print(skill)#模拟for循环iterator = manger.__iter__()while True:try:item = iterator.__next__()print(item)except StopIteration :break

自定义range 迭代器

"""自定MyRange类实现range(5)效果
"""class MyRangeIterator:# 迭代器def __init__(self,stop):self.number = -1self.stop = stopdef __next__(self):self.number += 1if self.number  < self.stop:return self.numberelse:raise StopIteration()class MyRange:def __init__(self, end):self.end = enddef __iter__(self):# 可迭代对象return MyRangeIterator(self.end)# for item in MyRange(5):  # 0~4
#     print(item)# 可以生成撑爆内存的数字
# 循环一次  计算一次  返回一次
for item in MyRange(9999999999999999999999999999999):print(item)for item in range(9999999999999999999999999999999):print(item)

yield 迭代返回值

例：

  def  my_range(end):start = 0 while start <end;yield start start +=1 for item in my_range(5):print(item)

#延迟操作/惰性操作
#循环一次计算一次返回一次

“”"
返回列表中所有数字的个位
方式1：传统思想
定义函数，创建列表，循环计算每一个元素的个位，存入列表

方式2：生成器思想
定义函数，循环计算每个元素的个位，通过yield 返回
体会：惰性操作/延迟操作/推算数据

数据 list01 = [54,55,36,67,28,69,90]
“”"

方法1 ：

def find_number_unit(list_target):list_result = []for number in list_target:unit = number % 10list_result.append(unit)return list_result list01 = [54,55,36,67,28,69,90]result = find_number_unit(list01)print(result)

方法2 #省内存 yieid 返回

def find_number_unit(list_target):for number in list_target:unit = number % 10yield unitlist01 = [54,55,36,67,28,69,90]result = find_number_unit(list01)  #调用不执行，延迟/惰性for item in result：print(item)

生成器

  class Generator：            # 生成器=  #可迭代对象 +迭代器def __iter__(self):     #可迭代对象return self def __next__(self):       #迭代器 ...                    def my_range(end):start = 0 while start <end:yieid startstart +=1

内置生成器

例： list01 = [23,45,65,32,4,6,90]
修改奇数

方法1：

  for i in range(len(list01)):if  list01[i] %2 :list01[i] =0

#(索引，元素)

方法2

 for i,element in enumerate(list01):if element %2:list01[i] = 0

例：

dic01 ={"name":"bob","age":20,"sex":"male","grade":6}
for key,value in dic01.items():print(key,value)for i,value in enumerate(dic01.items()):   #方法1print(i,value[0],value[1])for i,(key,value) in enumerate(dic01.items()):  #方法2 print(i,key,value)

zip 实现矩阵转置

例1

 list01 = ["a","b","c","d"]list02 = ["A","B","C","D"]for item in zip(list01,list02):print(item)

例 2 ：通过实现矩阵转置

     list02 = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]    # **方法 1**  （1,5,9,13） 代码已写死，多一个不行for item in zip(list[0],list[1],list[2],list[3])print(item)

#方法2 ：使用*号将列表元素拆开

for item in zip(*list01)  print(item)list02 = []for item in zip(*list01)list(item)  #变回列表 #或一步还原成列表  list02 = [list(item) for item in zip(*list01)]

“”"
生成器函数 —>给其他人用
生成器表达式 ----> 给自己用
“”"
数据 list01 = [64,4,True,“a”,False,“d”,5.4,“c”]
#列表推导式

list_result = [item for item in list01 if type(item) ==str]for item in list_result:print(item)

#生成器表达式

list_reslut = (item for item in list01 if type(item) ==str)

函数式编程

"""函数式编程
"""def  func01():print("func01")a = func01   #将函数赋值给变量
a()          #---->通过变量可以打印函数可以打印func01

价值: 通过参数调用函数，可以将逻辑注入到函数中
例：

def func03(a):print("func03执行")  a()   func03(func01)

“”"
函数式编程 ----思想
面向对象：
封装：分
继承：抽象统一隔离
多态
函数式编程
分：将通过和变化点分为多个函数
隔：使用参数隔离具体变化的函数
做：使用lambda定义变化函数
“”"

list01 = [45,655,34,4,24,5]
#需求：定义函数，获取所有大于10的数字
def find01()for item in list01:if item>10:yield item

#需求：定义函数，获取所有偶数

def find02()for item in list01:if item %2 ==0:yield itemfor number in find01()print(number.__dict__)
for number in find02()print(number.__dic__)

改：函数式编程

list01 = [45,655,34,4,24,5]
#提取变化函数

def condition01(item):return item>10def condition02(item):return item %2 ==0#提取通用函数def find(a):for item in list01:if a(item):yield item #变化+ 通用for item in find(condition01):pirnt(item)for item in find(condition02):pirnt(item)

类成员的静态方法

方法前面加 @staticmethod
定义： @staticmethod
def 方法名称(参数列表)
方法体

2）调用：类名.方法名（参数列表）
不建议通过对象访问静态方法

说明：
（1）使用@staticmethod修饰的目的是该方法不需要隐式参数
（2）静态方法不能访问实例成员和类成员

作用：定义常用的工具函数
例：

class  IterableHelper:  @staticmethod   #不要自动传参def find(iterable,func)for item in iterable:if func(item)yield item

匿名函数

有名函数用def 创建
无名函数用lambda
lambda 表达式不能赋值
lambda 函数体只能有一条语句

写法1
普通函数：

def func01(p1,p2):return p1>p2print(func01(10,5))

匿名函数：

 lambda p1,p2: p1>p2func02 = lambda p1,p2: p1>p2print(fun02(10,5))

得到：效果一样

写法2 ：有参数.无返回值

 def   func02(p1):print("参数是",p1)
func02(10)func02 = lambda p1: print("参数是",p1)func02(10)

写法3：无参数，有返回值

def  func03():return "result"
func03()func03 = lambda : "result"print(func03())

写法4：无参数，无返回值

def  func04():print "result"
func04()func03 = lambda : print "result"
func04()

####def 不能转换为lambda写法
例 1 ：

def func05(p):p[0] =100list01 = [10]
func05(list01)
func05  = lambda p1:p1[0]=100  #报错

例2：

def func06():for i in range(5)：print(i)
fun06()
func06 = lambda

例3：

list01 = [45,655,34,4,24,5]#提取变化函数
def condition01(item):return item>10def condition02(item):return item %2 ==0#提取通用函数 ---无能查找
def find(a):                #创建钩子for item in list01:if a(item):       #拉起钩子（执行条件）yield item for item in find(condition01):         #向钩子上挂条件
print(item)
for item in find(condition02):         #向钩子上挂条件
print(item)

改为： lambda例子

list01 = [45,655,34,4,24,5]
#提取通用函数 ---无能查找
def find(a):                #创建钩子for item in list01:if a(item):       #拉起钩子（执行条件）yield item for item in find(lambda item : item %2 ==0):   #改为lambda 可以取消上面代码condition01）
print(item)
for item in find(lambda item :  item>10):   #改为lambda 可以取消上面代码condition01）
print(item)

python_advanced相关推荐

python官网中文版新闻-新闻主页 - python兵者 - 博客园
一.功能需求分析 1.banner 2.推荐文章列表 3.文章标签导航 4.文章列表 5.分页二.模型设计根据功能分析,我们需要如下表,大量的经验和功能积累 1.表和字段分析 a 文章分类表 b ...
12搜索功能实现+docker
文章目录 docker 简介基本概念 Image(镜像) Container (容器) Repository (仓库) 安装 docker 新闻搜索功能实现需求分析搜索引擎原理 elastics ...
Django blog项目《四》：模板抽取
文章目录一.模板抽取分析二.模板抽取 1. base.html挖坑 1. head挖坑 2. body挖坑 2. app应用templates填坑 1. users 2. news 3. docs ...
十六.静态页面抽取模板 2021-03-31
十六.静态页面抽取模板引言模板标签之模板继承静态模板文件:链接:https://pan.baidu.com/s/1eZKi4a5fBTmy-DwAQmr51w 提取码:8mmy django-- ...