python基础
list
list是有序集合，可以随时添加和删除元素
classmates = ['Michael', 'Bob', 'Tracy']
>>> len(classmates)
3
list里面的元素的数据类型可不同
>>> L = ['Apple', 123, True]
len()获得list元素的个数
增classmates.append('linda') 向list追加一个元素到末尾 append 增添
classmates.insert(2,'liming') 把元素插入到指定位置 insert 插入
删classmates.pop() 删除末尾元素 pop 删除
classmate.pop(1) 删除某个位置的元素
改classmates[1] = 'sam' 把某个元素替换成别的元素，可以直接赋值给对应的索引位置
查classmates[0] 使用索引访问其中的元素
append()和extand()的区别
append() 方法只能添加一个元素，而 extend() 方法可以添加多个元素。
list1 = [1, 2, 3] # append() 方法添加元素
list1.append(4)
print(list1) # 输出：[1, 2, 3, 4]
list2 = [1, 2, 3] # extend() 方法添加元素
list2.extend([4, 5, 6])
print(list2) # 输出：[1, 2, 3, 4, 5, 6]
| 方法 | 描述 |
|---|---|
| list.append(x) | 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x] |
| list.extend(L) | 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L |
| list.insert(i, x) | 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) |
| list.remove(x) | 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误 |
| list.pop([i]) | 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记） |
| list.clear() | 移除列表中的所有项，等于del a[:] |
| list.index(x) | 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误 |
| list.count(x) | 返回 x 在列表中出现的次数 |
| list.sort() | 对列表中的元素进行排序 |
| list.reverse() | 倒排列表中的元素 |
| list.copy() | 返回列表的浅复制，等于a[:] |
tuple
与列表类似，但是元组一旦创建就不能修改，因此元组更安全，适合存储一些不需要修改的数据。
创建
tup1 = (1, 2, 3)
tup2 = tuple([4, 5, 6])
访问
print(tup1[0])
切片
tup = ('a', 'b', 'c', 'd', 'e')
print(tup[1:4]) # 输出：('b', 'c', 'd')
拼接
tup3 = tup1 + tup2
print(tup3) # 输出：(1, 2, 3, 4, 5, 6）
重复
tup = ('a', 'b', 'c')
print(tup * 3) # 输出：('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')
条件判断
age = 20
if age >= 6:
print('teenager')
elif age >= 18:
print('adult')
else:
print('kid')
转换
例： int('100')
模式匹配
如果要针对某个变量匹配若干种情况，可以使用match语句
score = 'B'
match score:
case 'A':
print('score is A.')
case 'B':
print('score is B.')
case 'C':
print('score is C.')
case _: # _表示匹配到其他任何情况
print('score is ???.')
循环
所以for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)
>>> list(range(5))
[0, 1, 2, 3, 4]
break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。这两个语句通常都必须配合if语句使用
dict
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael'] # 95
dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
把数据放入dict的方法，除了始化时指定外，还可以通过key放入：
>>> d['Adam'] = 67
>>> d['Adam'] #67
要避免key不存在的错误，有两种办法:
1.是通过in判断key是否存在
>>> 'Thomas' in d
False
2.通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
删:
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
Python中的字典di是无序的数据类型。字典中的键必须是唯一的，而值可以不唯一。
1.使用方括号[]和赋值运算符=的方法：
a = dict()
a['name'] = 'xufive'
a['gender'] = '男'
print(a) # 输出：{'name': 'xufive', 'gender': '男'}
这种方法只能添加或修改一个键值对，如果需要添加或修改多个键值对，就需要多次使用这种方法。
2.使用update()方法的方法：
a = dict()
a.update({'name':'xufive', 'gender':'男'})
print(a) # 输出：{'name': 'xufive', 'gender': '男'}
-
删除键值对 del my_dict['apple']
1.使用pop()方法删除多个键值对
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4} keys_to_remove = ['a', 'c'] for key in keys_to_remove: my_dict.pop(key, None) print(my_dict) # 输出：{'b': 2, 'd': 4}2.使用del语句删除多个键值对
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4} keys_to_remove = ['a', 'c'] for key in keys_to_remove: if key in my_dict: del my_dict[key] print(my_dict) # 输出：{'b': 2, 'd': 4} -
修改键值对 my_dict['banana'] = 5
-
查询键值对 print(my_dict['orange'])
set
set和dict类似，也是一组key的无序集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
添: 通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：
删: 通过remove(key)方法可以删除元素：
set可以看成数学意义上的无序和无重复元素的集合，两个set可以做数学意义上的交集、并集等操作
交集 & : x&y，返回一个新的集合，包括同时在集合 x 和y中的共同元素。
并集 | : x|y，返回一个新的集合，包括集合 x 和 y 中所有元素。
差集 - : x-y，返回一个新的集合,包括在集合 x 中但不在集合 y 中的元素。
交集 ^ : x^y，返回一个新的集合，包括集合 x 和 y 的非共同元素。
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.remove(4)
>>> s
{1, 2, 3}
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
再议不可变对象
>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'
要始终牢记的是，a是变量，而'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指，a本身是一个变量，它指向的对象的内容才是'abc'
当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了
-
不可变对象
是指创建后无法被修改的对象，例如【字符串、元组和数字等】对于不可变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
#对于字符串类型的变量，我们可以使用字符串方法来操作字符串，但是这些方法不会改变原始字符串的值，而是返回一个新的字符串
s = 'hello'
s.upper() # 返回新的字符串'HELLO'，但是s的值仍然是'hello'
-
可变对象
是指创建后可以被修改的对象，例如【列表和字典等】，对于可变对象，对其进行操作会改变对象本身的内容。：
#对于列表类型的变量，我们可以使用列表方法来操作列表，这些方法会直接修改原始列表的值
a = ['c', 'b', 'a']
a.sort() # 直接修改a的值，a变成['a', 'b', 'c']
总结
增删改查：
1、list
1）查: L[1] L[0] L(-1) #索引最后一个元素
2）增: L.append('赵六') #添加到最后一个位置 L.insert(2,'赵六') #添加到指定位置
3）删: L.pop() #删除最后一个位置的元素 L.pop(1) #删除指定位置的元素
4）改: L[1]='王丹'
5）空: L=[ ]
2、Tuple：
1）不能删改内容，索引方法和list相同
2）定义只有一个元素的tulpe： t=('张三',)
3、dict：
1）查：'李四' in d #查是否存在 d.get('李四') #不存在则无反馈 或d.get('李四',-1) #不存在返回-1
2）增/改：d['李四']=80
3）删：d.pop('李四')
4、set（一组key的合集，无value，不重复，无序）
1）增：s.add(4)
2）删：s.remove(4)
函数
调用函数
函数名就是指向一个函数对象的引用，可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
函数的参数
-
必选参数。例如：
def add(x, y): return x + y print(add(1, 2)) # 输出：3 -
默认参数：函数定义时可以指定默认值的参数，调用函数时如果不传入对应的参数值，则使用默认值。默认参数必须放在必选参数后面。例如：
def add(x, y=1): return x + y print(add(1)) # 输出：2def greet(name, message="Hello"): print(message + ", " + name) greet("Alice") # 输出：Hello, Alice greet("Bob", "Hi") # 输出：Hi, Bob在上面的例子中，
greet函数有两个参数，其中message参数设置了默认值为"Hello"。当我们只传入一个参数name时，message参数会使用默认值；当我们同时传入两个参数时，message参数会使用我们传入的值 -
可变参数：函数定义时可以接收任意个参数的参数，调用函数时可以传入任意个参数值，这些参数会被自动封装成一个tuple。可变参数使用*表示。例如：
def add(*args): result = 0 for arg in args: result += arg return result print(add(1, 2, 3)) # 输出：6#当Python函数有多个返回值时，它们会被打包成一个元组(tuple)并返回。这意味着你可以通过解包元组的方式来获取每个返回值 def my_function(): return 1, 2, 3 result = my_function() print(result) # 输出 (1, 2, 3) a, b, c = my_function() print(a, b, c) # 输出 1 2 3解包操作
在Python中，可以进行解包操作的可迭代对象包括元组、列表、集合、字典、字符串
a, b, c = (1, 2, 3) #元组和列表是最常见的解包对象 x, y, z = [4, 5, 6]此外，集合和字典也可以进行解包操作，但，集合和字典是无序的，因此解包时需要注意顺序。例如：
#集合和字典也可以进行解包操作，但需要注意的是，集合和字典是无序的，因此解包时需要注意顺序 s = {'a', 'b', 'c'} # 可能会出现不同的结果，因为集合是无序的 x, y, z = s #x=a y=b z=c d = {'name': 'Tom', 'age': 18} x, y = d #x=name y=age字符串也可以进行解包操作，但是只能解包为单个字符。例如：
a, b, c = 'abc' #a=a b=b c=c -
命名关键字参数：函数定义时可以接收任意个指定名称的参数，调用函数时必须传入指定名称的参数值，这些参数会被自动封装成一个dict。命名关键字参数必须放在可变参数后面，如果没有可变参数，则必须在*之后使用。命名关键字参数使用后面的参数名表示。例如：
def person(name, age, *, city, job): print(name, age, city, job) person('Bob', 25, city='Beijing', job='Engineer') # 输出：Bob 25 Beijing Engineer -
关键字参数：函数定义时可以接收任意个指定名称的参数，调用函数时可以传入任意个指定名称的参数值，这些参数会被自动封装成一个dict。关键字参数使用**表示。例如：
def person(name, age, **kw): print(name, age, kw) person('Bob', 25, city='Beijing', job='Engineer') # 输出：Bob 25 {'city': 'Beijing', 'job': 'Engineer'}高级特征
切片
Python中的切片操作是指对序列（如字符串、列表、元组等）进行截取操作，从而得到一个新的序列。切片操作使用中括号[]，并且可以指定起始位置、结束位置和步长。具体格式为：[起始位置:结束位置:步长]。其中，起始位置和结束位置可以省略，省略时表示从序列的开头或结尾开始截取；步长也可以省略，省略时默认为1。需要注意的是，切片操作不会改变原序列，而是返回一个新的序列
1.对字符串进行切片操作 2.对列表进行切片操作 3.对元组进行切片操作
str = 'Hello, World!' list = [1, 2, 3, 4, 5] tuple = (1, 2, 3, 4, 5)
print(str[7:]) # 输出：World! print(list[2:]) # 输出：[3, 4, 5] print(tuple[2:]) # 输出：(3, 4, 5)
迭代
迭代是指遍历可迭代对象中的元素，常与for循环结合使用
1.遍历列表
lst = [1, 2, 3, 4, 5]
for i in lst:
print(i)
2.遍历元组
tup = (1, 2, 3, 4, 5)
for i in tup:
print(i)
3.遍历字典的键
dic = {'one': 1, 'two': 2, 'three': 3}
for key in dic:
print(key)
4.遍历字典的值
dic = {'one': 1, 'two': 2, 'three': 3}
for value in dic.values():
print(value)
5.遍历字典的键值对
dic = {'one': 1, 'two': 2, 'three': 3}
for key, value in dic.items():
print(key, value)
6.遍历字符串
s = 'hello'
for i in s:
print(i)
7.使用enumerate同时遍历列表的下标和元素
lst = ['a', 'b', 'c']
for index, value in enumerate(lst):
print(index, value)
8.使用zip同时遍历多个列表
lst1 = [1, 2, 3]
lst2 = ['a', 'b', 'c']
for a, b in zip(lst1, lst2):
print(a, b)
列表生成式
列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式
写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：
for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else。
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
可以使用两层循环，可以生成全排列：
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
生成器
1.把一个列表生成式的[]改成()，就创建了一个generator：
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>
通过next()函数获得generator的下一个返回值，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。
当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：
>>> L = [x * x for x in range(10)]
>>> for n in g：
... print(n)
所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误
函数式编程
-
高阶函数
既然变量可以指向函数，函数的参数能接收变量，【那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数】。
一个最简单的高阶函数：
def add(x, y, f):
return f(x) + f(y)
map
>>> def f(x):
... return x * x
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
reduce
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方说对一个序列求和，就可以用reduce实现：（当然求和运算可以直接用Python内建函数sum()，没必要动用reduce）
>>> from functools import reduce
>>> def add(x, y):
... return x + y
>>> reduce(add, [1, 3, 5, 7, 9])
25
但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：
>>> from functools import reduce
>>> def fn(x, y):
... return x * 10 + y
>>> reduce(fn, [1, 3, 5, 7, 9])
13579
filter
关键在于正确实现一个“筛选”函数
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
把一个序列中的空字符串删掉，可以这么写：
def not_empty(s):
return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
# 结果: ['A', 'B', 'C']。
注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
sorted
sort函数和sorted函数都可以用于对列表进行排序，❓$\textcolor{#FF7F00}{sort()与sorted区别}$：
- sort()是列表的方法，只能用于列表，而sorted()是一个内置函数，可以接受任何可迭代对象作为参数，包括列表、元组、字典等。
- sort()方法会直接修改原列表，而sorted()函数不会修改原对象，而是返回一个新的已排序的列表。
- sort()方法没有返回值，而是直接对原列表进行排序，而sorted()函数返回一个已排序的列表。
下面是两个例子，分别演示sort()方法和sorted()函数的用法：
list1 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] # sort()方法的用法
list1.sort()
print(list1) # 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
list2 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] # sorted()函数的用法
new_list = sorted(list2)
print(new_list) # 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
reverse()和reversed()`都是用于反转序列的函数❓$\textcolor{#FF7F00}{reverse()与reversed区别}$：
reverse()是一个列表方法，用于反转列表中的元素顺序
a = [1, 2, 3, 4]
a.reverse() #reverse() 设计的目的就是反转原始列表并返回None。
print(a) # 输出 [4, 3, 2, 1]
reversed()是内置函数，用于返回一个反转后的迭代器对象，可用于任何序列类型，列表、元组、字符串等
a = [1, 2, 3, 4]
b = reversed(a) #reversed() 也能反转列表，同时「不修改」原始列表
print(list(b)) # 输出 [4, 3, 2, 1]
reversed()返回的是一个迭代器对象，而不是一个列表，如果需要将其转换为列表，需要使用list()函数进行转换
-
返回函数
函数作为返回值
可以不返回求和的结果，而是返回求和的函数：
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
我们调用lazy_sum()时，返回的并不是求和结果，而是求和函数：调用函数f时，才真正计算求和的结果
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
>>> f()
25
当我们调用lazy_sum()时，每次调用都会返回一个新的函数
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2 #返回False
闭包
注意到返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，所以，闭包用起来简单，实现起来可不容易。
另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。我们来看一个例子：
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。
如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：
def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
return fs
-
匿名函数
lambda x: x * x实际上就是：
def f(x):
return x * x
关键字lambda表示匿名函数，冒号前面的x表示函数参数
读和写文件
open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
不同模式打开文件的完全列表：
# 实例
f = open("/tmp/foo.txt", "w") # 打开一个文件
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
f.close() # 关闭打开的文件
f.read()
为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。
size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
f.close()
#Python 是一个非常好的语言。
#是的，的确非常好!!
f.readline()
f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
f = open("/tmp/foo.txt", "r")
str = f.readline()
print(str)
f.close() # Python 是一个非常好的语言。
f.readlines()
f.readlines() 将返回该文件中包含的所有行。
如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
f = open("/tmp/foo.txt", "r")
str = f.readlines()
print(str)
f.close() # ['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']
另一种方式是迭代一个文件对象然后读取每行:
f = open("/tmp/foo.txt", "r")
for line in f:
print(line, end='')
f.close()
#Python 是一个非常好的语言。
#是的，的确非常好!!
如果要写入一些不是字符串的东西, 那么将需要先进行转换:
f = open("/tmp/foo1.txt", "w")
value = ('www.runoob.com', 14)
s = str(value)
f.write(s)
f.close()
#$ cat /tmp/foo1.txt
#('www.runoob.com', 14)
f.tell()
f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
f.seek()
如果要改变文件指针当前的位置, 可以使用 f.seek(offset, from_what) 函数。
from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：
seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符
from_what 值为默认为0，即文件开头。下面给出一个完整的例子：
>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5) # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'
f.close()
在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。
当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。
>>> f.close()
>>> f.read()
# ValueError: I/O operation on closed file
with语句
with open()是Python中用于打开文件的一种更安全、更简洁的方式。使用with open()可以自动关闭文件，无论在处理文件时是否发生错误。
with open('example.txt', 'w') as f:
f.write('Hello, world!')
浙公网安备 33010602011771号