python取模恒等于3怎么表示

从决定不参加培训班开始 到现在已经四个月了 期间做了很多笔记 可能不怎么好 还是传到知乎吧 自己回头看也好

Python3

1 基础语法

1.1 编码

默认情况下，Python 3 源码文件以 UTF-8

1.2 标识符

• 第一个字符必须是字母或者是下划线_
• 标识符的其他部分由字母,数字和下划线组成
• 标识符对大小写敏感

1.3 保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

>>> import keyword
 >>> keyword.kwlist
 ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

1.4 注释

# 第一个注释
 # 第二个注释
  
 '''
 第三注释
 第四注释
 '''
  
 """
 第五注释
 第六注释
 """
 print ("Hello, Python!")

1.5 行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {},pycharm中设置四个空格,以tab键缩进

1.6 变量

Python 变量命名规则：

• 变量名必须以字母或下划线字符开头
• 变量名称不能以数字开头
• 变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）
• 变量名称区分大小写（age、Age 和 AGE 是三个不同的变量）

请记住，变量名称区分大小写

2 运算符

2.1 算术运算符

运算符描述实例+加 - 两个对象相加15 + 16 = 31-减 - 得到负数或是一个数减去另一个数16 - 15 = 1*乘 - 两个数相乘或是返回一个被重复若干次的字符串2*2 = 4/除 - x 除以 y5 / 2 = 2.5%取模 - 返回除法的余数5 % 2 = .......1**幂 - 返回x的y次幂5**2 = 5x5 = 25//取整除 - 向下取接近除数的整数9 // 2 >>>>2

2.2 比较运算符

以下假设变量a为10，变量b为20：

运算符描述实例==等于 - 比较对象是否相等(a == b) 返回 False。!=不等于 - 比较两个对象是否不相等(a != b) 返回 True。>大于 - 返回x是否大于y(a > b) 返回 False。<小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。(a < b) 返回 True。>=大于等于 - 返回x是否大于等于y。(a >= b) 返回 False。<=小于等于 - 返回x是否小于等于y。(a <= b) 返回 True。

2.3 赋值运算符

以下假设变量a为10，变量b为20：

运算符描述实例=简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c+=加法赋值运算符c += a 等效于 c = c + a-=减法赋值运算符c -= a 等效于 c = c - a*=乘法赋值运算符c *= a 等效于 c = c * a/=除法赋值运算符c /= a 等效于 c = c / a%=取模赋值运算符c %= a 等效于 c = c % a**=幂赋值运算符c = a 等效于 c = c

2.4 位运算符

运算符描述实例&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0同真为真|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。一真为真^按位异或运算符：当两对应的二进位相异时，结果为1~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1一起取反

2.5 成员运算符

运算符描述实例in如果在指定的序列中找到值返回 True，否则返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 True。not in如果在指定的序列中没有找到值返回 True，否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

2.6 身份运算符

身份运算符用于比较两个对象在内存地址当中的存储单元

运算符描述实例isis 是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 Falseis notis not 是判断两个标识符是不是引用自不同对象x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

2.7 运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符描述**指数 (最高优先级)~ + -按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)* / % //乘，除，取模和取整除+ -加法减法>> <<右移，左移运算符&位 'AND'^ |位运算符<= < > >=比较运算符== !=等于运算符= %= /= //= -= += *= **=赋值运算符is is not身份运算符in not in成员运算符not and or逻辑运算符

3 数据类型

3.1 标准数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

3.2 数字

Python3 支持 int、float、bool、complex（复数）。

Python3中把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

内置的 type() 函数可以用来查询变量所指的对象类型。
 >>> a, b, c, d = 20, 5.5, True, 4+3j
 >>> print(type(a), type(b), type(c), type(d))
 <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
 
 此外还可以用isinistance来判断,还可以判断继承关系
 >>>a = 111
 >>> isinstance(a, int)
 True
 
 >>> class A:
 ...     pass
 ... 
 >>> class B(A):
 ...     pass
 >>> isinstance(B(), A)
 True

Python 支持三种不同的数值类型：

• 整型(Int)
• 浮点型(float)
• 复数( (complex))

数学函数

函数返回值(描述)abs(x)返回数字的绝对值，如abs(-10) 返回 10ceil(x)返回数字的上入整数，如math.ceil(4.1) 返回 5fabs(x)返回数字的绝对值，如math.fabs(-10) 返回10.0floor(x)返回数字的下舍整数，如math.floor(4.9)返回 4pow(x,y)x**y 运算后的值。round(x , [,n])返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。sqrt(x)返回数字x的平方根。

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

choice(seq)从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。randrange ([start,] stop [,step])从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1random()随机生成下一个实数，它在[0,1)范围内。seed([x])改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。shuffle(lst)将序列的所有元素随机排序uniform(x, y)随机生成下一个实数，它在[x,y]范围内。sample(lst,k)对lst序列中随机获取k个元素,作为一个片段返回

3.3 String字符串

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 转义特殊字符。

字符串的截取的语法格式如下：变量[头下标:尾下标]

Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

