量化教程 2：Python介绍

作者：chen_h
微信号 & QQ：862251340
微信公众号：coderpai

---

介绍

Python 正迅速成为许多金融专业人士的首选语言。在这个教程中，我们将简单的介绍一些 Python 的关键概念。我们的目标是让读者掌握足够多的入门知识，这样他们可以开始使用其他资源来进一步的深入理解这些概念。

代码注释

代码注释是程序员在写代码时所做的记录。其目的就是为了让自己和后人更好的理解现在写的代码，因为经过一段时间之后，我们对代码的理解程度会降低，这时候看当时写的一些注释会加快我们的理解。实际运行代码时，注释的内容都是会被过滤掉的，也就是说这些注释都是不会被运行的。Python 中的注释通常使用 # 符号来进行。我们在一行代码最前面加上 # 符号，就会注释掉符号后面的任何内容。

# This is a comment
# These lines of code will not change any values
# Anything following the first # is not run as code

你可能也听到过另外的一个方法，就是使用三个引号来进行注释，这种注释方法称为多行注释，但这并不是完全准确。其实，这是一种特殊类型的字符串（我们将其称为一种数据类型），称为文档字符串，它一般的用途是用于解释函数的用途。

""" This is a special string """

如果你在代码中看到一些注释，我建议你应该仔细的阅读它们，因为它们将提供更多的代码含义，帮助你更好的理解程序。

变量

变量为编程中的值提供名称，也就是取个名字。如果你想要在以后重复使用这个值，则给该值取一个名称，将内容存储在一个变量中，这是非常有效率的一个操作，。编程中的变量含义与代数中的变量基本类似，他们的工作原理也基本类似。但是在 Python 中，他们可以采用多种不同的数据类型。也就是说，你可以不用特意为变量指定一个类型，它可以作为任何类型。

我们将在本章中介绍 Python 的基本变量类型：整数，浮点数，布尔值和字符串。

编程中的整数与数学中的整数是相同的，即小数点后没有值。我们在这里使用内置的打印函数来显示变量的值以及它的类型。

my_integer = 50
print(my_integer, type(my_integer))

无论变量是什么类型，变量都是用一个等号 = 来进行分配值。变量是区分大小写的，因此变量名的大小写修改，都会使得变量变成另一个变量。比如，一下代码就会报错：

one = 1
print(One) # 第一个字母改变为大写了

浮点数或者浮点是数学的真实表述。我们要定义一个浮点数时，我们需要包含一个小数点或者指定该值是一个浮点数。

my_float = 1.0
print(my_float, type(my_float))
my_float = float(1)
print(my_float, type(my_float))

请注意，我们可以使用 float() 函数强制将一个整数数字转为一个浮点数，相反我们也可以使用 int() 函数强制将一个浮点数数字转为一个整数。

my_int = int(3.14159)
print(my_int, type(my_int))

int() 函数会截断浮点数小数点后面的任何数字。

字符串允许你将文本作为变量进行操作。它们使用单引号或者双引号来进行定义。

my_string = 'This is a string with single quotes'
print(my_string)
my_string = "This is a string with double quotes"
print(my_string)

两者定义都是允许的，所以如果我们这样选择的话，我们可以在字符串中包含括号或者引号等符号。

my_string = '"Jabberwocky", by Lewis Carroll'
print(my_string)
my_string = "'Twas brillig, and the slithy toves / Did gyre and gimble in the wabe;"
print(my_string)

布尔或者 bools 是二元变量类型。一个布尔值智能采取两个值中的一个，这些值是 True 或者 False 。当你开始编程的时候，这个关于布尔值的概念还是非常多的，我们稍后会在逻辑运算符中进行介绍。

my_bool = True
print(my_bool, type(my_bool))

还有更多的数据类型可以在 Python 中进行变量操作，但以上这些是最基本的。稍后，我们就会在本教程中进行使用。

基础数学

Python 有一些内置的数学函数。这些可以通过导入数学包活通过包含任意数量的其它基于计算的数据包来进一步扩展。

所有基本的算术运算都支持：+ ，-，/ 和 * 。你可以通过使用 ** 来创建指数，并且使用 mod 运算符 % 引入模块算术。

