python自查手册

• Z时代
• 2024-01-10
• 分类：综合

一、数据类型

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）

• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

1.1 Number（数字）

Python3 支持 int、float、bool、complex（复数）。在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

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

isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型。isinstance()会认为子类是一种父类类型。

1.1.1 类型转换

• int(x) 将x转换为一个整数。

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

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

1.1.2 数字运算

 +, -, * 和 /，和其它语言（如Pascal或C）里一样。** 操作来进行幂运算。

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // 。// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

>>> 17 / 3  # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 17 % 3  # ％操作符返回除法的余数
2
>>> 5 * 3 + 2 
17
>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128

View Code

1.1.3 数学函数

函数          返回值 ( 描述 )
abs(x)     返回数字的绝对值，如abs(-10) 返回 10
ceil(x)       返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)      如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。

exp(x)       返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)       返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)      返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)      如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)       返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)     返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)      返回给定参数的最小值，参数可以为序列。
modf(x)      返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)      x**y 运算后的值。
round(x [,n])     返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。

sqrt(x) 返回数字x的平方根。

 1.1.4 随机函数

1.2 String（字符串）

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

#!/usr/bin/python3
str = 'Runoob'
print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

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

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

另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

1.2.1 转义字符

转义字符            描述
\(在行尾时)       续行符
\\                 反斜杠符号
\'                   单引号
\"                  双引号
\a                  响铃
\b                  退格(Backspace)
\000               空
\n                  换行
\v                  纵向制表符
\t                  横向制表符
\r                  回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。
\f                  换页
\yyy              八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
\xyy              十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
\other            其它的字符以普通格式输出

变量 a 值为字符串 "Hello"，b 变量值为 "Python"：1.2.2 字符串运算 

print( r'\n' )
print( R'\n' )

1.2.3 内置函数

1.3 List（列表）

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

#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

Python 列表截取可以接收第三个参数，参数作用是截取的步长。如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：

def reverseWords(input):
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ")
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1]
    # 重新组合字符串
    output = ' '.join(inputWords)
    return output
if __name__ == "__main__":
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw)
# runoob like I

View Code

1.3.1 函数

len(list)  列表元素个数 

max(list) 返回列表元素最大值

min(list) 返回列表元素最小值

list(seq) 将元组转换为列表

1.3.2 方法

list.append(obj) 列表末尾添加新的对象

list.count(obj) 统计某个元素在列表中出现的次数

list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.index(obj) 从列表中找出某个值第一个匹配项的索引位置

list.insert(index, obj)将对象插入列表

list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list.remove(obj) 移除列表中某个值的第一个匹配项

list.reverse() 反向列表中元素

list.sort( key=None, reverse=False) 对原列表进行排序

list.clear() 清空列表

list.copy() 复制列表

1.4 Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。tuple只有一个元素，需要在元素后添加逗号。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。 内置函数与list类似，只是list(seq)换为tuple(iterable)

#!/usr/bin/python3
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

1.5 Set（集合）

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

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

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

创建格式：

parame = {value01,value02,...}
或者
set(value)

#!/usr/bin/python3
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites)   # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')
# 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 中不同时存在的元素

{'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
Runoob 在集合中
{'b', 'c', 'a', 'r', 'd'}
{'r', 'b', 'd'}
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
{'c', 'a'}
{'z', 'b', 'm', 'r', 'l', 'd'}

1.5.1 集合操作

s.add(x) 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.update(x) 也可以添加元素，且参数可以是列表，元组，字典等

s.remove(x) 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.discard(x) 移除集合中的元素，且如果元素不存在，不会发生错误。

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

len(s) 计算集合 s 元素个数。

s.clear() 清空集合 s。

x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

1.5.2 方法

add()为集合添加元素

clear()移除集合中的所有元素

copy()拷贝一个集合

difference()返回多个集合的差集

difference_update()移除集合中的元素，该元素在指定的集合也存在。

discard()删除集合中指定的元素

intersection()返回集合的交集

intersection_update()返回集合的交集。

isdisjoint()判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

issubset()判断指定集合是否为该方法参数集合的子集。

issuperset()判断该方法的参数集合是否为指定集合的子集

pop()随机移除元素

remove()移除指定元素

symmetric_difference()返回两个集合中不重复的元素集合。

symmetric_difference_update()移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

union()返回两个集合的并集

update()给集合添加元素

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

1.6 Dictionary（字典）

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

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

#!/usr/bin/python3
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

1.6.1 方法

radiansdict.clear() 删除字典内所有元素
radiansdict.copy() 返回一个字典的浅复制
radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
key in dict 如果键在字典dict里返回true，否则返回false
radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys() 返回一个迭代器，可以使用 list() 来转换为列表
radiansdict.setdefault(key, default=None) 和get() 类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表
pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem() 随机返回并删除字典中的最后一对键和值。

二、条件控制

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

三、循环语句

3.1 while循环

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

在 Python 中没有 do..while 循环。

3.1.1 无限循环

while True:
    pass

3.1.2 while 循环使用 else 语句

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

#!/usr/bin/python3
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

3.2 for循环

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

#!/usr/bin/python3
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")
-----------------------------------------------
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

View Code

3.3 range()函数

如果你需要遍历数字序列，可以使用内置range()函数。

for i in range(5):
#区间:
for i in range(5,9) :
#指定不同的增量:
for i in range(0, 10, 3) :
#结合range()和len()函数
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):

