一、列表生成式

生成 1～100 的列表

  1. li = []
  2. for i in range(1,101):
  3.     li.append(i)
  4. print(li)

执行输出：

[1,2,3…]

生成 python1 期~11 期

  1. li = []
  2. for i in range(1,12):
  3.     li.append('python'+str(i)+'期')
  4. print(li)

执行输出：

[‘python1 期’, ‘python2 期’, ‘python3 期’…]

第二种写法

  1. li = []
  2. for i in range(1,12):
  3.     li.append('python%s' % i)
  4. print(li)

执行输出，效果同上

上面的代码，可以一行搞定

用列表推导式就可以了

用列表推导式能构建的任何列表，用别的都可以构建，比如 for 循环

特点：

1.一行，简单，感觉高端，但是不易排错

使用 debug 模式，没法依次查看每一个值。

第一个例子

  1. li = [i for i in range(1,101)]
  2. print(li)

第二个例子

  1. li = ['python%s 期' %i for i in range(1,12)]
  2. print(li)

循环模式

  1. [经过加工的 i for i in 可迭代对象]

比如 python1 期~python12 期，是加工的

也可以不加工，比如 1~100

1～10 平方结果

  1. li = [i ** 2 for i in range(1,11)]
  2. print(li)

执行输出：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

筛选模式

  1. [经过加工的 i for i in 可迭代对象 if 条件 筛选]

30 以内所有能被 3 整除的数

  1. l3 = [i for i in range(1,31) if i % 3 == 0]
  2. print(l3)

执行输出：