print('Addition: ', 2 + 2)
print('Subtraction: ', 7 - 4)
print('Multiplication: ', 2 * 5)
print('Division: ', 10 / 2)
print('Exponentiation: ', 3**2)

如果你对 mod 运算符不是很熟悉，你可以将它想象成余数函数一样进行运行。如果我们输入 15%4 ，那么它将返回的是 15 / 4 的余数。

print('Modulo: ', 15 % 4)

first_integer = 4
second_integer = 5
print(first_integer * second_integer)

如果你想在你的最终答案中有小数点，请确保你的变量是浮点数。如果你只用整数进行数学运算，你会得到一个整数。在计算中包括任何浮点数都会使得最终的结果是浮点数。

first_integer = 11
second_integer = 3
print(first_integer / second_integer)

first_number = 11.0
second_number = 3.0
print(first_number / second_number)

Python 有一些内置的数学函数。其中最值得注意的是：

• abs()
• round()
• max()
• min()
• sum()

这些函数都是按照你的预期效果来进行命名的。比如，我们调用 abs(x) 函数，那么函数将会返回参数 x 的绝对值。round() 函数会将数字进行四舍五入，默认是 0。max() 函数或者 min() 函数会返回一个数组的最大值或者最小值。sum() 函数会返回一组数组的和。如果你不熟悉这些函数的工作原理，请不要过于担心，我们将在下一章进行深入的讨论。

如果，我们要去调用别的数学函数，我们需要导入数学处理包。

import math

数学包为 Python 增加了很多新的数学函数，你可以阅读 Python 的 math 包，来详细了解这些函数。

import math

print('Pi: ', math.pi)
print("Euler's Constant: ", math.e)
print('Cosine of pi: ', math.cos(math.pi))

集合

列表

Python 中的列表是可以包含任何数据类型的对象的有序集合。我们使用方括号 [] 来定义一个列表。

my_list = [1, 2, 3]
print(my_list)

我们也可以通过使用括号来访问和索引列表。如果选择一个单独的元素，只需要在大括号中键入列表名称，然后输入要查找的列表的索引就行了。

print(my_list[0])
print(my_list[2])

Python 中的索引是从0 开始的，如果你有一个长度是 n 的列表，则列表的第一个元素位于索引 0 处，第二个元素位于索引的 1 处，以此类推。列表的最后一个元素是索引 n-1 。所以按照我们一贯的认知，第一个索引的访问和最后一个索引的访问都是非常容易出问题的，在此要小心。

print('The first, second, and third list elements: ', my_list[0], my_list[1], my_list[2])
print('Accessing outside the list bounds causes an error: ', my_list[3])

我们可以通过调用 len() 函数俩查看列表中元素的数量。

print(len(my_list))

我们可以通过访问索引并分配新值来更新和更改列表。

print(my_list)
my_list[0] = 42
print(my_list)

这与字符串的处理方式是完全不同的。列表是可变的，这也就意味着你可以更改列表的元素而不更改列表本身。一些数据类型，如字符串，是不可能改变的，也就是说一旦你创建成功，那么你就不能再对他进行修改。如果你对他进行了修改，那么其实是创建了一个新的元素。

my_string = "Strings never change"
my_string[0] = 'Z'

正如我们之前所说的，一个列表可以包含任何的数据类型。因此，我们也可以在列表中包含字符串，也就是把一个字符串变成列表中的某一个元素。

my_list_2 = ['one', 'two', 'three']
print(my_list_2)

同一个列表中，我们也可以包含多种数据类型，如下所示：

my_list_3 = [True, 'False', 42]

如果你想要将两个列表放在一起，那么你可以使用 + 符号来进行结合。

my_list_4 = my_list + my_list_2 + my_list_3
print(my_list_4)

除了访问列表中的单个元素外，我们还可以通过切片访问列表元素组。

my_list = ['friends', 'romans', 'countrymen', 'lend', 'me', 'your', 'ears']

切片

我们使用冒号 : 来切割列表。

print(my_list[2:4])

使用方法：我们可以从列表中的第三个元素开始选择一组元素，并且最后一个元素表示第四个元素。

我们也可以选择位于某个点之后的所有元素。

print(my_list[1:])

