python学习笔记

day01

数学操作符

数学操作符，优先级从高到低
数学操作符的操作顺序（也称为“优先级”）与数学中类似。*操作符首先求
值，接下来是、/、//和%操作符，从左到右。+和-操作符最后求值，也是从左到右。

比较操作符

“比较操作符”比较两个值，求值为一个布尔值

操作符的区别
操作符（等于）有两个等号，操作符（赋值）只有一个等号，
这两个操作符很容易混淆。只要记住：
操作符（等于）问两个值是否彼此相同。
操作符（赋值）将右边的值放到左边的变量中。
为了区别谁是谁，请注意==操作符（等于）包含两个字符，就像!=操作符（不
等于）包含两个字符一样。

数据类型

变量名

给变量命名需遵守以下 3 条规则：
1．只能是一个词。
2．只能包含字母、数字和下划线。
3．不能以数字开头。
下方是一些合法变量名的例子：

变量名是区分大小写的

函数

print()函数

print()函数：将括号内的字符串显示在屏幕上。

input()函数

input()函数：等待用户在键盘上输入一些文本，并按下回车键。

len()函数

len()函数：向 len()函数传递一个字符串（或包含字符串的变量），得到该函数求值
为一个整型值，即字符串中字符的个数。

str()、int()和 float()函数

类型转换：str()、int()和 float()函数将分别求值为传入值的字符串、整数和浮点数形式

day02

布尔操作符

3 个布尔操作符（and、or 和 not）用于比较布尔值。像比较操作符一样，它们
将这些表达式求值为一个布尔值。

二元布尔操作符

and 和 or 操作符

and 和 or 操作符总是接受两个布尔值（或表达式），所以它们被认为是“二元”
操作符。如果两个布尔值都为 True，and 操作符就将表达式求值为 True，否则求值
为 False。以下的“真值表”显示了布尔操作符的所有可能结果。

not 操作符

和 and 和 or 不同，not 操作符只作用于一个布尔值（或表达式）。not 操作符求
值为相反的布尔值。

混合布尔和比较操作符

计算机将先求值左边的表达式，然后再求值右边的表达式。知道两个布尔值后，
它又将整个表达式再求值为一个布尔值。和算术操作符一样，布尔操作符也有操作顺序。在所有算术和比较操作符求值后，Python 先求值 not 操作符，然后是 and 操作符，然后是 or 操作符。

控制流的元素

控制流语句的开始部分通常是“条件”，接下来是一个代码块，称为“子句”。

代码块

一些代码行可以作为一组，放在“代码块”中。可以根据代码行的缩进，知道
代码块的开始和结束。代码块有 3 条规则。
1．缩进增加时，代码块开始。
2．代码块可以包含其他代码块。
3．缩进减少为零，或减少为外面包围代码块的缩进，代码块就结束了。看一些有缩进的代码，更容易理解代码块。

控制流语句

if语句

最常见的控制流语句是 if 语句。if 语句的子句（也就是紧跟 if 语句的语句块），
将在语句的条件为 True 时执行。如果条件为 False，子句将跳过。
在英文中，if 语句念起来可能是：“如果条件为真，执行子句中的代码。”在 Python
中，if 语句包含以下部分：
1.if 关键字；
2.条件（即求值为 True 或 False 的表达式）；
3.冒号；
4.在下一行开始，缩进的代码块（称为 if 子句）。

else 语句

if 子句后面有时候也可以跟着 else 语句。只有 if 语句的条件为 False 时，else
子句才会执行。在英语中，else 语句读起来可能是：“如果条件为真，执行这段
代码。否则，执行那段代码”。else 语句不包含条件，在代码中，else 语句中包
含下面部分：
1.else 关键字；
2.冒号；
3.在下一行开始，缩进的代码块（称为 else 子句）。

elif 语句

虽然只有 if 或 else 子句会被执行，也存在“许多”可能的子句中有一个被执行。elif 语句是“否则如果”，总是跟在 if 或另一条 elif 语句后面。它提供了另一个条件，仅在前面的条件为 False 时才检查该条件。在代码中，elif 语句
总是包含以下部分：
1.elif 关键字；
2.条件（即求值为 True 或 False 的表达式）；
3.冒号；
4.在下一行开始，缩进的代码块（称为 elif 子句）。

