Python 基础语法总结

7、声明变量

Python 无需像 Java 和 C++ 一样在声明变量前需要知道类型，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。变量没有类型，分配内存后才有。

var = 1
print(var) # 输出 1

等号（=）赋值。 多变量赋值如下：

a = b = c = 1 # a = 1; b = 1; c = 1
a, b, c = 1, 2, "data" # a = 1; b = 2; c = "data"

一个变量可以通过赋值指向不同类型的对象。 在数值混合计算时，Python 会把整型转换成为浮点数。

8、标准数据类型

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

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

在这六种类型中： 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组） 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合） 注：del var 都能起到删除的作用。

变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

8.1 Number（数字）

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

• int (整数): 如 1，只有一种整数类型 int，表示为长整型。
• bool (布尔): 如 True。
• float (浮点数): 如 1.23、3E-2。
• complex (复数): 如 1 + 2j（complex(1, 2)），1.1 + 2.2j。

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

var = 228 # 当变量被赋值时，Number 对象即被创建
print(type(var)) # <class 'int'>
print(isinstance(var, int)) # True

isinstance 和 type 的区别在于：

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

class X: pass
class R(X): pass
print(isinstance(R(), X)) # True
print(type(R()) == X) # False

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

del x, x1

数值运算：

print(1 + 1)     # 加法 2
print(5.2 - 2)   # 减法 3.2
print(3 * 7)     # 乘法 21
print(2 / 4)     # 除法，取浮点数 0.5
print(2 // 4)    # 除法，取整数 0
print(5 % 2)     # 取余 1
print(2 ** 3)    # 乘方，8

数学函数：

• abs(x): 返回数字的绝对值。
• ceil(x): 返回数字的上入整数。
• exp(x): 返回 e 的 x 次幂。
• floor(x): 返回数字的下舍整数。
• log(x): 返回自然对数。
• max(x1, x2,...): 返回给定参数的最大值。
• min(x1, x2,...): 返回给定参数的最小值。
• pow(x, y): x 的 y 次幂。
• round(x[, n]): 返回浮点数 x 的四舍五入值。
• sqrt(x): 返回数字 x 的平方根。

随机数函数：

• choice(seq): 从序列的元素中随机挑选一个元素。
• randrange([start,] stop [,step]): 获取一个随机数。
• random(): 随机生成下一个实数，它在 [0,1) 范围内。
• seed([x]): 改变随机数生成器的种子。
• shuffle(lst): 将序列的所有元素随机排序。
• uniform(x, y): 随机生成下一个实数，它在 [x,y] 范围内。

三角函数：

• acos(x), asin(x), atan(x), cos(x), sin(x), tan(x) 等。
• degrees(x): 将弧度转换为角度。
• radians(x): 将角度转换为弧度。

数学常量：

• pi: 圆周率。
• e: 自然常数。

数字类型转换：

• int(x): 将 x 转换为一个整数。
• float(x): 将 x 转换到一个浮点数。
• complex(x): 将 x 转换到一个复数。

8.2 字符串 (String)

Python 中单引号和双引号使用完全相同。 使用三引号 (''' 或 """) 可以指定一个多行字符串，或者使用反斜杠 可以作为续行符。

word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
print(word)
print(sentence)
print(paragraph)

转义符 ： 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。如 r"this is a line with \n" 则 会显示，并不是换行。 字符串可以用 + 运算符连接在一起，用 * 运算符重复。

Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。 与 C 字符串不同的是，Python 字符串不能被改变。 Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

字符串截取： 变量 [头下标：尾下标：步长]。

str_data = 'example'
print(str_data[0:-1]) # example
print(str_data[0])    # e
print(str_data[2:5])  # amp
print(str_data[2:])   # ample
print(str_data * 2)   # exampleexample
print(str_data + '你好') # example你好
print('ex\nample')   # ex
                        # ample
print(r'ex\nample')  # ex\nexample

转义字符：

• : 换行
• : 横向制表符
• : 回车
• \: 反斜杠符号
• ": 双引号
• ': 单引号

字符串运算符：

• +: 字符串连接
• *: 重复输出字符串
• []: 通过索引获取字符串中字符
• [:]: 截取字符串中的一部分
• in: 成员运算符
• not in: 成员运算符
• %: 格式字符串

字符串格式化符号：

• %c: 格式化字符及其 ASCII 码
• %s: 格式化字符串
• %d: 格式化整数
• %f: 格式化浮点数字
• %x: 格式化无符号十六进制数

字符串内建函数：

1. capitalize(): 将字符串的第一个字符转换为大写
2. center(width, fillchar): 返回一个指定的宽度居中字符串
3. count(str, beg=0, end=len(string)): 返回 str 在 string 里面出现的次数
4. encode(encoding='UTF-8', errors='strict'): 编码字符串
5. endswith(suffix, beg=0, end=len(string)): 检查字符串是否以 obj 结束
6. expandtabs(tabsize=8): 把 tab 符号转为空格
7. find(str, beg=0, end=len(string)): 检测 str 是否包含在字符串中
8. index(str, beg=0, end=len(string)): 跟 find() 方法一样，但找不到会报错
9. isalnum(): 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True
10. isalpha(): 如果字符串至少有一个字符并且所有字符都是字母则返回 True
11. isdigit(): 如果字符串只包含数字则返回 True
12. islower(): 如果字符串中包含至少一个区分大小写的字符，且都是小写，则返回 True
13. isspace(): 如果字符串中只包含空白，则返回 True
14. istitle(): 如果字符串是标题化的则返回 True
15. isupper(): 如果字符串中包含至少一个区分大小写的字符，且都是大写，则返回 True
16. join(seq): 以指定字符串作为分隔符，合并 seq 中所有的元素
17. len(string): 返回字符串长度
18. ljust(width[, fillchar]): 返回原字符串左对齐并使用 fillchar 填充至长度 width 的新字符串
19. lower(): 转换字符串中所有大写字符为小写
20. lstrip(): 截掉字符串左边的空格或指定字符
21. maketrans(): 创建字符映射的转换表
22. max(str): 返回字符串 str 中最大的字母
23. min(str): 返回字符串 str 中最小的字母
24. replace(old, new[, max]): 将字符串中的 str1 替换成 str2
25. rfind(str, beg=0, end=len(string)): 类似于 find() 函数，不过是从右边开始查找
26. rindex(str, beg=0, end=len(string)): 类似于 index()，不过是从右边开始
27. rjust(width[, fillchar]): 返回原字符串右对齐并使用 fillchar 填充至长度 width 的新字符串
28. rstrip(): 删除字符串末尾的空格
29. split(str="", num=count): 以 str 为分隔符截取字符串
30. splitlines([keepends]): 按照行分隔，返回列表
31. startswith(substr, beg=0, end=len(string)): 检查字符串是否是以指定子字符串 substr 开头
32. strip([chars]): 在字符串上执行 lstrip() 和 rstrip()
33. swapcase(): 将字符串中大写转换为小写，小写转换为大写
34. title(): 返回 "标题化" 的字符串
35. translate(table, deletechars=""): 根据表转换 string 的字符
36. upper(): 转换字符串中的小写字母为大写
37. zfill(width): 返回长度为 width 的字符串，原字符串右对齐，前面填充 0
38. isdecimal(): 检查字符串是否只包含十进制字符

8.3 List（列表）

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。 del 删除某一项。

my_list = ["data", "0228", 1011, 0.228]
test = ["hello world!"]
print(my_list) # ['data', '0228', 1011, 0.228]
print(my_list[0]) # data
print(my_list[1:3]) # ['0228', 1011]
print(my_list[2:]) # [1011, 0.228]
print(my_list * 2) # ['data', '0228', 1011, 0.228, 'data', '0228', 1011, 0.228]
print(my_list + test) # ['data', '0228', 1011, 0.228, 'hello world!']

与 String 不一样的是，列表中的元素是可以改变的：

my_list[2] = "love"
print(my_list) # ['data', '0228', 'love', 0.228]

列表脚本操作符：

• 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. len(list): 列表元素个数
2. max(list): 返回列表元素最大值
3. min(list): 返回列表元素最小值
4. list(seq): 将元组转换为列表

Python 还包含以下方法：

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

8.4 Tuple（元组）

string、list 和 tuple 都属于 sequence（序列），元组（tuple）与列表类似，不同之处如下：

• 元组的元素不能修改，但可以对元组进行连接组合。
• 虽然 tuple 的元素不可改变，但它可以包含可变的对象，比如 list 列表。
• 元组中的元素值是不允许删除的，但可以使用 del 语句来删除整个元组。
• 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

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

内置函数：

1. len(tuple): 计算元组元素个数。
2. max(tuple): 返回元组中元素最大值。
3. min(tuple): 返回元组中元素最小值。
4. tuple(seq): 将列表转换为元组。

8.5 Set（集合）

集合（set）是由一个或数个不同或相同的整体组成的，构成集合的事物或对象称作元素或是成员。 基本功能是进行成员关系测试和删除重复元素（不能包含重复元素）。 可以使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典。

my_set = set(["data", 111, 111]) # my_set = {"data", 111}
print(my_set) #{'data', 111} # 重复的元素会被自动屏蔽掉
# 成员测试
if "data" in my_set:
    print("data 在集合中")
else:
    print("data 不在集合中")

集合还可以用来集合运算：

set_a = set("data")
set_b = set("test")
print(set_a - set_b) # 差集
print(set_a | set_b) # 并集
print(set_a & set_b) # 交集
print(set_a ^ set_b) # 对称差集

内置方法完整列表：

• add(): 为集合添加元素
• clear(): 移除集合中的所有元素
• copy(): 拷贝一个集合
• difference(): 返回多个集合的差集
• discard(): 删除集合中指定的元素
• intersection(): 返回集合的交集
• pop(): 随机移除元素
• remove(): 移除指定元素
• union(): 返回两个集合的并集
• update(): 给集合添加元素

8.6 Dictionary（字典）

和 Java 中的 Map 类似。 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。 字典是一种映射类型，字典用 {} 标识，也可以用构造函数 dict() 直接通过键值对构造。它是一个无序的 键 (key) : 值 (value) 的集合。 键 (key) 必须使用不可变类型，所以可以用数字，字符串或元组充当，而用列表就不行。 在同一个字典中，键 (key) 必须是唯一的，创建时如果同一个键被赋值两次，则只有后一个值会被记住。

dict_var = {}
dict_var["lover"] = "data"
dict_var[520] = "value"
print(dict_var["lover"]) # data
print(dict_var[520]) # value

另一种方式：

dict_var = {"lover": "value", 520: "data"}
print(dict_var) #{'lover': 'value', 520: 'data'}
print(dict_var.keys()) # dict_keys(['lover', 520]) 输出所有键
print(dict_var.values()) # dict_values(['value', 'data']) 输出所有值

构造函数 dict()：

dict_var = dict([("lover", "value"), (520, "data")])
print(dict_var) #{'lover': 'value', 520: 'data'}

常见内置函数：

1. len(dict): 计算字典元素个数，即键的总数。
2. str(dict): 输出字典，以可打印的字符串表示。
3. type(variable): 返回输入的变量类型。

Python 字典还包含了以下内置方法：

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

8.7 数据类型转换

数据类型转换函数简介：

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

9、输入

读取键盘输入 input()：

var = input("请输入：")
print(var)

10、输出

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

var1 = "love"
var2 = "data"
print(var1) # love
print(var2) # data
print("-----------")
print(var1, end=" ")
print(var2, end=" ") # love data

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。 如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

s = 'Hello, Runoob'
print(str(s)) # 'Hello, Runoob'
print(repr(s)) # 'Hello, Runoob'

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

# 旧式格式化输出
print("我喜欢%s已经%d年了" % ("name", 16))
# 新式格式化输出
print("我喜欢{}已经{}年了".format("name", 16))
print("我喜欢{1}已经{0}年了".format(16, "name"))

11、import

在 Python 用 import 或者 from...import 来导入相应的模块。

• 将整个模块导入：import somemodule
• 从某个模块中导入某个函数：from somemodule import somefunction
• 从某个模块中导入多个函数：from somemodule import firstfunc, secondfunc
• 将某个模块中的全部函数导入：from somemodule import *
• import A as B: 给予 A 库一个 B 的别称。

12、运算符

算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符、身份运算符。

算术运算符： 假设变量 a 为 10，变量 b 为 21：

• +: 加
• -: 减
• *: 乘
• /: 除
• %: 取模
• **: 幂
• //: 取整除

比较运算符： 假设变量 a 为 10，变量 b 为 20：

• ==: 等于
• !=: 不等于
• >: 大于
• <: 小于
• >=: 大于等于
• <=: 小于等于

赋值运算符：

• =: 简单的赋值运算符
• +=: 加法赋值运算符
• -=: 减法赋值运算符
• *=: 乘法赋值运算符
• /=: 除法赋值运算符
• %=: 取模赋值运算符
• **=: 幂赋值运算符
• //=: 取整除赋值运算符

位运算符： 按位运算符是把数字看作二进制来进行计算的。

• &: 按位与
• |: 按位或
• ^: 按位异或
• ~: 按位取反
• <<: 左移动运算符
• >>: 右移动运算符

逻辑运算符：

• and: 布尔 "与"
• or: 布尔 "或"
• not: 布尔 "非"

成员运算符：

• in: 如果在指定的序列中找到值返回 True
• not in: 如果在指定的序列中没有找到值返回 True

身份运算符：

• is: 判断两个标识符是不是引用自一个对象
• is not: 判断两个标识符是不是引用自不同对象

运算符优先级： 从高到低依次为：**, ~ + -, / % //, - +, << >>, &, ^ |, <= < > >=, <> == !=, = %= /= //= -= += *= **=, 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

for 语句：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for x in my_list:
    print(x)

range() 函数： 是一个迭代器，range 函数大多数时常出现在 for 循环中。

for x in range(5):
    print(x) # 0 1 2 3 4

for x in range(5, 10):
    print(x) # 5 6 7 8 9

for x in range(0, 10, 2):
    print(x) # 0 2 4 6 8

break 和 continue：

• break: 跳出 for 和 while 的循环体。
• continue: 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

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

while True:
    pass

14、迭代器与生成器

14.1 迭代器

Python 最强大的功能之一。 是访问集合元素的一种方式。 是一个可以记住遍历的位置的对象。 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。 迭代器有两个基本的方法：iter() 和 next()。 字符串，列表或元组对象都可用于创建迭代器。

my_list = [1, 2, 3, 4, 5]
it = iter(my_list) # 创建迭代器对象
print(next(it)) # 1
print(next(it)) # 2

创建一个迭代器： 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()。

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

StopIteration： StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况。

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 是一个类似 return 的关键字，迭代一次遇到 yield 时就返回 yield 后面 (右边) 的值。

def yield_test():
    print("开始...")
    yield "hello"
    print("测试")

test = yield_test()
print(next(test)) # 开始 hello
print(next(test)) # 测试

15、函数

定义一个函数 & 调用函数： 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。 任何传入参数和自变量必须放在圆括号中间。 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。 函数内容以冒号起始，并且缩进。 return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。

def test(var):
    if var == "data":
        print("love u")
    else:
        print("piss off")

test("data")

Python 函数的参数传递：

• 不可变类型（strings, tuples, numbers）：类似 C++ 的值传递。
• 可变类型：类似 C++ 的引用传递，如列表，字典。

匿名函数 lambda：

sum_func = lambda x1, x2: x1 + x2
print(sum_func(1, 2)) # 3

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

• L (Local): 局部作用域
• E (Enclosing): 闭包函数外的函数中
• G (Global): 全局作用域
• B (Built-in): 内置作用域

以 L -> E -> G -> B 的规则查找。

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

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

def sum(arg1, arg2):
    total = arg1 + arg2 # total 在这里是局部变量
    print("函数内是局部变量：", total)
    return total

sum(10, 20)
print("函数外是全局变量：", total)

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

num = 1
def fun1():
    global num
    print(num) # 1
    num = 123
    print(num) # 123
fun1()
print(num) # 123

16、文件（File）

读和写文件： open() 将会返回一个 file 对象，基本语法格式如下： open(filename, mode) filename：包含了你要访问的文件名称的字符串值。 mode：决定了打开文件的模式：只读，写入，追加等。

简要如下图： 模式 r, r+, w, w+, a, a+。

写入字符串：

f = open("files/test.txt", "w")
f.write("I love data")
f.close()
# 读取文件内容
f = open("files/test.txt", "r")
str_data = f.read()
print(str_data) # I love data
f.close()

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

import pickle

data1 = {'a': [1, 2.0, 3, 4+6j], 'b': ('string', 'Unicode string'), 'c': None}
output = open('data.pkl', 'wb')
pickle.dump(data1, output)
output.close()

pkl_file = open('data.pkl', 'rb')
data1_loaded = pickle.load(pkl_file)
pkl_file.close()

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

1. file.close(): 关闭文件。
2. file.flush(): 刷新文件内部缓冲。
3. file.fileno(): 返回一个整型的文件描述符。
4. file.isatty(): 如果文件连接到一个终端设备返回 True。
5. file.read([size]): 从文件读取指定的字节数。
6. file.readline([size]): 读取整行。
7. file.readlines([sizeint]): 读取所有行并返回列表。
8. file.seek(offset[, whence]): 设置文件当前位置。
9. file.tell(): 返回文件当前位置。
10. file.truncate([size]): 截断文件。
11. file.write(str): 将字符串写入文件。
12. file.writelines(sequence): 向文件写入一个序列字符串列表。

OS 文件/目录方法： 包括 os.access, os.chdir, os.chmod, os.getcwd, os.listdir, os.mkdir, os.path 模块等。

17、错误与异常

即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。

异常处理：try-except-finally

import sys

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

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

raise 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)

预定义的清理行为-with 语句： 一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

18、面向对象

面向编程的首要前提是你得先面向对象编程。

面向对象技术简介：

• 类 (Class): 用来描述具有相同的属性和方法的对象的集合。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。
• 数据成员：类变量或者实例变量。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写。
• 继承：即一个派生类继承基类的字段和方法。
• 实例化：创建一个类的实例。

定义一个类：

class ClassName:
    pass

访问类对象：

class R:
    name = "data"
    def getName(self): # 必须有 self
        return "11"
r = R()
print(r.name) # data
print(r.getName()) # 11

构造方法 (init)： 类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。

class R1:
    def __init__(self, x, r):
        self.x = x
        self.r = r

r = R1("xiaobin", "ranxia")
print(r.x + " " + r.r)

继承： 语法如下：

class DerivedClassName(BaseClassName1):
    pass

class XB:
    def __init__(self, name):
        self.name = name
    def say(self):
        print("我的名字是" + self.name)

class XX(XB):
    def __init__(self, name, mother):
        XB.__init__(self, name)
        self.mother = mother
    def say(self): # 重写父类的 say 方法
        print("我的名字是" + self.name + " " + "我的妈妈是" + self.mother)

xb = XB("xiaobin")
xb.say()
xx = XX("xiao", "ran")
xx.say()

类的私有属性： __private_attrs: 两个下划线开头，声明该属性为私有。

类的专有方法：

• __init__: 构造函数
• __del__: 析构函数
• __repr__: 打印，转换
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

运算符重载：

class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def __str__(self):
        return 'Vector (%d, %d)' % (self.a, self.b)

    def __add__(self, other):
        return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1 + v2) # Vector(7, 8)

19、标准库

标准库概览：

• os: 提供了不少与操作系统相关联的函数。
• glob: 提供了一个函数用于从目录通配符搜索中生成文件列表。
• sys: 提供通用工具脚本经常调用命令行参数。
• re: 为高级字符串处理提供了正则表达式工具。
• math: 模块为浮点运算提供了对底层 C 函数库的访问。
• random: 提供了生成随机数的工具。
• urllib.request, smtplib: 用于访问互联网以及处理网络通信协议。
• datetime: 为日期和时间处理同时提供了简单和复杂的方法。
• zlib, gzip, bz2, zipfile, tarfile: 以下模块直接支持通用的数据打包和压缩格式。
• timeit: 提供了一个度量不同方法之间的性能差异工具。
• doctest: 开发高质量软件的方法之一是为每一个函数开发测试代码。
• os.path: 获取文件的属性信息。