linux系统中python的高级特性 || python的高阶函数
一.python的高级特性
1. 高级特性:迭代
迭代含义：
可以通过 for 循环来遍历这个 list 或 tuple,这种遍历我
们称为迭代(Iteration)。只要是可迭代对象,无论有无下标,
都可以迭代。2.字典迭代
1.默认情况下,dict 迭代的是 key值。
d = dict(a=1, b=2)
for i in d:
print(i)
2.迭代key-value值。
for i in d:
print("%s -> %s" %(i, d[i])) 3.判断对象是否可迭代
from collections import Iterable #导入模块
isinstance(1, int)
1.不可迭代类型
#整形是否可迭代
print(isinstance(1, Iterable))
#浮点型是否可迭代
print(isinstance(1.02, Iterable))
#复数是否可迭代
print(isinstance(2e-9, Iterable))
#布尔类型是否可迭代
print(isinstance(True, Iterable))
2.可迭代类型：
#字符串是否可迭代
print(isinstance('hello', Iterable))
#集合是否可迭代
print(isinstance({1,2,3,4}, Iterable))
#字典是否可迭代
print(isinstance(dict(a=1,b=2), Iterable))
4.高级特性:列表生成式
列表生成式是Python 内置的非常简单却强大的可以用来创建
list的生成式。
方法一：
l = []
for i in range(5):
l.append(i)
方法二：
[ i for i in range(5)]列表的变形 :
显示列表: 1～100之间能被3整除数的数的平方
def is_div_three(num):
#方法一：
if num % 3 == 0:
return True
else:
return False
#方法二：
return num % 3 == 0
print([num**2 for num in range(1,101) if is_div_three(num)])
示例：
1. 找出/var/log/目录中所有以.log结尾的文件
import os #倒入os模块
print([filename for filename in os.listdir('/var/log')
if filename.endswith('.log')])
#查找/var/log文件以.log结尾的文件，并打印文件名
2. 找出/etc/目录中所有以.conf结尾的文件
print([filename for filename in os.listdir('/etc/')
if filename.endswith('.conf')])
3.找出/etc/目录中所有以.conf结尾的文件，
并把这些文件名转化为大写的文件名.
print([filename.upper() for filename in os.listdir
('/etc/')if filename.endswith('.conf')])
示例1：
给定一个正整数，编写程序计算有多少对质数的和等于输入的这个
正整数，并输出结果。输入值小于1000。
如，输入为10, 程序应该输出结果为2。（共有两对质数的和为10,
分别为：(5,5),(3,7)）
- 输入描述:
输入包括一个整数n,(3 ≤ n < 1000)
- 输出描述:
输出对数
- 示例1 :
输入:
10
输出:
2
# 定义函数：判断一个数是否是质数：
def is_prime(num):
if num <= 0:
return False
elif num == 1 and num == 2:
return True
else:
# 判断是否是质数：质数：从2-num-1之间，不能被任何数整除：
for i in range(2, num):
if num % i == 0:
return False
else:
return True
n = int(input("num:")) #输入一个数
# 质数的列表：
primes_list = [num for num in range(n) if is_prime(num)]
# 方法一：
count = 0 # 数量为0
for num1 in primes_list: #判断第一个数是否在质数列表
for num2 in primes_list: #判断第二个数是否在质数列表
if num1 + num2 == n and num1 <= num2:
# print(num1,num2)
count +=1
print(count)
# 方法二：
count = 0
for num1 in primes_list:
if n - num1 in primes_list and num1 <= n - num1:
# print(n, n - num1)
count += 1
print(count)
# 方法三：
primes_pair = [(num1,n-num1) for num1 in primes_list
if n-num1 in primes_list and num1<=n-num1]
print(len(primes_pair))
5高级特性:集合生成式
d = dict(a=6, b=2, c=3, e=6)
#查找0-9之间能被3的数
print({i for i in range(10) if i%3==0})
#查看字典的value值能被3整除的数
print({i for k,i in d.items() if i%3==0})
示例2：
service = {
'http': 80,
'mysql': 3306,
'ssh': 22
}
1. 需求： 将所有的key值变为大写;
# 1-1. 传统方法:
new_service = {}
for key,value in service.items():
new_service[key.upper()] = value
print(new_service)
# 1-2. 集合生成式方法:
print({k.upper():v for k,v in service.items()})
2.需求：key值变大写，value值在原先基础上加1：
service = {
'http': 80,
'mysql': 3306,
'ssh': 22
}
print({k.upper():v+1 for k,v in service.items()})
3.需求：大小写key值合并，统一以小写值输出；
d = dict(a=2, B=10, b=4, e=1, A=1)
# 方法一：
print({k.lower():d.get(k.lower(),0)+d.get(k.upper(),0) for k,v in d.items()})
# get :不存在返回value值，存在返回0
# 方法二：
d1 = {}
for k,v in d.items():
k = k.lower()
if k in d1:
d1[k] += v
else:
d1[k] = v
print(d1)
4.把字典的key和value值调换
d1 = {'name': 'westos', 'passwd': 'redhat'}
print({v:k for k,v in d1.items()})
6. 生成器
生成器:在循环的过程中不断推算出后续的元素呢?这样就不必创
建完整的 list,从而节省大量的空间。在 Python 中,这种一
边循环一边计算的机制,称为生成器(Generator)1. 列表生成式修改为生成器
li = [i for i in range(100) if i%2==0]
# 生成器
g = (i for i in range(100) if i%2==0)
print(g,type(g))
2.查看生成器内容的两种方式
2-1.python3中 g.__next__方法(), python2.x中g.next()；
print(g.__next__())
print(g.__next__())
print(g.__next__())
2-2. for循环
isinstance(1, int)
isinstance(1, (int, float))
from collections import Iterable #导入模块
print(isinstance(g, Iterable))
for i in g:
print(i) 
# for循环的底层原理：
g1 = (i for i in range(3))
while True:
try:
print(g1.__next__())
except StopIteration :
print("生成器执行结束")
break
7. 斐波拉契数列(Fibonacci)
斐波拉契数列(Fibonacci):除第一个和第二个数
外,任意一个数都可由前两个数相加得到:1, 1, 2, 3, 5, 8, 13, 21,...
def fib(num): # num=5
a, b, count = 0, 1, 1 # a=0, b=1
while count <= num:
yield b # 1
a, b = b, a + b # a=1, b=1
count += 1
# 如果函数中有yield关键字， 返回一个生成器对象;
# 目前不执行函数内容；
g = fib(10)
# 当遇到g.__next__方法时， 执行函数, 当遇到yield停止执行;
# print(g.__next__())时yield后面的值
print(g.__next__())
# 再次调用g.__next__方法时， 从上次停止的地方继续执行，
# 遇到yield停止;
print(g.__next__())
g.close() # 关闭生成器
for循环查看生成器：
for i in g:
print(i)
示例：生成器_迷你聊天机器人
def chat_robot():
while True:
received = yield
g = chat_robot()
g.__next__()
# send方法， 给生成器传递值， 直到遇到下一个yield停止;
g.send("ls")
迷你聊天机器人：
def chat_robot():
res = ''
while True:
received = yield res
if "名字" in received:
res = "我是小冰..."
elif '年龄' in received:
res = '年龄18！'
elif '真的吗' in received:
res = '当然了！'
else:
res = '我不知道你在说什么, 请换种说法!'
def main():
Robot = chat_robot()
Robot.__next__()
while True:
send_data = input("小茗>>")
if send_data == 'q' or send_data == 'quit':
print("我也要休息了....")
break
robot_data = Robot.send(send_data)
print("小冰>>", robot_data)
main()
二. 高阶函数
1.高阶函数
高阶函数:变量可以指向函数,函数的参数能接收变量,那么一个函数就
可以接收另一个函数作为参数,这种函数就称之为高阶函数。
1.map函数:map() 函数接收两个参数,一个是函数,一个是序列,
map将传入的函数依次作用到序列的每个元素,并把结果作为新的list 返回。
2.reduce函数：reduce 把一个函数作用在一个序列[x1, x2, x3...]上,这个函数必须接收两个参数,reduce 把结果继续和序列的下一个元素
做累积计算。
3.filter函数:filter() 也接收一个函数和一个序列。和 map()
不同的时,filter() 把传入的函数依次作用于每个元素,然后根据返
值是 True还是 False 决定保留还是丢弃该元素。
4.sorted函数:排序也是在程序中经常用到的算法。无论使用冒泡排序
还是快速排序,排序的核心是比较两个元素的大小。通常规定如下:
x < y, return -1
x == y, return 0
x > y, return 1
5.匿名函数:当我们在传入函数时,有些时候,不需要显式地定义函数,
直接传入匿名函数更方便。
关键字 lambda 表示匿名函数,冒号前面的 x 表示函数参数1.map函数:
from collections import Iterable
def mypower(num):
return num**2
m = map(mypower, [1,2,3])
print(type(m),isinstance(m, Iterable))
for i in m:
print(i, end=',')
def fun(*num):
return sum(num)
m = map(fun, [1, 2, 3], {5, 6, 7})
for i in m:
print(i)
print(list(map(str, [1, 2, 3])))
2.reduce函数:
from functools import reduce #导入reduce函数
def add(x, y):
return x + y
print(reduce(add, range(2, 1001, 2)))
示例：
数的阶乘: n! 5!= 5*4*3*2*1 3!= 3*2*1
from functools import reduce
def mypower(x,y):
return x*y
n = int(input("num:")) #输入数字
print(reduce(mypower, range(n, 1, -1))) # ((1*2)*3)
3.sorted函数：
排序：默认由小到大
print(sorted([23,56546,78]))
排序： 由大到小。 reverse=True, 代表排序后进行反转;
print(sorted([23,56546,78], reverse=True))
示例：
info = [
['001', 'apple', 1000, 2],
['002', 'xiaomi', 10, 2000],
['003', 'Oppo', 200, 1900],
['004', 'computer', 900, 5000]
]
# price：按价格进行排序：
def sorted_by_count(item):
return item[3]
print(sorted(info, key=sorted_by_count))
info = {
'001':{
'name':'apple',
'count':1000,
'price':2
},
'002': {
'name': 'xiaomi',
'count': 10,
'price': 2000
},
'003': {
'name': 'Oppo',
'count': 200,
'price': 1900
}
}
def sorted_by_count(item):
return item['price']
print(sorted(info.values(), key=sorted_by_count))
print(sorted(info.values(), key=lambda item:item['price']))
示例：
高阶函数_返回值是函数：
# 闭包: 函数里面嵌套函数;
def compare1(base): # base=10
def compare2(y): # y = 3
return base > y
return compare22. 装饰器
装饰器:
• 装饰器就是用来装饰函数。
• 想要增强原有函数的功能;但不希望修改now()函数的定义;
• 在代码运行期间动态增加功能的方式。
import functools #导入模块
1. 装饰器函数
def 装饰器名称(fun):
@functools.wraps(fun)
def wrapper(*args, **kwargs):
pass
return wrapper
2. 使用装饰器函数
@装饰器名称 # hello = 装饰器名称(hello)
# hello = wrapper
def hello():
pass
hello() # 实质执行的是wrapper函数
hello.__name__
hello.__doc__示例：
import time
def compute_time(fun):
def wrapper():
start_time = time.time()
fun()
end_time = time.time()
print("%s 函数执行时间为%ss" %(fun.__name__, end_time-start_time))
return wrapper
@compute_time # hello=compute_time(hello)
def hello():
print("hello")
time.sleep(1)
@compute_time # 这里是 python 提供的一个语法糖
def hello1():
print("hello1....")示例：
实现日志记录的装饰器函数：
日志格式: 时间 函数名 运行时间: 运行结果:
import time #导入模块用来计算时间戳
def info_log(fun):
def wrapper():
start_time = time.time()
res = fun()
end_time = time.time()
print("%s %s 执行时间为%.2fs 执行结果为：%s" %(time.ctime(),fun.__name__,end_time-start_time,res))
return res
return wrapper
#
@info_log
def hello():
print("hello")
time.sleep(1)
return True
hello()
示例：
将所有的0移动到最后面：
n = int(input())
nums = [int(input()) for i in range(n)]
def move_zero_last(num):
if num == 0:
return 1
else:
return 0
print(sorted(nums,key=move_zero_last))
将所有的0移动到最前面：
nums = [int(input()) for i in range(n)]
def move_zero_befor(num):
if num == 0:
return 0
else:
return 1
print(sorted(nums,key=move_zero_befor)闭包：函数里面嵌套函数
def compare1(base): #base = 10
def compare2(y): #y = 3
return base > y
return compare2
b = compare1(10)
print(b)
print(b(3))
print(compare1(10))
3.语法糖
import time #导入模块用来计算时间戳
def hello():
print("hello")
time.sleep(1) #函数执行时间休眠几秒
def compute_time(fun): #定义计算时间的函数（装饰器）
def wrapper():
start_tiem = time.time()
fun()
end_tiem = time.time()
print("%s 函数执行时间为%ss" %(fun.__name__,end_tiem-start_tiem))
return wrapper
hello = compute_time(hello)
@compute_time #语法糖：等于： hello = compute_time(hello
def hello1():
print("hello1")
time.sleep(1) #函数执行时间休眠几秒示例：
import time
import random
def info_log(fun): #fun=add
def wrapper(*args,**kwargs):
#args=(1,2) #形参，接收的参数和关键字；
start_time = time.time()
res = fun(*args,**kwargs) #add(args)
end_time = time.time()
print("%s %s 执行时间为%.2fs 执行结果为：%s" %(time.ctime(),fun.__name__,end_time-start_time,res))
return res
return wrapper
#
@info_log
def add(x,y):
time.sleep(1)
return x**y
add(2,2)
print(add(2,5))
4. 函数的解包
1.对列表或者元组进行解包的；
def fun(*args):
print(args)
fun(1,2,3,4,5)
li = [1,2,3,4,5,6]
print(*li)
fun(*li)
2.对字典解包的
def fun1(**kwargs):
print(kwargs)
info = {'name':'fentiao', 'age':10}
fun1(**info)5. 装饰器的第2个模板
import functools
def is_admin(fun):
@functools.wraps(fun)
def wrapper(*args, **kwargs): # {"name":'redhat'}
if kwargs['name'] == 'admin':
fun(*args, **kwargs)
else:
print("no permission")
return wrapper
login_seesion = ['root','admin', 'redhat']
def is_login(fun):
@functools.wraps(fun)
def wrapper(*args, **kwargs):
if kwargs['name'] in login_seesion:
fun(*args, **kwargs)
else:
print("%s没有登陆" %(kwargs['name']))
return wrapper
@is_login
@is_admin
def bbs(name):
print("bbs.......")
bbs(name='redhat') #不是admin用户没有权限
6. 多个装饰器的执行顺序
def decorator_a(func): # func=f
# print('Get in decorator_a')
def inner_a(*args, **kwargs):
print('Get in inner_a')
return func(*args, **kwargs) # f(1)
return inner_a
def decorator_b(func): # decorator_b(inner_a)
# print('Get in decorator_b')
def inner_b(*args, **kwargs):
print('Get in inner_b')
return func(*args, **kwargs) # inner_a(1)
return inner_b
# 当有多个装饰器时， 从下到上调用装饰器；
@decorator_b # f = decorator_b(inner_a) # f=inner_b
@decorator_a # f = decorator_a(f) f=inner_a
def f(x):
print('Get in f')
return x * 2
f(1)
7.匿名函数
计算0-1000之间所有偶数的和：
from functools import reduce #导入模块
def add(x, y):
return x + y
f = lambda x,y : x+y
print(f)
print(reduce(lambda x,y: x+y , range(2, 1001, 2)))执行结果：
8.模块
字体颜色：
HAEDER = '\033[95m' #枚红
OKBLUE = '\033[94m' #蓝色
OKGREEN = '\033[92m' #绿色
WARNING = '\033[93m' #黄色
FAIL = '\033[36m' #青色
END = '\033[0m'
def add(x, y):
return x + y
if __name__ == "__main__": # 判断的是这个脚本内容是否为被导入的模块内容
print(HAEDER+ '这是example模块的显示' + END)
print(OKBLUE+ '这是example模块的显示' + END)
print(OKGREEN+ '这是example模块的显示' + END)
print(WARNING+ '这是example模块的显示' + END)
print(FAIL+ '这是example模块的显示' + END)
print("这是example模块__name__：", __name__)
1.内置模块:
import time #计算时间
import functools #函数模块
import random #生成随机数
2.自定义模块:
import example
3.python模块的默认搜索路径:
import sys
print(sys.path)
# 追加模块的默认搜索路径:
sys.path.append('/mnt')
print(sys.path)
# 将新的搜索路径加到最前面:
sys.path.insert(0, '/tmp')
print(sys.path)