python基础3_高阶内置函数&线程进程

高阶内置函数：

学习地址：https://blog.csdn.net/weixin_42134789/article/details/82381828
高阶函数定义：
1.函数套函数，函数的参数有函数
2. return一个函数

对于返回是一个函数对象的函数，有两种处理方式：
1.直接使用list将map转换成list，如list（map（func，sep））
2.使用for遍历去取值，for i in map（dunc，sep）

amy 和 all函数：（不常用）
any（）：参数是一个可迭代对象，使用布尔函数bool（）对可迭代中的每个元素进行判断真假
1.如果可迭代对象不是空，只要有一个元素是真，返回Ture
2.如果可迭代对象是空，则返回False

data=['a','b','c','']
print(any(data))
data1=[]
print(any(data1))
#打印结果：  
True
False

all（）：参数是一个可迭代对象，使用布尔函数bool（）对可迭代中的每个元素进行判断真假
1.如果可迭代对象不是空，必须所有元素都是真，返回Ture
2.如果可迭代对象是空，则返回True

data=['a','b','c','']
print(all(data))
data1=[]
print(all(data1))
data2=['a','b','c','d']
print(all(data2))
#打印结果
False
True
True

匿名函数lambda函数，返回的是函数对象
lambda 参数: 表达式

filter(func, seq)函数，返回的是函数对象
filter过滤列表中的元素，并且返回⼀个由所有符合要求的元素所构成的列表，符合要求即函数映射到该元素时返回值为True,将序列中的数值通过函数将元素为真的筛选出来
print时，加了list转换，是为了python2/3的兼容性,在python2中map直接返回列表，但在python3中返回迭代器因此为了兼容python3,需要list转换⼀下

data=[1,2,3,4,4,6]
a=filter(lambda x:x!=4,data)
print(a) #函数对象
print(list(a)) #将函数对象转换成列表
#打印结果
<filter object at 0x03469F30>
[1, 2, 3, 6]

map(func, seq…)函数，返回的是函数对象，第一个参数func是一个函数，第二个参数seq是可迭代对象）
将可迭代对象中的每个元素放到函数中进行处理
print时，加了list转换，是为了python2/3的兼容性,在python2中map直接返回列表，但在python3中返回迭代器因此为了兼容python3,需要list转换⼀下

1.只传入一个可迭代对象时正常处理

data=[1,2,3,4,4,6]
a=map(lambda x:x+1,data)
print(a)  #函数对象
print(list(a)) #将函数对象转换成列表
#打印结果
<map object at 0x00D99F30>
[2, 3, 4, 5, 5, 7]

2.有多个可迭代对象时，行的从这些参数中取元素，并调用func，map中如果传入的几个序列的长度不一，那么会依据最短的序列进行计算

data=[1,2,3,4,4,6]
data2=[10,11,12]
a=map(lambda x,y:x+y,data,data2) 
#传入了两个可迭代对象，则lamdba中需要有两个参数，否则会报错
print(a)
print(list(a))
#打印结果
<map object at 0x0035F930>
[11, 13, 15]

sorted()函数 返回的是列表形式
可迭代对象（字符串、列表、元组、字典）都可以进行迭代，和list.sort（）区别在于list.sort()是在原有列表上进行修改，sorted()不在原有基础上操作
sorted((1,4,8,9,3,6), reverse=True)倒排序 ，默认reverse=Flase正序排序
sorted(list, key=lambda x:x[0])，多维参数 key指使用可迭代对象中的某一个关键字进行排序

data='ksyahaja'
print(sorted(data)) #默认正序
print(sorted(data,reverse=True)) #倒序
#打印结果
['a', 'a', 'a', 'h', 'j', 'k', 's', 'y']
['y', 's', 'k', 'j', 'h', 'a', 'a', 'a']

data1=['dsaw','abde','iaj','jsjs']
print(sorted(data1,key=lambda x:x[1]))#以元素中的第二个关键字排序
#打印结果
['iaj', 'abde', 'dsaw', 'jsjs']

zip() 函数，返回的是函数对象
传入可迭代的对象（字符串、列表、元组、字典），将对象中的元素打包成一个个元组，生成的是zip对象，使用list方法可以将其变成列表，使用dict方法可以将其变成字典，zip对象支持直接遍历
zip()后的样式：[(),(),()]
zip(*some_list)方法
可以实现元组列表的反向解压，注意unzip只支持元组列表，不支持dict直接解压
1.使用zip函数将多个列表打包成一个个元组。多个可迭代对象时，以最短的为准

data='12345'
data1=['aa','bb','cc','dd']
data2='678'
a=zip(data,data1,data2)
print(a)
print(list(a))
#打印结果
<zip object at 0x02A63080>
[('1', 'aa', '6'), ('2', 'bb', '7'), ('3', 'cc', '8')]