注意：

• 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
• 2、字符串可以用+运算符连接在一起，用*运算符重复。
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变。

Python转义字符

转义字符描述(在行尾时)续行符反斜杠符号n换行v纵向制表符t横向制表符r回车f换页

字符串格式化

符号描述%s格式化字符串,print "string=%2s" % string # output: string=hello%d格式化整数,print "num=%3d" % num # output: num= 14%f格式化浮点数字，可指定小数点后的精度-------------print('num=%0.2f'%5.344),保留两位小数f'hello {name}'使用f ' ', ' '内填入字符串,{ }内填入变量的名字.format'{0} {1} {0}' .foramt(),{ }内不指定位置,按默认顺序

字符串内建函数

序号方法描述1capitalize()将字符串的第一个字符转换大写2center(width,fillchar)返回一个指定的宽度width居中的字符串,fillchar为填充的字符,默认的空格3count(str,beg=0,end=len(string))返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数4endswith(suffix, beg=0, end=len(string))检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.5find(str,beg=0,end=len(string))检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-16index(str,beg=0,end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常.7isdigit()如果字符串只包含数字则返回 True 否则返回 False..8islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False9isupper()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False10join()以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串11ljust(width,fillcahr)返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。12lstrip()截掉字符串左边的空格或指定字符。13replace(old,new,[,max])把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。14spit(str=' ' ,num=string.count(str))num=string.count(str))以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串15swapcase()将字符串大写转换为小写,小写转换为大写16upper()转换字符串中的小写字母为大写17zfill()返回长度为 width 的字符串，原字符串右对齐，前面填充0

3.4 列表

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：变量[头下标:尾下标]

注意：

• 1、List写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，list可以被索引和切片。
• 3、List可以使用+操作符进行拼接。
• 4、List中的元素是可以改变的

访问列表中的值

list1 = ['Google', 'Runoob', 1997, 2000];
 list2 = [1, 2, 3, 4, 5, 6, 7 ];
  
 print ("list1[0]: ", list1[0])
 print ("list2[1:5]: ", list2[1:5])

更新列表

将新的值复制给指定的列表的下标: list[5] = 1998

删除列表元素

del list[2]

Python列表函数

序号方法描述1list.append()在列表末尾添加新的对象(对象可以为列表,元组)2list.count()统计某个元素在列表中出现的次数3list.extend()在列表末尾一次性追加另一个序列中的多个值(用新列表来拓展原来的列表)4list.index(obj)从列表中找出某个值第一个匹配项的索引位置5list.insert(index,obj)将对象插入列表6list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值7list.remove(obj)移除列表中某个值的第一个匹配项8list.reverse(obj)反向列表中元素9list.sort(key=None,reverse=False)对原列表进行排序10list.clear()清空列表11list.copy复制列表

3.5 元组

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法一样。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用+操作符进行拼接

元组可以使用下标来访问元组中的值

元组中的元素值是不允许修改的

元组中的元素值是不允许删除,单我们可以使用del 语句来删除整个元组

3.6 Set集合

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复的元素

可以使用{ }或者set()函数创建集合,注意:创建一个空集合必须用set()而不是{ },因为 { } 是用来创建一个空字典。

1 添加元素

s.add(x) 添加元素x到集合中

s.update(x) x参数可以是列表,元组,字典

2 移除元素

s.remove(x) 如果元素不存在,则会发送错误

s.discard(x) 如果元素不存在,不会发生错误

s.pop() 随机删除集合中的一个元素

3 计算集合元素个数
4 清理集合

len(s)

s.clear()

5 集合内置方法

3.7 Dictionary字典

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value)

键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的

1 访问字典里的值

通过dict['key']来访问

2 修改字典

向字典添加新内容的方法是增加新的键/值对:

dict['key'] = value

删除字典元素

del dict['name'] # 删除键 'name'

dict.clear # 清空字典

del dict # 删除字典

popitem() # 随机返回并删除字典中的最后一对键和值

3.8 Python数据类型转换

函数描述[int(x ,base])将x转换为一个整数float(x)将x转换到一个浮点数[complex(real ,imag])创建一个复数str(x)将对象 x 转换为字符串repr(x)将对象 x 转换为表达式字符串eval（str)* 用来计算在字符串中的有效Python表达式,并返回一个对象* tuple(s)将序列 s 转换为一个元组list(s)将序列 s 转换为一个列表set(s)转换为可变集合dict(d)创建一个字典。d 必须是一个 (key, value)元组序列。frozenset(s)转换为不可变集合chr(x)将一个整数转换为一个字符ord(x)将一个字符转换为它的整数值hex(x)将一个整数转换为一个十六进制字符串oct(x)将一个整数转换为一个八进制字符串

4 程序控制结构

4.1 条件控制

if elif else

if 嵌套

原则：先实行外侧循环。满足外侧循环的条件后，开始内部循环，待内部循环结束后，重新判定外部循环条件是否继续或结束。

4.2 循环控制

counter = 0
 num = 0
 while counter < 100:
     counter += 1
     sum += counter

