python基础--生成器（续）,内置高阶函数

生成器示例

 def create_num(all_num):
        print('-----1-------')
        a, b = 0, 1
        current_num = 0
        while current_num < all_num:
            print('-----2-----')
            ret = yield a
            print('>>>>ret>>>>',ret)
            print('-----3------')
            a, b = b, a + b
            current_num += 1
            print('-----4------')
    
        return 'ok'


obj1 = create_num(100)
print('obj1:',obj1)
red = next(obj1)
print(red)
red1 = obj1.send('python')
print(red1)

生成器实现多任务

import time

def task_1():
    while True:
        print('-----1-------')
        time.sleep(0.1)
        yield


def task_2():
    while True:
        print('-------2---------')
        time.sleep(0.1)
        yield

#task_1()
#task_2()

def main():
    t1 = task_1()
    t2 = task_2()
    """
    类似于两个while True一起执行
    先让t1运行一会，当t1遇到yield的时候，再返回到18行
    然后执行t2,当它遇到yield的时候，再次切换到t1中
    这样t1/t2/t1/t2的交替运行，最终实现了多任务---->协程
    """
    while True:
        next(t1)
        next(t2)

main()

"""
并行(真的)：有两个任务，两个cpu，一个任务占一个cpu
并发(假的):有四个任务，两个cpu，四个任务交替占有cpu执行
"""

yield实现单线程并发

import time

def consumer(name):
    print('%s 准备学习了～' %(name))
    while True:
        lesson = yield
        print('开始[%s]了,[%s]老师来讲课了～' %(lesson,name))

def producer(name):
    c1 = consumer('A')
    c2 = consumer('B')
    c1.__next__()
    c2.__next__()
    print('同学们开始上课了～')
    for i in range(10):
        time.sleep(1)
        print('到了两个同学')
        c1.send(i)
        c2.send(i)

producer('westos')
"""
利用了关键字yield一次性返回一个结果，阻塞，重新开始
send 唤醒
"""

使用greenlet完成多任务
为了更好的使用协程来完成多任务，python中的greeblet模块
对其进行的封装
在python环境变量下，利用下面命令，安装模块

 pip3 install greenlet

代码：

from greenlet import greenlet
import time

def test1():
    while True:
        print('---A----')
        gr2.switch()
        time.sleep(0.5)

def test2():
    while True:
        print('----B----')
        gr1.switch()
        time.sleep(0.5)

"""
greenlet这个类对yield进行的封装
"""
gr1= greenlet(test1)
gr2 = greenlet(test2)

gr1.switch()

对两个函数进行反复调用实现多任务

gevent模块实现多任务

import gevent

def f1(n):
    for i in range(n):
        print(gevent.getcurrent(),i)
        gevent.sleep(1)
def f2(n):
    for i in range(n):
        print(gevent.getcurrent(),i)
        gevent.sleep(1)
def f3(n):
    for i in range(n):
        print(gevent.getcurrent(),i)
        gevent.sleep(1)
g1 = gevent.spawn(f1,5)
g2 = gevent.spawn(f2,5)
g3 = gevent.spawn(f3,5)

g1.join()
g2.join()
g3.join()

对三个函数分别调用5次，本例只输出了对象

题目描述:
现在IPV4下用一个32位无符号整数来表示，一般用点分方式来显示
点将IP地址分成4个部分，每个部分为8位，
表示成一个无符号整数（因此不需要用正号出现），
如10.137.17.1，是我们非常熟悉的IP地址，
一个IP地址串中没有空格出现（因为要表示成一个32数字）。
现在需要你用程序来判断IP是否合法。
输入描述:
输入一个ip地址
输出描述:
返回判断的结果YES or NO
示例1:

输入
10.138.15.1
输出
YES

nums = list(map(int,input().split('.')))
for i in nums:
    # if i<0 or i>255:
    #     print('NO')
    # else:
    #     print('YES')
    if i < 0 or i > 255:
        print('NO')
        exit()
    else:
        print('YES')

当四个部分都在范围内时就会返回四个yes，此时的ip地址才是正确的

