python 一些高级用法

scott198512

已于 2024-05-23 10:10:44 修改

阅读量1.1w

点赞数 1

分类专栏： python 文章标签： windows

于 2019-03-18 19:45:11 首次发布

本文链接：https://blog.csdn.net/scott198510/article/details/88648306

版权

python 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

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+5

8. 三大推导式

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,10

def 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进阶之高级用法详细总结的文章就介绍到这里