列表推导式,生成器表达式,内置函数

找到嵌套列表中名字含有两个'e'的所有名字

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
l4 = [name for i in names for name in i if name.count('e') == 2 ]
print(l4)

执行输出：

['Jefferson', 'Wesley', 'Steven', 'Jennifer']

列表推导式，最多不超过3个for循环
判断只能用一个

字典推导式
将一个字典的key和value对调

mcase = {'a': 10, 'b': 34}
mcase_frequency = {mcase[k]: k for k in mcase}
print(mcase_frequency)

执行输出：

{10: 'a', 34: 'b'}

集合推导式

计算列表中每个值的平方，自带去重功能

 

squared = {x**2 for x in [1, -1, 2]}
print(squared)
# Output: set([1, 4])

执行输出：
{1, 4}

 

生成器表达式

l_obj = ('python%s期' % i for i in range(1,12))
print(l_obj)

执行输出：

<generator object <genexpr> at 0x000002DDBEBADE60>

结果是一个生成器对象

如何取值呢？使用__next__方法

l_obj = ('python%s期' % i for i in range(1,12))
#print(l_obj)
print(l_obj.__next__())
print(l_obj.__next__())
print(l_obj.__next__())

执行输出：

python1期
python2期
python3期

列表推导式：一目了然，占内存
生成器表达式： 不便看出，节省内存。

 

 

内置函数

 

 

✴✴✴ 表示很重要

✴ 表示一般

作用域相关

locals ：函数会以字典的类型返回当前位置的全部局部变量。
globals：函数以字典的类型返回全部全局变量

其他相关

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

print(eval('3+4'))

执行输出： 7

ret = eval('{"name":"老司机"}')
print(ret,type(ret))

执行输出： {'name': '老司机'} <class 'dict'>

eval的作用相当于拨开字符串2边的引号，执行里面的代码

✴✴✴exec:执行字符串类型的代码，流程语句

 

print(exec('3+4'))

执行输出：None

ret1 = '''
li = [1,2,3]
for i in li:
    print(i)
'''
print(exec(ret1))

执行输出：

1
2
3
None

 

eval和exec 功能是类似的
区别：
1.eval有返回值,exec没有没有值
2.exec适用于有流程控制的,比如for循环。eval只能做一些简单的。

compile:将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。

code1 = 'for i in range(0,3): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)

执行输出：

0
1
2

compile这个函数很少用，未来几年都不会用得到

 

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

def func1():
    print(555)
a = 3
f = func1
print(callable(f))
print(callable(a))

执行输出：

True
False

callable其实就是判断一个对象是否是函数，是就返回True，其他类型直接返回False

✴✴✴dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

print(dir(list))

执行输出：

['__add__', '__class__', '__contains__'...]

 

✴✴✴range：函数可创建一个整数对象，一般用在 for 循环中。
✴next：内部实际使用了__next__方法，返回迭代器的下一个项目。

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it) #next内部封装了__next__方法,都是求下一个值
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

执行输出：

1
2
3
4
5

数学运算：

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

 

print(divmod(10,3)) #计算除数与被除数的结果

执行输出：

(3, 1)

divmod 在分页功能中，会用用到此函数

 

 round：保留浮点数的小数位数，默认保留整数 四舍五入。

print(round(3.1415)) #默认取整

 执行输出： 3

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

print(pow(2,3,5)) #求x**y次幂（三个参数为x**y的结果对z取余

执行输出： 3

解释：这里为3个参数，2的3次方，结果为8。用8和5做除法，取余为3，最终输出3

 

✴✴✴sum：对可迭代对象进行求和计算（可设置初始值）。
✴✴✴min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
✴✴✴max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。

print(sum([1,2,3,4]))

执行输出： 10

print(max([1,2,3,4]))

执行输出： 4

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

执行输出： -5

key表示定义规则

 相关内置函数
     ✴✴✴reversed：将一个序列翻转，并返回此翻转序列的迭代器。

ite = reversed(['a',2,3,'c',4,2])
for i in ite:
    print(i)

执行输出：

2
4
c
3
2
a

 

字符串相关
  ✴✴✴str：将数据转化成字符串。
  ✴✴✴format:用于格式化输出。

字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐

print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))

执行输出：

test               
                test
        test       

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

编码转换，将unicode转换为utf-8

s1 = '老司机'
s2 = s1.encode('utf-8')
print(s2)
#print(s2.decode('utf-8')) #解码

执行输出：

b'\xe8\x80\x81\xe5\x8f\xb8\xe6\x9c\xba'

第二种方法：

s1 = '老司机'
print(bytes(s1,encoding='utf-8'))

执行输出：

b'\xe8\x80\x81\xe5\x8f\xb8\xe6\x9c\xba'