无限循环

while的条件永远不为fasle时可用产生无限循环

4.3 终止语句

break

n = 10
 while n > 0:
     n -= 1
     if n == 6:
         break
     print(n)
 print('结束')
 
 >>>>9,8,7,结束

continue

n = 10
 while n > 0:
     n -= 1
     if n == 6:
         continue
     print(n,end=',')
 print('结束')
 
 >>>9,8,7,5,4,3,2,1,0,结束

pass

5 迭代器与生成器

5.1 迭代器

迭代是访问集合元素的一种方式

迭代器是一个可以记住遍历的位置的对象

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter()创建迭代器对象 和 next()输出迭代器的下一个元素,没有时报错。

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
 >>> it = iter(list)    # 创建迭代器对象
 >>> print (next(it))   # 输出迭代器的下一个元素
 1
 >>> print (next(it))
 2
 >>>
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration: # 标识迭代的完成,防止出现无限循环的情况
        sys.exit()

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。

_iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next__() 方法并通过 StopIteration 异常标识迭代的完成。

next() 方法会返回下一个迭代器对象。

5.2 生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中,每次遇到yield函数就会暂停并保存当前所有的运行信息,并在下一次执行next()fa方法时从当前位置继续运行

调用一个生成器函数,返回的是一个迭代器对象

以下实例使用yield实现斐波那契数列:

import sys

def fibonacci(n):
	a,b = 0,1
	counter = 0
	while (counter>n):
		return
	yield a
	a,b = b,a+b
	counter += 1
f = fibonacci(10)	# f是一个迭代器,由生成器返回生成

while True:
	try:
		print(next(f),end=' ')
	expect Stopiteration:
		sys.exit()

>>>>0 1 1 2 3 5 8 13 21 34 55

6 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。

6.1 函数的定义

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式]
• 调用函数也相当简单,使用函数名+圆括号()即可

6.2 参数的传递

在python中,类型属于对象,变量是没有类型的;它仅仅是一个对象的引用(一个指针)

a = [1,2] a = “runoob”

在上面的例子当中,指向List类型,也可以指向String类型

6.2.1 可更改与不可更改对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型: 变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 指向5的引用被丢弃，不是改变a的值，相当于新生成了a。
• 可变类型: 变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5

Python函数的参数传递

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型: 类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

参数

• 必需参数: 以正确的顺序传入函数。调用时的数量必须和声明时的一样,必须传入一个参数。
• 关键字参数: 使用关键字参数来确定传入的参数值。允许参数的顺序与声明时不一致,因为python解释器能够用参数名匹配参数值
• 默认参数:调用函数时,如果没有传递参数，则会使用默认参数。

def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

>>名字:  runoob
>>年龄:  35
# 不传入age参数时,会使用默认的age = 35

• 不定长参数: 可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
  *args 传入的是元组;**kwargs传入的是字典

匿名函数

python使用lambda来创建匿名函数，不再使用def这样的标准语句来定义一个函数

• lambda只是一个表达式，函数体很简单
• lambda的主体不是代码块，仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间。不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

retunrn语句

return [表达式]

7 命名空间/作用域

7.1 命名空间

命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。

命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。

一般有三种命名空间：

• 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
• 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
• 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）

Python 的查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间。

命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束。

7.2 作用域

作用域就是一个 Python 程序可以直接访问命名空间的正文区域。

在一个python程序中,直接访问一个变量,会从内到外依次访问所有的作用域直到找到

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。作用域分为4种,分别是:

• L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
• E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。位于局部与全局作用域之间,可以是闭包函数外的函数中
• G（Global）：当前脚本的最外层，比如当前模块的全局变量。
• B（Built-in）： 包含了内建的变量/关键字等。，最后被搜索

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例

total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

>>>函数内是局部变量 :  30
>>>函数外是全局变量 :  0

global和nonlocal关键字

当内部作用域想修改外部作用域的变量时,就需要使用global和nonlocal关键字

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

>>>1
>>>123
>>>123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

>>>100
>>>100

8 模块与包

8.1 模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

模块的好处:可维护性更强，方便代码重用。

• 1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
• 2、sys.argv 是一个包含命令行参数的列表。
• 3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

模块的导入：内置模块 import os

• dir() 列出对象的所有属性及方法
• help() 查看类，方法的帮助信息
• __name__ 模块的名称
• __file__ 文件的全路径

8.2 包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。

比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

目录只有包含一个叫做 init.py 的文件才会被认作是一个包

9 OS

os

10 错误和异常

Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。

异常处理

try/except

try 语句按照如下方式工作；

• 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。
• 如果没有异常发生，忽略 except 子句，try 子句执行后结束。
• 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
• 如果一个异常没有与任何的 excep 匹配，那么这个异常将会传递给上层的 try 中。

try/except........else

• else 子句将在 try 子句没有发生任何异常的时候执行。
• 使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。
• 异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。

try-finally

try-finally 语句无论是否发生异常都将执行最后的代码。(finally)

抛出异常

raise [Exception,[,args[,traceback]]]