3.4 break、continue、else

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

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

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。

pass是空语句，是为了保持程序结构的完整性。 

四、函数

4.1  函数的创建和调用

def 函数名（参数列表）:
    函数体
    [return xxx]

#!/usr/bin/python3
# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

4.2 函数的参数传递

4.2.1 位置实参

#!/usr/bin/python3
#可写函数说明
def printme(str1, str2):
   "打印任何传入的字符串"
   print (str1, str2)
   return
# 调用 printme 函数
a = 's'
b = 'w'
printme(a, b)

4.2.2 关键字参数

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

#!/usr/bin/python3
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
#调用printme函数
printme( str = "菜鸟教程")

4.2.3 默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

#!/usr/bin/python3
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

4.2.4 不定长参数

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

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

#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
----------------------------------
70
(60, 50)

还有一种就是参数带两个星号 **，加了两个星号 ** 的参数会以字典的形式导入。

#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
-------------------
1
{'a': 2, 'b': 3}

声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 * 后的参数必须用关键字传入。

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6

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

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

#不可变对象
def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
a=1
print(id(a))
change(a)
----------------
4379369136
4379369136
4379369424

#可变对象
#!/usr/bin/python3
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
---------------
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

 4.2.6 匿名函数

 python 使用 lambda 来创建匿名函数。只能写一行。

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

#!/usr/bin/python3
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
----------------
相加后的值为 :  30
相加后的值为 :  40

 五、python面向对象

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。

类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

#!/usr/bin/python3
#类定义
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))
    # 静态方法,使用类名直接访问
    @staticmethod
def sleep():
pass
    # 类方法，使用类名直接访问
    @classmethod
def eat(cls):
pass
#单继承示例
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))
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
# 类实例化
s = student('ken',10,60,3)
# 访问类的属性或方法
s.speak()
# 用子类对象调用父类已被覆盖的方法
# python2中调用super方法必须是新类（有继承的类），此时people应继承object。python3默认都是新类
super(student,s).speak()
# 类实例化
test = sample("Tim",25,80,4,"Python")
# 访问类的属性或方法
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

ken 说: 我 10 岁了，我在读 3 年级

ken 说: 我 10 岁。

我叫 Tim，我是一个演说家，我演讲的主题是 Python

 5.2 特殊属性&方法

特殊属性：
__dict__ : 类或实例绑定的所有属性和方法的字典
__class__ : 所属类
__bases__ : 父类
__base__ : 第一个继承的父类
__mro__ : 类的层次结构

特殊方法：
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方
__subclasses__: 子类列表

 5.3 浅拷贝&深拷贝

浅拷贝：copy.copy拷贝时对象包含的子对象内容不拷贝，因此源对象和拷贝对象会引用同一个子对象

深拷贝：copy.deepcopy函数，递归拷贝对象中包含的子对象。

 六、File

6.1 open方法

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

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

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

 6.2 File对象

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

file.close()关闭文件。关闭后文件不能再进行读写操作。

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

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

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

file.read([size])从文件读取指定的字节数，如果未给定或为负则读取所有。

file.readline([size])读取整行，包括 "\n" 字符。

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

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

file.tell()返回文件当前位置。

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

file.write(str)将字符串写入文件，返回的是写入的字符长度。

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

6.3 with语句

with open('logo.png', 'rb') as img:
    img.read()

with语句自动管理上下文资源，不论什么原因跳出with块，都能确保文件能够正确关闭（自动调用特殊方法__exit()__），以此达到释放资源的目的。

 7. os模块

7.1 常用函数

os.getcwd() 返回当前工作目录

os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。 

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

os.makedirs(path[, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。

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

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

os.removedirs(path) 递归删除目录。

os.chdir(path) 改变当前工作目录。

7.2 os.path() 模块

os.path.abspath(path)     返回绝对路径
os.path.exists(path)     路径存在则返回True,路径损坏返回False
os.path.join(path1[, path2[, ...]])      把目录和文件名合成一个路径
os.path.splitext(path)     分割路径中的文件名与拓展名
os.path.basename(path)      返回文件名
os.path.dirname(path)     返回文件路径
os.path.isfile(path)     判断路径是否为文件
os.path.isdir(path)     判断路径是否为目录

 八、异常

8.1 异常处理

>>> def divide(x, y):
        try:
            result = x / y
        except ZeroDivisionError:
            print("division by zero!")
        else:
            print("result is", result)
        finally:
            print("executing finally clause")
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。如果没有异常发生，忽略 except 子句，try 子句执行后结束。如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。

else 子句将在 try 子句没有发生任何异常的时候执行。使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。

finally 语句无论异常是否发生都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。

8.2 抛出异常

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

try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')
    raise

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

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

8.3 traceback模块

import logging
import traceback
try:
    raise NameError('HiThere')
except NameError:
    err_msg = traceback.format_exc()
    logging.info(err_msg)

以上是 python自查手册 的全部内容， 来源链接： utcz.com/z/388455.html