while 循环语句

利用 while 语句，可以让一个代码块一遍又一遍的执行。只要 while 语句的条
件为 True，while 子句中的代码就会执行。在代码中，while 语句总是包含下面几
部分：
1.关键字；
2.条件（求值为 True 或 False 的表达式）；
3.冒号；
4.从新行开始，缩进的代码块（称为 while 子句）。
while 语句看起来和 if 语句类似。不同之处是它们的行为。if 子句
结束时，程序继续执行 if 语句之后的语句。但在 while 子句结束时，程序执行跳回
到 while 语句开始处。while 子句常被称为“while 循环”，或就是“循环”。在 while 循环中，条件总是在每次“迭代”开始时检查（也就是每次循环执行时）。如果条件为 True，子句就会执行，然后，再次检查条件。当条件第一次为 False时，while 子句就跳过。

break 语句

如果执行遇到 break 语句，就会马上退出 while 循环子句。在代码中，break 语句仅包含 break 关键字。

continue 语句

像 break 语句一样，continue 语句用于循环内部。如果程序执行遇到 continue
语句，就会马上跳回到循环开始处，重新对循环条件求值（这也是执行到达循环末
尾时发生的事情）。

for 循环

在条件为 True 时，while 循环就会继续循环（这是它的名称的由来）。让一个代码块执行固定次数，可以通过 for 循环语句和 range()函数来实现。

“类真”和“类假”的值

其他数据类型中的某些值，条件认为它们等价于 True 和 False。在用于条件
时，0、0.0 和’ '（空字符串）被认为是 False，其他值被认为是 True。

not name相当于 not name != ’ ’
for 语句： for i in range(5): ，总是包含以下部分：
1.for 关键字；
2.一个变量名；
3.in 关键字；
4.调用 range()方法，最多传入 3 个参数；
5.冒号；
6.从下一行开始，缩退的代码块（称为 for 子句）。

函数

range()函数

day03

range()的开始、停止和步长参数

range()函数可以用多个参数调用，参数之间用逗号分开，这能够改变传递给 range()的整数，实现各种整数序列，包括从 0 以外的值开始。
for i in range(12, 16):
print(i)
第一个参数是 for 循环变量开始的值，第二个参数是上限，但不包含它，也就
是循环停止的数字。
range()函数也可以有第三个参数。前两个参数分别是起始值和终止值，第三个
参数是“步长”。步长是每次迭代后循环变量增加的值。

在为 for 循环生成序列数据方面，range()函数很灵活。举例来说，甚至可以用
负数作为步长参数，让循环计数逐渐减少，而不是增加。

导入模块

Python 程序可以调用一组基本的函数，这称为“内建函数”，包括你见到过的
print()、input()和 len()函数。Python 也包括一组模块，称为“标准库”。每个模块都
是一个 Python 程序，包含一组相关的函数，可以嵌入你的程序之中。
在开始使用一个模块中的函数之前，必须用 import 语句导入该模块。在代码中，
import 语句包含以下部分：
1.import 关键字；
2.模块的名称；
3.可选的更多模块名称，之间用逗号隔开。

from import 语句

import 语句的另一种形式包括 from 关键字，之后是模块名称，import 关键字和
一个星号，例如 from random import *。
使用这种形式的 import 语句，调用 random模块中的函数时不需要 random.前缀。

用 sys.exit()提前结束程序

当程序执行到指令的底部时，总是会终止。但是，通过调用 sys.exit()函数，可以让程序终止或退出。因为这个函数在 sys 模块中，所以必须先导入 sys，才能使用它。

函数

def 语句定义了一个名为 hello()的函数，def 语句之后的代码块是函数体。这段代码在函数调用时执行，而不是在函数第一次定义时执行。函数之后的 hello()语句行是函数调用。在代码中，函数调用就是函数名后跟上括号，也许在括号之间有一些参数。如果程序执行遇到这些调用，就会跳到函数
的第一行，开始执行那里的代码。如果执行到达函数的末尾，就回到调用函数的那行，继续像以前一样向下执行代码。

注意：保存在变元中的值，在函数返回后就丢失了。

