Day16 of learning python--部分内置函数和匿名函数

1.重点掌握的四个内置函数，zip，filter，map，sorted

（1）zip，连接不同的列表，组成元组，返回的是一个可迭代的内存地址

l= [1,2,3]
l2 = ['a','b','c']
for i in zip(l,l2):
    print(i)
结果：
(1, 'a')
(2, 'b')
(3, 'c')

（2）filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

#从一个list[1,2,3,4,5,6,7]中删除偶数，保留奇数
def is_odd(x):
    return  x%2 == 1
    # return type(x) == str  判断是不是字符串

ret = filter(is_odd,[1,2,3,4,5,6,7])
print(ret)
for i in ret:
    print(i)
# ret = [i for i in [1,2,3,4,5,6,7] if i%2 == 1]
# print(ret)
结果为：
[1,3,5,7]

def is_str(s):
    return s and str(s).strip()
# 去掉空字符串，删除None
ret = filter(is_str,[1,'hello','','   ',None,[],'hello world',12,13])
for i in ret:
    print(i)

请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
print(list(filter(is_sqr, range(1, 101))))

 （3）map，Python中的map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

ret = map(abs,[1,2,3,-8])
print(ret)
for i in ret:
    print(i)
结果为：
1
2
3
8

filter 执行了filter之后的结果集合 <=执行之前的个数，filter只管筛选，不会改变原来的值
map 执行前后元素个数不变，但是值可能改变了

（4）sorted,对List、Dict进行排序，Python提供了两个方法
方法1.用List的成员函数sort进行排序，在本地进行排序，不返回副本
方法2.用built-in函数sorted进行排序（从2.4开始），返回副本，原始输入不变

l = [1,-5,6,7,-10]
l.sort(key=abs)   # 在原列表的基础上进行排序
print(l)
结果：[1, -5, 6, 7, -10]
print(sorted(l,key=abs,reverse=True))   # 直接创建新的列表，但是要慎用，因为会占内存，不改变原有的列表
print(l)
结果：[-10, 7, 6, -5, 1]，[1, -5, 6, 7, -10]，[[1, 2], '    ', 'hello world']
l = ['    ',[1,2],'hello world']  # 按照长度排序
new_l = sorted(l,key=len)  # len也是一个函数名   以什么进行排序
print(new_l)

结构为：sorted(iterable, key=None, reverse=False)
参数说明：
iterable：是可迭代类型;
key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;
reverse：排序规则. reverse = True  降序 或者 reverse = False 升序，False默认值。
返回值：有序列表
2.其他的内置函数
（1）reversed(),反转，返回的是一个可迭代的

# reversed()
l = [1,2,3,4,5]
# l.reverse()
# print(l)
l2 = reversed(l)   # 保留原列表，返回一个反向迭代器
print(l2)

 （2）slice，切片规则

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

 （3）bytes，转换成bytes类型

　　在内存的存储方式都是unicode，文件存储都是gbk或者utf-8等。我拿到的是gbk编码，我想转换成utf-8编码。注意：网络编程，只能传二进制，照片和视频也是以二进制存储，html网页爬取到的也是bytes编码

print(bytes('你好',encoding='gbk').decode('gbk'))    # unicode转换成GBK的bytes,再以'gbk'解码成unicode
print(bytes('你好',encoding='utf-8'))  # unicode转换成utf-8的bytes
结果：
你好
b'\xe4\xbd\xa0\xe5\xa5\xbd'

 （4）bytearray，转换成bytes的组合，可以通过修改其中的数值，来改变原来编码之前的字符串

b_array = bytearray('你好',encoding='utf-8')
print(b_array)
print(b_array[0])
结果：
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
228

 （5）ord，字符按照unicode转数字。chr 数字按照unicode转字符。ascii，只要是ascii码中的内用就打印出来，不是就是转换成\u

print(ascii('你好'))
name = 'egg'
print('你好%r'%name)
结果：
'\u4f60\u597d'
你好'egg'

 （6）repr，全打印

print(repr('1'))
print(repr(1))
print('1')
结果：
'1'
1
1

 （7）all 判断是否有bool值为False的值，any 判断是否有bool值为True的值

print(all['a','',123])
print(any['a','',123])
结果：
True
True

3.匿名函数

函数名 = lambda 参数 ：返回值

#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

dic = {'k1':10,'k2':100,'k3':30}
print(max(dic,key=lambda k:dic[k]))  #根据返回值判断最大值，返回值最大的那个参数是结果

 

 lambda经常和min，max，filter，map，sorted搭配使用

res = map(lambda x:x**2,[1,5,7,4,9])
for i in res:
    print(i)

res = filter(lambda x:x>10,[5,6,10,9,15])
for i in res:
    print(i)
结果为：
1
25
49
16
81
15

 

# 现有两元组(('a'),('b')),(('c'),('d'))，请使用python中匿名函数生成列表{'a': 'c', 'b': 'd'},[{'a':'c'},{'b':'d'}]
# res = lambda x,y:zip(x,y)
# print(dict((res((('a'),('b')),(('c'),('d'))))))

res = list(map(lambda t:{t[0]:t[1]},zip((('a'),('b')),(('c'),('d')))))  #zip 出来的是一个迭代器
print(res)

res = lambda t1,t2:[{i:j} for i,j in zip(t1,t2)]
print(res((('a'),('b')),(('c'),('d'))))

 

面试题，比较绕

def multipliers():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])
结果是：
[6, 6, 6, 6]
正确使用：
def multipliers():
    return (lambda x:i*x for i in range(4))  #修改为返回一个生成器，这个是一个生成器表达式，含有for
print([m(2) for m in multipliers()])
结果为:
[0, 2, 4, 6]

 

4.作业讲解，处理一个文件，返回所需要返回的内容

dic = {'name':1,'id':0,'age':2,'phone':3,'job':4}
# 读取文件 -- 将文件中的内容整理到内存里
def get_line(filename):
    with open(filename,encoding='gbk') as f:
        for line in f:
            line = line.strip()
            line_lst = line.split(',')
            yield line_lst

# 处理得到的信息
def condiction_filter(condiction):
    condiction = condiction.strip()
    if '>' in condiction:
        col,val= condiction.split('>')
        g = get_line('F:\hello.txt')
        for line_lst in g:
            if int(line_lst[dic[col]]) > int(val):   # 由于分割的是一个字符串
                yield line_lst
    elif '<' in condiction:
        col,val = condiction.split('<')
        g = get_line('F:\hello.txt')
        for line_lst in g:
            if int(line_lst[dic[col]]) < int(val):   # 由于分割的是一个字符串
                yield line_lst
    else:
        col, val = condiction.split('=')
        g = get_line('F:\hello.txt')
        for line_lst in g:
            if int(line_lst[dic[col]]) == int(val):  # 由于分割的是一个字符串
                yield line_lst

# 展示符合条件的员工信息
def views(view_lst,employe):
    l = []  # 符合条件的空列表
    for i in employe:
        for k in view_list:
            l.append(i[dic[k]])
    print(l)

# 接收用户的信息 --分析信息
# ret = input('>>>')
ret = 'select name,age where age=22'
view,condiction = ret.split('where')
view = view.replace('select','').strip()
view_list = view.split(',')
# print(view_list,condiction)
employe = condiction_filter(condiction)
views(view_list,employe)