Python初学笔记（优达学城）

Python笔记：
1.Python中的特殊运算符：a**b是指a的b次方；^是取异或的运算符
2.Python支持这种形式的赋值：x,y,z=1,2,3
3.Python中可以不用在语句末尾加；
4.变量命名是可以使用数字、字母、下划线，只能以字母和下划线开头。 注：不可以有空格
5.命名时用小写字母，用下划线区分单词
6.不能使用保留字或内置标识符，它们在 Python 中具有重要含义，你将在整个这门课程中学到这些知识。python 保留字列表请参阅此处。创建对值清晰描述的名称可以帮助你避免使用这些保留字。下面是这些保留字的简要表格。

7.用#来写注释！！！
8.特殊运算符

9.使用科学记数法来定义很大的数字，例如：4.445e8 等于 4.445 * 10 ** 8，也就是 444500000.0。
10. Python中的float是近似值，会出现很多个小数相加后结果不对的现象（即结果略有误差）（此句存疑！！！）
11. 因为0.1的浮点数（或近似值）实际上比0.1稍微大些，当我们将好几个这样的值相加时，可以看出在数学上正确的答案与Python生成的答案之间有区别。

>>> print(.1 + .1 + .1 == .3)
False

12. 你可以使用函数 type 检查数据类型：
    例：

>>>print(type(x))
int
>>>print(type(y))
float

13.如果只有整数部分，会被认为是int型，如果带小数点则被认为是float型。注：写成356.也被认为是float型（即小数点后可不加任何数但是仍然被认为是float型）
14.每行代码应该不超过80个字符，虽然在某些使用情况下，99个字符也可以。此规则是由IBM制定的。
15.
布尔型运算符、比较运算符和逻辑运算符
布尔数据类型存储的是值 True 或 False，通常分别表示为 1 或 0。

通常有 6 个比较运算符会获得布尔值：

比较运算符
符号使用情况 布尔型 运算符
5 < 3 False 小于
5 > 3 True 大于
3 <= 3 True 小于或等于
3 >= 5 False 大于或等于
3 == 5 False 等于
3 != 5 True 不等于
你需要熟悉三个逻辑运算符：

逻辑使用情况 布尔型 运算符

5 < 3 and 5 == 5	False	and - 检查提供的所有语句是否都为 True
5 < 3 or 5 == 5	True	or - 检查是否至少有一个语句为 True
not 5 < 3	True	not - 翻转布尔值

16.输出字符串时单引号（’）和双引号（"）都可以。
17.支持直接将字符串赋值给变量，单引号（’）和双引号（"）都可以。而且，字符串中可以包含标点、空格、数字等。
18.在字符串中有单引号或者双引号时，要用反斜杠（\）来转义引号。

Python支持用“+”对字符串进行相加操作（只是机械地进行相加而已）
例：
>>> first_word = 'Hello'
>>> second_word = 'There'
>>> print(first_word + second_word) 
HelloThere

在两个单词间加入空格：
例：
>>> print(first_word + ' ' + second_word)
Hello There

Python支持用“*”对字符串进行重复字符串的操作：
>>> print(first_word * 5)
HelloHelloHelloHelloHello

用len函数输出字符串长度：
>>> print(len(first_word))
5

Python支持索引（下标从0开始）
>>> first_word[0]
H
>>> first_word[1]
e

19.len() 仅适用于“序列（例如字符串、字节、元组、列表或范围）或集合（例如字典、集合或冻结集合）”，当对整数使用len()函数时会报错：TypeError: object of type ‘int’ has no len()
20.字符串方法
在此视频中，我们介绍了方法。方法就像某些你已经见过的函数：
len(“this”)
type(12)
print(“Hello world”)
上述三项都是函数。注意，它们使用了小括号并接受一个参数。

type 和 print 函数可以接收字符串、浮点型、整型和很多其他数据类型的参数，函数 len 也可以接受多种不同数据类型的参数，稍后你将在这节课中详细了解。

python 中的方法和函数相似，但是它针对的是你已经创建的变量。方法与特定变量中的数据类型相关。 方法相当于通过.来调用的一种函数。例如，lower()是一个字符串方法，对于一个叫 “sample string” 的字符串，它可以这样使用：sample_string.lower()。

下图显示了任何字符串都可以使用的方法。

每个方法都接受字符串本身作为该方法的第一个参数。但是，它们还可以接收其他参数。我们来看看几个示例的输出。

>>> my_string ="sebastian thrun"
>>> my_string.islower()   	//islower()函数是用来判断字符串是否全部为小写字母
True
>>> my_string.count('a')	//count()函数是用来输出字符串中某一字符出现的次数
2
>>> my_string.find('a')		//find()函数是用来判断字符串是否全部为小写字母
3
>>> my_string.title()		//title()函数是用来将字符串转成title的形式，就是每个单词首字母大写
'Sebastian Thrun'
>>> print(my_string.title())
Sebastian Thrun

可以看出，count 和 find 方法都接受另一个参数。但是，islower 方法不接受参数。如果我们要在变量中存储浮点数、整数或其他类型的数据，可用的方法可能完全不同！
21.列表和成员运算符（list是用一对大括号包括("["、"]") ）
lst_of_random_things = [1, 3.4, ‘a string’, True]
这是一个包含 4 个元素的类别。在 python 中，所有有序容器（例如列表）的起始索引都是 0。因此，要从上述列表中获取第一个值，我们可以编写以下代码：

>>> lst_of_random_things[0]
1

易错点：