[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

30 以内所有能被 3 整除的数的平方

  1. li = [i**2 for i in range(1,31) if i % 3 == 0]
  2. print(li)

执行输出：

[9, 36, 81, 144, 225, 324, 441, 576, 729, 900]

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

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

执行输出：

[‘Jefferson’, ‘Wesley’, ‘Steven’, ‘Jennifer’]

列表推导式，最多不超过 3 个 for 循环

判断只能用一个

常用的是列表推导式

字典推导式

将一个字典的 key 和 value 对调

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

执行输出：

{10: ‘a’, 34: ‘b’}

相当于

  1. mcase = {'a': 10, 'b': 34}
  2. mcase_frequency = {}
  3. for k in mcase:
  4.     mcase_frequency[k]=mcase[k]
  5. print(mcase_frequency)

执行效果同上！

如果 Key 和 value 是一样的，不适合上面的代码

集合推导式

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

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

执行输出：

{1, 4}

  1. a = {1,1,4}
  2. print(type(a))

执行输出：

结果是一个集合，它也是用{}表示的。

集合和字典是有区别的：

有键值对的，是字典，比如{‘k1’:1,’k1’:2}

没有键值对的，是集合，比如{1,2,3,4}

二、生成器表达式

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

执行输出：

at 0x000002DDBEBADE60>

结果是一个生成器对象

如何取值呢？使用next方法

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

执行输出：

python1 期

python2 期

python3 期

列表推导式：一目了然，占内存

生成器表达式： 不便看出，节省内存。

三、内置函数

  1.     ![](https://cdn.nlark.com/yuque/0/2020/png/1484428/1597393562757-be4c8436-4866-441f-9f78-34e1a2a90503.png)

什么是内置函数？就是 Python 给你提供的，拿来直接用的函数，比如 print，input 等等。截止到 python 版本 3.6.2，现在 python 一共为我们提供了 68 个内置函数。它们就是 python 提供给你直接可以拿来使用的所有函数。

  1.     ![](https://cdn.nlark.com/yuque/0/2020/png/1484428/1597393562770-2e622846-198e-4a4e-9f95-0467a325d158.png)

✴✴✴** 表示很重要**

✴** 表示一般**

作用域相关域相关

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

globals：函数以字典的类型返回全部全局变量。

其他相关

字符串类型代码的执行 eval，exec，complie

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

  1. print(eval('3+4'))

执行输出：7

  1. ret = eval('{"name":"老司机"}')
  2. print(ret)

执行输出： {‘name’: ‘老司机’}

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

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

  1. print(exec('3+4'))

执行输出：None

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

执行输出：

1

2

3

None

eval 和 exec 功能是类似的

区别：

1.eval 有返回值,exec 没有返回值

2.exec 适用于有流程控制的,比如 for 循环。eval 只能做一些简单的。

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

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

执行输出：

0

1

2

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

输入输出相关 input，print

✴✴✴**input:函数接受一个标准输入数据，返回为 string 类型。**

✴✴✴**print:打印输出。**

  1. #print(self, *args, sep=' ', end='\n', file=None)
  2. print(333,end='')
  3. print(666,)

执行输出：

333666

  1. print(333,end='**')
  2. print(666,)

执行输出：

333**666

默认是用空格拼接

  1. print(11, 22, 33)

执行输出：

11 22 33

sep 将每一个字符串拼接起来，这里指定使用|

  1. print(11, 22, 33, sep = '|')

执行输出：

11|22|33

写入文件

  1. with open('log.txt',encoding='utf-8',mode='w') as f1:
  2.     print('5555',file=f1)

执行程序，查看 log.txt 文件内容为: 555

内存相关 hash id

✴✴✴**id:用于获取对象的内存地址。**

  1. a = 123
  2. print(id(a))

执行输出：

1500668512

✴✴✴**hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。**

  1. print(hash(123)) #数字不变
  2. print(hash('123'))

执行输出：

123

4876937547014958447

true 和 False 的哈希值对应 1 和 0

  1. print(hash(True))
  2. print(hash(False))

执行输出：

1

0

模块相关import

import：函数用于动态加载类和函数 。

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

调用相关

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

判断对象是否可调用的，就判断它是不是一个函数名

函数名返回 True,其他，返回 False

  1. def func1():
  2.     print(555)
  3. a = 3
  4. f = func1
  5. print(callable(f))
  6. print(callable(a))

执行输出：

True

False

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

查看内置属性

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

  1. print(dir(list))

执行输出：

[‘add‘, ‘class‘, ‘contains‘…]

迭代器生成器相关

✴✴✴**range：函数可创建一个整数对象，一般用在 for 循环中。**

✴**next：内部实际使用了next方法，返回迭代器的下一个项目。**

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

执行输出：

1

2

3

4

5

✴**iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）。**

  1. from collections import Iterable
  2. from collections import Iterator
  3. l = [1,2,3]
  4. print(isinstance(l,Iterable))  # 判断是否可迭代
  5. print(isinstance(l,Iterator))  # 判断是否为迭代器

执行输出：

True

False

  1. from collections import Iterable
  2. from collections import Iterator
  3. l = [1,2,3]
  4. l1 = iter(l) #生成迭代器
  5. print(isinstance(l1,Iterable))
  6. print(isinstance(l1,Iterator))

执行输出：

True

True

数字相关

数据类型：

  1. **<font style="color:#F5222D;">✴✴✴</font>****<font style="color:#F5222D;">bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。</font>**

**✴✴✴**int：函数用于将一个字符串或数字转换为整型。经常用

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

执行输出：

0

12

3

4

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

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

将数字转换为浮点型，默认保留小数点 1 位

  1. print(type(3.14))
  2. print(float(3))

执行输出：

3.0

进制转换：

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

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

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

  1. print(bin(5))
  2. print(oct(7))
  3. print(hex(10)) #10 用 a 表示

执行输出：

0b101

0o7

0xa

数学运算：

**✴**abs：函数返回数字的绝对值。

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

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

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

  1. print(abs(-20)) #绝对值

执行输出：20

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

执行输出：

(3, 1)

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

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

执行输出：3

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

执行输出：2

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

✴✴✴**sum：对可迭代对象进行求和计算（可设置初始值）。**

✴✴✴**min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。**

✴✴✴**max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。**

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

执行输出：10

sum 最多只有 2 个参数

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

执行输出：4

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

执行输出： -5

key 表示定义规则

和数据结构相关

列表和元祖

✴✴✴**list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。**

✴✴✴**tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。**

相关内置函数

✴✴✴**reversed：将一个序列翻转，并返回此翻转序列的迭代器。**

slice：构造一个切片对象，用于列表的切片。

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

执行输出：

2

4

c

3

2

a

  1. li = ['a','b','c','d','e','f','g']
  2. sli_obj = slice(3) #从 0 切到 3
  3. print(li[sli_obj])

执行输出：

[‘a’, ‘b’, ‘c’]

如果有 10 个列表，统一切前 3 个，sli_obj 可能有点用

slice 几乎用不到

slice 可以定义一个切片规则

字符串相关

** ✴✴✴str：将数据转化成字符串。**

**✴✴✴**format:用于格式化输出。

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

  1. print(format('test', '<20'))
  2. print(format('test', '>20'))
  3. print(format('test', '^20'))

执行输出：

  1. test               
  2.                 test
  3.         test

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

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

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

执行输出：

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

第二种方法：

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

执行输出：

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

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

它不能解码

bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

bytearry 很少用

  1. ret = bytearray('alex',encoding='utf-8') #4 个字母对应的 ascii 顺序[97,108,101,120]
  3. print(id(ret))
  4. print(ret)
  5. print(ret[0]) #97 是 ascii 码的顺序
  6. ret[0] = 65 #65 是大写 a 的位置
  7. print(ret)
  8. print(id(ret))

执行输出：

2177653717736

bytearray(b’alex’)

97

bytearray(b’Alex’)

2177653717736

memoryview：本函数是返回对象 obj 的内存查看对象。所谓内存查看对象，就是对象符合缓冲区协议的对象，为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。

  1. ret = memoryview(bytes('你好',encoding='utf-8'))
  2. print(len(ret)) # utf-8 的 bytes 类型，放在一个 list 中 [\xe4,\xbd,\xa0,\xe5,\xa5,\xbd]
  4. print(ret)
  5. print(bytes(ret[:3]).decode('utf-8'))
  6. print(bytes(ret[3:]).decode('utf-8'))
  7. print('你好'.encode('utf-8'))

执行输出：

6

你

好

b’\xe4\xbd\xa0\xe5\xa5\xbd’

**✴**ord:输入字符找该字符编码的位置

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

ascii:是 ascii 码中的返回该值，不是就返回\u…

  1. print(ord('a')) #ascii 码的位置
  2. print(chr(98)) #98 对应 a
  3. print(ord('中')) #按照 unicode 查找
  4. print(ascii('中')) #不是 ascii 码就返回\u...

执行输出：

97

b

20013

‘\u4e2d’

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

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

执行输出：

我叫’taibai’

‘{“name”:”alex”}’

{“name”:”alex”}

repr 在面向对象中会用到

数据集合

**✴✴✴**dict：创建一个字典。

**✴✴✴**set：创建一个集合。

frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

相关内置函数

**✴✴✴**len:返回一个对象中元素的个数。

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

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

执行输出：

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

按照绝对值排序

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

执行输出：

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

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

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

执行输出：

True

True

enumerate 是一个迭代器

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

执行输出：

(0, ‘jack’)

(1, ‘rose’)

(2, ‘wusir’)

(3, ‘嫂子’)

(4, ‘老司机’)

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

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

执行输出：

0 jack

1 rose

2 wusir

3 嫂子

4 老司机

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

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

执行输出：

10 jack

11 rose

12 wusir

13 嫂子

14 老司机

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

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

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

执行输出：

False

True

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

  1. print('__iter__' in dir(zip(l1,l2,l3,l4)))
  2. print('__next__' in dir(zip(l1,l2,l3,l4)))

执行输出：

True

True

zip 也是一个迭代器

zip 拉链方法 形成元组的个数与最短的可迭代对象的长度一样

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

执行输出：

(1, ‘a’, ‘*’)

(2, ‘b’, ‘**’)

(3, ‘c’, (1, 2, 3))

(4, 5, 777)

我们把 list 当做列向量来看就很好理解了，zip 就是拉链，把一件挂着的衣服拉起来。这就是 zip 的功能。所以

当做列向量看，就是拉起来的拉链了。

而转置的 z 就是把拉链放水平，多形象！

zip 结果取决于最短的一个,返回的数据是元组

面试题，必考 zip

✴✴✴**filter：过滤·。**

filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是 True

类似于[i for i in range(10) if i > 3]

取列表中的偶数

  1. def func(x):
  2.     return x % 2 == 0
  3. ret = filter(func,[1,2,3,4,5,6,7])
  4. print(ret)
  5. for i in ret:
  6.     print(i)

执行输出：

2

4

6

使用列表生成式完成上面的功能

  1. li = [i for i in [1,2,3,4,5,6,7] if i % 2 == 0]
  2. print(li)

执行输出，效果同上

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

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

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

执行输出：

1

4

9

16

25

map 也是迭代器

匿名函数

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

返回一个数的平方

使用函数方式

  1. def func1(x):
  2.     return x ** 2

使用匿名函数一行搞定

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

执行输出：25 

  1.     ![](https://cdn.nlark.com/yuque/0/2020/png/1484428/1597393563105-5a68022c-ab00-499e-9d02-4af9d1fb467d.png)

上面是我们对 calc 这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明

  1. 函数名 = lambda 参数 ：返回值
  3. #参数可以有多个，用逗号隔开
  4. #匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
  5. #返回值和正常的函数一样可以是任意数据类型
  1. def func2(x,y):
  2.     return x + y

改成匿名函数

  1. fun = lambda x,y:x+y
  2. print(fun(1,3))

执行输出：4

lambda 单独拿出来，没有啥意义

主要是和内置函数结合使用

lambda 函数与内置函数的结合。

sorted，map，fiter，max，min，reversed

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

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

执行输出：k2

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

lambda 就是字典的 value

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

改成 lambda lambda 可以不要函数名 

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

执行输出：

1

25

49

16

64

打印出大于 10 的元素

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

执行输出：

11

12

40

20

50

79

如果 l1 列表的数据，有上百万，不能使用列表推导式，非常占用内存

建议使用 lamdba，它只占用一行

作业：

  1. 下面题都是用内置函数或者和匿名函数结合做出：
  3. 1，用 map 来处理字符串列表,把列表中所有人都变成 sb,比方 alex_sb
  4.     name=['oldboy','alex','wusir']
  6. 2，用 map 来处理下述 l，然后用 list 得到一个新的列表，列表中每个人的名字都是 sb 结尾
  7. l=[{'name':'alex'},{'name':'y'}]
  9. 3，用 filter 来处理,得到股票价格大于 20 的股票名字
  10. shares={
  11.    'IBM':36.6,
  12.    'Lenovo':23.2,
  13.    'oldboy':21.2,
  14.    'ocean':10.2,
  15. }
  17. 4，有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。
  18. 结果：list 一下[9110.0, 27161.0,......]
  19. portfolio = [
  20.   {'name': 'IBM', 'shares': 100, 'price': 91.1},
  21.     {'name': 'AAPL', 'shares': 50, 'price': 543.22},
  22.     {'name': 'FB', 'shares': 200, 'price': 21.09},
  23.     {'name': 'HPQ', 'shares': 35, 'price': 31.75},
  24.     {'name': 'YHOO', 'shares': 45, 'price': 16.35},
  25.     {'name': 'ACME', 'shares': 75, 'price': 115.65}]
  27. 5，还是上面的字典，用 filter 过滤出单价大于 100 的股票。
  29. 6，有下列三种数据类型，
  30.     l1 = [1,2,3,4,5,6]
  31.     l2 = ['oldboy','alex','wusir','太白','日天']
  32.     tu = ('**','***','****','*******')
  33. 写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是 4 个。）
  34.     [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。
  36. 7，有如下数据类型：
  37. l1 = [{'sales_volumn': 0},
  38.      {'sales_volumn': 108},
  39.      {'sales_volumn': 337},
  40.      {'sales_volumn': 475},
  41.      {'sales_volumn': 396},
  42.      {'sales_volumn': 172},
  43.      {'sales_volumn': 9},
  44.      {'sales_volumn': 58},
  45.      {'sales_volumn': 272},
  46.      {'sales_volumn': 456},
  47.      {'sales_volumn': 440},
  48.      {'sales_volumn': 239}]
  49. 将 l1 按照列表中的每个字典的 values 大小进行排序，形成一个新的列表。

答案：

1.

  1. name=['oldboy','alex','wusir']
  2. a = map(lambda x:x+'_sb',name)
  3. for i in a:
  4.     print(i)

执行输出：

oldboy_sb

alex_sb

wusir_sb

2.

  1. l=[{'name':'alex'},{'name':'y'}]
  2. a = map(lambda x:x['name'] + '_sb',l)
  3. li = []
  4. for i in a:
  5.     li.append(i)
  6. print(li)

执行输出：

[‘alex_sb’, ‘y_sb’]

3.

  1. shares={
  2.    'IBM':36.6,
  3.    'Lenovo':23.2,
  4.    'oldboy':21.2,
  5.    'ocean':10.2,
  6. }
  8. a = filter(lambda x:shares[x] > 20,shares)
  9. for i in a:
  10.     print(i)

执行输出：

oldboy

Lenovo

IBM

4.

  1. portfolio = [
  2.   {'name': 'IBM', 'shares': 100, 'price': 91.1},
  3.     {'name': 'AAPL', 'shares': 50, 'price': 543.22},
  4.     {'name': 'FB', 'shares': 200, 'price': 21.09},
  5.     {'name': 'HPQ', 'shares': 35, 'price': 31.75},
  6.     {'name': 'YHOO', 'shares': 45, 'price': 16.35},
  7.     {'name': 'ACME', 'shares': 75, 'price': 115.65}]
  9. a = map(lambda x:x['shares']*x['price'],portfolio)
  10. li = []
  11. for i in a:
  12.     #print(i)
  13.     li.append(i)
  14. print(li)

执行输出：

[9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]

5.

  1. portfolio = [
  2.   {'name': 'IBM', 'shares': 100, 'price': 91.1},
  3.     {'name': 'AAPL', 'shares': 50, 'price': 543.22},
  4.     {'name': 'FB', 'shares': 200, 'price': 21.09},
  5.     {'name': 'HPQ', 'shares': 35, 'price': 31.75},
  6.     {'name': 'YHOO', 'shares': 45, 'price': 16.35},
  7.     {'name': 'ACME', 'shares': 75, 'price': 115.65}]
  9. a = filter(lambda x:x['price'] > 100,portfolio)
  10. for i in a:
  11.     print(i)

执行输出：

{‘price’: 543.22, ‘name’: ‘AAPL’, ‘shares’: 50}

{‘price’: 115.65, ‘name’: ‘ACME’, ‘shares’: 75}

6.

  1. l1 = [1,2,3,4,5,6]
  2. l2 = ['oldboy','alex','wusir','太白','日天']
  3. tu = ('**','***','****','*******')
  4. a = zip(l1,l2,tu)
  5. li = []
  6. for i in a:
  7.     #print(i)
  8.     li.append(i)
  9. print(li)

执行输出：

[(1, ‘oldboy’, ‘‘), (2, ‘alex’, ‘*‘), (3, ‘wusir’, ‘‘), (4, ‘太白’, ‘*‘)]

7.

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)

执行输出：

[{‘sales_volumn’: 0}, {‘sales_volumn’: 9}, {‘sales_volumn’: 58}, {‘sales_volumn’: 108}, {‘sales_volumn’: 172}, {‘sales_volumn’: 239}, {‘sales_volumn’: 272}, {‘sales_volumn’: 337}, {‘sales_volumn’: 396}, {‘sales_volumn’: 440}, {‘sales_volumn’: 456}, {‘sales_volumn’: 475}]