Python控制流 & Lambda表达式
Python 控制流
zip()
比如我们有两个列表，我们想将他俩组成一个列表，我们可以使用内置函数 zip() ，zip() 会返回一个迭代器，我们可以使用for去遍历。也可以配合range打印索引。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| >>> items = ['bananas', 'mattresses', 'dog kennels', 'machine', 'cheeses']
>>> weights = [15, 34, 42, 120, 5]
>>> print(list(zip(items,weights)))
[('bananas', 15), ('mattresses', 34), ('dog kennels', 42), ('machine', 120), ('cheeses', 5)]
>>> for cargo in zip(items, weights):
... print(cargo[0], cargo[1])
...
bananas 15
mattresses 34
dog kennels 42
machine 120
cheeses 5
>>> for i, item in zip(range(len(items)),items):
... print(i, item)
...
0 bananas
1 mattresses
2 dog kennels
3 machine
4 cheeses
|
enumerate()
enumerate() 会返回这些元组，包含索引和列表值，并以迭代的方式呈现出来。
1
2
3
4
5
6
7
8
| >>> for i, item in enumerate(items):
... print(i, item)
...
0 bananas
1 mattresses
2 dog kennels
3 machine
4 cheeses
|
列表推导式
1
2
3
4
5
6
7
8
9
10
11
| >>> squares = [x**2 for x in range(9)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64]
>>> squares = [x**2 for x in range(9) if x % 2 == 0]
>>> squares
[0, 4, 16, 36, 64]
>>> squares = [x**2 if x % 2 == 0 else x + 3 for x in range(9)]
>>> squares
[0, 4, 4, 6, 16, 8, 36, 10, 64]
|
列表推导式是将后面遍历出来的结果，进行处理后append到list后面。
也可以在迭代后增加 if 关键字，判断是否满足某个条件。
如果要添加else ，则需要将 if else 提前。
元组
集合
集合会消除重复项，set()函数会将list转为集合，新增用add()， 删除用pop()
1
2
3
4
5
6
7
8
9
10
11
12
13
| >>> a = [1, 1, 2, 2, 2, 3, 3, 4, 4]
>>> b = set(a)
>>> b
{1, 2, 3, 4}
>>> b.add(5)
>>> b
{1, 2, 3, 4, 5}
>>> b.pop()
1
>>> b
{2, 3, 4, 5}
|
字典
和列表集合不同，字典存放的是键值对。
每个键需要是相同的类型，和集合一样我们可以通过in 来查看某个值是否在字典中。get()函数可以获取对应的值，如果没有返回None
1
2
3
4
5
6
7
8
9
10
11
12
| >>> elements = {'hydrogen' : 1, 'helium' : 2, 'carbon' : 6}
>>> elements['lithium'] = 3
>>> print(elements)
{'hydrogen': 1, 'helium': 2, 'carbon': 6, 'lithium': 3}
>>> print('mithril' in elements)
False
>>> print(elements.get('dilithium'))
None
>>> print(elements.get('helium'))
2
|
复合数据结构
1
2
3
4
5
6
7
8
9
10
11
12
| >>> elements = {"hydrogen": {"number": 1,
... "weight": 1.00794,
... "symbol": "H"},
... "helium": {"number": 2,
... "weight": 4.002602,
... "symbol": "He"}}
>>> print(elements["helium"])
{'number': 2, 'weight': 4.002602, 'symbol': 'He'}
>>> print(elements["helium"]["weight"])
4.002602
|
Python Lambda 表达式
在python中可以使用Lambda 表达式创建匿名函数。很适合创建只用一次的函数。
1
2
3
4
5
6
|
>>> def double(x):
... return x**2
...
>>> double(5)
25
|
1
2
3
4
5
6
7
8
|
>>> double = lambda x : x**2
>>> double(5)
25
>>> mul = lambda x, y : x*y
>>> mul(2,3)
6
|
lamada 后面跟的是参数。
迭代器/生成器
迭代器是每次可以返回一个对象元素的对象，例如返回一个列表。我们到目前为止使用的很多内置函数（例如 enumerate）都会返回一个迭代器。
迭代器是一种表示数据流的对象。这与列表不同，列表是可迭代对象，但不是迭代器，因为它不是数据流。
生成器是使用函数创建迭代器的简单方式。也可以使用类定义迭代器
下面是一个叫做 my_range 的生成器函数，它会生成一个从 0 到 (x - 1) 的数字流。
1
2
3
4
5
| def my_range(x):
i = 0
while i < x:
yield i
i += 1
|
注意，该函数使用了 yield 而不是关键字 return。这样使函数能够一次返回一个值，并且每次被调用时都从停下的位置继续。关键字 yield 是将生成器与普通函数区分开来的依据。
下面是实现了 enumerate 函数一样的功能。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| >>> lessons = ["Why Python Programming", "Data Types and Operators", "Control Flow", "Functions", "Scripting"]
>>> def my_enumerate(lists, start):
i = 0
while (i < len(lists)):
yield (start,lists[i])
i += 1
start += 1
>>> for i, lesson in my_enumerate(lessons, 1):
print("Lesson {}: {}".format(i, lesson))
Lesson 1: Why Python Programming
Lesson 2: Data Types and Operators
Lesson 3: Control Flow
Lesson 4: Functions
Lesson 5: Scripting
|