//你可能会试图用下面的语句访问最后一个元素，但是是不正确的
>>> lst_of_random_things[len(lst_of_random_things)] 
//正确的应该是：
>>> lst_of_random_things[len(lst_of_random_things) - 1] 
True
//一定不要忘记减一，因为容器下标是从0开始的

此外，你可以使用负数从列表的末尾开始编制索引，其中 -1 表示最后一个元素，-2 表示倒数第二个元素，等等。

>>> lst_of_random_things[-1] 
True
>>> lst_of_random_things[-2] 
a string

22.列表切片
使用切片功能从列表中提取多个值。在使用切片功能时，务必注意，起始索引包含在内，终止索引排除在外。
例：[a:b]等于[a~b) (即左边包含，右边不包含）注：此处的下标还是从0开始，即和list对应。
因此：

>>> lst_of_random_things = [1, 3.4, 'a string', True]
>>> lst_of_random_things[1:2]
[3.4]

仅返回列表中的 3.4。注意，这与单个元素索引依然不同，因为你通过这种索引获得了一个列表。冒号表示从冒号左侧的起始值开始，到右侧的元素（不含）结束。

如果你要从列表的开头开始，也可以省略起始值。

>>> lst_of_random_things[:2]
[1, 3.4]

或者你要返回到列表结尾的所有值，可以忽略最后一个元素。

>>> lst_of_random_things[1:]
[3.4, 'a string', True]

这种索引和字符串索引完全一样，返回的值将是字符串。

23.“在”列表里还是“不在”列表里？
你发现，我们还可以使用 in 和 not in 返回一个布尔值，表示某个元素是否存在于列表中，或者某个字符串是否为另一个字符串的子字符串。

>>> 'this' in 'this is a string'
True
>>> 'in' in 'this is a string'
True
>>> 'isa' in 'this is a string'
False
>>> 5 not in [1, 2, 3, 4, 6]
True
>>> 5 in [1, 2, 3, 4, 6]
False

24.可变性和顺序
可变性是指对象创建完毕后，我们是否可以更改该对象。如果对象（例如列表）可以更改，则是可变的。但是，如果无法更改对象以创建全新的对象（例如字符串），则该对象是不可变的。

>>> my_lst = [1, 2, 3, 4, 5]
>>> my_lst[0] = 'one'
>>> print(my_lst)
['one', 2, 3, 4, 5]

正如上述代码所显示的，你可以将上述列表中的 1 替换为 'one。这是因为，列表是可变的。

但是，以下代码不可行：

>>> greeting = "Hello there"
>>> greeting[0] = 'M'

这是因为，字符串是不可变的。意味着如果要更改该字符串，你需要创建一个全新的字符串。

对于你要使用的每种数据类型，你都需要注意两个事项：
可变吗？
有序吗？
字符串和列表都是有序的。但是，你将在后续部分看到某些数据类型是无序的。对于接下来要遇到的每种数据类型，有必要理解如何设定索引，可变吗，有序吗。了解数据结构的这些信息很有用！

此外，你将发现每种数据类型有不同的方法，因此为何使用一种数据类型（而不是另一种）在很大程度上取决于这些特性，以及如何轻松地利用这些特性！

25.实用的列表函数（第一部分）
len() 返回列表中的元素数量。
max() 返回列表中的最大元素。最大元素的判断依据是列表中的对象类型。数字列表中的最大元素是最大的数字。字符串列表中的最大元素是按照字母顺序排序时排在最后一位的元素。因为 max() 函数的定义依据是大于比较运算符。如果列表包含不同的无法比较类型的元素，则 max() 的结果是 undefined。
min() 返回列表中的最小元素。它是 max() 函数的对立面，返回列表中的最小元素。
sorted() 返回一个从最小到最大排序的列表副本，并使原始列表保持不变。也可通过添加可选参数reverse = true来实现按照从大到小的顺序排序。
例：print(sorted(sizes,reverse=True)) 其中size是要排序列表的名称。

这里列一个Python中特殊的地方：

//下面是字符串类型的例子：
>>> name='Jim'
>>> student = name
>>> name='Tim'
>>> print(name)
Tim
>>> print(student)
Jim
//可以看出，改变name的值时，对student的值没有任何影响

//下面是列表类型的例子：
>>> scores = ["B","C","A", "D", "B", "A"]
>>> grades = scores
>>> print("scores:"+str(scores))
scores:['B', 'C', 'A', 'D', 'B', 'A']
>>> print("grades:"+ str(grades))
grades:['B', 'C', 'A', 'D', 'B', 'A']
>>> scores[3] ="B"
>>> print("scores:" +str(scores))
scores:['B', 'C', 'A', 'B', 'B', 'A']	//注意这里的第四个元素改变了
>>> print("grades:" + str(grades))
grades:['B', 'C', 'A', 'B', 'B', 'A']	//注意这里的第四个元素改变了

//可以看出，当改变了score列表中的元素之后，grades列表的元素也跟着改变。

出现上述现象的原因是：scores和grades两个列表本质上是指向同一个列表的，即scores和grades都是同一列表的变量名称，两个名称都可以用来访和更改该列表。

26.实用的列表函数（第二部分）
join 方法
join 是一个字符串方法，将字符串列表作为参数，并返回一个由列表元素组成并由分隔符字符串分隔的字符串。

>>> new_str = "\n".join(["fore", "aft", "starboard", "port"])
>>> print(new_str)
fore
aft
starboard
port

在此示例中，我们使用字符串 “\n” 作为分隔符，以便每个元素之间都有一个换行符。我们还可以在 .join 中使用其他字符串作为分隔符。以下代码使用的是连字符。

>>> name = "-".join(["García", "O'Kelly"])
>>> print(name)
García-O'Kelly

请务必注意，用英文逗号 (,) 将要连接的列表中的每项分隔开来。忘记分隔的话，不会触发错误，但是会产生意外的结果。
注：join方法只可连接字符串类型，如果列表中有其他类型的话则报错！！！

append 方法
实用方法 append 会将元素添加到列表末尾。

>>> letters = ['a', 'b', 'c', 'd']
>>> letters.append('z')
>>> print(letters)
['a', 'b', 'c', 'd', 'z']

27.元组
元组是另一个实用容器。它是一种不可变有序元素数据类型。通常用来存储相关的信息。请看看下面这个关于纬度和经度的示例：

location = (13.4125, 103.866667)
print(“Latitude:”, location[0])
print(“Longitude:”, location[1])
元组和列表相似，它们都存储一个有序的对象集合，并且可以通过索引访问这些对象。但是与列表不同的是，元组不可变，你无法向元组中添加项目或从中删除项目，或者直接对元组排序。

元组还可以用来以紧凑的方式为多个变量赋值。

dimensions = 52, 40, 100
length, width, height = dimensions
print(“The dimensions are {} x {} x {}”.format(length, width, height))
在定义元组时，小括号是可选的，如果小括号并没有对解释代码有影响，程序员经常会忽略小括号。

在第二行，我们根据元组 dimensions 的内容为三个变量赋了值。这叫做元组解包。你可以通过元组解包将元组中的信息赋值给多个变量，而不用逐个访问这些信息，并创建多个赋值语句。

如果我们不需要直接使用 dimensions，可以将这两行代码简写为一行，一次性为三个变量赋值！

length, width, height = 52, 40, 100
print(“The dimensions are {} x {} x {}”.format(length, width, height))

28.集合
集合是一个包含唯一元素的可变无序集合数据类型。集合的一个用途是快速删除列表中的重复项。

>>> numbers = [1, 2, 6, 3, 1, 1, 6]
>>> unique_nums = set(numbers)
>>> print(unique_nums)
{
     1, 2, 3, 6}

集合和列表一样支持 in 运算符。和列表相似，你可以使用 add 方法将元素添加到集合中，并使用 pop 方法删除元素。但是，当你从集合中拿出元素时，会随机删除一个元素。注意和列表不同，集合是无序的，因此没有“最后一个元素”。

>>> fruit = {
     "apple", "banana", "orange", "grapefruit"}
>>> print("watermelon" in fruit)
False
>>> fruit.add("watermelon")
>>> print(fruit)
{
     'orange', 'grapefruit', 'watermelon', 'banana', 'apple'}
>>> print(fruit.pop())  # remove a random element 此处pop出的元素是随机的，所以下一行的答案每次运行可能不一样
orange
>>> print(fruit)
{
     'grapefruit', 'watermelon', 'banana', 'apple'}

你可以对集合执行的其他操作包括可以对数学集合执行的操作。可以对集合轻松地执行 union、intersection 和 difference 等方法，并且与其他容器相比，速度快了很多。

29.字典和恒等运算符
字典
字典是可变数据类型，其中存储的是唯一键到值的映射。下面是存储元素和相应原子序数的字典。

>>> elements = {
     "hydrogen": 1, "helium": 2, "carbon": 6}
>>> print(elements["helium"])	//输出新元素
2
>>> elements["lithium"] = 3	//插入新元素
>>> print(elements)	
{
     'hydrogen': 1, 'helium': 2, 'carbon': 6, 'lithium': 3}	//新元素被插入了
>>> print("carbon" in elements)	//使用in来判断要找到数据是否存在
True
>>> print(elements.get("dilithium"))
None

字典的键可以是任何不可变类型，例如整数或元组，而不仅仅是字符串。甚至每个键都不一定要是相同的类型！我们可以使用方括号并在括号里放入键，查询字典中的值或向字典中插入新值。

我们可以像检查某个值是否在列表或集合中一样，使用关键字 in 检查值是否在字典中。字典有一个也很有用的相关方法，叫做 get。get 会在字典中查询值，但是和方括号不同，如果没有找到键，get 会返回 None（或者你所选的默认值）。如果你预计查询有时候会失败，get 可能比普通的方括号查询更合适。

>>> print("carbon" in elements)
True
>>> print(elements.get("dilithium"))
None

Carbon 位于该字典中，因此输出 True。Dilithium 不在字典中，因此 get 返回 None，然后系统输出 None。如果你预计查询有时候会失败，get 可能比普通的方括号查询更合适，因为错误可能会使程序崩溃。

恒等运算符

你可以使用运算符 is 检查某个键是否返回了 None。或者使用 is not 检查是否没有返回 None。

>>> print(elements.get("dilithium"))
None
>>> n = elements.get("dilithium")
>>> print(n is None)
True
>>> print(n is not None)
False

30.返回默认值的 get
字典有一个也很有用的相关方法，叫做 get。get 会在字典中查询值，但是和方括号不同，如果没有找到键，get 会返回 None（或者你所选的默认值）。如果你预计查询有时候会失败，get 可能比普通的方括号查询更合适。

>>> elements.get('dilithium')
None
>>> elements['dilithium']
KeyError: 'dilithium'
>>> elements.get('kryptonite', 'There\'s no such element!')
"There's no such element!"

在上个示例中，我们指定了一个默认值（字符串 'There’s no such element!），当键没找到时，get 会返回该值。

31.复合数据结构
我们可以在其他容器中包含容器，以创建复合数据结构。例如，下面的字典将键映射到也是字典的值！

elements = {
     "hydrogen": {
     "number": 1,
                         "weight": 1.00794,
                         "symbol": "H"},
              "helium": {
     "number": 2,
                         "weight": 4.002602,
                         "symbol": "He"}}

我们可以如下所示地访问这个嵌套字典中的元素。

helium = elements["helium"]  # get the helium dictionary
hydrogen_weight = elements["hydrogen"]["weight"]  # get hydrogen's weight

32.If 语句
if 语句是一种条件语句，根据条件为 true 还是 false 运行或执行相关代码。下面是一个简单的示例：

if phone_balance < 5:
    phone_balance += 10
    bank_balance -= 10

我们来详细讲解下每部分。

if 语句以关键字 if 开始，然后是要检查的条件，在此例中是 phone_balance < 5，接着是英文冒号。条件用布尔表达式指定，结果为 True 或 False。
这行之后是一个条件为 true 时将执行的缩进代码块。在此例中，仅在 phone_balance 小于 5 时才执行使 phone_balance 递增和使 bank_balance 递减的行。如果不小于 5，这个 if 块中的代码将被跳过。

33.If、Elif、Else
除了 if 条件之外，if 语句经常还会使用另外两个可选条件。例如：

if season == 'spring':
    print('plant the garden!')
elif season == 'summer':
    print('water the garden!')
elif season == 'fall':
    print('harvest the garden!')
elif season == 'winter':
    print('stay indoors!')
else:
    print('unrecognized season')

①if：if 语句必须始终以 if 条件开始，其中包含第一个要检查的条件。如果该条件为 True，Python 将运行这个 if 块中的缩进代码，然后跳到 if 语句之后的剩余代码。
②elif：elif 条件用来检查其他条件（前提是 if 语句中之前的条件结果为 False）。可以从示例中看出，可以使用多个 elif 块处理不同的情形。
③else：最后是 else 条件，它必须位于 if 语句的末尾。该条件语句不需要条件。如果 if 语句中所有前面的语句结果都为 False 时，将运行 else 块中的代码。

34.缩进
一些其他语言使用花括号来表示代码块从哪开始，从哪结束。在 Python 中，我们使用缩进来封装代码块。例如，if 语句使用缩进告诉 Python 哪些代码位于不同条件语句里面，哪些代码位于外面。

在 Python 中，缩进通常是四个空格一组。请严格遵守该惯例，因为更改缩进会完全更改代码的含义。如果你是 Python 程序员团队的成员，则所有人都必须遵守相同的缩进惯例！

35.复杂的布尔表达式
If 语句有时候会使用更加复杂的条件布尔表达式。可能包括多个比较运算符、逻辑运算符，甚至包括算式。例如：

if 18.5 <= weight / height**2 < 25:
    print("BMI is considered 'normal'")

if is_raining and is_sunny:
    print("Is there a rainbow?")

if (not unsubscribed) and (location == "USA" or location == "CAN"):
    print("send email")

对于非常复杂的条件，你可能需要结合使用 and、or 和 not。使用括号可以使运算符组合更清晰。

无论是简单还是复杂的条件，if 语句中的条件都必须是结果为 True 或 False 的布尔表达式，该值决定了 if 语句中的缩进代码块是否执行。

36.正反面示例
在为 if 语句编写布尔表达式时，需要注意以下几个事项。

①请勿使用 True 或 False 作为条件

Bad example

if True:
    print("This indented code will always get run.")

虽然“True”是一个有效的布尔表达式，但不是有用的条件，因为它始终为 True，因此缩进代码将始终运行。同样，if False 也不应使用，该 if 语句之后的语句将从不运行。

Another bad example

if is_cold or not is_cold:
    print("This indented code will always get run.")

同样，使用你知道将始终结果为 True 的条件（例如上述示例）也是毫无用途的。布尔表达式只能为 True 或 False，因此 is_cold 或 not is_cold 将始终为 True，缩进代码将始终运行。

②在使用逻辑运算符编写表达式时，要谨慎
逻辑运算符 and、or 和 not 具有特定的含义，与字面英文意思不太一样。确保布尔表达式的结果和你预期的一样。

Bad example

if weather == "snow" or "rain":
    print("Wear boots!")

这段代码在 Python 中是有效的，但不是布尔表达式，虽然读起来像。原因是 or 运算符右侧的表达式 “rain” 不是布尔表达式，它是一个字符串。稍后我们将讨论当你使用非布尔型对象替换布尔表达式时，会发生什么。

③请勿使用 == True 或 == False 比较布尔变量
这种比较没必要，因为布尔变量本身是布尔表达式。

Bad example

if is_cold == True:
    print("The weather is cold!")

这是一个有效的条件，但是我们可以使用变量本身作为条件，使代码更容易读懂，如下所示。

Good example

if is_cold:
    print("The weather is cold!")

如果你想检查布尔表达式是否为 False，可以使用 not 运算符。

37.真假值测试
如果我们在if 语句中使用非布尔对象代替布尔表达式，Python 将检查其真假值，判断是否运行缩进代码。默认情况下，Python 中对象的真假值被视为 True，除非在文档中被指定为 False。

以下是在 Python 中被视为 False 的大多数内置对象：
定义为 false 的常量：None 和 False
任何数字类型的零：0、0.0、0j、Decimal(0)、Fraction(0, 1)
空序列和空集合：””、()、[]、{}、set()、range(0)
示例：

errors = 3
if errors:
    print("You have {} errors to fix!".format(errors))
else:
    print("No errors to fix!")

在上述代码中，errors 的真假值为 True，因为它是非零数字，因此输出了错误消息。这是一个编写 if 语句的简练方式。

38.altitude < 1000 and speed > 100
altitude < 1000 为 False，因此我们甚至不需要检查第二个条件，整个表达式为 False。

(propulsion == “Jet” or propulsion == “Turboprop”) and speed < 300 and altitude > 20000
(propulsion == “Jet” 为 False，并且 propulsion == “Turboprop” )为 False，因此括号内的整个表达式为 False。它使用 and 与另一个表达式相结合，因此我们甚至不需要检查这些表达式，整个表达式肯定为 False，因为第一部分为 False。

not (speed > 400 and propulsion == “Propeller”)
要判断这道练习，我们需要首先查看括号里的内容，然后向其应用 not。speed > 400 为 False，因为我们使用 and，这使得括号里的整个表达式为 False。应用 not 使该表达式变成 True。

(altitude > 500 and speed > 100) or not propulsion == “Propeller”
我们先看看括号里的表达式。altitude > 500 为 True，并且 speed 大于 100，因此括号里的表达式为 True。无论其他表达式的值是什么，因为它们是用 or 连接起来的，整个表达式将为 True。

这里我们还要介绍一个布尔表达式求值所用的技术——短路求值

如果a = False，对于a and b求值时，将直接得到结果为False，不会再对b的值做考核，不论它是True或False。

如果a = True，对于a or b求值时，将直接得到结果为True，不会再对b的值做考核，不论它是True或False。

你能思考一下这是为什么吗？

练习解决方案：使用对象的真假值
我们首先设置 prize = None，如果得分能够获得奖品，则更新 prize。然后如果有奖品的话，使用 prize 的真假值输出消息，如果没有奖品，则输出另一条消息。

prize = None
if points <= 50:
prize = “a wooden rabbit”
elif 151 <= points <= 180:
prize = “a wafer-thin mint”
elif points >= 181:
prize = “a penguin”

if prize:
result = "Congratulations! You won " + prize + “!”
else:
result = “Oh dear, no prize this time.”

print(result)

39.For 循环
Python 有两种类型的循环：for 循环和 while 循环。for 循环用来遍历可迭代对象。

可迭代对象是每次可以返回其中一个元素的对象，包括字符串、列表和元组等序列类型，以及字典和文件等非序列类型。你还可以使用迭代器和生成器定义可迭代对象，我们将在这门课程的稍后阶段详细了解迭代器和生成器。

我们来了解下 for 循环的各个组成部分。请看下面的示例：

# iterable of cities
cities = ['new york city', 'mountain view', 'chicago', 'los angeles']

# for loop that iterates over the cities list
for city in cities:
    print(city.title())

For 循环的组成部分
循环的第一行以关键字 for 开始，表示这是一个 for 循环
然后是 iteration_variable in iterable，表示正在被遍历的是可迭代的对象，并且用迭代变量表示当前正在被处理的可迭代对象的元素。在此示例中，迭代变量 city 在第一次迭代时将是“new york city”，在第二次迭代时将是“mountain view。
for 循环头部始终以英文冒号 : 结束。
for 循环头部之后的是在此 for 循环的每次迭代时运行的缩进代码块。在此块中，我们可以使用迭代变量访问当前正在被处理的元素的值。
你可以随意命名迭代变量。常见模式是为迭代变量和可迭代对象指定相同的名称，但是分别使用单复数形式（例如 ‘city’ 和 'cities）

创建和修改列表
除了从列表中提取信息之外，你还可以使用 for 循环创建和修改列表。你可以在 for 循环的每次迭代时向新列表中添加元素，创建一个列表。如下所示。

# Creating a new list
cities = ['new york city', 'mountain view', 'chicago', 'los angeles']
capitalized_cities = []

for city in cities:
    capitalized_cities.append(city.title())

修改列表稍微复杂些，需要使用新的函数：range()。

range() 是一个内置函数，用于创建不可变的数字序列。它有三个参数，必须都为整数。

range(start=0, stop, step=1)
Start是该序列的第一个数字，stop比该序列的最后一个数字大 1，step是该序列中每个数字之间的差。如果未指定的话，start默认为 0，step 默认为 1（即上述 =0和 =1）。

①如果你在 range() 的括号里指定一个参数，它将用作 ‘stop’ 的值，另外两个参数使用默认值。
E.g. list(range(4)) 返回 [0, 1, 2, 3]
②如果你在 range() 的括号里指定两个参数，它们将用作 ‘start’ 和 ‘stop’ 的值，‘step’ 将使用默认值。 E.g. list(range(2, 6)) 返回 [2, 3, 4, 5]
③或者你可以为三个参数 ‘start、stop’ 和 ‘step’ 均指定一个值。 E.g. list(range(1, 10, 2)) 返回 [1, 3, 5, 7, 9]
注意，在这些示例中，我们将 range 封装在列表中。因为 range 本身的输出是一个 range 对象。我们可以通过将其转换为列表或在 for 循环中遍历它，查看 range 对象中的值集合。

我们可以使用 range 函数为 cities 列表中的每个值生成索引。这样我们便可以使用 cities[index] 访问列表中的元素，以便直接修改 cities 列表中的值。

cities = ['new york city', 'mountain view', 'chicago', 'los angeles']

for index in range(len(cities)):
    cities[index] = cities[index].title()

虽然修改列表是 range 函数的一个用途，但是并非只有这一个用途。你将经常使用 range 和 for 循环重复某个操作一定的次数。

for i in range(3):
    print("Hello!")

40.While 循环
For 循环是一种“有限迭代”，意味着循环主体将运行预定义的次数。这与“无限迭代”循环不同，无限迭代循环是指循环重复未知次数，并在满足某个条件时结束，while 循环正是这种情况。下面是一个 while 循环的示例。

card_deck = [4, 11, 8, 5, 13, 2, 8, 10]
hand = []

# adds the last element of the card_deck list to the hand list
# until the values in hand add up to 17 or more
while sum(hand)  <= 17:
    hand.append(card_deck.pop())
print(sum(hand))

这个示例包含两个函数。sum 返回列表中的元素之和，pop 是一个列表方法，它会从列表中删除最后一个元素并返回该元素。

While 循环的组成部分
第一行以关键字 while 开始，表示这是一个 while 循环。
然后是要检查的条件。在此示例中是 sum(hand) <= 17。
while 循环头部始终以冒号 : 结束。
该头部之后的缩进部分是 while 循环的主体。如果 while 循环的条件为 true，该循环的主体将被执行。每次运行循环主体时，条件将被重新评估。这个检查条件然后运行循环的流程将重复，直到该表达式变成 false。
循环的缩进主体应该至少修改测试表达式中的一个变量。如果测试表达式的值始终不变，就会变成无限循环！

41.Break、Continue
有时候我们需要更精准地控制何时循环应该结束，或者跳过某个迭代。在这些情况下，我们使用关键字 break 和 continue，这两个关键字可以用于 for 和 while 循环。
break 使循环终止
continue 跳过循环的一次迭代

42.Zip 和 Enumerate
zip 和 enumerate 是实用的内置函数，可以在处理循环时用到。

Zip
zip 返回一个将多个可迭代对象组合成一个元组序列的迭代器。每个元组都包含所有可迭代对象中该位置的元素。例如，

list(zip([‘a’, ‘b’, ‘c’], [1, 2, 3])) 将输出 [(‘a’, 1), (‘b’, 2), (‘c’, 3)].

正如 range() 一样，我们需要将其转换为列表或使用循环进行遍历以查看其中的元素。

你可以如下所示地用 for 循环拆分每个元组。

letters = [‘a’, ‘b’, ‘c’]
nums = [1, 2, 3]

for letter, num in zip(letters, nums):
print("{}: {}".format(letter, num))
除了可以将两个列表组合到一起之外，还可以使用星号拆分列表。

some_list = [(‘a’, 1), (‘b’, 2), (‘c’, 3)]
letters, nums = zip(*some_list)
这样可以创建正如之前看到的相同 letters 和 nums 列表。

Enumerate
enumerate 是一个会返回元组迭代器的内置函数，这些元组包含列表的索引和值。当你需要在循环中获取可迭代对象的每个元素及其索引时，将经常用到该函数。

letters = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]
for i, letter in enumerate(letters):
print(i, letter)
这段代码将输出：

