Python（四）—— 推导式&内置函数

10. 推导式

推导式就是构建比较有规律的列表、生成器、字典等一种简便的方式

10.1 列表推导式

首先我们先看一下这样的代码，给出一个列表，通过循环，想列表中添加1~10

li = []
for i in range(10):
    li.append(i)
​
print(li)

那么按照上面的要求我们用列表推导式写一下

print([i for i in range(10)])

列表推导式分为两种模式：

• 1、循环模式：[ 变量(加工的变量) for 变量 in iterable ]

• 2、筛选模式：[ 变量(加工的变量) for 变量 in iterable if 条件 ]

10.2 循环模式

刚才我们看到的就是循环模式，那么有同学会问到，什么叫' 加工的变量'？这个也比较简单，接下来我们做几道题：

• 练习1：将10以内所有整数的平方写入列表

print( [i*i for i in range(1,11)] )

• 练习2：100以内所有的偶数写入列表

print( [i for i in range(2,101,2)] )

• 练习3：从python1期到python10期写入列表lst

print([f'python{i}期'for i in range(1,11)])

上面那个格式化输出的变量 f'python{i}期'，就是加工的变量

10.3 筛选模式

筛选模式就是在上面的基础上加上一个判断条件，将满足条件的变量留到列表中

• 练习1：三十以内可以被三整除的数

print( [i for i in range(30) if i % 3 is 0] )

• 练习2：过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母

l = ['qingyan', 'yuluo', 'aa', 'b']
print([i.upper() for i in l if len(i) > 3])

• 练习3：找到嵌套列表中名字含有两个‘e’的所有名字（有难度）

------- 正常写法 -------

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
        ['Yuluo', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]

lst = []
for i in names:
    for j in i:
        if j.count('e') > 1:
            lst.append(j)
print(lst)

# 输出结果：
['Jefferson', 'Wesley', 'Steven', 'Jennifer']

----- 列表推导式写法 -----

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
        ['Yuluo', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]

print([j for i in names for j in i if j.count('e') > 1])

# 输出结果：
['Jefferson', 'Wesley', 'Steven', 'Jennifer']

10.4 生成器表达式

生成器表达式和列表推导式的语法上一模一样，只是把 [] 换成 () 就行了

• 例如：比如将十以内所有数的平方放到一个生成器表达式中

gen = (i**2 for i in range(10))
print(gen)
​
# 输出结果: 
<generator object <genexpr> at 0x0000026046CAEBF8>

生成器表达式也可以进行筛选

• 例如：获取1-100内能被3整除的数

gen = (i for i in range(1,100) if i % 3 == 0)
for num in gen:
    print(num)

生成器表达式和列表推导式的区别:

• 1、列表推导式比较耗内存，所有数据一次性加载到内存。而生成器表达式遵循迭代器协议，逐个产生元素
• 2、得到的值不一样，列表推导式得到的是一个列表，生成器表达式获取的是一个生成器
• 3、列表推导式一目了然，生成器表达式只是一个内存地址

推导式只能构建相对复杂的并且有规律的对象，对于没有什么规律，而且嵌套层数比较多（for循环超过三层）这样就不建议大家用推导式构建

生成器的惰性机制：生成器只有在访问的时候才取值，说白了，你找他要才给你值，不找他要，他是不会执行的

10.5 字典推导式

需要一个key，一个value，用法基本上都差不多

lst1 = ['jay','jj','yuluo']
lst2 = ['周杰伦','林俊杰','雨落']

dic = { lst1[i]:lst2[i] for i in range(len(lst1)) }
print(dic)

# 输出结果：
{'jay': '周杰伦', 'jj': '林俊杰', 'yuluo': '雨落'}

10.6 集合推导式

集合的特点是无序且不重复，所以集合推导式自带去重功能

lst = [1,2,3,-1,-3,-7,9]

s = {abs(i) for i in lst}
print(s)

# 输出结果：
{1, 2, 3, 7, 9}

11. 内置函数一

函数就是以功能为导向，一个函数封装一个功能，那么Python将一些常用的功能（比如len）给我们封装成了一个一个的函数，供我们使用，他们不仅效率高（底层都是用C语言写的），而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个

