python3--列表推导式，生成器表达式，内置函数
python3--列表推导式，生成器表达式，内置函数
python列表推导式
l = [i for i in range(10)]
print(l)
ll = ['选择{}'.format(i) for i in range(1,5)]
print(ll)执行结果
生成器表达式
1，把列表解析的[]换成()得到的就是生成器表达式
2，列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3，python不但使用迭代器协议，让for循环变得更加通用，大部分内置函数，也是使用迭代器协议访问对象的，例如sum函数是python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和
求1到3的x的2次方的和
print(sum(x ** 2 for x in range(4)))执行结果14
各种推导式玩法
推导式套路
之前已经学习了最简单的列表推导式和生成器表达式，但是除此之外，其实还有字典推导式，集合推导式等等
下面是一个以列表推导式为例的推导式详细格式，同样适用于其他推导式
variable = [out_exp_res for out_exp in input_list if out_exp == 2]
out_exp_res: 列表生产元素表达式，可以是有返回值的函数
for out_exp in input_list: 迭代input_list将out_exp传入out_exp_res表达式中
if out_exp == 2 根据条件过滤哪些值可以列表推导式
例1：30以内所有能被3整除的数
s1 = [i for i in range(30) if i % 3 == 0]
print(s1)执行结果
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
例2：30以内所有能被3整除的数的平方
s1 = [i**2 for i in range(30) if i % 3 == 0]
print(s1)执行结果
[0, 9, 36, 81, 144, 225, 324, 441, 576, 729]
例3：找到嵌套列表中名字含有两个'e'的所有名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
s2 = [i for i in names for i in i if i.count('e') == 2]
print(s2)执行结果
['Jefferson', 'Wesley', 'Steven', 'Jennifer']
字典推导式
例1：将一个字典的key和value对调
mcase = {'a': 10, 'b': 34}
s2 = {mcase[k]: k for k in mcase}
print(s2)执行结果
{10: 'a', 34: 'b'}
例2：合并大小写对应的value值，将k统一成小写
mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
s2 = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys()}
print(s2)执行结果
{'a': 17, 'z': 3, 'b': 34}
集合推导式
例1：计算列表中每个值的平方，自带去重功能
s2 = {x**2 for x in [1,-1,2]}
print(s2)执行结果
{1, 4}
练习题：
例1：过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母
s1 = ['asd', 'aaa', 'abcd', 'dhuifw']
s2 = [i.upper() for i in s1 if len(i) > 3]
print(s2)执行结果
['ABCD', 'DHUIFW']
例2：求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元组列表
例3：求M中3,6,9组成的列表M=[[1,2,3],[4,5,6],[7,8,9]]
M = [[1,2,3],[4,5,6],[7,8,9]]
s1 = [i[-1] for i in M]
print(s1)执行结果
[3, 6, 9]
内置函数
什么是内置函数？就是python给你提供的，拿来直接用的函数，比如print，input等等，截止到python版本3.6，现在python一共为我们提供了68个内置函数，它们就是python提供给你直接可以拿来使用的函数
1 作用域相关
locals:函数会以字典的类型返回当前位置的全部局部变量
globals:函数以字典的类型返回全部全局变量
例子
a = 1
b = 2
def func(*argv):
c = 2
print(locals())
print(globals())
func(3)执行结果
2：其它相关
字符串类型代码的执行eval,exec,complie
eval:执行字符串类型的代码，并返回最终结果
例1
print(eval('2 + 2'))
n = 81
print(eval("n + 4"))
eval('print(666)')执行结果
4
85
666
exec:执行字符串类型的代码
s = '''
for i in [1,2,3]:
print(i)
'''
exec(s)执行结果
1
2
3
compile:将字符串类型的代码编译，代码对象能够通过exec语句来执行或者eval()进行求值
code1 = 'for i in range(0,10):print(i)'
compile1 = compile(code1, '', 'exec')
exec(compile1)执行结果
1,2，3,4,5,6,7,8,9
有返回值的字符串形式的代码用eval,没有返回值的字符串形式的代码用exec,一般不用compile
输入输出相关input,print
input:函数接收一个标准输入数据，返回为string类型
print:打印输出
''' 源码分析
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
"""
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
sep: 打印多个值之间的分隔符，默认为空格
end: 每一次打印的结尾，默认为换行符
flush: 立即把内容输出到流文件，不作缓存
"""'''
print(111,222,333,sep='*')
print(111, end='') # 两行的结果
print(222)
f = open('log','w',encoding='utf-8')
print('写入文件',file=f,flush=True)执行结果
内存相关hash ,id
hash：获取一个对象(和哈希对象:int,str,bool,tuple)的哈希值
print(hash(123))
print(hash('123'))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))执行结果
123
-1089558323302803215
1
0
2528502973977326415
id：用于获取对象的内存地址
print(id(123))
print(id('123'))1679778400
2709492781664
文件操作相关
open：函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写
模块相关
__import__: 函数用于动态加载类和函数
帮助
help：函数用于查看函数或模块用途的详细说明
print(help(list))
调用相关
callable：函数用于检查一个对象是否可调用，如果返回True,object仍然可能调用失败，但如果返回为False,调用对象object绝对不会成功
print(callable(0))
print(callable('hello'))
def add(a,b):
return a + b
print(callable(add))
class A: # 类
def test(self):
return 0
print(callable(A)) # 类返回True
a = A()
print(callable(a)) # 没有实现__call__,返回False执行结果
False
False
True
True
False
查看内置属性
dir: 函数不带参数时，返回当前范围内的变量，方法和定义的类型列表：带参数时，返回参数的属性，方法列表。如果参数包含方法__dir__(),该方法将被调用，如果参数不包含__dir__(),该方法将最大限度收集参数信息
print(dir([])) #查看列表的方法
迭代器生成器相关
range:函数可以创建一个整数对象，一般用在for循环中
next：内部实际使用了__next__方法，返回迭代器的下一个项目
it = iter([1,2,3,4,5])
#循环
while True:
try:
#获取一下个值
x = next(it)
print(x)
except StopIteration:
#遇到StopIteration就退出循环
break执行结果
1
2
3
4
5
iter: 函数用来生成迭代器(将一个可迭代对象生成迭代器)
from collections import Iterable
from collections import Iterator
l = [1,2,3]
print(isinstance(l,Iterable)) # True
print(isinstance(l,Iterator)) # False
l1 = iter(l)
print(isinstance(l1,Iterable)) # True
print(isinstance(l1,Iterator)) # True执行结果
True
False
True
True
基础数据类型相关
数字相关
数据类型
bool: 用于将给定参数转换为布尔类型，如果没有参数，返回False
int: 函数用于将一个字符串或数字转换为整型
print(int())
print(int('12'))
print(int(3.6))
print(int('0100',base=2)) #将2进制的0100转化成十进制，结果为4执行结果为
0
12
3
4
float:函数用于将整数和字符串转换成浮点数
complex:函数用于创建一个值为real + imag*j的复数或者转化一个字符串为复数，如果第一个参数为字符串，则不需要指定第二个参数
print(complex(1,2))
print(complex(1))
#注意，这个地方在'+'号两边不能有空格，也就是不能写成'1 + 2j',否则报错
print(complex('1+2j'))执行结果
(1+2j)
(1+0j)
(1+2j)
进制转换
bin：将十进制转换成二进制并返回
oct：将十进制转化成八进制字符串并返回
hex：将十进制转化成十六进制字符串并返回
print(bin(10),type(bin(10)))
print(oct(10),type(oct(10)))
print(hex(10),type(hex(10)))执行结果
0b1010
0o12
0xa
数学运算
abs：函数返回数字的绝对值
divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a//b,a%b)
round: 保留浮点数的小数位数，默认保留整数
pow：求x**y次幂（三个参数为x**y的结果对z取余)
print(abs(-5))
print(divmod(7,2))
print(round(7/3,2))
print(round(7/3))
print(round(3.32567,3))
print(pow(2,3)) #两个参数为2**3次幂
print(pow(2,3,3)) #三个参数为2**3次幂，对3取余执行结果
5
(3, 1)
2.33
2
3.326
8
2
sum：对可迭代对象进行求和计算（可设置初始值）
min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）
max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）
print(sum([1,2,3]))
print(sum([1,2,3],100))
print(min([1,2,3])) #返回最小值
ret = min([1,2,-5,],key=abs) #按照绝对值的大小，返回此序列最小值
print(ret)
dic = {'a':3,'b':3,'c':1}
# x为dic的key，lambda的返回值(即dic的值进行比较)返回最小的值对应的键
print(min(dic, key=lambda x:dic[x]))
print(max([1,2,3])) #返回此序列最大值
ret1 = max([1,2,-5],key=abs) #返回绝对值的大小，返回此序列最大值
print(ret1)
dic1 = {'a':3,'b':2,'c':1}
# x为dic的key，lambda的返回值（即dic的值进行比较），返回最大的值对应的键
print(max(dic,key=lambda x:dic[x]))执行结果
6
106
1
1
c
3
-5
a
和数据结构相关
列表和元组
list：将一个可迭代对象转化成列表(如果是字典，默认将key作为列表的元素)
tuple：将一个可迭代对象转化成元组(如果是字典，默认将key作为元组的元素)
例子
l = list((1,2,3))
print(l)
l1 = list({1,2,3})
print(l1)
l2 = list({'k1':1,'k2':2})
print(l2)
tu = tuple([1,2,3])
print(tu)
tu1 = tuple((1,2,3))
print(tu1)
tu2 = tuple({'k1':1,'k2':2})
print(tu2)执行结果
[1, 2, 3]
[1, 2, 3]
['k1', 'k2']
(1, 2, 3)
(1, 2, 3)
('k1', 'k2')
相关内置函数
reversed:将一个列表翻转，并返回此翻转序列的迭代器
slice:构造一个切片对象，用于列表的切片
例子
ite = reversed(['a','2',3,'c',4,2])
for i in ite:
print(i)
li = ['a','b','c','d','e']
sli_obj = slice(3)
print(li[sli_obj])
sli_obj = slice(0,4,2)
print(li[sli_obj])执行结果
2
4
c
3
2
a
['a', 'b', 'c']
['a', 'c']
字符串相关
str：将数据转化成字符串
format：与具体数据相关，用于计算各种小数，精数等
例子
print(format('test','20'))
print(format('test','^20'))
s1 = format(3, 'b') # 转换成二进制
s2 = format(97, 'c') # 转换成unicode字符
s3 = format(11, 'd') # 转化成10进制
s4 = format(11, 'o') # 转换成8进制
s5 = format(11, 'x') # 转换成16进制 小写字母表示
s6 = format(11, 'X') # 转换成16进制 大写字母表示
print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
print(s6)执行结果
test
test
test
11
a
11
13
b
B
bytes: 用于不同编码之间的转化
s = '你好'
bs = s.encode('utf-8')
print(bs)
s1 = bs.decode('utf-8')
print(s1)
bs = bytes(s, encoding='utf-8')
print(bs)
b = '你好'.encode('gbk')
b1 = b.decode('gbk')
print(b1.encode('utf-8'))执行结果
b'\xe4\xbd\xa0\xe5\xa5\xbd'
你好
b'\xe4\xbd\xa0\xe5\xa5\xbd'
b'\xe4\xbd\xa0\xe5\xa5\xbd'
bytearry:返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值范围 0 <= x < 256
ret = bytearray('sam', encoding='utf-8')
print(id(ret))
print(ret)
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))执行结果
memoryview
ret = memoryview(bytes('你好', encoding='utf-8'))
print(len(ret))
print(ret)
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))执行结果
6
<memory at 0x0000018F0BC4D1C8>
你
好
ord:输入字符找该字符编码的位置
chr:输入位置数字找出其对应的字符
ascii:是ascii码中的返回该值，不是就返回/u
# ord 输入字符找该字符编码的位置
print(ord('a'))
print(ord('中'))
# chr 输入位置数字找出其对应的字符
print(chr(97))
print(chr(20013))
# 是ascii码中的返回该值，不是就返回/u
print(ascii('a'))
print(ascii('中国'))执行结果
97
20013
a
中
'a'
'\u4e2d\u56fd'
repr:返回一个对象的string形式（原形毕露）
# %r 原封不动的写出来
name = 'sam'
print('我叫{}'.format(name))
# repr原形毕露
print(repr('{"name": "sam"}'))
print('{"name": "sam"}')执行结果
我叫sam
'{"name": "sam"}'
{"name": "sam"}
数据集合
dict:创建一个字典
set:创建一个集合
frozenset:返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
len:返回一个对象中元素的个数
sorted:对所有可迭代的对象进行排序操作
L = [('a', 1), ('c', 3), ('d', 4), ('b', 2),]
print(sorted(L, key=lambda x:x[1])) # 利用key
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students, key=lambda s: s[2])) # 利用key按年龄排序
print(sorted(students, key=lambda s: s[2], reverse=True)) # 按降序执行结果
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
enumerate:枚举，返回一个枚举对象
print(enumerate([1,2,3]))
for i in enumerate([1,2,3]):
print(i)
for i in enumerate([1,2,3],100):
print(i)执行结果
<enumerate object at 0x0000029F8542E8B8>
(0, 1)
(1, 2)
(2, 3)
(100, 1)
(101, 2)
(102, 3)
all:可迭代对象中，全部都是True才是True
any:可迭代对象中，有一个True就是True
print(all([1,2,True,0]))
print(any([1,'',0]))执行结果
False
True
zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
l1 = [1,2,3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3))
for i in zip(l1,l2,l3):
print(i)执行结果
(1, 'a', '*')
(2, 'b', '**')
(3, 'c', (1, 2, 3))
filter:过滤
# filter 过滤，通过你的函数，过滤一个可迭代对象，返回的是True
# 类似于[i for i in range(10) if i > 3]
def func(x): return x % 2 == 0
ret = filter(func,[1,2,3,4,5,6,7])
print(ret)
for i in ret:
print(i)执行结果
<filter object at 0x00000177ADEAA1D0>
2
4
6
map：会根据提供的函数对指定序列做映射
ret = map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
for i in ret:
print(i)
ret1 = map(lambda x:x**2, [1,2,3,4,5]) # 使用lambda匿名函数
for i in ret1:
print(i)
# 提供了两个列表，对相同位置的列表数据进行相加
ret2 = map(lambda x,y :x+y, [1,3,5,7,9], [2,4,6,8,10])
for i in ret2:
print(i)匿名函数lamdba
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数
def calc(n):
return n ** n
print(calc(10))
# 换成匿名函数
calc1 = lambda n:n**n
print(calc1(10))执行结果
10000000000
10000000000
上面是对calc这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明
函数名 = lamdba 参数:返回值
#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以使任意数据类型
可以看出，匿名函数并不是真的不能有名字
匿名函数的调用和正常的调用也没有什么区别，就是函数名(参数)就可以了
匿名函数与内置函数举例
l = [3,2,100,999,213,1111,31121,333]
print(max(l))
dic = {'k1':10,'k2':100,'k3':30}
print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])
res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
print(i)
res1 = filter(lambda x:x>10,[5,8,11,9,15])
for i in res1:
print(i)