day16:内置函数二

1,大作业,yield 返回之后可以对数据进行处理了就，注意函数的解耦，每一个小功能写成一个函数，增强可读性，写之前自己要先把整体功能分块，先做什么，在做什么

# 现在需要对这个员工信息文件进行增删改查。
 
# 可以进行查询，支持三种语法：
# 支持：大于小于等于，还要支持模糊查找。
# 示例：
# select name, age where age>22
# select * where job=IT
# select * where phone like 133
 
# 用户信息处理-分析信息
# user_msg = input('>>>')
user_msg = 'select * where age>22'  # 规律都有where
view,condition= user_msg.split('where') # 查询内容，查询条件，拆包
 
# view = view.split('select').pop().strip()  # strip不可以去掉完整的字符串,split前面字典必然有个空值，因为是从头开始切得
view = view.replace('select','').strip() # 和上一句效果一样的
view_list = view.split(',')
 
# 读取文件  ---将文件内容整理
def get_line(filename):
    '''
    返回员工的列表
    :param filename:
    :return:
    '''
    with open(filename,encoding='utf-8') as f1:
        for line in f1:
            line = line.strip()
            list_line = line.split(',')
            yield list_line #  这一句是关键，信息可以拿出去处理了
 
dic = {'name':1,'id':0, 'age':2,'phone':3,'job':4}
 
def condition_filter(condition):
    '''条件筛选'''
    print(condition)
    condition = condition.strip()
    if '>' in condition:
        col,value = condition.split('>')
        print(col,value)
        g_line = get_line('employ_list.txt')
        for line in g_line:
            if int(line[dic.get(col)]) > int(value):
                yield line
 
# 尽量做到程序的解耦，就是把它拆分成几个函数去完成
def view(view_list,staff_g):
    '''展示符合条件的员工信息'''
 
    for staff in staff_g:
        if '*' in view_list:
            view_list = dic.keys()
 
        for i in view_list:
            print(staff[dic[i]],end=' ')
        print('\r')
 
staff_g = condition_filter(condition)
view(view_list,staff_g)

2，凡是参数里面带key的要特别记忆一下，因为可能会在面试题里面考试,目前就是min和max函数，另外，min和max可以接受多个参数，sum只可以接收iterable和start并且只能是数字

3，数据结构相关的24个，先说序列，list和tuple 函数，这两个只有在数据类型强制转换的时候才会用

4，数据类型：int,bool,和其他的很多；数据结构:指的是容器相关的，list,tuple,set,str,dic,tuple和dict是Python独有的，别的语言没有，所以这两个一定不要忘了

5，reversed 函数

# 这个的话，原来的函数就不存在了
l = [1,2,3,4,5]
l.reverse()
print(l)
 
l = [1,2,3,4,5]
l2 = reversed(l)
print(l)  # 首先原来的列表没变
print(l2) # 第二给出了迭代器，不改变原列表，返回反序的迭代器
 
运行结果：
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
<list_reverseiterator object at 0x10b1397b8>

6，slice切片函数,注意内置函数是不需要用点来调用的，都可以直接用的

l = [145,221,45,67,56,789,222,334,556,54]
sli = slice(1,6,2)  # 只是给出一个切片规则
print(l[sli])  #这两句效果是一样的
print(l[1:6:2])# 其实内部流程是一样的，也是一种语法糖
 
运行结果：
[221, 67, 789]
[221, 67, 789]

7，字符串相关的函数,首先format函数

str.format() # 这个是字符串的format格式化输出
format() # 内置函数的format非常的强大，有很多的功能，这里简单写几个

8，和小数相关的，数学相关的，非常强大，有兴趣可以去专门研究

print(format('test','<20')) # 20个空间，左对齐
print(format('test','>20')) # 20个空间，右对齐
print(format('test','^20')) # 20个空间，居中

9，bytes函数，转换成bytes类型，其实读到内存里面都是Unicode的，我们想把它转成UTF-8,我们是把他转换成了bytes类型的utf-8,为何要转换成bytes?主要原因：

# bytes()函数就是把unicode转换成GBK或者是utf-8，哪些情况需要转呢，比方说我拿到了GBK想转换为UTF8
# 就需要先decode 成Unicode，在encode成utf-8
print(bytes('你好',encoding='GBK')) # unicode 转换成GBK的bytes
print(bytes('你好',encoding='utf-8'))  # Unicode转换成utf-8的bytes
print(bytes('你好',encoding='GBK').decode('GBK'))
# 文件里面存的是GBK，我想存储UTF-8格式的，读到内存里，内存转换成Unicode，这个转换的过程是decode的，然后从内存里面拿出来
# 转换成utf-8的，这个过程是encode的过程，编码，bytes过程
 