返回值和 return 语句

用 def 语句创建函数时，可以用 return 语句指定应该返回什么值。return 语句包
含以下部分：
1.return 关键字；
2.函数应该返回的值或表达式。
如果在 return 语句中使用了表达式，返回值就是该表达式求值的结果。

None 值

在 Python 中有一个值称为 None，它表示没有值。None 是 NoneType 数据类型
的唯一值（其他编程语言可能称这个值为 null、nil 或 undefined）。就像布尔值 True
和 False 一样，None 必须大写首字母 N。
对于所有没有 return 语句的函数定义，Python 都会在末尾加上 return
None。这类似于 while 或 for 循环隐式地以 continue 语句结尾。而且，如果使用不
带值的 return 语句（也就是只有 return 关键字本身），那么就返回 None。

关键字参数和 print()

大多数参数是由它们在函数调用中的位置来识别的。但是，“关键字参数”是由函数调用时加在它们前面的关键字来识别的。关键字参数通常用于可选变元。例如，print()函数有可选的变元 end 和 sep，分别指定在参数末尾打印什么，以及在参数之间打印什么来隔开它们。print()函数自动在传入的字符串末尾添加了换行符。但是，可以设置 end 关键字参数，将它变成另一个字符串。，如果向 print()传入多个字符串值，该函数就会自动用一个空格分隔它们，因此，可以传入 sep 关键字参数，替换掉默认的分隔字符串。

局部和全局作用域

在被调用函数内赋值的变元和变量，处于该函数的“局部作用域”。在所有函数之外赋值的变量，属于“全局作用域”。处于局部作用域的变量，被称为“局部变量”。处于全局作用域的变量，被称为“全局变量”。一个变量必是其中一种，不能既是局部的又是全局的。
可以将“作用域”看成是变量的容器。当作用域被销毁时，所有保存在该作用域内的变量的值就被丢弃了。只有一个全局作用域，它是在程序开始时创建的。如果程序终止，全局作用域就被销毁，它的所有变量就被丢弃了。否则，下次你运行程序的时候，这些变量就会记住它们上次运行时的值。
一个函数被调用时，就创建了一个局部作用域。在这个函数内赋值的所有变量，存在于该局部作用域内。该函数返回时，这个局部作用域就被销毁了，这些变量就丢失了。下次调用这个函数，局部变量不会记得该函数上次被调用时它们保存的值。
作用域很重要，理由如下：
1.全局作用域中的代码不能使用任何局部变量；
2.但是，局部作用域可以访问全局变量；
3.一个函数的局部作用域中的代码，不能使用其他局部作用域中的变量。
4.如果在不同的作用域中，你可以用相同的名字命名不同的变量。也就是说，可以有一个名为 spam 的局部变量，和一个名为 spam 的全局变量。

global 语句

如果需要在一个函数内修改全局变量，就使用 global 语句。
区分一个变量是处于局部作用域还是全局作用域，有 4 条法则：
1．如果变量在全局作用域中使用（即在所有函数之外），它就总是全局变量。
2．如果在一个函数中，有针对该变量的 global 语句，它就是全局变量。
3．否则，如果该变量用于函数中的赋值语句，它就是局部变量。
4．但是，如果该变量没有用在赋值语句中，它就是全局变量。

异常处理

错误可以由 try 和 except 语句来处理。那些可能出错的语句被放在 try 子句中。如果错误发生，程序执行就转到接下来的 except 子句开始处。如果在 try 子句中的代码导致一个错误，程序执行就立即转到 except 子句的代码。在运行那些代码之后，执行照常继续。请注意，在函数调用中的 try 语句块中，发生的所有错误都会被捕捉。

day04

函数是将代码逻辑分组的主要方式。因为函数中的变量存在于它们自己的局部作用域内，所以一个函数中的代码不能直接影响其他函数中变量的值。这限制了哪些代码才能改变变量的值，对于调试代码是很有帮助的。
函数是很好的工具，帮助你组织代码。你可以认为他们是黑盒。它们以参数的Python 编程快速上手——让繁琐工作自动化形式接收输入，以返回值的形式产生输出。它们内部的代码不会影响其他函数中的变量。