我们也可以选择位于某个点之前的所有元素。

print(my_list[:4])

Python 还有一个特别神奇的地方就是，我们可以使用负数来表示从末尾开始的索引，而不是从头开始。例如，索引 -1 表示列表的最后一个元素。

print(my_list[-1])

Python 不具有原始矩阵，但是使用列表我们可以产生一个能简单工作的矩阵。我们可以使用软件包（比如 numpy）会将矩阵添加为单独的数据类型，但在基本的 Python 中，创建矩阵的最佳方式是使用列表的列表。

我们也可以使用内置函数来生成列表。特别是我们会看到 range() 。列表的范围可以我们自己指定，然后返回一个构造的列表。

b = 10
my_list = list(range(b))
print(my_list)

与我们之前的列表切片类似的方法，我们可以为我们的列表定义开始位置和结束位置。这将返回一个包含开始和结束（不包含最后一个元素）的列表，就像一个切片一样。

a = 0
b = 10
my_list = list(range(a, b))
print(my_list)

我们也可以指定一个步长，这也是一个从切片学来的类似概念。

a = 0
b = 10
step = 2
my_list = list(range(a, b, step))
print(my_list)

元祖

元祖是一种类似于列表的数据类型，它里面的元素可以容纳不同的数据类型。这里跟列表的关键区别是，元祖是不可变的。我们通过用逗号来分割元祖里面不同的元素。用圆括号来定义一个常规的元祖。

my_tuple = 'I', 'have', 30, 'cats'
print(my_tuple)

my_tuple = ('I', 'have', 30, 'cats')
print(my_tuple)

正如我们前面所提到的，元祖里面的元素是无法被更改的。如果你想要更改元祖里面的元素，那么你必须重新创建一个元祖。

my_tuple[3] = 'dogs' # Attempts to change the 'cats' value stored in the the tuple to 'dogs'

但是你可以像列表一样使用切片。

print(my_tuple[1:3])

并将不同元祖链接起来，就像你链接字符串的方式一样。

my_other_tuple = ('make', 'that', 50)
print(my_tuple + my_other_tuple)

我们可以通过创建一个元祖，来将不同数值打包在一起，或者我们可以通过一个元祖，将一堆数值从一个元祖中解压出来，将他们取出。

str_1, str_2, int_1 = my_other_tuple
print(str_1, str_2, int_1)

解压元祖的时候，元祖里面的值会分配给对应的等号左边的变量。某些函数（包括用户自定义的函数）可能会返回元素，所以我们可以使用这种方法来直接解压我们想要的值，从而得到它们。

集合

集合是一组无序的，不重复的元素的组合。它们工作原理跟数学中的集合概念一模一样，并且我们使用大括号 {} 来进行定义。

things_i_like = {'dogs', 7, 'the number 4', 4, 4, 4, 42, 'lizards', 'man I just LOVE the number 4'}
print(things_i_like, type(things_i_like))

请注意，最终集合中重复的元素都会进行内部删除，这个操作会自动的执行。我们也可以使用 set() 函数从一个列表中创建一个集合。

animal_list = ['cats', 'dogs', 'dogs', 'dogs', 'lizards', 'sponges', 'cows', 'bats', 'sponges']
animal_set = set(animal_list)
print(animal_set) # Removes all extra instances from the list

在一个集合上调用 len() 函数，我们可以知道这个集合中有多少个元素。

print(len(animal_set))

由于一个集合是无序的，所以我们无法使用索引来访问集合中的各个元素。但是，我们可以轻松的查询某个元素是否在集合中，并通过使用内置的集合函数来获取集合的交集和并集。

'cats' in animal_set # Here we check for membership using the `in` keyword.

在上述代码，我们检查了元素 cats 是否包含在我们的 animal_set 集合中，并且这个代码将返回 True 结果，告诉我们 cats 这个元素确实是在我们的集合中。

关于集合运算，我们可以使用典型的集合数学运算符来进行计算，即我们可以使用 | 来表示集合的并集，使用 & 来表示集合的交集。所以，当我们在程序中使用 | 或者 & 符号的时候，我们就能得到我们想要的运算结果了。

print(animal_set | things_i_like) # You can also write things_i_like | animal_set with no difference