# 网络编程，网络传输的角度，两个机器想要进行通信，只能传递二进制
# 照片和视频也只能是二进制传输
# 文件存储，平时写进去，读出来，已经指定编码了，二进制，就是bytes
# HTML 爬取到的也是二进制编码
# 工作的时候，编码是个大工程，一定要学好
# 2.7里面编码是混乱的，Python3记住这几个就好，
 
运行结果：
b'\xc4\xe3\xba\xc3'
b'\xe4\xbd\xa0\xe5\xa5\xbd'

10，bytearray函数，用的不多，byte类型的一个数组，好处是修改字符串的时候可以节省内存，不好的地方麻烦，只能通过字符编码来改，例如把你改成您

# 发现规律了吗？
b_array = bytearray('你好',encoding="utf-8")
print(b_array)
# bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(b_array[0])
print(hex(b_array[0]))
print(hex(b_array[1]))
 
s1 = 'lisa'
s2 = 'lisa2'  # 当然我们可以按照自己改，但是比较麻烦，还要查编码，用的不多，了解一下就行
 
运行结果：
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
228
0xe4
0xbd

11，memoryview这个用的也不多，但要知道的，更鸡肋的功能，memoryview是一个字节类型的切片，你能看到的只是字节，不占用内存，只是给你看看，但是转成字符串又开始占内存了

memoryview切的时候就不占了，不给你，只给你看看，只是从原来的内存里拿一部分给你看，根据字节也不好操作，不用太研究

s ='jdshfiuascidjhueughiqlbi'
s2 = s[:10] #不用memoryview 每切一次都会创建一个新的

12，字符按照Unicode转换成数字ord函数

# 参数必须是字符类型
print(ord('a'))
print(ord(''))
print(ord('好'))  # 中文也可以检测，是按照Unicode来转换的
运行结果：
97
49
22909

13，数字按照Unicode转成字符，和上一个刚好相反

print(chr(68))
print(chr(98))
 
#没有的结果为空
运行结果：
D
b

14，ASCII函数，如果是ASCII中的，就打印ASCII码，不是就打印出\u...这个方法了解一下就行，用的不多

print(ascii('你'))
print(ascii("a"))
 
运行结果：
'\u4f60'
'a'

15，下面这个方法用的比较多repr方法

name = 'lisa'
print("你好%s"%name)  #  %s  str
print("你好%r"%name)  # %r repr，其实内部就是调用了repr方法
 
# 带着符号就打出字符串了，后面面向对象还会讲，其实是一个很神奇的函数
# 原封不动的输出某个变变量
print(repr(1))
print(repr(''))
# 所有的字符串在这里都会原形毕露，防止你忘了是字符串类型，这里了解一下就好，
 
运行结果：
你好lisa
你好'lisa'
1
''

16，下面讲解数据集合，set，frozenset和dict方法，有没有发现，只要是大括号括起来的，都是无序的，set类似于字典的key，就是没有value的字典，可哈希，不重复，和字典要求一样，frozenset之后就不可以变了，frozen之后就可以做字典的key了

17，比较重要的，len,enumerate这个不写了，由于很熟悉了。

18，两个需要了解一下的函数，注意参数必须是iterabal的，不然后报错

# 判断是否有bool值是false的值，也就是全为真值，最后结果才为真，有一个false整体就是false
print(all(range(10)))
print(all([1,'',9]))
print(all([1,' ',9])) # 控制也代表有值，就代表这个字符串不为空
print(bool('')) # 注意空串和空值的区别，只有是空串的时候才为false
print(bool(' '))
print('***************************')
 
# 判断是否有bool值为true的值，有一个false，整体就是false
print(any([1,'',2]))
print(any([1,' ',2]))
print(any([0,'',()]))
 
运行结果：
False
False
True
False
True
***************************
True
True
False

19，zip,filter,sored,map非常重要的四个函数，zip 有拉链的意思，

# 拉链方法
list1=[1,2,3]
list2=['a','b','c']
list3 =['*','**',[],'pp']
dict1 = {'k1':1,'k2':2}
z1= zip(list1,list2)
 