• 重点讲解以下内置函数：

abs()     enumerate()   filter()     map()    max()       min()
open()    range()       print()      len()    list()      dict()
str()     float()       reversed()   set()    sorted()    sum()
tuple()   type()        zip()        dir() 

• 自主掌握以下内置函数：

all()     any()   bytes()  callable()   chr()   ord() 
divmod()  eval()  exec()   format()     iter()  globals()  
hash()    help()  id()     input()      int()   complex()     
locals()  next()  oct()    frozenset()  pow()   repr()      round()

• 未来需要掌握：

classmethod() delattr() getattr()  hasattr() staticmethod()  
isinstance()  object()  property() setattr() issubclass()   super()

11.1 all、any

all：可迭代对象中，全都是True才是True

print( all([1,2,True,0]) )    # False

any：可迭代对象中，有一个True 就是True

print( any([1,'',0]) )        # Ture

​

11.2 bytes

bytes：用于不同编码之间的转化

s = '你好'
bs = s.encode('utf-8')
print(bs)                  # b'\xe4\xbd\xa0\xe5\xa5\xbd'
​
s1 = bs.decode('utf-8')
print(s1)                  # 你好
​
bs = bytes(s,encoding='utf-8')
print(bs)                  # b'\xe4\xbd\xa0\xe5\xa5\xbd'
​
b = '你好'.encode('gbk')
b1 = b.decode('gbk')
print(b1.encode('utf-8'))  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

11.3 callable

callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功

name = 'yuluo'
def func():
    pass
    
print(callable(name))   # False
print(callable(func))   # True

11.4 chr与ord

ord：输入字符找该字符编码的位置

print(ord('a'))     # 'a'在编码里是97位
print(ord('中'))    # '中'在编码里是20013位

chr：输入位置数字找出其对应的字符

print(chr(97))      # 编码里第97位是'a'
print(chr(20013))   # 编码里第20013位是'中'

11.5 eval

eval：执行字符串类型的代码，并返回最终结果

eval('2 + 2')        # 直接计算2+2=4
n = 81
eval("n + 4")        # 可设置开始值，使得81+4=85
eval('print(666)')   # 直接把输出结果返回666

11.6 exec

exec：执行字符串类型的代码

s = '''
for i in [1,2,3]:
    print(i)
'''
​
exec(s)         # 1 2 3  直接把字符串内的代码运行了

11.7 hash

hash：获取一个对象的哈希值（可哈希对象：int，str，bool，tuple）

print(hash(111))         # 111
print(hash('字符串'))     # 3226097080720691364
print(hash(True))        # 1
print(hash(False))       # 0
print(hash((1,2,3)))     # 529344067295497451

11.8 help

help：函数用于查看函数或模块用途的详细说明

print(help(list))          # 查看list的详细说明
print(help(str.split))     # 查看split方法的详细说明

11.9 int、float、complex

int：函数用于将一个字符串或数字转换为整型

print(int())                 # 0
print(int('12'))             # 12
print(int(3.6))              # 3
print(int('0100',base=2))    # 将2进制的 0100 转化成十进制。结果为 4

float：函数用于将整数和字符串转换成浮点数

print(float(3))              # 3.0

函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数

print(complex(1,2))          # (1+2j)

11.10 bin、oct、hex

bin：将十进制转换成二进制并返回

print(bin(10),type(bin(10)))     # 0b1010 <class 'str'>

oct：将十进制转化成八进制字符串并返回

print(oct(10),type(oct(10)))     # 0o12 <class 'str'>

hex：将十进制转化成十六进制字符串并返回

print(hex(10),type(hex(10)))     # 0xa <class 'str'>

11.11 divmod、round、pow

divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)

print(divmod(7,2))        # (3, 1)

round：保留浮点数的小数位数，默认保留整数

print(round(7/3))         # 默认结果（保留整数）：2
print(round(7/3,2))       # 结果保留2位小数：2.33
print(round(3.32567,3))   # 保留3位小数3.326

pow：求 x**y次幂（三个参数为x**y的结果对z取余）