用 | 符号，我们将两个集合组合在一起，可以去除两个集合中任意重复的元素，使得两个集合的总集保持元素的唯一性。

print(animal_set & things_i_like) # You can also write things_i_like & animal_set with no difference

用 & 符号，我们将两个集合组合在一起，最终的集合只会返回包含它们所共同拥有的元素。

如果你对 Python 的内置函数感兴趣，那么你可以随时查看这个官方文档。

字典

Python 中另一个重要的数据结构就是字典。我们使用大括号 {} 和冒号 : 组合来定义一个字典。大括号定义字典的开始和结束，冒号来定义键值对。字典本质上是由一组一组的键值对来组成的。任何元素的关键字必须是不可变的数据类型。也就是说，字符串和元祖都会成为候选关键字。键是可以被添加或者被删除的。

在下面的例子中，我们有一个由键值对组成的字典，其中键是小说类型（数据类型是字符串），值是该类型内的书籍列表（数据类型是列表）。由于列表仍被视为单个实体，因此我们可以使用整个列表来作为一个键值对。

my_dict = {"High Fantasy": ["Wheel of Time", "Lord of the Rings"], 
           "Sci-fi": ["Book of the New Sun", "Neuromancer", "Snow Crash"],
           "Weird Fiction": ["At the Mountains of Madness", "The House on the Borderland"]}

字典定义结束之后，我们可以通过在括号中指明其键来访问任何的值。

print(my_dict["Sci-fi"])

我们还可以更改给定键的相关值。

my_dict["Sci-fi"] = "I can't read"
print(my_dict["Sci-fi"])

我们也可以通过新的键来定义一个新的键值对，这对我们添加新的内容是非常有帮助的。

my_dict["Historical Fiction"] = ["Pillars of the Earth"]
print(my_dict["Historical Fiction"])

print(my_dict)

字符串

我们已经知道了字符串通常是用于文本。根据我们的需要，我们可以使用内置操作轻松的进行字符串组合，拆分和格式化。

+ 符号表示字符串互相之间的链接。它将两个字符串组合成一个更长的字符串。

first_string = '"Beware the Jabberwock, my son! /The jaws that bite, the claws that catch! /'
second_string = 'Beware the Jubjub bird, and shun /The frumious Bandersnatch!"/'
third_string = first_string + second_string
print(third_string)

字符串的索引表示方法也是和列表相同的。

my_string = 'Supercalifragilisticexpialidocious'
print('The first letter is: ', my_string[0]) # Uppercase S
print('The last letter is: ', my_string[-1]) # lowercase s
print('The second to last letter is: ', my_string[-2]) # lowercase u
print('The first five characters are: ', my_string[0:5]) # Remember: slicing doesn't include the final element!
print('Reverse it!: ', my_string[::-1])

内置的对象和类通常具有与它们相关的称为方法的特殊功能。我们通过使用小黑点 . 来访问这些方法。我们将在以后的文章中来更多的介绍对象以及相关的方法。

使用字符串方法，我们可以计算一个字符或者一组字符的实例。

print('Count of the letter i in Supercalifragilisticexpialidocious: ', my_string.count('i'))
print('Count of "li" in the same word: ', my_string.count('li'))

我们还可以在一个字符串中找到一个字符或者一组字符的第一个实例。

print('The first time i appears is at index: ', my_string.find('i'))

以及如何替换字符串中的字符。

print("All i's are now a's: ", my_string.replace('i', 'a'))
print("It's raining cats and dogs".replace('dogs', 'more cats'))

还有一些字符串独有的方法。比如函数 upper() 会将字符串中的所有字符转换为大写，同理我们也有函数 lower() 会将字符串中的所有字符转换为小写。

my_string = "I can't hear you"
print(my_string.upper())
my_string = "I said HELLO"
print(my_string.lower())

字符串格式

我们可以使用 format() 方法，来添加变量值并且来格式化字符串。

my_string = "{0} {1}".format('Marco', 'Polo')
print(my_string)
my_string = "{1} {0}".format('Marco', 'Polo')
print(my_string)

我们使用大括号 {} 来指示我们稍后将要填充的字符串内容，并且我们使用 format() 函数的参数来提供需要替换的值。大括号内的数字表示 format() 参数中值的索引。