0 a
1 b
2 c
3 d
4 e

第四章：函数
1.定义函数
函数定义示例：

def cylinder_volume(height, radius):
    pi = 3.14159
    return height * pi * radius ** 2

定义 cylinder_volume 函数后，我们可以如下所示地调用该函数。
cylinder_volume(10, 3)
函数定义包含几个重要部分。

函数头部
我们从函数头部开始，即函数定义的第一行。

①函数头部始终以关键字 def 开始，表示这是函数定义。
②然后是函数名称（在此例中是 cylinder_volume，因为函数名是要一个单词，所以需要用_进行连接），遵循的是和变量一样的命名规范。你可以在本页面下方回顾下命名规范。
③名称之后是括号，其中可能包括用英文逗号分隔的参数（在此例中是 height 和 radius）。形参（或实参）是当函数被调用时作为输入传入的值，用在函数主体中。如果函数没有参数，这些括号留空。
④头部始终以英文冒号 : 结束。
函数主体
函数的剩余部分包含在主题中，也就是函数完成操作的部分。

①函数主体是在头部行之后缩进的代码。在此例中是定义 π 和返回体积的两行代码。
②在此主体中，我们可以引用参数并定义新的变量，这些变量只能在这些缩进代码行内使用。
③主体将经常包括 return 语句，用于当函数被调用时返回输出值。return 语句包括关键字 return，然后是经过评估以获得函数输出值的表达式。如果没有 return 语句，函数直接返回 None（例如内置 print() 函数）。