列表

列表数据类型

“列表”是一个值，它包含多个字构成的序列。术语“列表值”指的是列表本身（它作为一个值，可以保存在变量中，或传递给函数，像所有其他值一样），而不是指列表值之内的那些值。列表值看起来像这样：[‘cat’, ‘bat’, ‘rat’, ‘elephant’]。就像字符串值用引号来标记字符串的起止一样，列表用左方括号开始，右方括号结束，即[]。列表中的值也称为“表项”。表项用逗号分隔（就是说，它们是“逗号分隔的”）。

day05

列表数据类型

用下标取得列表中的单个值

列表后面方括号内的整数被称为“下标”。列表中第一个值的下标是 0，第二个值的下标是 1，第三个值的下标是 2，依此类推。
如果使用的下标超出了列表中值的个数，Python 将给出 IndexError 出错信息。下标只能是整数，不能是浮点值。
列表也可以包含其他列表值。这些列表的列表中的值，可以通过多重下标来访问,第一个下标表明使用哪个列表值，第二个下标表明该列表值中的值。

负数下标

虽然下标从 0 开始并向上增长，但也可以用负整数作为下标。整数值−1 指的是列表中的最后一个下标，−2 指的是列表中倒数第二个下标，以此类推。

利用切片取得子列表

“切片”可以从列表中取得多个值，结果是一个新列表。切片输入在一对方括号中，像下标一样，但它有两个冒号分隔的整数。请注意下标和切片的不同。
 spam[2]是一个列表和下标（一个整数）。
 spam[1:4]是一个列表和切片（两个整数）。
在一个切片中，第一个整数是切片开始处的下标。第二个整数是切片结束处的Python 编程快速上手——让繁琐工作自动化下标。切片向上增长，直至第二个下标的值，但不包括它。切片求值为一个新的列表值。
作为快捷方法，你可以省略切片中冒号两边的一个下标或两个下标。省略第一个下标相当于使用 0，或列表的开始。省略第二个下标相当于使用列表的长度，意味着分片直至列表的末尾。

用 len()取得列表的长度

len()函数将返回传递给它的列表中值的个数，就像它能计算字符串中字符的个数一样。

用下标改变列表中的值

一般情况下，赋值语句左边是一个变量名，就像 spam = 4。但是，也可以使用列表的下标来改变下标处的值。例如，spam[1] = ‘aardvark’意味着“将列表 spam 下标 1 处的值赋值为字符串’aardvark’。

列表连接和列表复制

+操作符可以连接两个列表，得到一个新列表，就像它将两个字符串合并成一个新字符串一样。*操作符可以用于一个列表和一个整数，实现列表的复制。

用 del 语句从列表中删除值

del 语句将删除列表中下标处的值，表中被删除值后面的所有值，都将向前移
动一个下标。
del 语句也可用于一个简单变量，删除它，作用就像是“取消赋值”语句。如果在删除之后试图使用该变量，就会遇到 NameError 错误，因为该变量已不再存在。在实践中，你几乎永远不需要删除简单变量。del 语句几乎总是用于删除列表中的值。

in 和 not in 操作符

利用 in 和 not in 操作符，可以确定一个值否在列表中。像其他操作符一样，in和 not in 用在表达式中，连接两个值：一个要在列表中查找的值，以及待查找的列表。这些表达式将求值为布尔值。

多重赋值技巧

多重赋值技巧是一种快捷方式，让你在一行代码中，用列表中的值为多个变量赋值。变量的数目和列表的长度必须严格相等，否则 Python 将给出 ValueError。

针对+、-、、/和%操作符，都有增强的赋值操作符

+=操作符也可以完成字符串和列表的连接，=操作符可以完成字符串和列表的复制。

方法

方法和函数是一回事，只是它是调用在一个值上。例如，如果一个列表值存储在 spam 中，你可以在这个列表上调用 index()列表方法（稍后我会解释），就像spam.index(‘hello’)一样。方法部分跟在这个值后面，以一个句点分隔。每种数据类型都有它自己的一组方法。例如，列表数据类型有一些有用的方法，用来查找、添加、删除或操作列表中的值。

用 index()方法在列表中查找值