有关 format() 更多的操作，你可以参阅官方 format() 文档。

如果你需要一些快速的处理方式，那么你也可以使用 % 符号来操作，这种符号称为字符串格式操作符。

print('insert %s here' % 'value')

% 符号基本上提示 Python 创建一个占位符。无论在字符串 % 之后的字符都表示放置占位符的值的类型是什么类型。这个字符被称为转换类型，一旦字符串被关闭，我们需要另一个 % ，随后的值将被插入。如果你只想插入一个值，那么你可以使用这种方法来进行插入，如果你想要插入多个值，则这些值必须包含在一个元祖里面。

print('There are %s cats in my %s' % (13, 'apartment'))

在这些例子中， %s 表示 Python 应该将值转换为字符串。有多重转换类型可用于获取格式的更多特定信息。请参考字符串格式文档以获得更多实例和更完整的使用细节。

逻辑运算符

基本逻辑

正如我们之前介绍的一样，逻辑运算符处理的是布尔值。如果你还及得，一个布尔值应该只能取两个值，一个是 True ，另一个是 False 。我们可以制作的基本逻辑语句是使用内置的定义器。比如，== 表示等于，!= 表示不等于，< 表示小于，> 表示大于，<= 表示小于或等于，>= 表示大于或等于。

print(5 == 5)
print(5 > 5)

这些比较器操作还可以与变量一起使用。

m = 2
n = 23
print(m < n)

我们可以将这些比较操作串联在一起，使用逻辑运算符或者和，而不是使用逻辑运算符来创建更加复杂的逻辑语句。

statement_1 = 10 > 2
statement_2 = 4 <= 6
print("Statement 1 truth value: {0}".format(statement_1))
print("Statement 2 truth value: {0}".format(statement_2))
print("Statement 1 and Statement 2: {0}".format(statement_1 and statement_2))

or 运算符执行逻辑或运算。这是一个包容性的，也就是说只要两个元素中任何一个元素是 True 的，那么整个逻辑运算返回的值就是 True 的，只有当两个元素都是 False 的时候，那么整个逻辑运算返回的值才是 False 。and 运算符执行逻辑和运算，也就是说这个操作需要运算两边的元素都是 True ，那么整个逻辑运算才回返回 True ，否则返回的值都是 False 。not 运算符执行的是逻辑非运算。也就是说这个运算符只颠倒运算符后面的表达的布尔值。比如，当 not 运算符后面是 True 时，那么整个逻辑运算返回的就是 False ；当 not 运算符后面是 False 时，那么整个逻辑运算返回的就是 True 。

假设，我们有两个逻辑语句 P 和 Q ，那么对于上面的基本逻辑运算符操作的真值表如下：

P	Q	not P	P and Q	P or Q
True	True	False	True	True
False	True	True	False	True
True	False	False	False	True
False	False	True	False	False

我们可以使用逻辑运算符将多个逻辑语句串联在一起使用。

print(((2 < 3) and (3 > 0)) or ((5 > 6) and not (4 < 2)))

逻辑语句可以表达的非常复杂，也可以表达的非常简单，这种复杂度往往取决于我们需要表达的内容。如果我们逐步评估上述逻辑语句，我们会看到我们正在评估的是 True and True 或 False and not False 。这也就变成了最终评估的 True or False ，得到最后的评估结果 True 。

条件语句

我们可以创建只有满足一组条件才能执行的代码段。我们将 if 语句与逻辑语句结合使用，以便在代码中创建分支。

当条件被认为是 True 的时候， if 语句模块才会被执行。如果条件评估为 False ，那么 if 语句块将被简单的跳过。条件语句是使用逻辑运算符或者通过使用 Python 中的某个函数的布尔值来进行的。 if 语句是用冒号和锁紧文本块来进行定义的。

# This is the basic format of an if statement. This is a vacuous example. 
# The string "Condition" will always evaluated as True because it is a
# non-empty string. he purpose of this code is to show the formatting of
# an if-statement.
if "Condition": 
    # This block of code will execute because the string is non-empty
    # Everything on these indented lines
    print(True)