函数的命名规范
函数名称遵守和变量一样的命名规范。

①仅在函数名称中使用普通字母、数字和下划线。不能有空格，需要以字母或下划线开头。
②不能使用在 Python 中具有重要作用的保留字或内置标识符，我们将在这门课程中学习这方面的知识。要了解 python 保留字列表，请参阅此处。
③尝试使用可以帮助读者了解函数作用的描述性名称。

默认参数
我们可以向函数中添加默认参数，以便为在函数调用中未指定的参数提供默认值。

def cylinder_volume(height, radius=5):
    pi = 3.14159
    return height * pi * radius ** 2

在上述示例中，如果在函数调用中忽略了 radius，则将该参数设为 5。如果我们调用 cylinder_volume(10)，该函数将使用 10 作为高度，使用 5 作为半径。但是，如果调用 cylinder_volume(10, 7)，7 将覆盖默认的值 5。

此外注意，我们按照位置向参数传递值。可以通过两种方式传递值：按照位置和按照名称。下面两个函数的效果是一样的。

cylinder_volume(10, 7)  # pass in arguments by position
cylinder_volume(height=10, radius=7)  # pass in arguments by name

2.变量作用域是指可以在程序的哪个部分引用或使用某个变量。

在函数中使用变量时，务必要考虑作用域。如果变量是在函数内创建的，则只能在该函数内使用该变量。你无法从该函数外面访问该变量。

