1.听写
1.利用列表生成式 生成列表
list0 = ["", "\n", "\t\t", "good", "hello", "\tnice"]
生成的列表中不包含空白字符序列和空字符序列
split() # 以空格或者\n\t\b\r
strip()
list1 = [item for item in list0 if len(item.split()) != 0]
print(list1)
2.利用字典生成式
dict0 = {"A":"a", "B":"b", "C":"c", "d":"D"} # 去除掉不一样的键值对
dict1 = {k:v for k, v in dict0.items() if ord(k) + 32 == ord(v)}
print(dict1)
2.课堂概述
函数补充:闭包
装饰器
模块和包:包是对模块的分类管理
main - 程序入口的声明
高阶函数:map —> 根据一些需求 重新设定序列中的元素内容
reduce ---> 导入模块 functools
filter ---> 筛选的功能
sorted ---> 排序
zip ---> 按对合并两个序列
常用模块的使用:time
datetime
calendar
os ---> 操作系统的文件目录 文件读写
3.闭包
格式:
在一个函数内部 嵌套另外一个函数 [函数内部声明的内容只能作用与函数本身 出了函数没有任何意义]
def out(形参列表):
外部函数体
def inner(参数列表):
内部函数体
def out():
print("外部函数")
def inner():
print("内部函数") # 这种函数的内部函数的调用只能在外部函数体中调用
return inner
# 想在函数外部调用inner能直接调用吗? 不能 只能间接调用 内部函数可以当做一个值被进行传递
func = out()
print(func)
func()
'''
外部函数
<function out.<locals>.inner at 0x000002114E219AE8>
内部函数
'''
4.装饰器
特殊的闭包: 将内部函数当做外部函数的运行结果被返回
def out(功能名字): # 外层函数的参数的作用是 接受添加新需求的功能
外部函数
def inner(*values, **kwargs):
内部函数
result = 功能名字(*values, **kwargs)
return result
return inner
添加装饰器的语法:
在指定功能的声明上方添加 @糖语法 @外部函数名
@out
def func():
# 案例
'''
打印九九乘法表
调用函数本身 除了指定函数本身的功能 再计算出函数运行时间
前提 不能动函数中的内容 --->装饰器
'''
import time
def get_time(func):
def inner(*values, **kwargs):
start = time.time()
result = func(*values, **kwargs)
stop = time.time()
print(stop - start)
return result
return inner
# 添加装饰器的语法: @糖语法 格式：@外部函数名
@get_time
def print_table():
time.sleep(1) # 睡一会
for row in range(1, 2):
for col in range(1, row + 1):
print("%d * %d = %d" % (col, row, (col * row)), end="\t")
print()
# 指定行数 打印对应函数的行数的乘法表
@get_time
def print_table_line(line):
time.sleep(1) # 睡一会
for row in range(1, line + 1):
for col in range(1, row + 1):
print("%d * %d = %d" % (col, row, (col * row)), end="\t")
print()
print_table_line(2)
@get_time
def add(num1, num2):
res = num1 + num2
return res
@get_time
def show(**kwargs):
print(kwargs)
res = add(12, 34)
print(res)
show(age=18, name="小沐")
'''
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1.0000569820404053
0.0
46
{'age': 18, 'name': '小沐'}
0.0
'''
import time
def get_time(func):
print("外部函数")
print(func)
def inner():
print("内部函数")
start = time.time()
func()
stop = time.time()
print(stop - start)
return inner
@get_time
# 解释器做了一个操作: 将外部函数已经被执行了 并将被装饰的功能传入到了外部函数中
# 解释器调用外部函数后 使用什么变量名接受外部函数运行的结果? 给外部函数传递的什么名字 就是用什么名字接受的
print_table = get_time(print_table) # SyntaxError: invalid syntax
def print_table():
time.sleep(1) #睡一会
for row in range(1, 10):
for col in range(1, row + 1):
print("%d * %d = %d" % (col, row, (col * row)), end="\t")
print()
res = get_time(print_table)
'''
外部函数
<function print_table at 0x000001C72C7D9AE8>
外部函数
<function get_time.<locals>.inner at 0x000001C72C7D9E18>
'''
装饰器的作用: 在不改变原有功能A的基础上 调用A 为A增加新的功能
当为一个功能添加上装饰器之后 装饰器对应的外部函数只会被执行一次 @外部函数的时候执行的
为指定功能增加新的功能: 计算指定功能的运算时间
扫描二维码关注公众号，回复：
5483177 查看本文章
练习:
设置一个装饰器 使指定功能只能被调用1次 第一次调用返回结果 之后在调用返回None
@装饰器
def add(a, b):
return a + b
res = add(12, 34)
print(res) # 46
res = add(12, 34)
print(res) #None
在外部函数添加一个状态值 默认值
到内部函数中 获取这个默认值
执行功能
修改默认值
# 练习
def run_only(func): #func = add
is_run = False
def wrapper(*values, **kwargs): # 12, 34
nonlocal is_run
if not is_run:
is_run = True
res = func(*values, **kwargs)
return res
else:
return None
return wrapper
@run_only #add = run_only(add)
def add(num1, num2):
return num1 + num2
res = add(12, 34)
print(res) # 46
res = add(12, 34)
print(res) # None
res = add(12, 34)
print(res) # None
5.模块和包
模块: 一个py文件就是一个模块 每个py文件之间是可以互相访问的 访问的前提需要导入模块
第三方模块:
random ---> python提供好的
还有一些模块需要自己下载资源 这种模块称之为第三方模块
下载指令:pip install 模块名
pymsql pygame
模块导入方式
1. import 模块名
模块名.功能
2. from 模块 import 对应的功能
只能使用该功能 ---> 使用的时候直接调用功能名
3. from 模块 import *
导入模块中__all__这个列表中指定的对应的功能
包:
可以把他当做文件夹
作用: 用来对模块进行分类管理
将相同功能的模块存放于同一个目录下
为模块提供多级命名空间
test
abc.txt
subtest
abc.txt
如何创建包: 新建 - python package
包名使用的是小写英文字母 分级之间的包名是用点来进行分割的
test.subtest
想使用包中的模块的话
导入方式:
import 一级包名.二级包名...n级包名.模块名
创建出来包之后 在包的目录下自带一个__init__.py文件: 作用用于标识该目录不是一个普通的计算机中的文件夹 而是程序中的包
程序入口的规范写法
程序的起始文件中
声明一个main方法
写的程序入口的需求
做一个if判断
if __name__ == "__main__":
main()
6.高阶函数
# map ---> 根据指定需求 将序列中的元素的状态发生变化
'''
map 两个参数：1.接受的是一个函数
2.序列
作用: 将序列中的元素依次作用于函数 将函数运行的结果返回并存在map类型的数据中
'''
# 将一个存放整型数据的列表 把元素转变成字符串类型
list0 = [12, 56, 71, 83, 29]
list1 = []
for item in list0:
list1.append(str(item))
print(list1)
list2 = [str(item) for item in list0]
print(list2)
list3 = list(map(str, list0))
print(list3)
# functools 中的 reduce ---> 指定的是一个累计的功能
import functools
'''
两个参数:1.结束函数[必须接受两个参数]
第一次传入的是序列中前两个元素 之后在传入的是上次的累计结果和下一个元素
2.序列
'''
# 累乘
res = functools.reduce(lambda x,y: x * y, [5, 4, 3, 2, 1])
print(res)
# filter ---> 进行的筛选的功能
'''
1.函数: 返回结果为bool类型
True 保留该数据
False 舍弃该数据
2.序列: 将序列中元素依次作用于函数 根据需求返回状态 当是否保留该元素
'''
list0 = [" ", "\n\t", "hello", "world\n"]
list1 = [item for item in list0 if len(item.split()) != 0]
print(list1)
list2 = list(filter(lambda x: len(x.split()) != 0, list0))
print(list2)
# 筛选掉不及格的键值对
dict0 = {"语文":22, "数学":65, "政治":77}
dict1 = {k:v for k,v in dict0.items() if v >= 60}
print(dict1)
dict2 = dict(filter(lambda x: x[1] >= 60, dict0.items()))
print(dict2)
# sorted ---> 排序[会生成一个新的 不影响原来的]
list0.sort() ---> 这个影响原列表
# 按照大小升序排序
list0 = ["11111", "444444", "55555", "2222", "333"]
list0.sort()
print(list0)
list0.sort(reverse=True)
print(list0)
list0.sort(key=len)
print(list0)
list1 = sorted(list0, key=len, reverse=True)
print(list1)
# zip ---> 将多个序列中的元素进行一对一的组合成元组
'''
zip:接受的是多个序列
将序列中的元素进行组合 存放于元组中 最后生成zip类型的数据
'''
res = zip([1, 2, 3], [5, 6,7])
print(res) # <zip object at 0x00000276C58B2F48>
list0 = list(res)
print(list0) # [(1, 5), (2, 6), (3, 7)]
dict0 = dict(list0)
print(dict0) # {1: 5, 2: 6, 3: 7}
keys = dict0.keys()
print(keys) # dict_keys([1, 2, 3])
# 将字典中的kv颠倒
res = zip(dict0.values(), dict0.keys())
dict1 = dict(res)
print(dict1) # {5: 1, 6: 2, 7: 3}