else:
    # So if the condition that we examined with if is in fact False
    # This block of code will execute INSTEAD of the first block of code
    # Everything on these indented lines
    print(False)
# The else block here will never execute because "Condition" is a non-empty string.

i = 4
if i == 5:
    print('The variable i has a value of 5')

因为在这个例子中 i=4 ，但是 if 语句只有当 i 查询到等于 5 的时候才会执行，所以 print 语句永远也不会执行。如果 if 语句中的条件违背评估为 True ，那么我们可以添加 else 语句来创建应急代码块。

i = 4
if i == 5:
    print("All lines in this indented block are part of this block")
    print('The variable i has a value of 5')
else:
    print("All lines in this indented block are part of this block")
    print('The variable i is not equal to 5')

我们可以通过使用功能 elif (“else if” 的缩写) 来实现一个 if 语句中的其他分支。我们可以包含尽可能多的 elif 语句，直到我们耗尽了我们想要的所有的条件逻辑分支。

i = 1
if i == 1:
    print('The variable i has a value of 1')
elif i == 2:
    print('The variable i has a value of 2')
elif i == 3:
    print('The variable i has a value of 3')
else:
    print("I don't care what i is")

你也可以在 if 语句中嵌套 if 语句来检查更多的条件。

i = 10
if i % 2 == 0:
    if i % 3 == 0:
        print('i is divisible by both 2 and 3! Wow!')
    elif i % 5 == 0:
        print('i is divisible by both 2 and 5! Wow!')
    else:
        print('i is divisible by 2, but not 3 or 5. Meh.')
else:
    print('I guess that i is an odd number. Boring.')

请记住，我们可以使用逻辑运算符将多个条件组合在一起！

i = 5
j = 12
if i < 10 and j > 11:
    print('{0} is less than 10 and {1} is greater than 11! How novel and interesting!'.format(i, j))

你也可以使用逻辑运算来比较字符串。

my_string = "Carthago delenda est"
if my_string == "Carthago delenda est":
    print('And so it was! For the glory of Rome!')
else:
    print('War elephants are TERRIFYING. I am staying home.')

与其他数据类型一样，== 符号将检查它的两边是否具有相同的值。在这种情况下，我们比较字符串的值是否相同。然而，使用 > 或者 < 符号的字符串之间的比较可能不会那么直观，所以我们就不在本章内对字符串进行大小比较了。但我们可以简单的提一下，字符串的大小写比较其实就是比较的字符串的字典顺序，但具体的比较可能会更加的复杂。

一些内置函数返回的是一个布尔值，所以他们可以作为 if 语句中的条件。当然，用户定义的函数也可以被用作为判断条件，最终返回一个布尔值。这个内容我们将在稍后与函数定义一起讨论。

in 关键字通常用于检查一个值是否是另一个值中的元素。我们可以在 if 语句的上下文中检查某元素是否包含在某元素之内，从而来作为我们的判断条件。

my_string = "Carthago delenda est"
if 'a' in my_string or 'e' in my_string:
    print('Those are my favorite vowels!')

这里我们用来检查变量 my_string 是否包含任何特定的字母，比如字母 a 或者字母 e 。稍后我们将使用他来遍历列表。

循环结构

循环结构是变成最重要的部分之一。for 循环和 while 循环提供了重复运行代码块的方法。while 循环将迭代直到满足某个条件。如果在迭代之后的任何时候条件不在满足了，那么我们的循环就会终止了。for 循环将迭代一些列的值或者操作，并且在序列结束时终止循环。你可以在 for 循环中包含条件来决定是否应该尽早的终止循环，或者你也可以简单的让它一直运行下去。

i = 5
while i > 0: # We can write this as 'while i:' because 0 is False!
    i -= 1
    print('I am looping! {0} more to go!'.format(i))

有了 while 循环之后，我们需要确保实际上迭代是在不断的向前进行的，因为只有这样，我们才能在某一次迭代之后结束迭代。在这种情况下，我们使用速记 i -= 1 来表示 i 值的不断减小（这是 i = i - 1 的简写），这样每次迭代 i 的值就会不断变小。最终我们会将 i 的值减小到 0，也就是说这时候我们的判断条件为 False 时推出循环。