# This will result in an error
def some_function():
    word = "hello"

print(word)

这意味着你可以为在不同函数内使用的不同变量使用相同的名称。

# This works fine
def some_function():
    word = "hello"

def another_function():
    word = "goodbye"

像这样在函数之外定义的变量依然可以在函数内访问。

# This works fine
word = "hello"

def some_function():
    print(word)

print(word)

注意，我们可以在此函数内以及函数外输出 word。作用域对理解信息在用 Python 和任何编程语言编写的程序中的传递方式来说很关键。

关于变量作用域的更多信息
在编程时，你经常会发现相似的想法不断出现。你将使用变量进行计数、迭代和累积要返回的值。为了编写容易读懂的代码，你会发现你需要对相似的想法使用相似的名称。一旦你将多段代码放到一起（例如，一个脚本中有多个函数或函数调用），你可能需要为两个不同的概念使用相同的名称。

幸运的是，你不需要不断想出新的名称。可以为对象重复使用相同的名称，只要它们位于不同的作用域即可。

良好实践：建议将变量定义在所需的最小作用域内。虽然函数_可以_引用在更大的作用域内定义的变量，但是通常不建议这么做，因为如果程序有很多变量，你可能不知道你定义了什么变量。

3.在函数内，我们可以成功地输出外部变量的值。因为我们只是访问该变量的值。当我们尝试将此变量的值更改或重新赋值为另一个值时，我们将遇到错误。Python 不允许函数修改不在函数作用域内的变量。

