1. zip用法
Zip()是一个内置的 Python 函数，它为我们提供了一个元组迭代器。Zip 是一种包含真实数据的容器。它采用可迭代元素作为输入，并在其上返回一个迭代器（元组的迭代器）。它从左到右计算可迭代对象。我们可以使用生成的迭代器快速有效地解决常见的编程问题，例如创建字典。解压缩等相过程，对于解压缩，我们使用带有函数的 * 字符。
# ZIPPING
a = ("SHIVAM", "SACHIN", "VIKALP", "RAGHAV", "PRANAY")
b = ("SINGLA", "SINGLA", "GARG", "GUPTA", "GUPTA")
x = zip(a, b)
# use the tuple() function to display
# a readable version of the result:
print(tuple(x))
# ZIPPING AND UNZIPPING
name = ['sachin', 'shivam', 'vikalp']
age = [20, 18, 19]
result = zip(name, age)
result_list = list(result)
print(result_list)
n, a = zip(*result_list)
print('name =', n)
print('age =', a)
2. generator
生成器函数允许我们声明一个行为与迭代器相同的函数，即它可以用来代替 for 循环。生成器是迭代器，但它们只能迭代一次。生成器在 Python 中引入了 yield 语句，它的工作方式有点像 return，因为它返回一个值。生成器将创建元素并仅在需要时将它们存储在内存中，即一次一个。这意味着，如果你必须创建大量浮点数，则一次只能将它们存储在内存中！这大大简化了代码，使代码比简单的 for 循环更有效。
# A simple generator function
def my_func():
n = 1
print('First Number')
# Generator function contains yield statements
yield n
n += 1
print('Second Number ')
yield n
n += 1
print('Last Number ')
yield n
# Using for loop
for number in my_func():
print(number)
def str(my_str):
length = len(my_str)
for i in range(0, length ):
yield my_str[i]
# For loop to print the string as
# it is using generators and for loop.
for char in str("Shivam And Sachin"):
print(char, end ="")
3. decorator
装饰器是 Python 的重要组成部分之一。它对于向之前实现的函数添加功能非常有帮助，而无需对原始函数进行任何更改。在 Decorator 中，函数作为参数传递到另一个函数中，然后在包装函数中调用。它允许我们包装另一个函数以扩展包装函数的功能，而无需永久修改它。装饰器通常在定义要装饰的函数之前调用。当你想为现有代码提供更新的代码时，装饰器非常有效。
def decorator(a_func):
def wrapper():
print("Before executing function requiring decoration.")
a_func()
print("After executing requiring decoration.")
return wrapper
def function():
print("Function requiring decoration.")
function()
function = decorator(function)
function()
def flowerDecorator(func):
def newFlowerPot(n):
print("We are decorating the flower vase.")
print("You wanted to keep % d flowers in the vase." % n)
func(n)
print("Our decoration is done.")
return newFlowerPot
def flowerPot(n):
print("We have a flower vase.")
flowerPot = flowerDecorator(flowerPot)
flowerPot(5)
4. Lambda
Lambda表达式又被称之为匿名函数
格式
lambda 参数列表：函数体
def add(x,y):
return x+y
print(add(3,4))
#上面的函数可以写成Lambda函数
add_lambda=lambda x,y:x+y
add_lambda(3,4)5. map函数
函数就是有输入和输出，map的输入和输出对应关系如下图所示：
就是要把一个可迭代的对象按某个规则映射到新的对象上。
因此map函数要有两个参数，一个是映射规则，一个是可迭代对象。
list1=[1,2,3,4,5]
r=map(lambda x:x+x,list)
print(list1(r))
# result is : [2,4,6,8,10]
m1=map(lambda x,y:x*x+y,[1,2,3,4,5],[1,2,3,4,5])
print(list(ml))
# result is : [2,6,12,20,30]6. filter函数
filter的输入和输出对应关系如下图所示：
def is_not_none(s):
return s and len(s.strip())>0
list2=['','','hello','xxxx', None,'ai']
result=filter(is_not_none, list2)
print(list(result))
# [‘hello',‘xxxx',‘ai']7. reduce函数
结果：15=1+2+3+4+5
相当于每一次计算都是基于前一次计算的结果：
还可以为reduce计算添加初始值：
from functools import reduce
f=lambda x,y:x+y x=reduce(f,[1,2,3,4,5],10)
print(r)
# 25=10+1+2+3+4+58. 三大推导式
8.1 列表推导式
list1=[1,2,3,4,5,6]
f=map(lambda x:x+x,list1)
print(list(f))
list2=[i+i for i in list1]
print(list2)
list3=[i**3 for i in list1]
print(list3)
#筛选列表的例子
list4=[i*4 for i in list1 if i>3]
print(list4)
#result:
[2,4,6,8,10,12]
[2,4,6,8,10,12]
[1,8,27,64,125,216]
[16,25,36]8.2 集合推导式
直接把上面代码copy下来，然后把列表改成集合
list1={1,2,3,4,5,6}
list2={i+i for i in list1}
print(list2)
list3={i**3 for i in list1}
print(list3)
#筛选列表的例子
list4={i*4 for i in list1 if i>3}
print(list4)
#结果
{2, 4, 6, 8, 10, 12}
{64, 1, 8, 216, 27, 125}#这里是乱序的
{16, 24, 20}8.3 字典推导式
s={
"zhangsan":20,
"lisi":15,
"wangwu":31
}
#拿出所有的key，并变成列表
s_key=[ key for key, value in s.items()]
print(s_key)
#结果
['zhangsan','lisi','wangwu']
# 交换key和value位置，注意冒号的位置
s1={ value: key for key, value in s.items()}
print(s1)
#结果
{20:'zhangsan',15:'1isi',31:'wangwu'}
s2={ key: value for key, value in s.items() if key=="1isi"}
print(s2)
#结果
{"lisi":15}9. 闭包
闭包：一个返回值是函数的函数
import time
def runtime():
def now_time():
print(time.time())
return now_time #返回值是函数名字
f=runtime()#f就被赋值为一个函数now_time()了
f()#运行f相当于运行now_time()再来看一个带参数的例子：
假设有一个csv文件，内容有三行，具体如下：
a,b,c,d,e
1,2,3,4,5
6,7,8,9,10def make_filter(keep):# keep=8
def the_filter(file_name):
file=open(file name)#打开文件
lines=file.readlines()#按行读取文件
file.close()#关闭文件
filter_doc=[i for i in lines if keep in i]#过滤文件内容
return filter_doc
return the_filter
filter1=make_filter("8")#这一行调用了make_filter函数，且把8做为参数传给了keep，接受了the_filter函数作为返回值
#这里的filter1等于函数the_filter
filter_result=filter1("data.csv")#把文件名data.csv作为参数传给了函数the_filter
print(filter_result)
#结果
['6,7,8,9,10']10. 装饰器、语法糖、注解
# 这是获取函数开始运行时间的函数
import time
def runtime(func):
def get_time():
print(time.time())
func()# run被调用
return get_time
@runtime
def run()
print('student run')
#运行
run()
#结果
当前时间
student run由于有装饰器@runtime的存在，会把run这个函数作为参数丢到runtime(func)里面去，如果调整打印时间代码的位置会有不同结果：
# 这是获取函数结束运行时间的函数
import time
def runtime(func):
def get_time():
func()# run被调用
print(time.time())
return get_time
@runtime
def run()
print('student run')
#运行
run()
#结果
student run
当前时间这里还用到了闭包的概念，在运行run函数的时候，调用的实际上是get_time函数。
对于多个参数的函数如何调用，看下面例子
#有一个参数
import time
def runtime(func):
def get_time(i):
func(i)# run被调用
print(time.time())
return get_time
@runtime
def run(i)
print('student run')
#运行
run(1)#有两个参数
import time
def runtime(func):
def get_time(i,j):
func(i,j)# run被调用
print(time.time())
return get_time
@runtime
def run(i,j)
print('student run')
#运行
run(1,2)可以发现，这样写对于函数的多态不是很好，因此可以写为：
#自动适配参数
import time
def runtime(func):
def get_time(*arg):
func(*arg)# run被调用
print(time.time())
return get_time
@runtime
def run(i)
print('student1 run')
@runtime
def run(i,j)
print('student2 run')
#运行
run(1)
run(1,2)再次进行扩展，更为普适的写法，可以解决传入类似i=4的关键字参数写法：
#自动适配参数
import time
def runtime(func):
def get_time(*arg,**kwarg):
func(*arg,**kwarg)# run被调用
print(time.time())
return get_time
@runtime
def run(i)
print('student1 run')
@runtime
def run(*arg,**kwarg)
print('student2 run')
@runtime
def run()
print('no param run')
#运行
run(1)
run(1,2,j=4)
run()到此这篇关于Python进阶之高级用法详细总结的文章就介绍到这里
3605
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
