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 提前。

元组

1
2
a = (1, 2)
x, y = a  # 元组解包

集合

集合会消除重复项，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
# Lambda 表达式
>>> 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