python核心基本知识

python简介

Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言。

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。

Python 特点

• **1.易于学习：**Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
• **2.易于阅读：**Python代码定义的更清晰。
• **3.易于维护：**Python的成功在于它的源代码是相当容易维护的。
• **4.一个广泛的标准库：**Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
• **5.互动模式：**互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
• **6.可移植：**基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
• **7.可扩展：**如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
• **8.数据库：**Python提供所有主要的商业数据库的接口。
• **9.GUI编程：**Python支持GUI可以创建和移植到许多系统调用。
• 10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

python基础

编码

Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。

python保留字

>>> 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']

注释

Python中单行注释以 # 开头,还有 ‘’’ 和 “”"：

行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

if True:
    print ("True")
else:
    print ("False")

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()

数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 如 True。
• float (浮点数), 如 1.23、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。

bin():返回二进制数
oct():返回八进制数
hex():返回十六进制数
ord():返回ASCII 码
chr():返回对应的字符

数学函数

数字函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
fabs(x)	返回数字的绝对值
sqrt(x)	返回数字x的平方根。
floor(x)	返回数字的下舍整数
max(x1,x2…)	返回给定参数的最大值，参数可以为序列。
min(x1,x1…)	返回给定参数的最小值，参数可以为序列。
round(x)	返回浮点数 x 的四舍五入值
random()	随机生成下一个实数，它在[0,1)范围内。
shuffle(list)	将序列的所有元素随机排序
uniform(x,y)	随机生成下一个实数，它在[x,y]范围内。
chioce(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

字符串(String)

• python中单引号和双引号使用完全相同。
• 使用三引号(’’'或""")可以指定一个多行字符串。（可以用于书写HTMl和SQL语句）
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
• 可以把字符串看作一种特殊的元组。
• 不换行处理：print(x,end=" ")

对于一个字符串，索引从前面0,1,2,3,4… 索引从后面-1,-2,-3,-4,-5…

符号	字符串转义字符
\	字符串续行符
\ \	字符串反斜杠符号
\ ’	字符串单引号
\ ‘’	字符串双引号
\ n	字符串换行
\ t	字符串横向制表符(大空格)

符号	字符串格式化符号解释
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数字，可指定小数点后的精度
%o	格式化无符号八进制数
%x	格式化无符号十六进制数

符号	字面量格式化字符串
%	print(‘Hello ==%s’ %==name)
f	print(f"Hello {name}")

字符串函数	返回值（描述）
count(str, begin=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
encode(encoding=‘UTF-8’,errors=‘strict’)	以 encoding 指定的编码格式编码字符串
startswith(substr, beg=0,end=len(string))	检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
endswith(suffix, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
rfind(str, beg=0,end=len(string))	类似于 find()函数，不过是从右边开始查找.
isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
join(seq)	以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)	返回字符串长度
lower()	转换字符串中所有大写字符为小写.
upper()	转换字符串中的小写字母为大写
replace(old, new [, max])	把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
rstrip()	删除字符串字符串末尾的空格.
split(str="", num=string.count(str))	以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串

等待用户输入

input("\n\n按下 enter 键后退出。")

import 与 from…import

将somemodule 模块中的全部函数导入，格式为： from somemodule import *

基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

多个变量赋值

a = b = c = 1

a, b, c = 1, 2, "runoob"
以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

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

• Number（数字） （不可变）
• String（字符串） （不可变）
• Tuple（元组） （不可变）
• List（列表） （可变）
• Set（集合） （可变）
• Dictionary（字典） （可变）
• **不可变数据（3 个）：**Number【int、float、bool、complex（复数）】（数字）、String（字符串）、Tuple（元组）；
• **可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。

注意：在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的==**type() 函数和或isinstance ( a , type )**可以用来查询变量所指的对象类型==。

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

可以使用del语句删除一些对象引用。

del var1[,var2[,var3[....,varN]]]

您可以通过使用del语句删除单个或多个对象。例如：

del var
del var_a, var_b

注意：

• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
• 4、在混合计算时，Python会把整型转换成为浮点数。

>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0

Python 使用反斜杠 ** 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob

List（列表）

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

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

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

List 内置了有很多方法，例如

• append(obj)、在列表末尾添加新的对象
• += list 、添加
• pop([index =-1]) 、移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
• del() 、 删除列表元素 如：del list[2]
• remove(obj) 、移除列表中某个值的第一个匹配项
• count() 、 统计某个元素在列表中出现的次数
• index() 、 从列表中找出某个值第一个匹配项的索引位置
• insert() 、 将对象插入列表
• sort() 、对原列表进行排序
• clear() 、 清空列表
• copy() 、复制列表

注意：

• 1、List写在方括号之间，元素用逗号隔开。

• 2、和字符串一样，list可以被索引和切片。

• 3、List可以使用+操作符进行拼接。

• 4、List中的元素是可以改变的。

• 如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：

def reverseWord(input) :              # defined 定义
    inputWords = input.split(" ")
    inputWords = inputWords[-1::-1]      //第三个参数为负数表示逆向读取
    output = " ".join(inputWords)
    return output

if __name__ == "__main__":
    input = "I like runoob"
    rw = reverseWord(input)
    print(rw)

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表， 号用于重复列表。*

列表操作符表达式	结果
len([1, 2, 3])	3
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]
3 in [1, 2, 3]	True
for x in [1, 2, 3]: print(x, end=" ")	1 2 3

列表的遍历案例

案例一：在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
for index , value in enumerate(['tic','tac','toe']):  #遍历一个序列
    print(index,value)
---------
输出为：
0 tic
1 tac
2 toe
================================
 案例二：同时遍历两个或更多的序列，可以使用 zip() 组合：
questions = ['name','quest','favorite color']
answers = ['lancelot','the holy grail','blue']
for q,a in zip(questions,answers):
    print('What is your {0}?  It is {1}'.format(q,a))  #将两个序列的对应元素包装在一起
-----------
输出为：
What is your name?  It is lancelot
What is your quest?  It is the holy grail
What is your favorite color?  It is blue
===============================
案例三：要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：
for i in reversed(range(1,10,2)):  
    #range参数解析：从第一个参数开始到第二个参数结束，进位为第三个参数
    print(i,end=" ")
---------
输出为：
9 7 5 3 1 
=============================
案例四：要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值
basket = ['apple','orange','apple','pear','orange','banana']
for f in sorted(set(basket)):
    #set函数解析，元素不能重复
    print(f, end =" ")
---------------
输出为：
apple banana orange pear 
=========================

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改（元素一但存储就不好修改）。

**元组写在小括号 () 里，元素之间用逗号隔开，不需要括号也可以。**拥有正向索引和反向索引

虽然tuple的元素不可改变，但它可以包含可变的对象，(String只能存储字符对象)比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

string、list 和 tuple 都属于 sequence（序列）。

• +=tuple 、添加

• del() 、 删除元祖

• len() 、计算元组元素个数。

• max(tuple) 、返回元组中元素最大值。

• min(tuple) 、返回元组中元素最小值。

• tuple(iterable) 、将可迭代系列转换为元组。如列表转元组

• 元组操作符表达式	结果
  len((1, 2, 3)	3
  (1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)
  (‘Hi!’) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)
  3 in (1, 2, 3)	True
  for x in (1, 2, 3): print(x, end=" ")	1 2 3

Set（集合）

集合（set）是一个无序的不重复元素序列。

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

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

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

• add(x) :添加
• update(x) : 添加任意类型
• remove(x) ：删除元素 ，将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
• discard(x)：移除集合中的元素，且如果元素不存在，不会发生错误。
• len()：
• clear() :
• union() :返回两个集合的并集

Dictionary（字典）

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

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

==构造函数 dict()==可以直接从键值对序列中构建字典如下：

键(key)必须使用不可变类型，且不可变。值可以取任意数据类型

在同一个字典中，键(key)必须是唯一的。

另外，字典类型也有一些内置的函数，例如==clear()、keys()、values()==等。

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 3、创建空字典使用 { }。

函数：

• update(Dir) : 添加元素

• pop(key)：删除

• del()：

• str(dict)：输出字典，以可打印的字符串表示。

• get(key) ：返回指定键的值

• keys() :

• values():

• clear() ： 删除字典内所有元素

• len(dict)：计算字典元素个数，即键的总数。

• type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。

• copy():

• 字典操作符表达式	结果
  len({1:’ ‘, 2:’ ‘, 3:’ '})	3
  3 in {1:’ ‘, 2:’ ‘, 3:’ '}	True

  字典的遍历案例

  案例一：在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：
  knights = {'gallahad':'the pure','robin':'the brave'}
  for k in knights.items():   
      print(k)
  #('gallahad', 'the pure')
  #('robin', 'the brave')
  
  print("===============")
  for v in knights.items():
      print(v)
  #('gallahad', 'the pure')
  #('robin', 'the brave')
  
  print("==============")
  for k,v in knights.items():
      print(k,v)
  #gallahad the pure
  #robin the brave
  

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)	将一个整数转换为一个八进制字符串

Python3 运算符

• 算数运算符：+,-,*,/,%,**(幂),//(取整除)
• 比较运算符：==,!=,>,<,>=,<=
• 赋值运算符：=,+=,-=,*=,/=,%=,**=,//=,:=(海象运算符,在表达式内部为变量赋值3.8版本)
• 逻辑运算法：&(有零为0),|(有一为一),~(非),^(异为1),<<(左移),>>(右移)
• 位运算符：and , or , not
• 成员运算符：in , not in (成员运算符,测试实例中包含了一系列的成员，包括字符串，列表或元组。)
• 身份运算符：is(类似 id(x) == id(y)) , is not(类似 id(a) != id(b))
• 运算符优先级：

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

斐波那契数列

# 斐波那契数列  : 后一个数为前两个数的和
a = 0
b = 1
print(a,end=", ")
print(b,end=", ")
while b < 10000 :
    print(b,end=", ")
    a, b= b, a + b

条件语句

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

• 如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
• 如果 “condition_1” 为False，将判断 “condition_2”
• 如果"condition_2" 为 True 将执行 “statement_block_2” 块语句
• 如果 “condition_2” 为False，将执行"statement_block_3"块语句

循环语句

while循环

while 判断条件(condition)：
    执行语句(statements)……

while 循 环使用 else 语句

在 while … else 在条件语句为 false 时执行 else 的语句块。

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

无限循环

注意：可以使用 CTRL+C 来退出当前的无限循环。

var = 1
while var == 1 :  # 表达式永远为 true
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)
 
print ("Good bye!")

for 语句

for 实例中使用了 break 语句，break 语句用于跳出当前循环体

for <variable> in <sequence>:
    <statements>  break
else:
    <statements>

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

pass语句：pass 不做任何事情，一般用做占位语句，

(循环体由多个循环块组成)

range()函数

自动生成数列增值为1

print(range(5))              # range(0, 5)
for i in range(5):
    print(i,end = " ")      # 0 1 2 3 4  

迭代器

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

迭代器有两个基本的方法：iter() 和 next()。

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

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
print (next(it))   # 输出迭代器的下一个元素  # 1

或

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")    # 1 2 3 4 

生成器

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

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

import  sys
def fibonacci(n):       # 生成器函数 - 斐波那契
    a,b,counter = 0,1,0
    while True:
        if (counter >= n):
            return
        yield a
        a,b = b, a + b
        counter += 1
def fibonacciNow(n):       # 生成器函数 - 斐波那契
    a,b,counter = 0,1,0
    while True:
        if (counter >= n):
            return
        yield b
        a,b = b, a + b
        counter += 1
f = fibonacci(10)   # f 是一个迭代器，由生成器返回生成
g = fibonacciNow(10)  # g 是一个迭代器，由生成器返回生成
for x in f:
    print(x, end = " ")

print()

for x in g :
    print(x , end =" ")

函数

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

可更改(mutable)与不可更改(immutable)对象

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

• **不可变类型：**变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
• **可变类型：**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

不定长参数

加了星号 ***** 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

====================
def greetPerson(*name):
    print('Hello', name)
greetPerson('Runoob', 'Google')  # Hello ('Runoob', 'Google')

• 加了两个星号 ** 的参数会以字典的形式导入。

• 如果单独出现星号 ***** 后的参数必须用关键字传入。如：

def f(a,b,*,c):
...     return a+b+c

f(1,2,3)   # 报错
f(1,2,c=3) # 正常

匿名函数

目的是调用小函数时不占用栈内存从而增加运行效率。

lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda a , b : a + b
print(sum(12,15))     #27

输入与输出

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

• str()： 函数返回一个用户易读的表达形式。
• repr()： 产生一个解释器易读的表达形式。

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

写的方法：

• write(" ",“w+”)
• writelines()

读的方法：

• read([size])

• readline([size])

• readlines([sizeint])

pickle 模块

python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

基本接口：(写)

pickle.dump(obj, file, [,protocol])

有了 pickle 这个对象, 就能对 file 以读取的形式打开:（读）

x = pickle.load(file)

File方法

• open() ：打开一个文件，并返回文件对象，如果该文件无法被打开，会抛出 OSError。

一般格式：

open(file, mode='r')

完整格式：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• ***close()*** ：关闭文件。

• flush(): 刷新文件内部缓冲。

• seek(offset ,[,whence]): 移动文件读取指针到指定位置

• tell(): 返回文件当前位置。

• truncate([size]): 从文件的首行首字符开始截断，截断文件为 size 个字符

错误和异常

Python 有两种错误很容易辨认：语法错误和异常。

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

try/except

异常捕捉可以使用 try/except 语句。

try/except…else

try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。

else 子句将在 try 子句没有发生任何异常的时候执行。

try-finally 语句

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

抛出异常

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

raise语法格式如下：

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

assert（断言）

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

断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况，例如我们的代码只能在 Linux 系统下运行，可以先判断当前系统是否符合条件。

语法格式如下：

assert expression

等价于：

if not expression:
    raise AssertionError

assert 后面也可以紧跟参数:

assert expression [, arguments]

等价于：

if not expression:
    raise AssertionError(arguments)

OS模块

Python是跨平台的语言，也即是说同样的源代码在不同的操作系统不需要修改就可以同样实现。

因此Python的作者就倒腾了OS模块这么一个玩意儿出来，有了OS模块，我们不需要关心什么操作系统下使用什么模块，OS模块会帮你选择正确的模块并调用。

os模块中关于文件/目录常用的函数使用方法

函数名	使用方法
getcwd()	返回当前工作目录
chdir(path)	改变工作目录
listdir(path=’.’)	列举指定目录中的文件名（’.‘表示当前目录，’…'表示上一级目录）
mkdir(path)	创建单层目录，如该目录已存在抛出异常
makedirs(path)	递归创建多层目录，如该目录已存在抛出异常，注意：'E:\a\b’和’E:\a\c’并不会冲突
remove(path)	删除文件
rmdir(path)	删除单层目录，如该目录非空则抛出异常
removedirs(path)	递归删除目录，从子目录到父目录逐层尝试删除，遇到目录非空则抛出异常
rename(old, new)	将文件old重命名为new
system(command)	运行系统的shell命令
walk(top)	遍历top路径以下所有的子目录，返回一个三元组：(路径, [包含目录], [包含文件])【具体实现方案请看：第30讲课后作业_】
以下是支持路径操作中常用到的一些定义，支持所有平台
os.curdir	指代当前目录（’.’）
os.pardir	指代上一级目录（’…’）
os.sep	输出操作系统特定的路径分隔符（Win下为’\’，Linux下为’/’）
os.linesep	当前平台使用的行终止符（Win下为’\r\n’，Linux下为’\n’）
os.name	指代当前使用的操作系统（包括：‘posix’, ‘nt’, ‘mac’, ‘os2’, ‘ce’, ‘java’）

os.path模块中关于路径常用的函数使用方法

函数名	使用方法
basename(path)	去掉目录路径，单独返回文件名
dirname(path)	去掉文件名，单独返回目录路径
join(path1[, path2[, …]])	将path1, path2各部分组合成一个路径名
split(path)	分割文件名与路径，返回(f_path, f_name)元组。如果完全使用目录，它也会将最后一个目录作为文件名分离，且不会判断文件或者目录是否存在
splitext(path)	分离文件名与扩展名，返回(f_name, f_extension)元组
getsize(file)	返回指定文件的尺寸，单位是字节
getatime(file)	返回指定文件最近的访问时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
getctime(file)	返回指定文件的创建时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
getmtime(file)	返回指定文件最新的修改时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
以下为函数返回 True 或 False
exists(path)	判断指定路径（目录或文件）是否存在
isabs(path)	判断指定路径是否为绝对路径
isdir(path)	判断指定路径是否存在且是一个目录
isfile(path)	判断指定路径是否存在且是一个文件
islink(path)	判断指定路径是否存在且是一个符号链接
ismount(path)	判断指定路径是否存在且是一个挂载点
samefile(path1, paht2)	判断path1和path2两个路径是否指向同一个文件