print(pow(2,3))           # 8   两个参数为2**3次幂
print(pow(2,3,3))         # 2   三个参数为2**3次幂，对3取余

​ ​

11.12 repr

repr：返回一个对象的string形式（原形毕露）

# %r  原封不动的写出来
name = 'yuluo'
print('我叫%r' %name)               # 我叫'yuluo'
​
# repr 原形毕露
print(repr('{"name":"yuluo"}'))    # '{"name":"yuluo"}'
print('{"name":"yuluo"}')          # {"name":"yuluo"}

11.13. 匿名函数lambda

匿名函数，顾名思义就是没有名字的函数，那么什么函数没有名字呢？这个就是我们以后面试或者工作中经常用匿名函数 lambda，也叫一句话函数

现在有一个需求：你们写一个函数，此函数接收两个int参数，返回和值

def func(a,b):
    return a+b

print(func(3,4))

# 输出结果：
7

那么接下来我们用匿名函数完成上面的需求：

func = lambda a,b: a+b
print(func(3, 4))

# 输出结果：
7

我们分析一下上面的代码：函数名 = lambda 参数: 返回值

1）此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func

2）lambda 是定义匿名函数的关键字，相当于函数的def

3）lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行

func = lambda a,b,*args,sex= 'man',c,**kwargs: kwargs
print(func(3, 4,c=666,name='alex'))    # {'name': 'alex'}

"""注意：
所有类型的形参都可以加，但是一般使用匿名函数只是加位置参数，其他的用不到"""

4）返回值在冒号之后设置，返回值和正常的函数一样，可以是任意数据类型

5）匿名函数不管多复杂，只能写一行，且逻辑结束后直接返回数据

• 练习1：写匿名函数：接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）

func = lambda x:(x[0],x[2])
print(func('afafasd'))

# 输出结果：
('a', 'a')

• 练习2：写匿名函数：接收两个int参数，将较大的数据返回

func = lambda x,y: x if x > y else y
print(func(3,100))

# 输出结果：
100

12. 内置函数二（重要）

12.1 print

print：屏幕输出

def print(self, *args, sep=' ', end='\n', file=None): 
    
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
​
​
print(111,222,333,sep='*')    # 111*222*333
​
print(111,end='')             # 原先print默认换行，被改成了空
print(222)                    # 111222
​
f = open('log','w',encoding='utf-8')
print('写入文件',fle=f,flush=True)

12.2 list、tuple

list：将一个可迭代对象转换成列表

l1 = list('abcd')
print(l1)             # ['a', 'b', 'c', 'd']

tuple：将一个可迭代对象转换成元组

tu1 = tuple('abcd')
print(tu1)            # ('a', 'b', 'c', 'd')

12.3 abs

abs：返回绝对值

i = -5
print(abs(i))    # 5

12.4 sum

sum：求和

print(sum([1,2,3]))          # 6
print(sum((1,2,3),100))      # 106

12.5 max、min

max：求最大值

min：求最小值（max用法与之相同）

print(min([1,2,3]))            # 1  返回此序列最小值

ret = min([1,2,-5,],key=abs)   # 按照绝对值的大小，返回此序列最小值
print(ret)                     # 1

"""注意：加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，
然后通过你设定的返回值比较大小，返回最小的传入的那个参数"""


print(min(1,2,-5,6,-3,key=lambda x:abs(x)))   # 1  可以设置很多参数比较大小

dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))           # c  比较值得大小，输出键

"""x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键"""

12.6 reversed

reversed：将一个序列翻转，返回翻转序列的迭代器

l = reversed('你好')     # l 获取到的是一个生成器
print(list(l))          # ['好', '你']
​
ret = reversed([1, 4, 3, 7, 9])
print(list(ret))        # [9, 7, 3, 4, 1]

12.7 zip

zip：拉链方法，函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的内容，如果各个迭代器的元素个数不一致，则按照长度最短的返回

lst1 = [1,2,3]
lst2 = ['a','b','c','d']
lst3 = (11,12,13,14,15)
​
for i in zip(lst1,lst2,lst3):
    print(i)       # 此时lst1内的元素最少，故生成三个元组