2.使用dict方法将zip函数对象转换成字典

data='12345'
data1=['aa','bb','cc','dd']
print(dict(zip(data,data1)))
#打印结果
{'1': 'aa', '2': 'bb', '3': 'cc', '4': 'dd'}

enumerate()函数，返回的是函数对象
用于将一个可遍历的数据对象(如列表、元组或字符串)组合转换为一个索引序列，一般用于for循环中，同时列出元素和元素的索引号，直接使用enumerate方法生成是个enumerate对象，可以遍历的

data=['a','b','c','d']
for i ,v in enumerate(data):
    print(i,v)
#打印结果
0 a
1 b
2 c
3 d

reduce() 函数 折叠函数，对参数序列中元素进行累积。该方法第一个参数必需是函数，而且传入的函数必须且只有有2个参数，返回的是一个最终折叠的值
from functools import reduce—python3中reduce不是内置的了，要用需要先导入

from functools import reduce
data=[1,2,3,4]
c=reduce(lambda x,y:x+y,data)
print(c)
#打印结果 1+2+3+4=10
10

递归：（不是高阶函数）
1.递归一定要有一个退出条件
2.递归是自己调用自己
递归结构：

def jiecheng(n):
    if n==1:
        return 1
    return n*jiecheng(n-1)

类型转换-bool，int， long，float， bytearray，str， unicode， basestring ,list，tuple，
set ， dict， frozenset, complex。
◼ 文件IO- input， print， open， file， format
◼ 数学运算- abs，divmod， pow，sum， cmp， bin， oct， hex， chr， unichr， ord，max， min， round
◼ 集合切片- len ， range ， iter ， next ， slice ，enumerate， sorted， reversed
◼ 高阶函数- any， all， map， reduce， filter， zip
◼ 反射内省-type， isinstance， issubclass， callable， staticmethod， classmethod， getattr，
setattr， delattr， hasattr， super , dir， help，id ，hash， object， _ _ import_ _， compile，
reload， repr ，vars，locals，globals，eval，exec，execfile， property， memoryview

线程和进程：

学习地址：http://cenalulu.github.io/python/gil-in-python/
进程是活着正在运行中的程序，还有各种资源；线程是依赖于进程的，是进程的再细化
并发的程序是并行的，单核只有一个cpu时候，电脑的执行时间很快，1秒可以执行几百万条指令，人的感知比较慢，误以为是同时进行，实际上伪并行，而是程序将时间切细片进行执行
线程也是伪并行，依托进程的，在出现多核之后，如32核的，就可以将进程分配到32个cpu中执行，这时候就是真正的并行，然后线程在单个cpu中伪并行
对前端的处理会使用线程；多事物的处理会使用进程

python中优先使用进程，因为python有使用全局解释器锁
1.执行的时候是先将py文件编译成pyc文件，pyc是python更好理解的代码
2. python同一时刻只能执行一个pyc文件
3.多进程利用的是电脑的多核执行
4. 使用添加多进程代码需要写到if name == ‘main’:，否则会报错

多进程通信的方式有哪些：

1. 共享内存
2. 信号量
   3.管道：
3. socket
   多线程的通信方式：–和进程类似
   现在平台不怎么使用，因为现在平台都是分布式处理方式，现在都是基于消费队列

线程：
threading中的Thread

import time
import random
from threading import Thread
from multiprocessing import Process

# 使用time.sleep模拟一个耗时操作
def shuyi(n):
    print("殊一先睡{0}秒".format(n))
    time.sleep(n)
    print("现在殊一醒了")
def shuer(n):
    print("殊二先睡{0}秒".format(n))
    time.sleep(n)
    print("现在殊二醒了")

if __name__ == '__main__':
    n = random.randint(3, 5)
    # 使用线程库进行并行，注意target是函数名，args是参数，参数必须是元组
    thread = Thread(target=shuyi, args=(n,))
    thread.start()
    
    n = random.randint(3, 5)
    thread = Thread(target=shuer, args=(n,))
    thread.start()

进程：
multiprocessing 中的Precess，进程的使用方式和线程一样

import time
import random
from threading import Thread
from multiprocessing import Process

# 使用time.sleep模拟一个耗时操作
def shuyi(n):
    print("殊一先睡{0}秒".format(n))
    time.sleep(n)
    print("现在殊一醒了")

def shuer(n):
    print("殊二先睡{0}秒".format(n))
    time.sleep(n)
    print("现在殊二醒了")

if __name__ == '__main__':
    n = random.randint(3, 5)
     # 使用进程库进行并行，注意target是函数名，args是参数，参数必须是元组
    process = Process(target=shuyi, args=(n,))
    process.start()
    
    n = random.randint(3, 5)
    process = Process(target=shuer, args=(n,))
    process.start()