列表值有一个 index()方法，可以传入一个值，如果该值存在于列表中，就返回它
的下标。如果该值不在列表中，Python 就报 ValueError。

用 append()和 insert()方法在列表中添加值

要在列表中添加新值，就使用 append()和 insert()方法。append()方法调用，将参数添加到列表末尾。insert()方法可以在列表任意下标处插入一个值。insert()方法的第一个参数是新值的下标，第二个参数是要插入的新值。append()和 insert()的返回值是 None。方法属于单个数据类型。append()和 insert()方法是列表方法，只能在列表上调用，不能在其他值上调用。

用 remove()方法从列表中删除值

给 remove()方法传入一个值，它将从被调用的列表中删除。试图删除列表中不存在的值，将导致 ValueError 错误。如果该值在列表中出现多次，只有第一次出现的值会被删除。如果知道想要删除的值在列表中的下标，del 语句就很好用。如果知道想要从列表中删除的值，remove()方法就很好用。

用 sort()方法将列表中的值排序

数值的列表或字符串的列表，能用 sort()方法排序。也可以指定 reverse 关键字参数为 True，让 sort()按逆序排序。

关于 sort()方法，你应该注意 3 件事:
首先，sort()方法当场对列表排序。不要写出 spam = spam.sort()这样的代码，试图记录返回值。
其次，不能对既有数字又有字符串值的列表排序，因为 Python 不知道如何比较它们。
第三，sort()方法对字符串排序时，使用“ASCII 字符顺序”，而不是实际的字典顺序。这意味着大写字母排在小写字母之前。因此在排序时，小写的 a 在大写的Z 之后。
如果需要按照普通的字典顺序来排序，就在 sort()方法调用时，将关键字参数
key 设置为 str.lower。

续行字符\

类似列表的类型：字符串和元组

列表并不是唯一表示序列值的数据类型。例如，字符串和列表实际上很相似，只要你认为字符串是单个文本字符的列表。对列表的许多操作，也可以作用于字符串：按下标取值、切片、用于 for 循环、用于 len()，以及用于 in 和 not in 操作符。

可变和不可变数据类型

但列表和字符串在一个重要的方面是不同的。列表是“可变的”数据类型，它的值可以添加、删除或改变。但是，字符串是“不可变的”，它不能被更改。尝试对字符串中的一个字符重新赋值，将导致 TypeError 错误。
“改变”一个字符串的正确方式，是使用切片和连接。构造一个“新的”字符
串，从老的字符串那里复制一些部分。

元组数据类型

元组数据类型是列表数据类型的不可变形式。除了两个方面，“元组”数据类型几乎与列表数据类型一样：
首先，元组输入时用圆括号()，而不是用方括号[]。
其次，元组与列表的主要区别还在于，元组像字符串一样，是不可变的。元组不能让它们的值被修改、添加或删除。
如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，表明这种情况。否则，Python 将认为，你只是在一个普通括号内输入了一个值。逗号告诉Python，这是一个元组（不像其他编程语言，Python 接受列表或元组中最后表项后面跟的逗号）。
你可以用元组告诉所有读代码的人，你不打算改变这个序列的值。如果需要一个永远不会改变的值的序列，就使用元组。使用元组而不是列表的第二个好处在于，因为它们是不可变的，它们的内容不会变化，Python 可以实现一些优化，让使用元组的代码比使用列表的代码更快。

用 list()和 tuple()函数来转换类型

函数 list()和 tuple()将返回传递给它们的值的列表和元组版本。

引用

当你将列表赋给一个变量时，实际上是将列表的“引用”赋给了该变量。引用是一个值，指向某些数据。列表引用是指向一个列表的值。
变量包含对列表值的引用，而不是列表值本身。但对于字符串和整数值，变量就包含了字符串或整数值。在变量必须保存可变数据类型的值时，例如列表或字典，Python 就使用引用。对于不可变的数据类型的值，例如字符串、整型或元组，Python变量就保存值本身。虽然 Python 变量在技术上包含了对列表或字典值的引用，但人们通常随意地说，该变量包含了列表或字典。

传递引用

要理解参数如何传递给函数，引用就特别重要。当函数被调用时，参数的值被复制给变元。对于列表（以及字典），这意味着变元得到的是引用的拷贝。

