python基础语法总结（超详细），被逼无奈开始狂啃底层技术_python所有语法

7 radiansdict.keys()

返回一个迭代器，可以使用 list() 来转换为列表

8 radiansdict.setdefault(key, default=None)

和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

9 radiansdict.update(dict2)

把字典dict2的键/值对更新到dict里

10 radiansdict.values()

返回一个迭代器，可以使用 list() 来转换为列表

11 pop(key[,default])

删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

12 popitem()

随机返回并删除字典中的一对键和值(一般删除末尾对)。

8.7 数据类型转换

数据类型转换函数简介

函数 描述

int(x，base) 将x转换为一个整数，x是数字或者字符串，base是转换进制，如int(x, base=10)转为十进制

float(x) 将x转换到一个浮点数

complex(real，imag) complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。如：complex(1, 2) —>1+2j

str(x) 将对象 x 转换为字符串

repr(x) 将对象 x 转换为表达式字符串,函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式。如：print(repr(“ranxia”))---->‘ranxia’

eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象，x = 7 ， eval( ‘3 * x’ )-----> 21

tuple(s) 将序列 s 转换为一个元组

list(s)

将序列 s 转换为一个列表

set(s)

转换为可变集合

dict(d)

创建一个字典。d 必须是一个 (key, value)元组序列。

frozenset(s)

转换为不可变集合

chr(x)

将一个整数转换为一个字符

ord(x)

将一个字符转换为它的整数值

hex(x)

将一个整数转换为一个十六进制字符串

oct(x)

将一个整数转换为一个八进制字符串

9、输入

读取键盘输入-input()：

ranxia = input(“请输入：”) #请输入：love ranxia

print(ranxia) #love ranxia

10、输出

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

print():

ranxia = “love”

xiaobin = “xiao”

print(ranxia) #love

print(xiaobin) #xiao

print(“-----------”)

