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 compare2

2. 装饰器

装饰器:
• 装饰器就是用来装饰函数。
• 想要增强原有函数的功能;但不希望修改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)