题目描述： 密码要求
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
说明:长度超过2的子串
输入描述:
一组或多组长度超过2的子符串。每组占一行
输出描述:
如果符合要求输出：OK，否则输出NG
示例1
输入
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000
输出
OK
NG
NG
OK

 def passwd(str):
        if len(str)<8:
            return False
        else:
            countupper,countlower,countdigit,countspe=0,0,0,0
            for i in str:
                if i.isdigit():
                    countdigit=1
                elif i.isupper():
                    countupper=1
                elif i.lower():
                    countlower=1
                else:
                    countspe=1
        if countdigit+countupper+countlower+countspe>=3:
            return True
        else:
            return False
    def passwd3(str):
        for i in range(len(str)-3):
            if str.count(str[i:i+3])>1:
                return False
        return True
    
    while True:
        str = input('please input passwd:')
        if str == 'q':
            break
        if passwd(str) and passwd3(str):
            print('ok')
        else:
            print('ng')

高阶函数
实参是一个函数名
函数的返回值是一个函数

函数本身也可以赋值给变量 变量可以指向函数

print(abs(-11))
f = abs
print(f(-10))

传递的参数包含函数名

def fun(x,y,f):
    return f(x),f(y)

print(fun(-10,34,abs))

map()函数接收两个参数，一个是函数，一个是序列
map将传入的函数依次作用到序列的每个元素，并且把结果
作为新的序列返回

import random
#对于序列[-1,3,-4,-5]的每个元素求绝对值
print(list(map(abs,[-1,3,-4,-5])))
#对于序列的每个元素求阶乘
def factoria(x):
    """对与x求阶乘"""
    res = 1
    for i in range(1,x+1):
        res = res * i
    return res

li = [random.randint(2,7) for i in range(10)]
print(list(map(factoria,li)))

map函数练习
需求：用户接收遗传数字；讲该字符串中的所有数字转化为整型
并以列表格式输出

def fun(x):
    return int(float(x))
li=input('please input:')
li1=li.split(',')
print(list(map(fun,li1)))

reduce函数

reduce:把一个函数作用在一个序列上，这个函数必须接收两个参数
reduce把结果继续和序列的下一个元素做累积计算
reduce(f,[x1,x2,x3,x4]) = f(f(f(x1,x2),x3),x4)

from functools import reduce
"""
python2:reduce为内置函数
python3:from functools import reduce
"""
def multi(x,y):
    return x*y

print(reduce(multi,range(1,4)))


def add(x,y):
    return x+y

print(reduce(add,[1,2,3,4,5]))

filter过滤函数

filter 过滤函数
和map()类似，filter()也接收一个函数和一个序列
但是和map()不同的是，filter()把传入的函数依次作用于每个
元素，然后根据返回值是True还是False决定保留还是丢弃该元素
“”"
只能一个形参，函数的返回值只能是True或者False

def isodd(num):
    if num %2==0:
        return True
    else:
        return False
print(list(filter(isodd,range(100))))     ###拿出1～100之间的所有素数

sort和sorted

sorted和sort 的区别主要在于sorted是将排序完的数据赋予给一个新变量,而sort则是在原变量的基础上直接进行排序,不产生新变量

li = [1,2,4,6,3]
li.sort()
print(li)
a = sorted(li)
print(a)

默认sort和sorted方法由小到大进行排序，reverse=True 由大到小进行排序

a = sorted(li,reverse=True)
print(a)

info = [
    # 商品名称 商品数量 商品价格
    ['apple1', 200, 32],
    ['apple4', 40, 12],
    ['apple3', 40, 2],
    ['apple2', 1000, 23]
]


#print(sorted(info))
#按照商品数量进行排序
def sorted_by_count(x):
    return x[1]


#按照商品价格进行排序
def sorted_by_price(x):
    return x[2]


#先按照商品数量由小到大进行排序，如果商品数量一只，
#则按照商品价格由小到大进行排序
def sorted_by_count_price(x):
    return x[1], x[2]


#key代表排序的关键字
print(sorted(info,key=sorted_by_count))
print(sorted(info,key=sorted_by_price))
print(sorted(info, key=sorted_by_count_price))

高阶函数sorted练习

2018-携程-春招题)题目需求:
给定一个整形数组， 将数组中所有的0移动到末尾， 非0项保持不变；
在原始数组上进行移动操作， 勿创建新的数组;
输入:
第一行是数组长度， 后续每一行是数组的一条记录;
4
0
7
0
2
输出:
调整后数组的内容;
7
2
0
0
“”"

n = int(input('数组长度:'))
li = [int(input()) for i in range(n)]
def move_zore(item):
    if item == 0:
        return 1
    else:
        return 0
for i in sorted(li,key=move_zore):
    print(i)