print(ranxia,end=" “)

print(xiaobin,end=” ") #love xiao

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

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

str()： 函数返回一个用户易读的表达形式。

repr()： 产生一个解释器易读的表达形式。

s = ‘Hello, Runoob’

str(s)

‘Hello, Runoob’

repr(s)

“‘Hello, Runoob’”

str(1/7)

‘0.14285714285714285’

x = 10 * 3.25

y = 200 * 200

s = 'x 的值为： ’ + repr(x) + ‘, y 的值为：’ + repr(y) + ‘…’

print(s)

x 的值为： 32.5, y 的值为：40000…

repr() 函数可以转义字符串中的特殊字符

===================================================================================

… hello = ‘hello, runoob\n’

hellos = repr(hello)

print(hellos)

‘hello, runoob\n’

repr() 的参数可以是 Python 的任何对象

=======================================================================================

… repr((x, y, (‘Google’, ‘Runoob’)))

“(32.5, 40000, (‘Google’, ‘Runoob’))”

str.format() 的基本使用如下:

#旧式格式化输出

print(“我喜欢%s已经%d年了”%(“冉冉”,16)) #我喜欢冉冉已经16年了

#新式格式化输出

print(“我喜欢{}已经{}年了”.format(“冉冉”,16)) #我喜欢冉冉已经16年了

print(“我喜欢{1}已经{0}年了”.format(16,“冉冉”)) #我喜欢冉冉已经16年了 #这种方式可以指定顺序

11、import

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

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

import…as ----->import A as B,给予A库一个B的别称，帮助记忆

12、运算符

算术运算符

比较运算符

赋值运算符

逻辑运算符

位运算符

成员运算符

身份运算符

算术运算符 ：

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

运算符 描述 实例

• 加 - 两个对象相加 a + b 输出结果 31

• 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11

• 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210

/ 除 - x 除以 y b / a 输出结果 2.1

% 取模 - 返回除法的余数 b % a 输出结果 1

** 幂 - 返回x的y次幂 a**b 为10的21次方

// 取整除 - 向下取接近除数的整数

9//2

4

-9//2

-5

比较运算符：

以下假设变量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。

赋值运算符：

以下假设变量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 ** a

//= 取整除赋值运算符 c //= a 等效于 c = c // a

位运算符：

按位运算符是把数字看作二进制来进行计算的。下表中变量 a 为 60（0011 1100），b 为 13（0000 1101）

运算符 描述 实例

& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100

| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101

^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001

按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。

<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000

右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111

逻辑运算符：

假设变量 a 为 10, b为 20: 相当于C语言的 && ，|| ，！.

运算符 逻辑表达式 描述 实例

and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。

or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。

not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False

成员运算符：

成员运算符，成员包括字符串，列表或元组。

运算符 描述 实例

in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

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

if “ranxia” in xiaobin:

print(“ranxia 在集合xiaobin中”) # ranxia 在集合xiaobin中

elif (111 not in xiaobin) :

print(“111 在集合xiaobin中”) #222 不在集合xiaobin中

身份运算符：

身份运算符用于比较两个对象的存储单元

运算符 描述 实例

is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

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

注： id() 函数用于获取对象内存地址。

x1 = “xiaobin”

x2 = “xiaobin”

if x1 is x2: #换成id(x1) == id(x2)一样

print(“x1和x2有相同标识”) #x1和x2有相同标识

else:

print(“x1和x2没有相同标识”)

运算符优先级：

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

运算符 描述

** 指数 (最高优先级)

• • 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

• / % // 乘，除，取模和取整除

• • 加法减法

<< 右移，左移运算符

& 位 ‘AND’

^ | 位运算符

<= < > >= 比较运算符

<> == != 等于运算符

= %= /= //= -= += *= **= 赋值运算符

is is not 身份运算符

in not in 成员运算符

not and or

逻辑运算符

13、控制结构

条件控制

循环控制

条件控制：if 语句（if – elif – else），应注意与C语言的else if区分.无switch结构

if condition_1:

statement_block_1

elif condition_2:

statement_block_2

else:

statement_block_3

循环控制：while + for

while 循环: 没有 do…while 循环。

a = 0

while a < 10:

print(a)

a += 1 #0 1 2 3 4 5 6 7 8 9

for 语句:

xiaobin = [1,2,3,4,5,6,7,8,9]

for x in xiaobin:

print(x) #1 2 3 4 5 6 7 8 9

range()函数:

是一个迭代器，range函数大多数时常出如今for循环中。在for循环中可做为索引使用。事实上它也能够出如今不论什么须要整数列表的环境中.

for x in range(5):

print(x) # 0 1 2 3 4

也可以使用range指定区间的值：

for x in range(5,10):

print(x) # 5 6 7 8 9

也可以使range以指定数字开始并指定不同的步长(可以是负数)：

for x in range(0,10,2):

print(x) #0 2 4 6 8

for x in range(0,-10,-2):

print(x) #0 -2 -4 -6 -8

还可以结合range()和len()函数以遍历一个序列的索引，还可以使用range()函数来创建一个列表：list(range(5)) ------>[0, 1, 2, 3, 4]

break 和 continue :

和C语言和JAVA都一样，这里稍作叙述，新手需要细细体会：

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

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

pass语句：

Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句.

while True:

pass

14、迭代器与生成器

14.1 迭代器

Python最强大的功能之一.

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

是一个可以记住遍历的位置的对象。

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

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

字符串，列表或元组对象都可用于创建迭代器，通俗来讲，任何可以逐项地读取的对象，都做一个可迭代对象.

list = [1,2,3,4,5]

it = iter(list) #创建迭代器对象

print(next(it)) #1 输出下一个元素

print(next(it)) #2

有一点需要明确，迭代器指向的位置是元素之前的位置，其实和JAVA的ListIterator原理类似，如下图所示：

这里假设集合List由四个元素List1、List2、List3和List4组成，当使用语句it = iter(list)时，迭代器it指向的位置是上图中Iterator1指向的位置，当执行语句 next(it) 之后，迭代器指向的位置后移到上图Iterator2所指向的位置。

迭代器对象可以使用常规for语句进行遍历：

list = [5,6,7,8]

it = iter(list)

for x in it:

print(x,end=" ") #5 6 7 8

• 创建一个迭代器：

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

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

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

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:

def iter(self):

self.a = 1

return self

def next(self):

x = self.a

self.a += 1

return x

myclass = MyNumbers()

myiter = iter(myclass)

print(next(myiter))

print(next(myiter))

print(next(myiter))

print(next(myiter))

print(next(myiter))

StopIteration：

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

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 . . . 20的整数

14.2 生成器

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

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。调用一个生成器函数，返回的是一个迭代器对象（解决遍历时存储整个数列浪费内存的问题）。

更简单来说：

生成器是可以迭代的，但是你 只可以读取它一次 ，因为它并不把所有的值放在内存中，它是实时地生成数据:

yield 是一个类似 return 的关键字，迭代一次遇到yield时就返回yield后面(右边)的值。重点是：下一次迭代时，从上一次迭代遇到的yield后面的代码(下一行)开始执行。

也可以理解为：yield就是 return 返回一个值（这个值就是生成器），并且记住这个返回的位置，下次迭代就从这个位置后(下一行)开始。

def yield_test():

print(“开始…”)

yield “hello ranxia”

print(“测试”)

test = yield_test()

print(next(test)) #开始 hello ranxia

print(next(test)) #测试

可以看到“测试”并没有被输出，这里体现了它的return性，当执行第二条print(next(test))时，输出结果为“测试”，这一次的next开始的地方是接着上一次的next停止的地方执行的，所以调用next的时候，生成器并不会从test函数的开始执行，只是接着上一步停止的地方开始，然后遇到yield后，return出要生成的数，此步就结束。

注：百度和文档很多写得很生涩，这算是个最简单的例子了，先弄懂yield的特性和工作原理再去看什么yield实现斐波那契数列之类的就简单多了.

具体可以参见这篇译文：https://pyzh.readthedocs.io/en/latest/the-python-yield-keyword-explained.html

15、函数

定义一个函数&调用函数：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数，参数可有可无。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始，并且缩进。

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法如下：

def 函数名（参数列表）:

函数体

def test(var):

if var == “ranxia”:

print(“love u”)

else:

print(“piss off”)

#调用函数

test(“ranxia”) #love u

python 函数的参数传递：

不可变类型（strings、 tuples, 、 numbers ）：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

def xx(a):

a = 1

b=2

xx(b)

print(b) # 2 可见并没有改变值

匿名函数 lambda：

意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法如下：

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

sum = lambda x1,x2:x1+x2

print(sum(1,2)) #3

变量作用域：

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

L （Local） 局部作用域

E （Enclosing） 闭包函数外的函数中

G （Global） 全局作用域

B （Built-in） 内置作用域（内置函数所在模块的范围，其自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。可以使用dir查看）

import builtins

print(dir(builtins))

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

全局变量和局部变量：

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

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

total = 0 # 这是一个全局变量

可写函数说明

===================================================================

def sum( arg1, arg2 ):

#返回2个参数的和."

total = arg1 + arg2 # total在这里是局部变量. #函数内是局部变量 : 30

print ("函数内是局部变量 : ", total)

return total

#调用sum函数

sum( 10, 20 )

print ("函数外是全局变量 : ", total) #函数外是全局变量 : 0

global 和 nonlocal关键字：

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

num = 1

def fun1():

global num # 需要使用 global 关键字声明

print(num) # 1

num = 123

print(num) #123

fun1()

print(num) #123

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

def outer():

num = 10

def inner():

nonlocal num # nonlocal关键字声明

num = 100

print(num) #100

inner()

print(num) #100

outer()

16、文件（File）

读和写文件:

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

filename：包含了你要访问的文件名称的字符串值。

mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。

不同模式打开文件的完全列表：

模式 描述

r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。

r+ 打开一个文件用于读写。文件指针将会放在文件的开头。

rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

简要如下图：

模式 r r+ w w+ a a+

读 + + + +

写 + + + + +

创建 + + + +

覆盖 + +

指针在开始 + + + +

指针在结尾 + +

将字符串“I love ranxia”写入test.txt文件夹：

写入字符串

f = open(“files/test.txt”,“w”)

f.write(“I love ranxia”)

f.close()

#读取文件内容

f = open(“files/test.txt”,“r”)

str = f.read()

print(str) #I love ranxia

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

pickle 模块：

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

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

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

基本接口：

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

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

x = pickle.load(file)

注解：从 file 中读取一个字符串，并将它重构为原来的python对象。

file: 类文件对象，有read()和readline()接口。

实例 1：

import pickle

使用pickle模块将数据对象保存到文件

=================================================================================

data1 = {‘a’: [1, 2.0, 3, 4+6j],

‘b’: (‘string’, u’Unicode string’),

‘c’: None}

selfref_list = [1, 2, 3]

selfref_list.append(selfref_list)

output = open(‘data.pkl’, ‘wb’)

Pickle dictionary using protocol 0.

================================================================================================

pickle.dump(data1, output)

Pickle the list using the highest protocol available.

==================================================================================================================

pickle.dump(selfref_list, output, -1)

output.close()

实例 2：

import pprint, pickle

#使用pickle模块从文件中重构python对象

pkl_file = open(‘data.pkl’, ‘rb’)

data1 = pickle.load(pkl_file)

pprint.pprint(data1)

data2 = pickle.load(pkl_file)

pprint.pprint(data2)

pkl_file.close()

常见方法：

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

序号 方法及描述

1

file.close()

关闭文件。关闭后文件不能再进行读写操作。

2

file.flush()

刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

3

file.fileno()

返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。

4

file.isatty()

如果文件连接到一个终端设备返回 True，否则返回 False。

5

file.next()

Python 3 中的 File 对象不支持 next() 方法。

返回文件下一行。

6

file.read([size])

从文件读取指定的字节数，如果未给定或为负则读取所有。

7

file.readline([size])

读取整行，包括 “\n” 字符。

8

file.readlines([sizeint])

读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。

9

file.seek(offset[, whence])

设置文件当前位置

10

file.tell()

返回文件当前位置。

11

file.truncate([size])

从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。

12

file.write(str)

将字符串写入文件，返回的是写入的字符长度。

13

file.writelines(sequence)

向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

OS 文件/目录方法：

序号 方法及描述

1

os.access(path, mode)

检验权限模式

2

os.chdir(path)

改变当前工作目录

3

os.chflags(path, flags)

设置路径的标记为数字标记。

4

os.chmod(path, mode)

更改权限

5

os.chown(path, uid, gid)

更改文件所有者

6

os.chroot(path)

改变当前进程的根目录

7

os.close(fd)

关闭文件描述符 fd

8

os.closerange(fd_low, fd_high)

关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略

9

os.dup(fd)

复制文件描述符 fd

10

os.dup2(fd, fd2)

将一个文件描述符 fd 复制到另一个 fd2

11

os.fchdir(fd)

通过文件描述符改变当前工作目录

12

os.fchmod(fd, mode)

改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。

13

os.fchown(fd, uid, gid)

修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。

14

os.fdatasync(fd)

强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。

15

os.fdopen(fd[, mode[, bufsize]])

通过文件描述符 fd 创建一个文件对象，并返回这个文件对象

16

os.fpathconf(fd, name)

返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。

17

os.fstat(fd)

返回文件描述符fd的状态，像stat()。

18

os.fstatvfs(fd)

返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。

19

os.fsync(fd)

强制将文件描述符为fd的文件写入硬盘。

20

os.ftruncate(fd, length)

裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。

21

os.getcwd()

返回当前工作目录

22

os.getcwdu()

返回一个当前工作目录的Unicode对象

23

os.isatty(fd)

如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。

24

os.lchflags(path, flags)

设置路径的标记为数字标记，类似 chflags()，但是没有软链接

25

os.lchmod(path, mode)

修改连接文件权限

26

os.lchown(path, uid, gid)

更改文件所有者，类似 chown，但是不追踪链接。

27

os.link(src, dst)

创建硬链接，名为参数 dst，指向参数 src

28

os.listdir(path)

返回path指定的文件夹包含的文件或文件夹的名字的列表。

29

os.lseek(fd, pos, how)

设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效

30

os.lstat(path)

像stat(),但是没有软链接

31

os.major(device)

从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。

32

os.makedev(major, minor)

以major和minor设备号组成一个原始设备号

33

os.makedirs(path[, mode])

递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。

34

os.minor(device)

从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。

35

os.mkdir(path[, mode])

以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。

36

os.mkfifo(path[, mode])

创建命名管道，mode 为数字，默认为 0666 (八进制)

37

os.mknod(filename[, mode=0600, device])

创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。

38

os.open(file, flags[, mode])

打开一个文件，并且设置需要的打开选项，mode参数是可选的

39

os.openpty()

打开一个新的伪终端对。返回 pty 和 tty的文件描述符。

40

os.pathconf(path, name)

返回相关文件的系统配置信息。

41

os.pipe()

创建一个管道. 返回一对文件描述符(r, w) 分别为读和写

42

os.popen(command[, mode[, bufsize]])

从一个 command 打开一个管道

43

os.read(fd, n)

从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。

44

os.readlink(path)

返回软链接所指向的文件

45

os.remove(path)

删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。

46

os.removedirs(path)

递归删除目录。

47

os.rename(src, dst)

重命名文件或目录，从 src 到 dst

48

os.renames(old, new)

递归地对目录进行更名，也可以对文件进行更名。

49

os.rmdir(path)

删除path指定的空目录，如果目录非空，则抛出一个OSError异常。

50

os.stat(path)

获取path指定的路径的信息，功能等同于C API中的stat()系统调用。

51

os.stat_float_times([newvalue])

决定stat_result是否以float对象显示时间戳

52

os.statvfs(path)

获取指定路径的文件系统统计信息

53

os.symlink(src, dst)

创建一个软链接

54

os.tcgetpgrp(fd)

返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组

55

os.tcsetpgrp(fd, pg)

设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。

56

os.ttyname(fd)

返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。

57

os.unlink(path)

删除文件路径

58

os.utime(path, times)

返回指定的path文件的访问和修改的时间。

59

os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])