print(z1) # <zip object at 0x10cf51388>,这个地方一看是个内存地址，就要猜测是个迭代器了，
# 因为我们知道他是有多个值的，有时候迭代器不会明确说自己是迭代器的，我们要去猜,只要可迭代，就可以循环
print("__next__" in dir(zip))
for i in z1:
    print(i)
 
# 可以拉上不同类型的可迭代对象，不同数量，拉最少的数量，字典只是拉上key，字典很多时候都只是key,返回元祖，因为字典无序，所以有时候，顺序会颠倒的
print('**************************')
z2 = zip(list1,list2,list3,dict1)
for i in z2:
    print(i)
 
运行结果：
<zip object at 0x10258e408>
True
(1, 'a')
(2, 'b')
(3, 'c')
**************************
(1, 'a', '*', 'k1')
(2, 'b', '**', 'k2')

20，filter，非常重要的，像什么？像生成器表达式，和filter的效果是一样的，只是形式不一样，它里面的函数可以做的事情比生成式多。只做过滤，满足条件的筛选出来，注意return这儿，很多时候都可以简化

def is_odd(x):
    return x%2 == 1 # 本身就能代表真假,必须返回bool值，
 
# 接收两个参数，第一个是一个函数地址，也就是函数名，第二个参数是一个可迭代的，会把第二个里面每一个元素作为参数传递到第一个函数里面，根据
# 返回是true或者false来决定你是否在我筛选的范围之内
ret = filter(is_odd,[1,2,3,4,5,6,7,8,9])
print(ret)  # 返回也是迭代器
for i in ret:  #只要函数return是True就返回列表里面的原值，这里循环就可以取出
    print(i)
 
# ret = [i for i in[1,2,3,4,5] if i%2==1] 和生成式表达式一样的
# 这里不能推理出过程，必须记忆一下

# 判断是否是字符串
def is_str(x):
    return type(x) == str
# 这个fiter可以做很多事情的，我们可以删除None或者空字符串等等
ret = filter(is_str,[1,2,3,'lll',5,' pp',7,8,9])  #这里可以传任何数据类型
for i in ret:
    print(i)
 
运行结果：
lll
 pp

# 返回所有bool值不是false的值
def is_str(s):
    return s and str(s).strip()
    # if type(s) != int:
    #     return s and s.strip()
    # else:
    #     return s
# 这个fiter可以做很多事情的，我们可以删除None或者空字符串等等
ret = filter(is_str,[0,2,None,'lll','',' ', 'pp',7,8,9])  #这里可以传任何数据类型
for i in ret:
    print(i)

21，filter 100以内平方根为整数的值

import math
def is_sqrt(s):
    return math.sqrt(s)%1 == 0 # 判断是否是整数，取余1位零就可以了
 
ret = filter(is_sqrt,range(101))
for i in ret:
    print(i)
print(int(2.5))  #强转也是整数值了
 
运行结果：
0
1
4
9
16
25
36
49
64
81
100
2

22，非常重要的map函数，map和filter和列表生成式是分不开的，元列表，按照函数加工，返回值

ret = map(abs,[1,-2,-3,4,-5,6])
print(ret)
for i in ret:
    print(i)
# 输出结果，值变了，但是个数没变，abs的返回值，作为新值返回来
运行结果：
<map object at 0x1015db630>
1
2
3
4
5
6

23，结论：filter,执行了filter之后的机构集合小于等于执行之前的个数，并且filter只管筛选，不会改变原来的值，map之执行前后元素个数不变，值可能发生改变，二者的参数是一样的，一个函数名，一个iterable.

24，重要的，sorted 函数，排序方法，接收可迭代的类型，和一个函数名，根据要求排序。

l = [1,-8,3,-2,5,6]
# sort，是字符串对象的函数，sorted是内置函数，不用点来调用
l.sort(reverse=True)
print(l)
l.sort(key=abs)
# print(l) # 默认改过之后元列表就不存在和，默认升序，这点和reverse一样，都是原来的列表不存在了，但是，reverse
l = [1,-8,3,-2,5,6]
l.reverse() # 没有key
print(l)
 
ret = sorted(l,key=abs,reverse=True)
print(ret)  # 直接返回列表,不修改原来的列表，占内存
ret = reversed(l)
print(ret)  # 返回迭代器
 
运行结果：
[6, 5, 3, 1, -2, -8]
[6, 5, -2, 3, -8, 1]
[-8, 6, 5, 3, -2, 1]
<list_reverseiterator object at 0x108d057b8>