copy 模块的 copy()和 deepcopy()函数

在处理列表和字典时，尽管传递引用常常是最方便的方法，但如果函数修改了传入的列表或字典，你可能不希望这些变动影响原来的列表或字典。要做到这一点，Python 提供了名为 copy 的模块，其中包含 copy()和 deepcopy()函数。第一个函数copy.copy()，可以用来复制列表或字典这样的可变值，而不只是复制引用。
deepcopy()函数将同时复制它们内部的列表。

字典

字典数据类型

像列表一样，“字典”是许多值的集合。但不像列表的下标，字典的索引可以使用许多不同数据类型，不只是整数。字典的索引被称为“键”，键及其关联的值称为“键-值”对。在代码中，字典输入时带花括号{}。字典仍然可以用整数值作为键，就像列表使用整数值作为下标一样，但它们不必从 0 开始，可以是任何数字。

字典与列表

不像列表，字典中的表项是不排序的。名为 spam 的列表中，第一个表项是 spam[0]。
但字典中没有“第一个”表项。虽然确定两个列表是否相同时，表项的顺序很重要，
但在字典中，键-值对输入的顺序并不重要。
因为字典是不排序的，所以不能像列表那样切片。
尝试访问字典中不存在的键，将导致 KeyError 出错信息。这很像列表的“越界”
IndexError 出错信息。
尽管字典是不排序的，但可以用任意值作为键，这一点让你能够用强大的方式来
组织数据。

keys()、values()和 items()方法

有 3 个字典方法，它们将返回类似列表的值，分别对应于字典的键、值和键-值对：
keys()、values()和 items()。这些方法返回的值不是真正的列表，它们不能被修改，没有
append()方法。但这些数据类型（分别是 dict_keys、dict_values 和 dict_items）可以用于
for 循环。
利用 keys()、values()和 items()方法，循环分别可以迭代键、值或键-值对。请注意，items()方法返回的 dict_items 值中，包含的是键和值的元组。
如果希望通过这些方法得到一个真正的列表，就把类似列表的返回值传递给 list函数。也可以利用多重赋值的技巧，在 for 循环中将键和值赋给不同的变量。

get()方法

在访问一个键的值之前，检查该键是否存在于字典中，这很麻烦。好在，字典有一个 get()方法，它有两个参数：要取得其值的键，以及如果该键不存在时，返回的备用值。

setdefault()方法

你常常需要为字典中某个键设置一个默认值，当该键没有任何值时使用它。setdefault()方法提供了一种方式，在一行中完成这件事。传递给该方法的第一个参数，是要检查的键。第二个参数，是如果该键不存在时要设置的值。如果该键确实存在，方法就会返回键的值。

setdefault()方法是一个很好的快捷方式，可以确保一个键存在。

漂亮打印

程序中导入 pprint 模块，就可以使用 pprint()和 pformat()函数，它们将“漂亮打印”一个字典的字，，输出看起来更干净，键排过序。
如果字典本身包含嵌套的列表或字典，pprint.pprint()函数就特别有用。
如果希望得到漂亮打印的文本作为字符串，而不是显示在屏幕上，那就调用pprint.pformat()。

使用数据结构对真实世界建模

在“代数记谱法”中，棋盘空间由一个数字和字母坐标确定，棋子用字母表示：K 表示王，Q 表示后，R 表示车，B 表示象，N 表示马。描述一次移动，用棋子的字母和它的目的地坐标。一对这样的移动表示一个回合（白方先下），代数记谱法还有更多内容，但要点是你可以用它无二义地描述象棋游戏，不需要站在棋盘前。你的对手甚至可以在世界的另一边！实际上，如果你的记忆力很好，
甚至不需要物理的棋具：只需要阅读寄来的棋子移动，更新心里想的棋盘。
计算机有很好的记忆力。现在计算机上的程序，很容易存储几百万个像’2. Nf3Nc6’这样的字符串。这就是为什么计算机不用物理棋盘就能下象棋。它们用数据建模来表示棋盘，你可以编写代码来使用这个模型。这里就可以用到列表和字典。可以用它们对真实世界建模，例如棋盘。