贵阳企业建站系统模板,丽水品牌网站设计,兰州网站seo哪家公司好,苏州做外贸网站目录 推导式
1、列表推导式#xff08;用得最多的#xff09;
给你一个列表#xff0c;求所有数据的绝对值
列表推导式跟if运算
打印50以内能被3整除的数的平方#xff08;filter#xff09;#xff08;if的使用#xff09;
找到1000以内开平方的结果是整数的数用得最多的
给你一个列表求所有数据的绝对值
列表推导式跟if运算
打印50以内能被3整除的数的平方filterif的使用
找到1000以内开平方的结果是整数的数if的使用
打印50以内如果被2整除的数的平方否则打印自己(map)if和else的使用
打印名字中包含g的数据双重for循环
将二维数组转一维数据双重for循环
二维转一维将名字包含g的数据直接输出不包含g的数据转大写输出
2、集合推导式(在列表推导式的基础上去重) set
3、字典推导式 dict
构建一个字典: {a:1,b:2,c:3,d:4.........z:26}
迭代器
可迭代对象 实现了__iter__方法并且该方法返回一个迭代器
可以使用dir查看是否实现了__iter__方法即可判断是否为可迭代对象
迭代器
判断是否为迭代器或者是可迭代对象
可迭代对象 和 迭代器的区别
迭代器实现列表内数据的平方
map函数使用了惰性求值的特点map就是迭代器
实现一个迭代器类似range函数的迭代器返回0到num的数据
实现一个可以无限生成的斐波拉契数列的迭代器
生成器
生成器表达式返回的数据 for 临时变量 in 可迭代对象
生成器函数如果一个函数中包含了yield关键字它是一个生成器函数
使用生成器函数 --》 创建了一个生成器g g func_g()
用生成器函数实现传递给函数一下列表返回列表中每个元素的平方
生成器yield 和 yield from返回数据的区别
闭包
什么是闭包
闭包形成的条件
闭包的特点
闭包函数
装饰器
例子希望获取每一个函数运行时候的耗时
用装饰器来实现给函数添加记录运行时间的功能runtime装饰器
实现加记日志的功能如函数XXX被调用了log装饰器
一个函数可以使用多个装饰器多重装饰器
模块化拆分装饰器
创建 utils.py 文件将我们的runtime和log装饰器写入文件中
然后我们在父文件中调用 utils.py 文件中的装饰器
装饰器可以装饰普通的函数、也可以用来装饰类
作业 推导式 # 列表推导式用得最多的 # 字典推导式 # 集合推导式 1、列表推导式用得最多的
li1 [1,2,3,4]
# [返回值 for 临时变量 in 可迭代对象]
result [x*x for x in li1]
print(type(result), result)# map和列表推导式都可以做到
# map map object
# 列表推导式 list输出
class list [1, 4, 9, 16]
给你一个列表求所有数据的绝对值
# 给你一个列表求所有数据的绝对值
li2 [1,2 ,-1, 4, 6, -4]
result [abs(x) for x in li2 ]
print(result)输出
[1, 2, 1, 4, 6, 4]
列表推导式跟if运算
打印50以内能被3整除的数的平方filterif的使用
result [x**2 for x in range(1,50) if x%3 0]
print(result)
找到1000以内开平方的结果是整数的数if的使用
result [x for x in range(1,1000) if x**0.5%10 ]
print(result)
打印50以内如果被2整除的数的平方否则打印自己(map)if和else的使用
result [x**2 if x%2 0 else x for x in range(1,50) ]
print(result)
打印名字中包含g的数据双重for循环
names [[asdf, ag],[abg, abc],
]
result [name for lst in names for name in lst if g in name]
print(result)将二维数组转一维数据双重for循环
li [[1,2,3,4],[5,6,7,8]]
result [x for lst in li for x in lst]
print(result)相当于
# result []
# for lst in li:
# for x in lst:
# result.append(x)
二维转一维将名字包含g的数据直接输出不包含g的数据转大写输出
names [[asdf, ag],[abg, abc],
]
result [name if g in name else name.upper() for lst in names for name in lst]
print(result)与下面意思的一样
result []
for lst in names:for name in lst:if g in name:result.append(name)else:result.append(name.upper())
print(result)输出
[ASDF, ag, abg, ABC]
2、集合推导式(在列表推导式的基础上去重) set
lst [-1, 1, -4, 2, 4]
# 求数据的绝对值去重
result {abs(x) for x in lst}
print(result)# for 临时变量 in 可迭代数据
3、字典推导式 dict
d1 {a:2, b:1}
# 将key转化为大小
# {key:value for 临时数据 in 可迭代对象}
result {key.upper():value for key,value in d1.items()}
print(result)输出
{A: 2, B: 1}
构建一个字典: {a:1,b:2,c:3,d:4.........z:26}
# 构建一个字典: {a:1,b:2,c:3,d:4.........z:26}
# ord 字母转ASCII chr(ord(a)i)
# chr ASCII转字母 chr(97) aresult {chr(97i):i1 for i in range(26)}
print(result)输出
{a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10, k: 11, l: 12, m: 13, n: 14, o: 15, p: 16, q: 17, r: 18, s: 19, t: 20, u: 21, v: 22, w: 23, x: 24, y: 25, z: 26}迭代器 迭代器Iterator是Python中的一种对象它用于实现迭代遍历的机制允许你逐个访问集合中的元素而无需提前加载所有元素到内存中。迭代器提供了一种延迟获取数据的方式这对于处理大量数据或需要逐步处理数据的情况非常有用。 迭代器需要实现两个方法 __iter__()返回迭代器对象自身。通常该方法返回self。 __next__()返回集合中的下一个元素。如果没有元素可返回则引发StopIteration异常表示迭代已经结束。 迭代器的特点 惰性求值需要用到数据的时候再去计算结果不会一次性占用很多的内存空间和cpu十分的高效 可迭代对象 实现了__iter__方法并且该方法返回一个迭代器 可迭代对象Iterable是指可以被迭代遍历的对象。它们通常用于循环结构比如for循环。可迭代对象可以包含多个元素每次迭代都返回其中的一个元素直到所有元素都被访问完为止。 可以使用dir查看是否实现了__iter__方法即可判断是否为可迭代对象
print(dir(1))
print(dir(list))
# for i in 1:
# pass
# 报错int object is not iterable 表示 int 类型是不可迭代对象 # 常见的可迭代对象
# set, tuple, dict, str, bool
迭代器
str1 abc
# 迭代器
# 获得一个迭代器
# 迭代器实现了__iter__返回自己和__next__返回下一个数据方法
str1_iter str1.__iter__()
print(type(str1_iter), str1_iter)
print(str1_iter.__next__())
print(str1_iter.__next__())
print(next(str1_iter)) # 跟str1_iter.__next__()效果一样只是写法不一样
# 当没有数据了的时候会引发StopIteration错误
# print(str1_iter.__next__())# 当使用for去循环的时候会调用对象的__iter__方法获得一个迭代器
# 每次循环都是获取迭代器的__next__方法
# 如果遇到StopIteration错误循环结束
# 等同于for i in str1:输出
class str_iterator str_iterator object at 0x000002B1DFDA5DE0
a
b
c报错
Traceback (most recent call last):File D:\衡山-开发\python\pythonProject_day01\test.py, line 11, in moduleprint(str1_iter.__next__())
StopIteration判断是否为迭代器或者是可迭代对象
from collections.abc import Iterator,Iterable
print(isinstance(str1_iter, Iterator))#collections.abc模块的使用输出
True / False
可迭代对象 和 迭代器的区别 可迭代对象print 直接打印所有的数据 迭代器print打印对象本身无数据 对象.__next__ 或next(对象) 可迭代对象 存10w个数据 占用很多内存 迭代器 惰性求值next调用的时候才会去计算数据可用于数据量比较大的时候 不会一次占用很多的内存和CPU资源 迭代器实现了__iter__返回自己和__next__返回下一个数据方法 如果只实现了__iter__方法那么它只能是可迭代对象 迭代器实现列表内数据的平方
map函数使用了惰性求值的特点map就是迭代器
li [1,2,3,4,5]
result map(lambda x:x*x,li)
print(type(result), dir(result))
# result map 迭代器
print(result.__next__())
print(next(result))
实现一个迭代器类似range函数的迭代器返回0到num的数据
class MyRange():def __init__(self,num):self._start -1self.num num# 返回它自己def __iter__(self):return self# 返回def __next__(self):self._start 1if self._start self.num:return self._startelse:raise StopIteration #如果我们需要停止迭代器直接raise StopIteration
for item in MyRange(10):print(item)
如果我们需要停止迭代器直接raise StopIteration
实现一个可以无限生成的斐波拉契数列的迭代器
#0, 11235813....
class Fib(object):def __init__(self):self.cur 0self.next 1def __iter__(self):return selfdef __next__(self):self.cur,self.next self.next,self.curself.nextreturn self.cur
for i in Fib():if i100:breakprint(i,end )生成器 生成器Generator通常指的是一种能够逐步产生数据、内容或事件序列的程序或模型。 生成器通常是指一种特殊类型的函数它可以逐步产生数据流而不是一次性生成所有数据并将其存储在内存中。这在处理大量数据或需要逐步生成结果的情况下非常有用因为它可以减少内存占用。在Python中生成器函数使用关键字yield来逐步生成值。 特殊的迭代器不需要自己编写__iter__和__next__ 方法
生成器特点与迭代器一样。
数量大不需要立刻计算出结果而是需要的时候再计算。
生成器表达式返回的数据 for 临时变量 in 可迭代对象
li1 [1,2,3,4]
# (返回值 for 临时变量 in 可迭代对象)
result (x*x for x in li1)
print(type(result), dir(result))
print(next(result))
print(next(result))
print(next(result))
print(next(result))
生成器函数如果一个函数中包含了yield关键字它是一个生成器函数
def func_g():print(start)yield 1print(No1)yield 2print(No2)yield 3
使用生成器函数 --》 创建了一个生成器g g func_g()
迭代器\生成器 中能保存一些状态的。迭代器\生成器 中的数据只能取一次。
g func_g()
print(g, type(g), dir(g))
result next(g) # 执行函数代码, 遇到yield 返回yield后面的数据停止执行
print(result)
result next(g) # 接着之前的代码继续执行
print(result)
result next(g) # 接着之前的代码继续执行
print(result)输出
generator object func_g at 0x00000274E4845E70 class generator [__class__, __del__, __delattr__, __dir__, __doc__, __eq__, __format__, __ge__, __getattribute__, __gt__, __hash__, __init__, __init_subclass__, __iter__, __le__, __lt__, __name__, __ne__, __new__, __next__, __qualname__, __reduce__, __reduce_ex__, __repr__, __setattr__, __sizeof__, __str__, __subclasshook__, close, gi_code, gi_frame, gi_running, gi_yieldfrom, send, throw]start
1
No1
2
No2
3
用生成器函数实现传递给函数一下列表返回列表中每个元素的平方
li1 [1,2,3,4]
# func_g2(li1)
def func_g1(li):for item in li:yield item*item
g func_g1(li1)
for i in g:print(i)输出
1
4
9
16
生成器yield 和 yield from返回数据的区别 yield 返回的数据 yield from 迭代器 def func_g3():yield range(10)g3 func_g3()
print(next(g3))def func_g4():yield from range(10)
g4 func_g4()
print(next(g4))
print(next(g4))
print(next(g4))输出
range(0, 10)
0
1
2
闭包
什么是闭包 闭包是在函数内部定义的函数它可以访问其外部函数的变量即使外部函数已经执行完毕并且其作用域不再存在。这种机制允许变量的状态在函数调用之间得以保留。 闭包形成的条件 # 1. 必须有内外函数函数中嵌套函数 # 2. 外部函数必须返回内部函数 # 3. 内部函数要使用外部函数的变量 闭包的特点
变量不会随着外部变量执行完成而释放数据会被保存下来。有状态的
闭包函数
def outer_function(x):def inner_function(y):return x yreturn inner_functionclosure outer_function(10)
result closure(5) # result 等于 15 在这个例子中outer_function 返回了一个内部函数 inner_function内部函数引用了外部函数的参数 x。即使 outer_function 执行完毕后我们仍然可以通过调用 closure(5) 来使用内部函数这是因为闭包捕获了 x 的值。 装饰器 装饰器一种设计模式。 如果需要给函数或类添加一个功能但不改变原来的调用方式同时又不希望修改源代码或类的继承实现。 装饰器允许您在不修改原始函数代码的情况下通过添加额外的行为来扩展或修改函数的行为。 例子希望获取每一个函数运行时候的耗时
import time# 希望获取每一个函数运行时候的耗时
def func1():print(this is func1)time.sleep(1)def func2():print(this is func2)time.sleep(2)def func3():print(this is func3)time.sleep(3)start time.time()
func1()
print(func1 cost:, time.time()-start)start time.time()
func2()
print(func2 cost:, time.time()-start)start time.time()
func3()
print(func3 cost:, time.time()-start)输出
this is func1
func1 cost: 1.0075395107269287
this is func2
func2 cost: 2.010779619216919
this is func3
func3 cost: 3.002288579940796
以上缺点存在重复代码
用装饰器来实现给函数添加记录运行时间的功能runtime装饰器
import time# 希望获取每一个函数运行时候的耗时
# 装饰器接收的是一个函数, 返回值也需要是一个函数才能保证调用方式不变
def rumtime(func):# func -- 被装饰的函数# 因为被装饰的函数可能带参数也可能不带参数因此这里使用可变长参数# 目的是让代码更加灵活def inner(*args, **kwargs):start time.time()result func(*args, **kwargs)print(f函数运行时间为:{time.time() - start})return result# 返回值需要是一个函数return inner# 在被装饰的对象上方加装饰器名
rumtime
def func1():print(this is func1)time.sleep(1)
# 当使用runtime装饰func1时相当于执行了
# func1 runtime(func1) 内部runtime.inner函数
# 装饰器就相当于被装饰的函数func1()放到runtime()函数里面去了运行完后runtime装饰器会再返回一个函数放到func1()函数中去rumtime
def func2():print(this is func2)time.sleep(2)
# func2 runtime(func2)
# 新函数记录运行时间其中的函数功能 runtime.inner函数的功能rumtime
def func3():print(this is func3)time.sleep(3)func1()
func2()
func3()输出
this is func1
函数运行时间为:1.0070466995239258
this is func2
函数运行时间为:2.004884958267212
this is func3
函数运行时间为:3.0066428184509277实现加记日志的功能如函数XXX被调用了log装饰器
log 实现日志功能的装饰器
import time# 希望获取每一个函数运行时候的耗时
# 装饰器接收的是一个函数, 返回值也需要是一个函数才能保证调用方式不变
def rumtime(func):def inner(*args, **kwargs):start time.time()result func(*args, **kwargs)print(f函数运行时间为:{time.time() - start})return resultreturn innerdef log(func):def inner(*args, **kwargs):print(f{func.__name__}函数被执行了...)result func(*args, **kwargs)return resultreturn inner# 在被装饰的对象上方加装饰器名
rumtime
def func1():print(this is func1)time.sleep(1)
# 当使用runtime装饰func1时相当于执行了
# func1 runtime(func1) 内部runtime.inner函数log
def func2():print(this is func2)time.sleep(2)#调用装饰器
log
def func3():print(this is func3)time.sleep(3)func1()
func2()
func3()输出
this is func1
函数运行时间为:1.0148968696594238
func2函数被执行了...
this is func2
func3函数被执行了...
this is func3一个函数可以使用多个装饰器多重装饰器 实现的效果 func3 》 log(runtime(func3)) 》 log(runtime.inner) 因此当我们使用如下多个装饰器的时候log装饰器其实调用的函数是runtime内返回的inner函数因此log装饰器上显示的函数名就是inner函数啦 # 双重装饰器
log
rumtime
def func3():print(this is func3)time.sleep(3)输出
inner函数被执行了...
this is func3
函数运行时间为:3.0028884410858154 因此如果我们想要我们的log能调用到真正的func3函数我们需要对runtime装饰器进行修改 import time
import functools# 希望获取每一个函数运行时候的耗时
# 装饰器接收的是一个函数, 返回值也需要是一个函数才能保证调用方式不变
def rumtime(func):# functools.wraps(func)装饰器的功能是将func的原数据复制到inner上其中就包括了函数名functools.wraps(func)def inner(*args, **kwargs):start time.time()result func(*args, **kwargs)print(f函数运行时间为:{time.time() - start})return resultreturn innerdef log(func):functools.wraps(func)def inner(*args, **kwargs):print(f{func.__name__}函数被执行了...)result func(*args, **kwargs)return resultreturn inner# 在被装饰的对象上方加装饰器名
rumtime
def func1():print(this is func1)time.sleep(1)
# 当使用runtime装饰func1时相当于执行了
# func1 runtime(func1) 内部runtime.inner函数log
def func2():print(this is func2)time.sleep(2)# 多重装饰器
log
rumtime
def func3():print(this is func3)time.sleep(3)func1()
func2()
func3()输出
this is func1
函数运行时间为:1.0131046772003174
func2函数被执行了...
this is func2
func3函数被执行了...
this is func3
函数运行时间为:3.0059847831726074如上所示我们添加了functools包并在runtime和log装饰器里面调用了它如functools.wraps(func)它能将func的原数据复制到inner上其中就包括了函数名 模块化拆分装饰器
创建 utils.py 文件将我们的runtime和log装饰器写入文件中
import time
import functools
# 装饰器接收的是一个函数返回值也需要是一个函数才能保证调用方式不变
# 用闭包实现了一个装饰器
def runtime(func):# print(runtime-this is :,func)# func 被装饰的函数# 因为被装饰的函数可能带参数也可能不带参数因此这里使用可变长参数# 让代码更加灵活# functools.wraps将func函数的元数据复制到inner (函数名)functools.wraps(func)def inner(*args, **kwargs):start time.time()result func(*args, **kwargs)print(f函数执行花了:{time.time()-start}s)return result# 返回值需要是一个函数return inner# import logging
from inspect import isfunction
def log(func):# print(log-this is :,func)# func 被装饰的函数# 因为被装饰的函数可能带参数也可能不带参数因此这里使用可变长参数# 让代码更加灵活functools.wraps(func)def inner(*args, **kwargs):# logging.log()# isfunction可以用来判断func是否为函数输出Ture或者Falseif isfunction(func):print(f{func.__name__}函数被执行了...)else:print(f{func.__name__}创建了一个实例...)result func(*args, **kwargs)return result# 返回值需要是一个函数return inner然后我们在父文件中调用 utils.py 文件中的装饰器
from utils import log, runtime
装饰器可以装饰普通的函数、也可以用来装饰类
log
class A():logdef count(self):pass# log装饰器内可以判断它调用的到底是类还是函数
a A()
a.count()输出
A函数被执行了...
count函数被执行了...
作业 # 实现一个装饰器login_required # 如果需要调用被装饰的函数你需要已经登录了 # login_required # def index():pass # 1. 全局变量user None 未登录打印“请先登录再访问”,不调用index # not None 已经登录调用index # 2. 将用户数据保存到文件从文件中读取用户信息。
