Python(四)—— 推导式&内置函数

2023-12-26 07:38:08

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期到python100期写入列表lst
print( [f'python{i}' % i for i in range(1,19)] )

上面那个格式化输出的变量 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('中'))

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

print(chr(97)) ? ? ?# 编码里第97位是‘a'
print(chr(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':'alex','age':18},
       {'id':2,'name':'wusir','age':17},
       {'id':3,'name':'taibai','age':16},]
 
print(sorted(lst,key=lambda e:e['age']))  # 按照年龄对学生信息进行排序
 
# 输出结果:
[{'id': 3, 'name': 'taibai', 'age': 16}, 
 {'id': 2, 'name': 'wusir', 'age': 17}, 
 {'id': 1, 'name': 'alex', '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)

文章来源:https://blog.csdn.net/GDYuLuo/article/details/135206308
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。