输出在文件夹中的文件名通过在树中游走，向上或者向下。

60

os.write(fd, str)

写入字符串到文件描述符 fd中. 返回实际写入的字符串长度

61

os.path 模块

获取文件的属性信息。

17、错误与异常

即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常，比如除数为0，文件找不等。

异常处理：try-except-finally

这一部分内容和JAVA的异常处理类似：

import sys

try: #try是需要检测异常的语句块

f = open(‘myfile.txt’)

s = f.readline()

i = int(s.strip())

except OSError as err: #捕获异常并作出相应处理

print(“OS error: {0}”.format(err))

except ValueError:

print(“Could not convert data to an integer.”)

except:

print(“Unexpected error:”, sys.exc_info()[0])

raise

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

首先，执行try子句（在关键字try和关键字except之间的语句）

如果没有异常发生，忽略except子句，try子句执行后结束。

如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。

如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

except (RuntimeError, TypeError, NameError): pass

try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:

for arg in sys.argv[1:]:

try:

f = open(arg, ‘r’)

except IOError:

print(‘cannot open’, arg)

else:

print(arg, ‘has’, len(f.readlines()), ‘lines’)

f.close()

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。

抛出异常：

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

raise NameError(‘HiThere’)

Traceback (most recent call last):

File “”, line 1, in ?

NameError: HiThere

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

try:

raise NameError(‘HiThere’)

except NameError:

print(‘An exception flew by!’)

raise

An exception flew by!

Traceback (most recent call last):

File “”, line 2, in ?

NameError: HiThere

用户自定义异常：

可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:

class MyError(Exception):

def init(self, value):

self.value = value

def str(self):

return repr(self.value)

try:

raise MyError(2*2)

except MyError as e:

print(‘My exception occurred, value:’, e.value)

My exception occurred, value: 4

raise MyError(‘oops!’)

Traceback (most recent call last):

File “”, line 1, in ?

main.MyError: ‘oops!’

在这个例子中，类 Exception 默认的 init() 被覆盖。当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception):

“”“Base class for exceptions in this module.”“”

pass

class InputError(Error):

“”"Exception raised for errors in the input.

Attributes:

expression – input expression in which the error occurred

message – explanation of the error

“”"

def init(self, expression, message):

self.expression = expression

self.message = message

class TransitionError(Error):

“”"Raised when an operation attempts a state transition that’s not

文末有福利领取哦~