25，另外一个例子，sorted 要慎用，占用内存，和reverse不同，排序要挑算法的，一定要预知所有值，才可以排序，所以和reverse机制是不一样的，reverse只要去指定位置取就可以了，一个一个来，可以用迭代器，排序用不了，尽管占内存，也比已知的所有排序算法好很多，所有自己写的都没有sorted快，实现语言C语言，操作系统也有优化机制，用还是用人家的，自己写的会慢。

l = ['   ',[1,2,3,4,5],'hello world']
new_l = sorted(l,key=len,reverse=True) # reverse参数
print(new_l)
运行结果：
['hello world', [1, 2, 3, 4, 5], '   ']

26，这个函数也可以是自己定义的，复杂算法，不支持返回可迭代的，也可以根据需求来排序。sorted,min,max,key在后面，并且必须写，map，filter func在前面

def func(item):
    return len(item)
 
l = ['   ',[1,2,3,4,5],'hello world']
new_l = sorted(l,key=func,reverse=True) # iterable的每个元素作为参数进行计算，和上面的例子是一模一样的
print(new_l)
 
运行结果：
['hello world', [1, 2, 3, 4, 5], '   ']

27，最最重要的，匿名函数。匿名函数本身简单，但是难在和其他内置函数一起使用的时候，就比较难了,lambda定义匿名函数，和def差不多

def calc(n):
    return n**n
print(calc(5))
 
calc = lambda n:n**n
print(calc(5))
# 函数名  参数：返回值，不允许换行，一行写完
# 参数可以有多个，逗号分隔
 
运行结果：
3125
3125

28，练一练：

def add(x,y):
    return x+y
print(add(10,20))
 
add = lambda x,y:x+y
print(add(10,20))
 
运行结果：
30
30

29,匿名函数是可以有函数名字的，整个表达式就是函数名，可以赋值给一个变量，另外一个是，他真的可以匿名，后面的函数，给出的是比较标准，最后结果函数原来的迭代器里面的数字，

dic={'k1':10,'k2':100,'k3':30}
 
print(max(dic)) # 这样的话，默认的是拿key来做比较，所以最大的是k3
print(max(dic,key=lambda k:dic[k]))  #拿到value值最大的key，也就是k2,后面的key =给出了比较标准，给出最后还k2
print(dic[max(dic,key=lambda k:dic[k])])
 
运行结果：
k3
k2
100

30，带key的函数，min,max,sort map和filter，他们都可以和lambda 合作，一道简单的面试题

d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x)  #
x = t(x)  #
x = d(x)  #
print(x)
 
运行结果：
24

31，另外一道题，两个元祖联系起来的就是zip函数，应用匿名函数，只要考到匿名函数，一定不是单纯的匿名函数，肯定会用到内置函数，那内置函数就去想那五个函数，个数没变，内容变了，就是map函数，map函数的参数，就是可迭代对象的元素

# 现有两个元组(('a'),('b')),(('c'),('d'))，请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
 
# 第一个版本，自己写的，最复杂
tuple1 = (('a'),('b'))
tuple2 = (('c'),('d'))
ret = zip(tuple1,tuple2)
 
dict1 = {}
l = []
for i in ret:
    dict1.setdefault(i[0],i[1])
 
for i in dict1:
    l.append({i:dict1[i]})
print(l)
 
# 第二个版本：
ret = zip((('a'),('b')),(('c'),('d')))  # 这个返回本身就是iterable，可以作为map的参数
def func(tup):
    return {tup[0]:tup[1]}
ret = map(func,ret)
print(list(ret))
 
# 第三个版本：当然最好不要这样写，会挨骂的
print(list(map(lambda tup:{tup[0]:tup[1]},zip((('a'),('b')),(('c'),('d'))))))

32，这个题蛮刁钻的，不容易想到，生成器必考的，所以一看到就要往这边想

def multipliers():
    return [lambda x:i*x for i in range(4)]  # 这样的话，我要一次 后面的for循环都已经执行完了，所以i全部是3
 
print([m(2) for m in multipliers()])
# 请修改multipliers的定义来产生预期的结果
 
def multipliers():
    return (lambda x:i*x for i in range(4))  # 改成生成器，每要一次，for走一次
 
print([m(2) for m in multipliers()])
# 请修改multipliers的定义来产生预期的结果
 
运行结果：
[6, 6, 6, 6]
[0, 2, 4, 6]

33，要学会归纳，尤其是内置函数这一块儿