​
# 输出结果：
(1, 'a', 11)
(2, 'b', 12)
(3, 'c', 13)　

12.8 sorted

sorted：排序函数，默认是升序（从小到大）

语法：sorted( iterable, key=None, reverse=False)

• iterable：可迭代对象
• key：排序规则(排序函数)，在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数，根据函数运算的结果进行排序
• reverse：是否倒序，True 倒序，False 正序

--------- 正常用法 ---------

lst = [1,3,2,5,4]
lst2 = sorted(lst)
print(lst)                         # [1, 3, 2, 5, 4]
print(lst2)                        # [1, 2, 3, 4, 5]
 
 
lst3 = sorted(lst,reverse=True)    # 倒序
print(lst3)                        # [5, 4, 3, 2, 1]    

------ 字典使用sorted排序 ------

dic = {1:'a',3:'c',2:'b'}
print(sorted(dic))                 # [1,2,3]  字典排序返回的就是排序后的key

------ 和函数组合使用 ------

lst = ['天龙八部','西游记','红楼梦','三国演义']
 
def func(s):
    return len(s)                  # 计算字符串的长度
print(sorted(lst,key=func))        # ['西游记', '红楼梦', '天龙八部', '三国演义']

------ 和lambda组合使用 ------

lst = ['天龙八部','西游记','红楼梦','三国演义']
 
print(sorted(lst,key=lambda s:len(s)))

------ 列表中含字典的类型 ------
  
lst = [{'id':1,'name':'雨雨','age':18},
       {'id':2,'name':'落落','age':17},
       {'id':3,'name':'雨落','age':16},]
 
print(sorted(lst,key=lambda e:e['age']))  # 按照年龄对学生信息进行排序
 
# 输出结果:
[{'id': 3, 'name': '雨落', 'age': 16}, 
 {'id': 2, 'name': '落落', 'age': 17}, 
 {'id': 1, 'name': '雨雨', 'age': 18}]

12.9 filter

filter：筛选过滤

语法：filter(function, iterable)

• function：用来筛选的函数，在filter中会自动的把iterable中的元素传递给function，然后根据function返回的True或者False来判断是否保留此项数据
• iterable：可迭代对象

lst = [{'id': 1, 'name': '雨雨', 'age': 18},
{'id': 1, 'name': '落落', 'age': 17},
{'id': 1, 'name': '雨落', 'age': 16},]

ls = filter(lambda e: e['age'] > 16, lst)
print(list(ls))


# 输出结果:
[{'id': 1, 'name': '雨雨', 'age': 18}, 
 {'id': 1, 'name': '落落', 'age': 17}]

​​​​​​

12.10 map

map：映射函数

语法：map(function, iterable)

• 可以对可迭代对象中的每一个元素进映射，分别取执行function

------- 示例1：计算列表中每个元素的平方,返回新列表 -------

lst = [1,2,3,4,5]
​
def func(s):
    return  s*s       
​
mp = map(func,lst)
print(mp)              # <map object at 0x000002201954F9D0>
print(list(mp))        # [1, 4, 9, 16, 25]
​
​

lst = [1,2,3,4,5]                     # 改写成lambda
print(list(map(lambda s:s*s,lst)))    # [1, 4, 9, 16, 25]

------- 示例2：计算两个列表中相同位置的数据的和 -------
​
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2))) 
​
# 输出结果:
[3, 6, 9, 12, 15]

12.11 reduce

reduce：接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值

语法：reduce(function, iterable)

ret = reduce(func,[3,4,5,6,7])
print(ret)  # [7,5,6,7] = [12,6,7] = [18,7] = 25
​
​
------- 普通函数版 -------
​
from functools import reduce
def func(x,y):
    return x * 10 + y
    
l = reduce(func,[1,2,3,4])
print(l)
​
# 第一步：1 * 10 + 2 = 12      [12,3,4]
# 第二步：12 * 10 + 3 = 123    [123,4]
# 第三步：123 * 10 + 4 = 1234
​

------- lambda函数版 -------
l = reduce(lambda x,y: x * 10 + y,[1,2,3,4])
print(l)