但是上面的原则仅适用于整数和字符串，列表、字典、集合、类中可以在子程序（子函数）中通过修改局部变量达到修改全局变量的目的。

4.文档
文档使代码更容易理解和使用。函数尤其容易理解，因为它们通常使用文档字符串，简称 docstrings。文档字符串是一种注释，用于解释函数的作用以及使用方式。下面是一个包含文档字符串的人口密度函数。

def population_density(population, land_area):
    """Calculate the population density of an area. """
    return population / land_area

文档字符串用三个引号引起来，第一行简要解释了函数的作用。如果你觉得信息已经足够了，可以在文档字符串中只提供这么多的信息；一行文档字符串完全可接受，如上述示例所示。

def population_density(population, land_area):
    """Calculate the population density of an area.

    INPUT:
    population: int. The population of that area
    land_area: int or float. This function is unit-agnostic, if you pass in values in terms
    of square km or square miles the function will return a density in those units.

    OUTPUT: 
    population_density: population / land_area. The population density of a particular area.
    """
    return population / land_area

如果你觉得需要更长的句子来解释函数，可以在一行摘要后面添加更多信息。在上述示例中，可以看出我们对函数的参数进行了解释，描述了每个参数的作用和类型。我们经常还会对函数输出进行说明。

文档字符串的每个部分都是可选的。但是，提供文档字符串是一个良好的编程习惯。你可以在此处详细了解文档字符串惯例。