for 循环迭代会在最开始的时候设定循环长度，当你将循环刺手指定到循环中进行遍历。在这种情况下，我们遍历的列表是由 range() 构造的。for 循环按照顺序从列表中选择一个一个的值，并且暂时将 i 的值赋给它，以便可以使用该值执行操作。

for i in range(5):
    print('I am looping! I have looped {0} times!'.format(i + 1))

请注意，在此 for 循环中，我们使用 in 关键字。使用 in 关键字不但可以检查 if 语句中的条件是否满足。你还可以使用 in 关键字在 for 循环中迭代任何的元素集合。

在下一个例子中，我们将遍历一个集合，因为我们要检查元素的包含关系，并且添加新的元素到集合里面。

my_list = {'cats', 'dogs', 'lizards', 'cows', 'bats', 'sponges', 'humans'} # Lists all the animals in the world
mammal_list = {'cats', 'dogs', 'cows', 'bats', 'humans'} # Lists all the mammals in the world
my_new_list = set()
for animal in my_list:
    if animal in mammal_list:
        # This adds any animal that is both in my_list and mammal_list to my_new_list
        my_new_list.add(animal)

print(my_new_list)

在循环处理的时候，有两个语句是非常有用的，它们分别是 break 和 continue 。如果在执行循环的任何时候遇到了 break 语句，那么循环将会立即结束。

i = 10
while True:
    if i == 14:
        break
    i += 1 # This is shorthand for i = i + 1. It increments i with each iteration.
    print(i)

for i in range(5):
    if i == 2:
        break
    print(i)

continue 语句会告诉循环立即结束这个迭代，并且继续去执行下一次迭代。

i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)

此循环将会跳出打印数字 3，因为个循环到 i == 3 时，我们添加了 if 语句。此时程序会执行 continue 语句，代码就不会看到打印数字 3 的命令，因为程序已经移动到了下一次迭代中。 break 和 continue 语句是进一步的工具，可以帮助你控制循环的流程，从而控制你的一些算法流程。

在 Python 中，我们用来迭代循环的变量将在循环结束时保留其值。同样，在循环的上细纹中定义的任何变量都将集训存在于循环之外。

for i in range(5):
    loop_string = 'I transcend the loop!'
    print('I am eternal! I am {0} and I exist everywhere!'.format(i))

print('I persist! My value is {0}'.format(i))
print(loop_string)

我们也可以迭代字典！

my_dict = {'firstname' : 'Inigo', 'lastname' : 'Montoya', 'nemesis' : 'Rugen'}

for key in my_dict:
    print(key)

如果我们只是在不做别的事情的情况下遍历一个字典，那么我们只会得到关键字。我们可以使用键来获取值，如下所示：

for key in my_dict:
    print(my_dict[key])

或者我们可以使用 items() 函数同时获取键和值。

for key, value in my_dict.items():
    print(key, ':', value)

items() 函数为每个键 - 值对创建了一个元祖，并且 for 循环存储将该元祖解压缩到 key 中的每个单独执行的值。

函数

函数是一个可重用的代码块，你可以重复调用该代码块进行计算，输出数据或真正执行任何你想要的操作。这是灵活使用编程语言的非常关键的一方面。如果你想要添加到 Python 中的内置函数中，你可以定义自己的。

def hello_world():
    """ Prints Hello, world! """
    print('Hello, world!')

hello_world()

for i in range(5):
    hello_world()

函数使用 def 来进行定义，包括函数名称，参数列表和冒号定义。在冒号下面锁紧的所有内容都将包含在函数的定义中。

我们可以让我们的函数完成任何可以用普通代码块做的事情。例如，我们的 hello_world() 函数每次调用时都会打印一个字符串。如果我们想保留一个函数计算的值，我们可以定义一个函数的返回值，以便它返回我们想要的值。这是函数的一个非常重要的特性，因为纯粹在含糊中定义的任何变量都不会存在于函数之外。

def see_the_scope():
    in_function_string = "I'm stuck in here!"

see_the_scope()
print(in_function_string)

变量的作用域是代码块的一部分，其中该变量与特定值进行绑定。Python 中的函数有一个封闭的范围，使得他们中定义的变量只能在函数中直接访问。如果我们将这些值传递给返回的语句，我们可以将他们从函数中取出。这使得函数调用返回值，以便你可以将他们存储在具有更大范围的变量中。

