0 环境搭建

Unix & Linux

# tar -zxvf Python-3.6.1.tgz
# cd Python-3.6.1
# ./configure
# make && make install
1
2
3
4

1 特点及运用领域

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
跨平台、可移植、互动模式、GUI编程
1、可扩展：如果需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，可以使用C或C++完成那部分程序，然后从Python程序中调用。
2、数据库：Python提供所有主要的商业数据库的接口。
3、可嵌入: 可以将Python嵌入到C/C++程序，让程序的用户获得"脚本化"的能力。

2 基础语法及数据类型

[1] 基础语法
1、# -*- coding: cp-1252 -*-
2、使用反斜杠()来实现多行语句，在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()
3、complex (复数), 如 1 + 2j、 1.1 + 2.2j
4、使用三引号(’’‘或""")可以指定一个多行字符串
5、反斜杠可以用来转义，使用r可以让反斜杠不发生转义
6、字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
7、函数之间或类的方法之间用空行分隔，表示一段新的代码的开始
8、Python可以在同一行中使用多条语句，语句之间使用分号; 分割
9、print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=str，并以str结尾，可为空格或者逗号等
10、单行注释#，多行注释’’’ ‘’’ 或者’’’’’’ ‘’’’’’

[2] 数据类型
1、a = b = c = 1，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值；a, b, c = 1, 2, “runoob”，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 “runoob” 分配给变量 c
2、六个标准数据类型
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
除Number外，其余的数据类型均可以作为序列来遍历
3、内置的 type() 函数可以用来查询变量所指的对象类型，还可以用 isinstance() 来判断是否属于某一个类型isinstance(a, int)；isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型。
4、Python3中True 和 False 定义成关键字了，但它们的值还是 1 和 0，可以和数字相加
5、可以通过使用del语句删除单个或多个对象
6、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数，在混合计算时，Python会把整型转换成为浮点数。17 % 3 # 取余 ；2 ** 5 # 乘方。
7、复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
8、星号* 表示复制当前字符串，与之结合的数字为复制的次数，可在前也可在后。
9、Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm’会导致错误
10、加号 + 是列表连接运算符，星号 * 是重复操作，可前可后。
11、列表第三个参数为负数时表示逆向读取，翻转列表inputWords=inputWords[-1::-1]
12、tup1 = () # 空元组；tup2 = (20,) # 一个元素，需要在元素后添加逗号
13、元组可以用加号 + 连接运算符，星号 * 是重复操作，可前可后
14、可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典；parame = {value01,value02,…}或者set(value)

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam') 
print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集 
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素
1
2
3
4
5
6
7
8

15、列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
16、键(key)必须使用不可变类型，在同一个字典中，键(key)必须是唯一的
17、print (tinydict.keys()) # 输出所有键；print (tinydict.values()) # 输出所有值

#1
dict = {}
dict['one'] = "1"
dict[2]     = "2"
#2
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
#3
>>> {x: x**2 for x in (2, 4, 6)}
#4
>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
#5
>>> dict(Runoob=1, Google=2, Taobao=3
1
2
3
4
5
6
7
8
9
10
11
12

18、dict()内置函数的用法

>>>dict()                        # 创建空字典
>>> dict(a='a', b='b', t='t')     # 传入关键字
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
1
2
3
4

19、数据类型转化内置函数

3 运算符

1-算术运算符（+,-,*,/,%,//,**）
2-比较（关系）运算符（==,!=,>,<,>=,<=）
3-赋值运算符（=,+=,-=,*=,/=,%=,//=,**=）
4-逻辑运算符（and,or,not）前两个为真时返回后一个数，后一个为bool型
5-位运算符（&,|,~,^,<<,>>）
6-成员运算符（in,not in）可用于字符串，列表或元组
7-身份运算符（is,not is）[ 用于比较两个对象的存储单元，类似于id(x) == id(y)，id()返回对象的内存地址。is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等 ]

*运算符优先级

4 数据类型

1、Number

红色的标注表示该函数为内置函数，其余的为math模块的函数


random.sample(range(start,end,step), num) # 在指定范围内随机取样num个数

2、字符串

Python字符串格式化
[1] print (“我叫 %s 今年 %d 岁!” % (‘小明’, 10)) %c %s %d %f %e
[2] str.format

#1
>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
#2 通过字典设置参数
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
#3 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
#4 传入对象
class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

[3]数字格式化
位数不够，才进行填补

b、d、o、x 分别是二进制、十进制、八进制、十六进制

可以使用大括号 {} 来转义大括号

print ("{} 对应的位置是 {{0}}".format("runoob"))
1

[4] f-string字面量格式化字符串(3.6版本以后)
以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量/表达式计算后的值替换进去

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
>>> f'{1+2}'         # 使用表达式
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
1
2
3
4
5

Python三引号
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

Python常用字符串内置函数
1、count(str, beg= 0,end=len(string)) #返回 str 在 string 里面出现的次数
2、encode(encoding=‘UTF-8’,errors=‘strict’)；decode(encoding=“utf-8”, errors=“strict”)

str = "helloword您好";
#编码
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
#解码
print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))
print("GBK 解码：", str_gbk.decode('GBK','strict'))
1
2
3
4
5
6
7

3、find(substr, beg=0, end=len(string)) #如果包含子串substr返回开始的索引值，否则返回-1；rfind(str, beg=0,end=len(string))
index(str, beg=0, end=len(string)) 与find一样，但不存在时会发生异常；rindex( str, beg=0, end=len(string)) 右边开始第一个位置
4、isdigit() #如果字符串只包含数字则返回 True 否则返回 False
5、str.join(seq) #用str作为分隔符，将 seq 中所有的元素(字符串表示)合并为一个新的字符串
6、len(str) #返回字符串长度
7、replace(old, new [, max]) #将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次
8、split(substr="", num=str.count(substr)) #以 substr 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串；splitlines([keepends]) #按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
1
2

3、列表

常用函数和方法


1、sorted(list) 与 list.sort() 的区别在于，sorted不改变list，而sort是list本身的操作。
2、将列表当做堆栈使用，list.append()，list.pop()，先进后出，后进先出；将列表当作队列使用，list.append()，list.popleft()，先进先出，后进后出
3、列表推导式 [3*x for x in vec if x > 3] 将从vec中取出的元素利用if 子句作为过滤器，[表达式x | 给表达式提供满足一定条件的x值]

4、元组

1、元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
2、tup3 = “a”, “b”, “c”, “d” # 不需要括号也可以
3、元组中的元素值不允许修改和删除

5、字典

1、值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组
2、字典的增、删、改

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8               # 修改 Age
dict['School'] = "菜鸟教程"  # 添加信息
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
1
2
3
4
5
6

3、常用函数与方法
len(dict) #计算字典元素个数，即键的总数
str(dict) #输出字典，以可打印的字符串表示
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型
dict.clear() #删除字典内所有元素
dict.copy() #返回一个字典的浅复制
dict.get(key) #返回指定键的值，如果值不在字典中返回默认值none
key in dict #如果键在字典dict里返回true，否则返回false
dict.items() #以列表返回可遍历的(键, 值) 元组数组
dict.keys() #返回一个迭代器，可以使用 list() 来转换为列表
dict.values() #返回一个迭代器，可以使用 list() 来转换为列表
dict.update(dict2) #把字典dict2的键/值对更新到dict里

6、集合

1、可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
2、集合之间的操作（交、并、差、异或）

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a - b  # 集合a中包含而集合b中不包含的元素
>>> a | b  # 集合a或b中包含的所有元素
>>> a & b  # 集合a和b中都包含了的元素
>>> a ^ b  # 不同时包含于a和b的元素（a|b）-(a&b)
1
2
3
4
5
6

3、集合的操作
[1] 增加 s.add( x ) ; s.update( x ) #参数可以是列表，元组，字典且 x 可以有多个，用逗号分开。添加的是参数里面的元素，不是一个整体加入。

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>>thisset.add("Facebook")
>>> thisset.update([1,4],[5,6]) #加入的是1,4，5,6元素，不是整体
1
2
3

[2] 删除 s.remove( x ) #元素不存在会发生异常；s.discard( x ) #元素不存在不会发生异常；s.pop() #随机删除一个元素
[3] 常用方法
#添加元素
add() 为集合添加元素
update() 给集合添加元素
#删除元素
remove() 移除指定元素
discard() 删除集合中指定的元素
pop() 随机移除元素
#集合之间的操作
difference() 返回多个集合的差集
intersection() 返回多个集合的交集
union() 返回多个集合的并集
#移除和拷贝
clear() 移除集合中的所有元素
copy() 拷贝一个集合

7、遍历技巧

#字典 关键字和对应的值的遍历
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
#序列 索引位置和对应值可以使用 enumerate() 函数遍历同时得到
>>> for i, v in enumerate(['tic', 'tac', 'toe']): #enumerate(seq)遍历序列值和其对应的下标
...     print(i, v)
#同时遍历两个或更多的 序列，可以使用 zip() 组合
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers): #zip(seq1,seq2)两个序列的对应取值打包
...     print('What is your {0}?  It is {1}.'.format(q, a))
1
2
3
4
5
6
7
8
9
10
11
12

5 语句和函数

1、if条件语句的关键字为：if – elif – else；elif == else if；Python中没有switch – case语句
2、while循环语句； Python 中没有 do…while 循环；在 while … else 在条件语句为 false 时执行 else 的语句块

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>
1
2
3
4

3、for循环可以遍历任何序列的项目，如一个列表、元组、字典(键的遍历)或者一个字符串
4、break语句跳出最近的循环，continue语句结束当前这一次循环
5、range([start,]end[,step])；使用内置range()函数生成可遍历序列
6、pass语句是空语句，不做任何事情，一般用做占位语句
7、迭代器与生成器
[1] iter() 和 next()；利用 iter(字符串，列表或元组对象) 创建迭代器，用 next(it) 函数返回迭代对象的值；可使用for语句直接对迭代器对象进行遍历；当next(it)函数遍历完毕时，会抛出StopIteration 异常，可用 sys.exit() 结束迭代器的遍历。

import sys         # 引入 sys 模块
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()
1
2
3
4
5
6
7
8

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

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration 
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
  print(x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[3] 生成器
使用了 yield 的函数被称为生成器（generator）；生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器；遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。（说明了对返回值的处理在yield的后面，第二次的next()获得的就是第二个值，依次类推）

import sys
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a  #next()取到的值
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

8、函数

def 函数名（参数列表）:
    函数体
1
2

[1] 参数传递
传不可变对象和传可变对象；strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象，在函数中的修改会改变本身；类型属于对象，变量是没有类型的，仅仅是一个对象的引用（一个指针），指向对象。
[2] 参数
必需参数 def printme( str ):
关键字参数 printme( str = “hello world!”)
默认参数 def printme( str=“hello world!” ):
不定长参数 函数能处理比当初声明时更多的参数，这些参数叫做不定长参数
1、def functionname([formal_args,] *var_args_tuple ) 单星号 * 的参数会以元组(tuple)的形式存放所有未命名的变量参数
2、def functionname([formal_args,] **var_args_dict ) 双星号 ** 的参数会以字典(dict)的形式存放所有未命名的变量参数
3、声明函数时，参数中星号 * 可以单独出现，在调用函数时星号 * 后的参数必须用关键字传入

# 1 元组的形式保存
def printinfo( arg1, *vartuple ):
   print (arg1)
   for var in vartuple:
      print (var)
   return
printinfo( 10 ) #可不传入可变参数
printinfo( 70, 60, 50 )

# 2 字典的形式保存
def printinfo( arg1, **vardict ):
   print (arg1)
   print (vardict)
printinfo(1, a=2,b=3) #键值对的形式传入或者是字典对象传入

#\*后关键字传入
>>> def f(a,b,*,c):
...     return a+b+c
>>> f(1,2,c=3) # c在\*之后
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

[3] 匿名函数
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数；lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

lambda [arg1 [,arg2,.....argn]]:expression #返回表达式的值
1

[4] return语句
return [表达式] 语句用于退出函数；可用于中途满足一定条件后结束退出函数。

6 模块与包

1、模块是一个包含定义的函数和变量的文件，其后缀名是.py，模块可以被别的程序引入，以使用该模块中的函数
2、sys.argv 是一个包含命令行参数的列表；sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。
3、搜索路径
Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块，搜索路径被存储在sys模块中的path变量

>>> import sys
>>> sys.path
['当前执行脚本所在的目录', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
1
2
3

4、import module1[, module2[,… moduleN] ；from modname import name1[, name2[, … nameN]]；from modname import *
5、__name__属性
若想在模块被引入时，模块中的某一程序块不执行，可以用__name__属性来使该程序块仅在该模块自身运行时执行；说明： 每个模块都有一个__name__属性，当其值是’__main__'时，表明该模块自身在运行，否则是被引入。

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')
1
2
3
4

6、dir() 函数
内置的函数 dir() 可以找到模块内定义的所有名称(函数名、变量名、模块名等)，以一个字符串列表的形式返回

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
1
2
3

如果没有给定参数，那么 dir() 函数会罗列出**当前定义(脚本)**的所有名称(函数名、变量名、模块名等)
7、包
包是一种管理 Python 模块命名空间的形式，采用".模块名称"
[1] 目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包
[2] 最简单的情况，放一个空的 __init__.py，也可以包含一些 初始化代码 或者为 __all__变量赋值
[3] from package import module；from package.module import function；import package；import package.module
[4] 在__init__.py中定义__all__ = [“echo”, “surround”, “reverse”]，一个包下面的模板名称，则 from package import * 的时候就把这个列表中的所有名字作为包内容导入
[5] 如果模块sound.filters.vocoder 要使用包 sound.effects 中的模块 echo，使用绝对路径，写成 from sound.effects import echo，filters与effects是同一级的包，则需要用他们的上一级开始作为 \ 逐层导入。
[6] 无论是隐式的还是显式的相对导入都是从当前模块开始的

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...
#相对路径导入
from . import echo #当前目录下
from .. import formats #上一级目录下
from ..filters import equalizer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

7 输入与输出

[1] 读取键盘输入 Python提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘；input 可以接收一个Python表达式作为输入，并将运算结果返回
[2] 读和写文件
open() 将会返回一个 file 对象；open(filename, mode)；mode参数是非强制的，默认文件访问模式为只读®

[3] 文件对象的方法

#创建文件对象
内置函数open与os.open()不同
f=open(filename, mode=‘r’,[,buffering=-1, encoding=‘utf-8’])

#读取文件对象内容
f.read([size]) #当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回字符串或字节对象
f.readline() #从文件中读取单独的一行，包括 “\n” 字符，如果返回一个空字符串, 说明已经已经读取到最后一行
f.readlines([size]) #返回该文件中包含的所有行；如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割
line in f #直接迭代文件对象读取每一行

#内容写入文件对象
f.write(string) #将 string 写入到文件中, 然后返回写入的字符数；要写入一些不是字符串的东西, 那么将需要先进行转换，str()或者repr()进行类型转化
f.writelines([str1,str2,str3,…]) 方法用于向文件中写入一序列的字符串

#关闭文件对象
f.close() #关闭文件并释放系统的资源

#利用with关键字正确的关闭文件

>>> with open('/tmp/foo.txt', 'r') as f:
...     read_data = f.read()
1
2

[4] pickle 模块
1、python的pickle模块实现了基本的数据序列和反序列化
2、通过pickle模块的序列化操作，能够将程序中运行的对象信息保存到文件中去，永久存储 pickle.dump()
3、通过pickle模块的反序列化操作，能够从文件中创建上一次程序保存的对象pickle.load()

 #序列化
file1 = open('data.pkl', 'wb')
pickle.dump(obj, file1, [,protocol])
#反序列化
file2 = open('data.pkl', 'rb')
x = pickle.load(file2)  #从 file 中读取一个字符串，并将它重构为原来的python对象
pprint.pprint(x) #利用pprint模块的pprint方法可以打印保存的对象
1
2
3
4
5
6
7

8 OS模块文件/目录方法

[1] os 模块提供了非常丰富的方法用来处理文件和目录
[2] 常用方法
os.getcwd() 返回当前工作目录
os.chdir(path) 方法用于改变当前工作目录到指定的路径

os.makedirs(path) 方法用于递归创建目录
os.mkdir(path) 方法用于创建目录

os.remove(path) 删除文件
os.removedirs(path) 递归删除目录

os.rename(src, dst) 用于命名文件或目录
os.renames(old, new) 方法用于递归重命名目录或文件

os.system(‘mkdir today’) # 执行系统命令 mkdir today

os.path.join(path1[, path2[, …]]) 把目录和文件名合成一个路径
os.path.exists(path) 路径存在则返回True,路径损坏返回False
os.path.realpath(path) 返回path的真实路径
os.path.split(path) 把路径分割成 dirname 和 basename，返回一个元组
os.path.relpath(path[, start]) 从start开始计算相对路径
os.path.abspath(path) 返回绝对路径

9 错误和异常

语法分析器检查语句的语法错误； 运行期检测到的错误被称为异常；大多数的异常都不会被程序处理，以调用栈的形式显示具体错误信息

1、如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略2、如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行
3、如果一个异常没有与任何的 excep 匹配，那么这个异常将会传递给上层的 try 中
4、try…expect…else 使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。
5、异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
    except : #except子句可以忽略异常的名称，将被当作通配符使用,可以使用这种方法打印一个错误信息，然后再次把异常抛出,raise
    	print("Unexpected error:", sys.exc_info()[0])
    	raise
finally:
    print('这句话，无论异常是否发生都会执行。')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6、抛出异常raise
Python 使用 raise 语句抛出一个指定的异常

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))#错误说明语句
1
2
3

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

assert expression [, arguments]
==
if not expression:
    raise AssertionError(arguments)

import sys
assert ('linux' in sys.platform), "该代码只能在 Linux 下执行"
1
2
3
4
5
6
7

10 面向对象

1、类定义

class ClassName:
	#自定义属性
	i = 12345
	#定义私有属性,私有属性在类外部无法直接进行访问 变量名前有\_\_
    __weight = 0
	def __init__(self，realpart，imagpart): #初始化
	    self.data = []
	    self.r = realpart
        self.i = imagpart
    #自定义函数 加self 代表类的实例，而非类
	def hello(self,name):
	def deal(self):
	.... 
1
2
3
4
5
6
7
8
9
10
11
12
13

2、继承
[1] 单继承
注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法；BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内；除了类，基类定义在另一个模块中时，还可以用表达式

class DerivedClassName(modname.BaseClassName): #基类在另一个模块中
1

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #若要使用父类中的属性，则调用父类的构函，进行实例化
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

[2] 多继承

class DerivedClassName(Base1, Base2, Base3): #方法先从子类中查找，找不到从左到右查找父类
1

[3] 方法重写(覆盖)

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
1
2
3
4
5
6

[4] super() 调用父类的方法

class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
1
2
3
4
5
6
7

3、类属性与方法
[1] 私有属性，私有方法 ，只需在变量名和函数名前加 __ 即可；声明该方法/属性为私有方法/属性，只能在类的内部调用 ，不能在类的外部调用
[2] 专有方法（方法名前后有） __

11 命名空间和作用域

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

1、命名空间查找顺序
局部的命名空间–> 全局命名空间 --> 内置命名空间；如果找不到变量 runoob，它将放弃查找并引发一个 NameError 异常
2、命名空间的生命周期
命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束，因此无法从外部命名空间访问内部命名空间的对象
3、全局变量和局部变量
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问
4、global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了

#修改全局变量 num 
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()

#修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

12 其他

1、针对日常的文件和目录管理任务，shutil 模块提供了一个易于使用的高级接口

>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db') #复制文件
>>> shutil.move('/build/executables', 'installdir') #移动文件
1
2
3

2、文件通配符
glob模块提供了一个函数用于从指定目录进行通配符搜索中生成文件列表

>>> import glob
>>> glob.glob('path/*.py')
['primes.py', 'random.py', 'quote.py']
1
2
3

3、命令行参数
python demo.py one two three

>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three'] #列表的形式保存
1
2
3

4、字符串正则匹配
re模块为高级字符串处理提供了正则表达式工具，对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'
1
2
3
4
5

5、访问 互联网

>>> from urllib.request import urlopen
>>> for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
...     line = line.decode('utf-8')  # Decoding the binary data to text.
...     if 'EST' in line or 'EDT' in line:  # look for Eastern Time
...         print(line)

<BR>Nov. 25, 09:43:32 PM EST
#需要本地有一个在运行的邮件服务器
>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
... Beware the Ides of March.
... """)
>>> server.quit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6、日期和时间
datetime模块为日期和时间处理同时提供了简单和复杂的方法
7、数据压缩
以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)#压缩
>>> len(t)
37
>>> zlib.decompress(t)#解压
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979
1
2
3
4
5
6
7
8
9
10
11

8、测试模块
doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试，确认代码的结果是否与文档一致

import doctest
def average(values):
    """Computes the arithmetic mean of a list of numbers.
    >>> print(average([20, 30, 70])) #测试的命令
    40.0    #测试的需要结果
    """
    return sum(values) / len(values)
doctest.testmod()   # 自动验证嵌入测试
1
2
3
4
5
6
7
8