5.Lambda 表达式
你可以使用 Lambda 表达式创建匿名函数，即没有名称的函数。lambda 表达式非常适合快速创建在代码中以后不会用到的函数。尤其对高阶函数或将其他函数作为参数的函数来说，非常实用。

我们可以使用 lambda 表达式将以下函数

def multiply(x, y):
    return x * y

简写为：

double = lambda x, y: x * y

Lambda 函数的组成部分
①关键字 lambda 表示这是一个 lambda 表达式。
②lambda 之后是该匿名函数的一个或多个参数（用英文逗号分隔），然后是一个英文冒号 :。和函数相似，lambda 表达式中的参数名称是随意的。
③最后一部分是被评估并在该函数中返回的表达式，和你可能会在函数中看到的 return 语句很像。
鉴于这种结构，lambda 表达式不太适合复杂的函数，但是非常适合简短的函数。

第五章：脚本编写！！！（我的最爱！！）

1.在脚本中接受原始输入

我们可以使用内置函数 input 获取用户的原始输入，该函数接受一个可选字符串参数，用于指定在要求用户输入时向用户显示的消息。

name = input("Enter your name: ")
print("Hello there, {}!".format(name.title()))

这段代码提示用户输入姓名，然后在问候语中使用该输入。input 函数获取用户输入的任何内容并将其存储为字符串。如果你想将输入解析为字符串之外的其他类型，例如整数（如以下示例所示），需要用新的类型封装结果并从字符串转换为该类型。

num = int(input("Enter an integer"))
print("hello" * num)

我们还可以使用内置函数 eval 将用户输入解析为 Python 表达式。该函数会将字符串评估为一行 Python 代码。

result = eval(input("Enter an expression: "))
print(result)

如果用户输入 2 * 3，输出为 6。

2.

3.读写文件

以下是如何在 Python 中读写文件的方式。

读取文件

f = open('my_path/my_file.txt', 'r')
file_data = f.read()
f.close()

1.首先使用内置函数 open 打开文件。需要文件路径字符串。open 函数会返回文件对象，它是一个 Python 对象，Python 通过该对象与文件本身交互。在此示例中，我们将此对象赋值给变量 f。
2.你可以在 open 函数中指定可选参数。参数之一是打开文件时采用的模式。在此示例中，我们使用 r，即只读模式。这实际上是模式参数的默认值。
3.使用 read 访问文件对象的内容。该 read 方法会接受文件中包含的文本并放入字符串中。在此示例中，我们将该方法返回的字符串赋值给变量 file_data。
4.当我们处理完文件后，使用 close 方法释放该文件占用的系统资源。

写入文件

f = open('my_path/my_file.txt', 'w')
f.write("Hello there!")
f.close()