bytes：只能编码，将unicode ---> 非unicode  bytes(s1,encoding='utf-8')。

它不能解码

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

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

执行输出：

我叫'taibai'
'{"name":"alex"}'
{"name":"alex"}

 

✴✴✴sorted：对所有可迭代的对象进行排序操作。

li = [1,2,7,8,5,4,3]
print(sorted(li)) #默认升序

执行输出：

[1, 2, 3, 4, 5, 7, 8]

 

按照绝对值排序

li = [1,-2,-7,8,5,-4,3]
print(sorted(li,reverse=True,key=abs))

执行输出：   reverse=True 从大到小  默认False从小到大

[8, -7, 5, -4, 3, -2, 1]

 

✴✴✴enumerate:枚举，返回一个枚举对象。 (0, seq[0]), (1, seq[1]), (2, seq[2])

li = ['jack', 'rose', 'wusir', '嫂子', '老司机']
print(enumerate(li))
print('__iter__' in dir(enumerate(li)))
print('__next__' in dir(enumerate(li)))

执行输出：

<enumerate object at 0x00000223DD887828>
True
True

enumerate是一个迭代器

 

li = ['jack', 'rose', 'wusir', '嫂子', '老司机']
for i in enumerate(li):
    print(i)

执行输出：

(0, 'jack')
(1, 'rose')
(2, 'wusir')
(3, '嫂子')
(4, '老司机')

返回结果为：列表元素的索引以及对应的值

 

li = ['jack', 'rose', 'wusir', '嫂子', '老司机']
for k,v in enumerate(li):
    print(k,v)

执行输出：

0 jack
1 rose
2 wusir
3 嫂子
4 老司机

 

enumerate的第2个参数，表示从多少开始。默认从0开始

li = ['jack', 'rose', 'wusir', '嫂子', '老司机']
for k,v in enumerate(li,10):
    print(k,v)

执行输出：

10 jack
11 rose
12 wusir
13 嫂子
14 老司机

  ✴all：可迭代对象中，全都是True才是True
  ✴any：可迭代对象中，有一个True 就是True

print(all([1,2,True,0]))
print(any([1,'',0]))

执行输出：

False
True

 

✴✴✴zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

l1 = [1, 2, 3, 4]
l2 = ['a', 'b', 'c', 5，6]
l3 = ('*', '**', (1,2,3), 777)
z = zip(l1,l2,l3)
for i in z:
    print(i)

执行输出：

(1, 'a', '*')
(2, 'b', '**')
(3, 'c', (1, 2, 3))
(4, 5, 777)

✴✴✴filter：过滤·。

filter 过滤 通过你的函数，过滤一个可迭代对象，第一个传函数名 里面必须return真假 过滤
类似于[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 0x0000021325A4B6D8>
2
4
6

✴✴✴map:会根据提供的函数对指定序列做映射。

map相当于列表生成式循环模式

def square(x): #计算平方数
    return x ** 2
ret = map(square,[1,2,3,4,5]) #计算列表各个元素的平方
for i in ret:
    print(i)

执行输出：

1
4
9
16
25

匿名函数

匿名函数：为了解决那些功能很简单的需求而设计的一句话函数。

返回一个数的平方

使用函数方式

def func1(x):
    return x ** 2

 

使用匿名函数一行搞定

func = lambda x:x ** 2
print(func(5))

执行输出： 25

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

lambda单独拿出来，没有啥意义
主要是和内置函数结合使用

 

lambda 函数与内置函数的结合。
sorted，map，fiter，max，min，reversed

比较字典值的大小，并输出key的值

 

dic={'k1': 10, 'k2': 100, 'k3': 30}
print(max(dic, key=lambda x: dic[x]))

执行输出： k2

x表示dic的key,返回值就是dic[x] 也就是dic的value
lambda就是字典的value

 

def func(x):
    return x**2
res = map(func,[1,5,7,4,8])
for i in res:
    print(i)

改成lambda  lambda可以不要函数名 

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

执行输出：

1
25
49
16
64

打印出大于10的元素

l1 = [1,2,3,11,12,40,20,50,79]
ret = filter(lambda x:x > 10,l1)
#print(ret)
for i in ret:
    print(i)

执行输出：

11
12
40
20
50
79

 

将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。

l1 = [{'sales_volumn': 0},
     {'sales_volumn': 108},
     {'sales_volumn': 337},
     {'sales_volumn': 475},
     {'sales_volumn': 396},
     {'sales_volumn': 172},
     {'sales_volumn': 9},
     {'sales_volumn': 58},
     {'sales_volumn': 272},
     {'sales_volumn': 456},
     {'sales_volumn': 440},
     {'sales_volumn': 239}]
 
a = sorted(l1,reverse=False,key=lambda x:x['sales_volumn'])
print(a)