在这种情况下，具体而言，包含返回语句的函数允许我们保留我们在函数中定义的字符串值。

def free_the_scope():
    in_function_string = "Anything you can do I can do better!"
    return in_function_string
my_string = free_the_scope()
print(my_string)

就像我们可以从函数中获取值一样，我们也可以将值放入函数中。我们通过用参数定义我们的函数来做到这一点。

def multiply_by_five(x):
    """ Multiplies an input number by 5 """
    return x * 5

n = 4
print(n)
print(multiply_by_five(n))

在这个例子中，我们只有一个参数 x 作用于我们的函数。但我们也可以轻松添加更多的参数，我们只需要利用逗号来分隔各个参数。

def calculate_area(length, width):
    """ Calculates the area of a rectangle """
    return length * width

l = 5
w = 10
print('Area: ', calculate_area(l, w))
print('Length: ', l)
print('Width: ', w)

def calculate_volume(length, width, depth):
    """ Calculates the volume of a rectangular prism """
    return length * width * depth

如果我们还想要添加更多的参数，我们可以定义一个函数，以便它可以使用任意数量的参数。我们通过使用星号 * 来指定多个参数。

def sum_values(*args):
    sum_val = 0
    for i in args:
        sum_val += i
    return sum_val

print(sum_values(1, 2, 3))
print(sum_values(10, 20, 30, 40, 50))
print(sum_values(4, 2, 5, 1, 10, 249, 25, 24, 13, 6, 4))

当我们使用 *args 作为函数的参数时，是因为我们不知道用户会传递多少个参数给这个函数，比如就像我们不知道求和的序列会有多长一样。在这种情况下，* 是告诉 Python 我们将要传递任意数量的参数到这个函数中，并且这些参数以元祖的形式进行存储。

def test_args(*args):
    print(type(args))

test_args(1, 2, 3, 4, 5, 6)

当我们调用函数时，我们可以将许多元素放入参数元祖中。但是，因为 args 是一个元祖，所有当我们创建它之后，就不能再对其进行修改了。

变量的参数纯粹是按照惯例才取名为 args ，你可以简单的命名你的参数为 vars 或者 somethings 等。你可以向处理任何其他元祖一样对待 args 元祖，像上述 sum_values(*args) 函数一样轻松访问参数 args 中的值，并且遍历它。

我们的函数可以返回任何的数据类型。这使得我们可以轻松创建我们需要的函数。

这里我们定义了一个返回布尔值的函数。我们可以很容易的将这与 if 语句和需要布尔值的其它地方进行结合使用，提高我们的编程效率。

def has_a_vowel(word):
    """ 
    Checks to see whether a word contains a vowel 
    If it doesn't contain a conventional vowel, it
    will check for the presence of 'y' or 'w'. Does
    not check to see whether those are in the word
    in a vowel context.
    """
    vowel_list = ['a', 'e', 'i', 'o', 'u']

    for vowel in vowel_list:
        if vowel in word:
            return True
    # If there is a vowel in the word, the function returns, preventing anything after this loop from running
    return False

my_word = 'catnapping'
if has_a_vowel(my_word):
    print('How surprising, an english word contains a vowel.')
else:
    print('This is actually surprising.')

def point_maker(x, y):
    """ Groups x and y values into a point, technically a tuple """
    return x, y

这个上面的函数返回一个有序的输入参数对，并且作为一个元祖进行存储。

a = point_maker(0, 10)
b = point_maker(5, 3)
def calculate_slope(point_a, point_b):
    """ Calculates the linear slope between two points """
    return (point_b[1] - point_a[1])/(point_b[0] - point_a[0])
print("The slope between a and b is {0}".format(calculate_slope(a, b)))

这个函数就是计算两个之间的斜率！

print("The slope-intercept form of the line between a and b, using point a, is: y - {0} = {2}(x - {1})".format(a[1], a[0], calculate_slope(a, b)))

使用适当的语法，你可以定义函数来执行任何你想要的计算。这使得他们可以成为任何语言编程中不可或缺的部分。

---

来源：lecture 1