1.以写入 (‘w’) 模式打开文件。如果文件不存在，Python 将为你创建一个文件。如果以写入模式打开现有文件，该文件中之前包含的所有内容将被删除。如果你打算向现有文件添加内容，但是不删除其中的内容，可以使用附加 (‘a’) 模式，而不是写入模式。
2.使用 write 方法向文件中添加文本。
3.操作完毕后，关闭文件。

With
Python 提供了一个特殊的语法，该语法会在你使用完文件后自动关闭该文件。

with open('my_path/my_file.txt', 'r') as f:
    file_data = f.read()

该 with 关键字使你能够打开文件，对文件执行操作，并在缩进代码（在此示例中是读取文件）执行之后自动关闭文件。现在，我们不需要调用 f.close() 了！你只能在此缩进块中访问文件对象 f。

4.导入本地脚本

我们实际上可以导入其他脚本中的 Python，如果你处理的是大型项目，需要将代码整理成多个文件并重复利用这些文件中的代码，则导入脚本很有用。如果你要导入的 Python 脚本与当前脚本位于同一个目录下，只需输入 import，然后是文件名，无需扩展名 .py。

import useful_functions

Import 语句写在 Python 脚本的顶部，每个导入语句各占一行。该 import 语句会创建一个模块对象，叫做 useful_functions。模块是包含定义和语句的 Python 文件。要访问导入模块中的对象，需要使用点记法。

import useful_functions
useful_functions.add_five([1, 2, 3, 4])

我们可以为导入模块添加别名，以使用不同的名称引用它。

import useful_functions as uf
uf.add_five([1, 2, 3, 4])

使用 if main 块
为了避免运行从其他脚本中作为模块导入的脚本中的可执行语句，将这些行包含在 if __name__ == "__main__" 块中。或者，将它们包含在函数 main() 中并在 if main 块中调用该函数。

每当我们运行此类脚本时，Python 实际上会为所有模块设置一个特殊的内置变量 __name__。当我们运行脚本时，Python 会将此模块识别为主程序，并将此模块的 __name__ 变量设为字符串 "__main__"。对于该脚本中导入的任何模块，这个内置 __name__ 变量会设为该模块的名称。因此，条件 if __name__ == "__main__"会检查该模块是否为主程序。

5.我们的推荐模块

Python 标准库包含大量模块！为了帮助你熟悉那些实用的模块，我们在下面筛选了一些我们推荐的 Python 标准库模块并解释为何我们喜欢使用它们！

csv：对于读取 csv 文件来说非常便利
collections：常见数据类型的实用扩展，包括 OrderedDict、defaultdict 和 namedtuple
random：生成假随机数字，随机打乱序列并选择随机项
string：关于字符串的更多函数。此模块还包括实用的字母集合，例如 string.digits（包含所有字符都是有效数字的字符串）。
re：通过正则表达式在字符串中进行模式匹配
math：一些标准数学函数
os：与操作系统交互
os.path：os 的子模块，用于操纵路径名称
sys：直接使用 Python 解释器
json：适用于读写 json 文件（面向网络开发）
希望你能用上这些模块！

6.导入模块技巧

还有一些在不同情形下很有用的其他形式的 import 语句。

①要从模块中导入单个函数或类：
from module_name import object_name
②要从模块中导入多个单个对象：
from module_name import first_object, second_object
③要重命名模块：
import module_name as new_name
④要从模块中导入对象并重命名：
from module_name import object_name as new_name
⑤要从模块中单个地导入所有对象（请勿这么做）：
from module_name import *
⑥如果你真的想使用模块中的所有对象，请使用标准导入 module_name 语句并使用点记法访问每个对象。
import module_name

7.模块、软件包和名称

为了更好地管理代码，Standard 标准库中的模块被拆分成了子模块并包含在软件包中。软件包是一个包含子模块的模块。子模块使用普通的点记法指定。

子模块的指定方式是软件包名称、点，然后是子模块名称。你可以如下所示地导入子模块。

import package_name.submodule_name

Python中的小知识点：
1.真假是：True、False、None。注意首字母一定要大写！！！！！
2.列表和字符串都支持索引、切片、len()函数
3.list和字符串的区别：①字符串由一系列的字母组成，列表元素可以是任何类型的对象；②列表可以修改而字符串不能；
4.除列表之外的每种类型都可以用作字典的键。因为可以通过添加和删除元素更改列表，因此列表是可变的。
5.我们可以如下所示地定义字典：

>>> population = {
     'Shanghai': 17.8,
              'Istanbul': 13.3,
              'Karachi': 13.0,
              'Mumbai': 12.5}

我选择将每个键值对单独放一行，使这个字典定义更容易读懂，但是是否使用换行符以及在何处使用只是一种样式选择。下面这段代码也可行：

>>> population = {
     'Shanghai': 17.8, 'Istanbul': 13.3, 'Karachi': 13.0, 'Mumbai': 12.5}

6.print可以输出字符串以及整型等类型。但是在print中使用+进行连接时，要是想要在字符串后面接上整型等的话，必须用str强行转化成字符串类型，才能输出，否则报错。

Python的特殊之处：
1.python定义变量为什么不要声明类型？？
python是解释型语言，python的变量不需要声明，但是需要初始化，Python会自动检测类型。python解释器会为每个出现的对象分配内存，哪怕他们的值完全相等（注意是相等不是相同），其中变量其实通过一个标记调用内存中的值，而变量名就是这个标记的名称，python可以通过直接赋值初始化让一个变量拥有内存和值(电脑可以直接理解)，你可以这么理解，对比于编译型语言，解释器语言的优势在于，解释器帮你做了很多事，比如说动态分配内存–在python中可以直接给a赋值整形，浮点型，字符型等等，依次的赋给他。