Python 函数和方法
- 方法：方法属于类，通过类或对象调用方法，例如：
list.append(x) - 函数：函数不属于任何类，可以直接调用，例如：
list(iter)
Python 函数
print()
print() 内置函数，用于输出指定内容，默认 print() 输出内容后换行，如果要在一行显示，需在 print() 中用 , 号分割，语法格式：
print(objects, sep=' ', end='\n', file=sys.stdout)
- objects：表示输出的对象
- sep：用来间隔多个对象。默认是空格
- end：用来设定以什么结尾。默认值是换行符
\n - file： 要写入的文件对象
print() 默认输出后，会进行换行 “\n”，如果想更改，可以使用
end=""进行更改
print() 括号内打印字符时需要用单引号（'）或双引号（"）引用，引号必须是英文下的引号，中文会报错，语法错误
example：
x = 10
y = 20
print("Hello, World!")
print(x, y)
print(x, y, sep="; ")
print(x, end="...")
print(y)
Hello, World! # 输出结果
10 20
10; 20
10...20
input()
input() 内置函数，用于输入指定内容，输出为字符串类型，语法格式：
input("object")
- object：表示用于输入提示的内容
example：
a = input("请输入密码： ") # 将输入的内容赋值给 a
print(a)
print(type(a))
请输入密码： 123 # 输出结果，输入任意字符，如：123
123
<class 'str'>
len()
len() 内置函数，用于返回字符串、列表、字典、元组等的长度，语法格式：
len(object)
- object：要计算的字符串、列表、字典、元组等的变量名
标点符号和空格也算一个长度
example：
a = "Hello, World!"
print(len(a)) # 输出结果：13
range()
range() 内置函数，用于遍历数字序列，语法格式：
range(start, stop, step)
- start：值的是开始下标。range 序列里面的所有元素都有下标，第一个元素的下标是 0，所以，默认是从 0 开始
- stop：是结束位置。结束的位置下标为（元素个数 -1），例如：range 里面有 4 个元素，那么结束下标最大为 3，大于 3 则跳出 range
- step：是步长，如果 step 是 2，那么每次会隔开 1 个元素，默认步长为 1，即每个元素都会取到
example：
for i in range(0, 5):
print(i)
0 # 输出结果
1
2
3
4
type()
type() 内置函数，如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象，语法格式：
class type(name, bases, dict)
- name：类的名称
- bases：基类的元组
- dict：字典，类内定义的命名空间变量
example：
num = 20
print(type(num)) # 输出结果：<class 'int'>
class X(object):
a = 1
X = type('X', (object,), dict(a=1))
print(X) # 输出结果：<class '__main__.X'>
isinstance()
isinstance() 内置函数，用来判断数据类型是否是相对应的类型，它返回的是布尔值（True 或 False），语法格式：
isinstance(object, type)
- object：表示输入的对象
- type：判断的类型
example：
num = 20
n = isinstance(num, int)
print(n) # 输出结果：True
id()
id() 内置函数，用于返回变量所指的内存地址，语法格式：
id(object)
- object：表示输入的对象
example：
num = num01 = 20
print(id(num)) # 输出结果：2689225392976
print(id(num01)) # 输出结果：2689225392976
list()
list() 内置函数，用于将序列转换为列表，语法格式：
list(object)
- object：待转换为列表的数据类型
example：
a = {10, 20, 30}
b = list(a)
print(type(a)) # 输出结果：<class 'set'>
print(b) # 输出结果：[10, 20, 30]
print(type(b)) # 输出结果：<class 'list'>
tuple()
tuple() 内置函数，用于将序列转换为元组，语法格式：
tuple(object)
- object：待转换为元组的数据类型
example：
a = [10, 20, 30]
b = tuple(a)
print(type(a)) # 输出结果：<class 'list'>
print(b) # 输出结果：(10, 20, 30)
print(type(b)) # 输出结果：<class 'tuple'>
str()
str() 内置函数，用于将序列转换为字符串，语法格式：
str(object)
- object：待转换为字符串的数据类型
example：
a = 2135
b = str(a)
print(type(a)) # 输出结果：<class 'int'>
print(b) # 输出结果：2135
print(type(b)) # 输出结果：<class 'str'>
bool()
bool() 内置函数，用于评估任何值，并返回 True 和 False，语法格式：
bool(object)
-
object：待转换为布尔值的数据类型
-
任何字符串都是 True，空字符串除外。任何数字都是 True，除了 0。任何列表、元组、集合和字典都是 True，空的除外。
-
False 除了空值（例如：
()、[]、{}、""、 数字0）之外，计算为None的值。当然，结果为 False。
example：
print(bool("张三")) # 输出结果：True
print(bool()) # 输出结果：False
max()
max() 内置函数，用于返回元素中最大值，字符类型取字母表排序的靠后字母，语法格式：
max(object)
- object：传入可迭代对象
字母表中大写在前，小写在后
example：
a = "Hello, World!"
b = '6546186638948'
print(max(a)) # 输出结果：r
print(max(b)) # 输出结果：9
min()
min() 内置函数，用于返回元素中最小值，字符类型取字母表排序的靠后字母，语法格式：
min(object)
- object：传入可迭代对象
空格比字母值还要小
example：
a = "Hello, World!"
b = '6546186638948'
print(max(a)) # 输出结果：空格
print(max(b)) # 输出结果：1
enumerate()
enumerate() 内置函数，用于将序列组合为一个索引序列，多用于在 for 循环中，可以同时输出索引值和元素内容，语法格式：
enumerate(object, start)
- object：传入可迭代对象
- start：指定索引的起始值
example：
mylist = [10, 20, 30]
for index, i in enumerate(mylist):
print(index, i)
0 10 # 输出结果
1 20
2 30
lambda
lambda 内置函数，用于创建 lambda 函数，语法格式：
result = lambda [arg01[, arg02[,... [, argn]]]]: expression
- result：用于调用 lambda 表达式
- [arg01[, arg02[,… [, argn]]]]：可选参数，指定要传递的参数列表，多个参数间使用逗号 “,” 分隔
- expression：指定一个实现具体功能的表达式。如果有参数，那么在该表达式中将应用这些参数
通常情况下，这样的函数只使用一次，使用 lambda 表达式时，需要定义一个变量，用于调用该 lambda 表达式
example：将 lambda 函数赋值给一个变量，通过这个变量间接调用该 lambda 函数
num = lambda x, y: x + y
print(num(1, 2)) # 输出结果：3
sum()
sum() 内置函数，用于计算可迭代对象之和，语法格式：
sum(iterable[, start])
- iterable：表示可迭代对象
- start：表示指定相加的参数，如果没有设置这个值，默认为 0
example：
mylist = [10, 20, 30]
print(sum(mylist)) # 输出结果：60
print(sum(mylist, 50)) # 输出结果：110
sorted()
sorted() 内置函数，用于按字母排序，不改变原有列表，语法格式：
sorted(iterable, [key[, reverse]])
- iterable：指定可迭代对象
- key：指定带有一个参数的函数，用于从每个列表元素中提取比较键
- reverse：为一个布尔值。如果设为 True，则每个列表元素将按反向顺序比较进行排序；如果设为 False，实现升序排序，默认为 False
example：
mylists = ["zero", "banana", "Orange", "Kiwi", "cherry"]
x = sorted(mylists)
y = sorted(mylists, key=lambda mylist: mylist[2])
z = sorted(mylists, reverse=True)
print(x) # 输出结果：['Kiwi', 'Orange', 'banana', 'cherry', 'zero']
print(mylists) # 输出结果：['zero', 'banana', 'Orange', 'Kiwi', 'cherry']
print(y) # 输出结果：['Orange', 'cherry', 'banana', 'zero', 'Kiwi']
print(z) # 输出结果：['zero', 'cherry', 'banana', 'Orange', 'Kiwi']
zip()
zip() 内置函数，用于接收一系列可迭代对象作为参数，将对象中对应的元素打包成一个个元组（tuple），然后返回列表（list），语法格式：
若传入参数的长度不等，则返回列表的长度和参数中长度最短的对象相同。利用
*号操作符，可以将 list unzip（解压）
如果提前不对 zip() 函数进行数据类型转换，则只能进行遍历一次，第二次就是空值
zip([iterable, iterable, ...])
- iterable：传入可迭代对象
example：
name = ['zhangsan', 'lisi', 'wangwu']
age = ['20', '24', '25', '26']
mydict = zip(name, age)
print(dict(mydict)) # 输出结果：{'zhangsan': '20', 'lisi': '24', 'wangwu': '25'}
print(dict(mydict)) # 输出结果：{}
a = [1, 2, 3]
b = [4, 5, 6]
c = list(zip(a, b))
print(c) # 输出结果：[(1, 4), (2, 5), (3, 6)]
print(c) # 输出结果：[(1, 4), (2, 5), (3, 6)]
aa, bb = zip(*c)
print(aa, bb) # 输出结果：(1, 2, 3) (4, 5, 6)
set()
set() 内置函数，用于将一系列可迭代对象转换成集合，语法格式：
set([iterable, iterable, ...])
- iterable：传入可迭代对象
example：
myset = set("abcde")
myset01 = set(['10', '20', '30'])
myset02 = set(['10'])
print(myset) # 输出结果：{'b', 'e', 'a', 'c', 'd'}
print(myset01) # 输出结果：{'10', '30', '20'}
print(myset02) # 输出结果：{'10'}
round()
round() 内置函数，返回 number 舍入到小数点后 ndigits 位精度的值。如果 ndigits 被省略或为 None，则返回最接近输入值的整数，语法格式：
结果值会舍入至最接近的 10 的负 ndigits 次幂的倍数；如果与两个倍数同样接近，则选用偶数。因此，round(0.5) 和 round(-0.5) 均得出 0 而 round(1.5) 则为 2。ndigits 可为任意整数值（正数、零或负数）。如果省略了 ndigits 或为 None ，则返回值将为最接近 number 的整数。否则返回值与 number 的类型相同
round(number[, ndigits=None])
- number：表示输入的浮点类型字符
- ndigits=None：表示要保留的小数位
example：
print(round(3.4)) # 输出结果：3
print(round(3.5)) # 输出结果：4
print(round(3.1445, 2)) # 输出结果：3.14
print(round(3.1464, 2)) # 输出结果：3.15
print(round(3.145, 2)) # 输出结果：3.15
print(round(3.155, 2)) # 输出结果：3.15
print(round(3.165, 2)) # 输出结果：3.17
print(round(3.1450, 2)) # 输出结果：3.15
print(round(3.1554, 2)) # 输出结果：3.16
print(round(3.1655, 2)) # 输出结果：3.17
filter()
filter() 内置函数，用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表，语法格式：
filter(function, iterable)
- function：指定判断函数，是一个提供过滤条件的函数，返回布尔值
- iterable：可迭代对象数据
在调用 filter() 函数时，iterable 会被遍历，它的元素会被逐一传入 function 函数中，function 函数若返回 True，则元素被保留；若返回 False，则元素被过滤。最后遍历完成，已保留的元素被放到一个新的容器数据中
example：过滤出大于 50 的数
def num(x):
return x > 50
num01 = [66, 12, 91, 28, 92, 50, 4, 80, 99]
num02 = filter(num, num01)
num03 = list(filter(num, num01))
print(num02) # 输出结果：<filter object at 0x000001405661B310>
print(num03) # 输出结果：[66, 91, 92, 80, 99]
num01 = [66, 12, 91, 28, 92, 50, 4, 80, 99] # 用 lambda 函数替代
num02 = list(filter(lambda x: (x > 50), num01))
print(num02) # 输出结果：[66, 91, 92, 80, 99]
filter() 函数默认输出的是生成器对象，需要用 list() 函数转换为列表
map()
map() 内置函数，数用于对容器中的元素进行映射（或变换），语法格式：
map(function, iterable)
- function：指定变换规则的函数，返回变换之后的元素
- iterable：可迭代对象数据
在调用 map() 函数时，iterable 会被遍历，它的元素被逐一传入 function 函数中，在 function 函数中对元素进行变换
example：将列表中的数字乘以二
def num(x):
return x * 2
num01 = [1, 2, 3, 4, 5]
num02 = map(num, num01)
num03 = list(map(num, num01))
print(num02) # 输出结果：<map object at 0x0000026078ADB490>
print(num03) # 输出结果：[2, 4, 6, 8, 10]
num01 = [1, 2, 3, 4, 5] # 用 lambda 函数替代
num02 = list(map(lambda x: (x * 2), num01))
print(num02) # 输出结果：[2, 4, 6, 8, 10]
map() 函数默认输出的是生成器对象，需要用 list() 函数转换为列表
super()
super() 内置函数，用于调用父类（超类）的一种方法，在子类中可以通过 super() 方法来调用父类方法，解决多继承带来的重复调用（菱形继承）、查找顺序（MRO）问题，语法格式：
super(type[, object-or-type])
- type：类
- object-or-type：类，一般是 self
Python3 用 super().xxx 代替 Python2 super(Class, self).xxx
MRO——方法搜索顺序：MRO 是 method resolution order，主要用于在对继承是判断方法、属性的调用路径顺序，其实也就是继承父类方法时的顺序表，super() 函数严格按照 MRO 顺序执行。Python 中针对类提供了一个内置属性 __mro__ 可以查看方法的搜索顺序
在搜索方法时，是按照 __mro__ 的输出结果从左到右的顺序查找的
- 如果当前类中找到方法，就直接执行，不再搜索
- 如果没有找到，就查找下一个类中是否有对应的方法，如果找到，就直接执行，不再搜索
- 如果找到最后一个类，还是没有找到方法，程序报错
单继承：
class A:
def __init__(self):
self.n = 2
def add(self, m):
print('self is {0} @A.add'.format(self))
self.n += m
class B(A):
def __init__(self):
self.n = 3
def add(self, m):
print('self is {0} @B.add'.format(self))
super().add(m)
self.n += 3
b = B()
b.add(2)
print(b.n)
print(B.__mro__)
self is <__main__.B object at 0x106c49b38> @B.add # 输出结果
self is <__main__.B object at 0x106c49b38> @A.add
8
(<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
整体流程：
class B(A): class A:
def add(self, m): def add(self, m):
super().add(m) 1.---> self.n += m
self.n += 3 <----2. <----|
(5+3=8) (3+2=5)
super().add(m)调用父类方法def add(self, m)时, 此时父类中self并不是父类的实例而是子类的实例, 所以b.add(2)之后的结果是 5（n=3，m=2，3+2） 而不是 4（n=2，m=2，2+2）
多继承：
class A:
def __init__(self):
self.n = 2
def add(self, m):
print('self is {0} @A.add'.format(self))
self.n += m
class B(A):
def __init__(self):
self.n = 3
def add(self, m):
print('self is {0} @B.add'.format(self))
super().add(m)
self.n += 3
class C(A):
def __init__(self):
self.n = 4
def add(self, m):
print('self is {0} @C.add'.format(self))
super().add(m)
self.n += 4
class D(B, C):
def __init__(self):
self.n = 5
def add(self, m):
print('self is {0} @D.add'.format(self))
super().add(m)
self.n += 5
d = D()
d.add(2)
print(d.n)
print(D.__mro__)
self is <__main__.D object at 0x10ce10e48> @D.add # 输出结果
self is <__main__.D object at 0x10ce10e48> @B.add
self is <__main__.D object at 0x10ce10e48> @C.add
self is <__main__.D object at 0x10ce10e48> @A.add
19
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
整体流程：
class D(B, C): class B(A): class C(A): class A:
def add(self, m): def add(self, m): def add(self, m): def add(self, m):
super().add(m) 1.---> super().add(m) 2.---> super().add(m) 3.---> self.n += m
self.n += 5 <------6. self.n += 3 <----5. self.n += 4 <----4. <--|
(14+5=19) (11+3=14) (7+4=11) (5+2=7)
dir()
dir() 内置函数，如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表，语法格式：
dir([parameter])
- parameter：可选参数，可以是
""（表示字符串）、[]（表示列表）、()（表示元组）等，也可以是函数、类、方法等
example：
print(dir()) # 输出结果：['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'bmi']
print(dir(())) # 输出结果：['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
chr()
chr() 内置函数，函数返回值类型为 String，其数值表达式值取值范围为 0~255，语法格式：
chr(i)
- i：指定数值表达式，可以是十进制也可以是十六进制的数字
example：
for i in range(256):
print(chr(i), end='')
"""输出结果："""
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„
†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
for i in range(48, 58):
print(chr(i), end='') # 输出结果：0123456789
for i in range(65, 91):
print(chr(i), end='') # 输出结果：ABCDEFGHIJKLMNOPQRSTUVWXYZ
for i in range(97, 123):
print(chr(i), end='') # 输出结果：abcdefghijklmnopqrstuvwxyz
ord()
ord() 内置函数，函数返回值类型为 int 类型，语法格式：
ord(c)
- c：指定字符串，可以是 ASCII 和 Unicode 字符串
examle：
print(ord('0')) # 输出结果：48
print(ord('a')) # 输出结果：97
print(ord('A')) # 输出结果：65
open()
open() 内置函数，用于创建或者打开指定文件并创建文件对象，语法格式：
file = open(filename[, mode[, buffering[, encoding[, errors[, newline[, closefd[, opener]]]]]]])
- file：被创建的文件对象
- filename：要创建或打开的文件名称，需要用单引号或双引号括起来。可以使用相对路径也可以使用绝对路径
- mode：可选参数，指定文件的打开模式。默认的打开模式为只读（r）
- buffering：可选参数，指定读写文件的缓冲模式，值为 0 表示不缓存；值为 1 表示缓存；如果大于 1，则表示缓冲区的大小。默认为缓存模式
- encoding：指定文件编码。默认为 None。encoding 参数仅可在采用文本方式（即 mode 值带 t）读写数据的情况下有效，二进制方式下不可指定。常用的有 utf-8、ascii、gbk 等
- errors：指定在文本文件发生编码错误时如何处理。默认为 None。仅当 mode 参数采用文本方式时有效，二进制方式下不可指定。常用的可选值有 strict、ignore、replace、surrogateescape、xmlcharrefreplace、backslashreplace、namereplace 等。推荐参数为 “ignore” 表示在遇到编码错误时忽略该错误，程序继续执行
- newline：设置换行符。默认为 None。可选值包括 None、“\r”、“\n”、“\r\n”。
- closefd：控制传入的 file 参数类型。默认为 True，当为 True 时，file 参数可以是表示文件路径的字符串，也可以是文件描述符，当为 False 时，file 参数只能是文件描述符，传入字符串会报错
mode 参数列表如下：
| 参数 | 说明 |
|---|---|
| t | 文本模式（默认） |
| x | 写模式，新建一个文件，如果文件存在，则报错 |
| b | 二进制模式 |
| + | 打开一个文件进行更新（读写模式） |
| U | 通用换行模式（不推荐） |
| r | 只读模式打开文件，文件的指针将会放在文件的开头。文件必须存在 |
| rb | 只读模式以二进制格式打开文件，文件的指针将会放在文件的开头，一般用于非文本文件。例如：图片、声音等。文件必须存在 |
| r+ | 读写模式打开文件，写入新的内容覆盖原有内容，文件的指针将会放在文件的开头。文件必须存在 |
| rb+ | 读写模式以二进制格式打开文件，文件的指针将会放在文件的开头，一般用于非文本文件。例如：图片、声音等。文件必须存在 |
| w | 只写模式打开文件。文件如果存在，则将其覆盖，否则创建新文件 |
| wb | 只写模式以二进制格式打开文件，一般用于非文本文件。例如：图片、声音等。文件如果存在，则将其覆盖，否则创建新文件 |
| w+ | 读写模式打开文件，先清空原有内容，再写入内容。文件如果存在，则将其覆盖，否则创建新文件 |
| wb+ | 读写模式以二进制格式打开文件，一般用于非文本文件。例如：图片、声音等。文件如果存在，则将其覆盖，否则创建新文件 |
| a | 追加模式打开文件。如果该文件存在，文件指针将会放在文件的末尾，否则，创建新文件写入 |
| ab | 追加模式以二进制格式打开文件。如果该文件存在，文件指针将会放在文件的末尾，否则，创建新文件写入 |
| a+ | 读写、追加模式打开文件。如果该文件存在，文件指针将会放在文件的末尾，否则，创建新文件写入 |
| ab+ | 读写、追加模式以二进制格式打开文件。如果该文件存在，文件指针将会放在文件的末尾，否则，创建新文件写入 |
打开一个不存在的文件，example：
file = open('test.txt', 'w')
print("打开文件", file) # 输出结果：打开文件 <_io.TextIOWrapper name='test.txt' mode='w' encoding='cp936'>
以二进制形式打开文件，example：
file = open('picture.png', 'rb')
print(file) # 输出结果：<_io.BufferedReader name='picture.png'>
打开文件时指定编码方式，example：
file = open('test.txt', 'r', encoding='utf-8')
print(file) # 输出结果：<_io.TextIOWrapper name='test.txt' mode='r' encoding='utf-8'>
Python 方法
upper()
upper() 方法，用于以大写形式返回字符串，语法格式：
str.upper()
- str：表示对 upper 输入的对象
example：
a = "Hello, World!"
print(a.upper()) # 输出结果：HELLO, WORLD!
lower()
lower() 方法，用于以小写形式返回字符串，语法格式：
str.lower()
- str：表示对 lower 输入的对象
example：
a = "Hello, World!"
print(a.lower()) # 输出结果：hello, world!
strip()
strip() 方法，用于从开头或结尾删除任何字符，默认是空格，语法格式：
str.strip("object")
- str：表示对 strip 输入的对象
- object：表示要删除的对象
example：
mystr = " Hello, World! "
mystr01 = ", Hello, World! "
print(mystr.strip()) # 输出结果：Hello, World!
print(mystr01.strip(",")) # 输出结果： Hello, World!
lstrip()
lstrip() 方法，用于去掉字符串左侧的空格和特殊字符，语法格式：
str.lstrip("object")
- str：表示对 strip 输入的对象
- object：表示要删除的对象
example：
mystr = " Hello, World! "
mystr01 = ", Hello, World! "
print(mystr.lstrip()) # 输出结果：Hello, World!
print(mystr01.lstrip(",")) # 输出结果： Hello, World!
rstrip()
rstrip() 方法，用于去掉字符串右侧的空格和特殊字符，语法格式：
str.rstrip("object")
- str：表示对 strip 输入的对象
- object：表示要删除的对象
example：
mystr = " Hello, World! "
mystr01 = ", Hello, World!"
print(mystr.rstrip()) # 输出结果： Hello, World!
print(mystr01.rstrip("!")) # 输出结果：, Hello, World
replace()
replace() 方法，用于替换字符串，语法格式：
str.replace(old, new[, max])
- str：表示对 replace 输入的对象
- old：表示替换旧的字符对象
- new：表示替换新的字符对象
- [max]：最大匹配次数，匹配时从左到右最多次数
example：
a = "Hello, World! Hello, Python!"
print(a.replace("H", "h")) # 输出结果：hello, World! hello, Python!
print(a.replace("H", "h", 1)) # 输出结果：hello, World! Hello, Python!
split()
split() 方法，用于返回一个列表，指定字符串中的分隔符来分割列表，语法格式：
str.split(type="", num=string.count(str))[n]
- str：表示对 split 输入的对象
- type：表示进行分割的符号，默认为空格
- num：表示分割的次数
- [n]：表示分割后取第几个分片
example：以 “,” 号分割成列表
a = "Hello, World!, test"
b = "kkkpythonkiskkkgoodkk"
print(a.split(",")) # 输出结果：['Hello', ' World!', ' test']
print(a.split(",", 1)) # 输出结果：['Hello', ' World!, test']
print(a.split(",", 1)[0]) # 输出结果：Hello
print(b.split("k")) # 输出结果：['', '', '', 'python', 'is', '', '', 'good', '', '']
对于分隔符出现在首尾的情况，在首尾处分割，会产生同一个空串，对于出现在字符串中间的情况，单独出现，和普通情况没有区别，如果出现多个，两个分隔符中间就会产生一个空串
format()
format() 方法，用于接受传递的参数，格式化它们，并将它们放在占位符 “{}” 所在的字符串中，语法格式：
str.format(value)
- str：表示对 format 输入的对象
- value：表示要传递的参数
您还可以使用索引号
{0}将参数放到占位符中，不过需要确定索引号和参数位置所对应，否则会导致输出的顺序混乱
example：将数字插入字符串
age = 20
txt = "张三今年 {}"
print(txt.format(age)) # 输出结果：张三今年 20
example：接受多个参数
name = "张三"
age = 20
txt = "{} 今年 {}"
print(txt.format(name, age)) # 输出结果：张三今年 20
example：使用索引号
name = "张三"
age = 20
txt = "{0} 今年 {1}"
print(txt.format(name, age)) # 输出结果：张三今年 20
example：
print("我叫{}，今年{}岁了".format("张三", "20")) # 输出结果：我叫张三，今年20岁了
print("我叫{0}，今年{1}岁了".format("张三", "20")) # 输出结果：我叫张三，今年20岁了
print("我叫{1}，今年{0}岁了".format("张三", "20")) # 输出结果：我叫20，今年张三岁了。注意索引号和参数位置顺序
print("我叫{name}，今年{age}岁了".format(name="张三", age="20")) # 输出结果：我叫张三，今年20岁了
print("我叫{name}，今年{age}岁了".format(age="20", name="张三")) # 输出结果：我叫张三，今年20岁了。以 key=value 的形式无需注意索引号和参数位置顺序
mylist = ["张三", "20"]
print("我叫{List[0]}，今年{List[1]}岁了".format(List=mylist)) # 输出结果：我叫张三，今年20岁了
print("我叫{0[0]}，今年{0[1]}岁了".format(mylist)) # 输出结果：我叫张三，今年20岁了
mydict = {"name": "张三", "age": "20"}
print("我叫{Dict[name]}，今年{Dict[age]}岁了".format(Dict=mydict)) # 输出结果：我叫张三，今年20岁了
print("我叫{name}，今年{age}岁了".format(**mydict)) # 输出结果：我叫张三，今年20岁了
class value:
name = "张三"
age = "20"
print("我叫{Value.name}，今年{Value.age}".format(Value=value)) # 输出结果：我叫张三，今年20岁了
args = ["，", "。"]
kwargs = {"name": "张三", "age": "20"}
print("我叫{name}{}今年{age}岁了{}".format(*args, **kwargs)) # 输出结果：我叫张三，今年20岁了
*args表示任何多个无名参数，它是一个tuple或list；**kwargs表示关键字参数，它是一个dict。
数字格式化
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为 2) |
| 5 | {:x<4d} | 5xxx ) | 数字补 x (填充右边, 宽度为 4 |
| 10 | {:x<4d} | 10xx ) | 数字补 x (填充右边, 宽度为 4 |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
| 13 | {:>10d} | 13 | 右对齐 (宽度为 10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为 10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
| 11 | ‘{:b}’.format(11) | 1011 | 二进制 |
| 11 | ‘{:d}’.format(11) | 11 | 十进制 |
| 11 | ‘{😮}’.format(11) | 13 | 八进制 |
| 11 | ‘{:x}’.format(11) | b | 十六进制 |
| 11 | ‘{:#x}’.format(11) | 0xb | 0x 式十六进制 + 小写 |
| 11 | ‘{:#X}’.format(11) | 0xB | 0x 式十六进制 + 大写 |
example：
a = 3.1415926
print("保留两位小数：{:.2f}".format(a)) # 输出结果：保留两位小数：3.14
叹号，example：
print("{!s}好".format("你")) # 输出结果：你好
print("{!r}好".format("你")) # 输出结果："你"好
print("{!a}好".format("你")) # 输出结果："\u4f60"好
s：str() 是面向用户的，目的是可读性r：repr() 带有引号a：ascii() 是面向 Python 解析器的，返回值表示在 python 内部的含义，ascii()，返回 ascii 编码
insert()
insert() 方法，用于在列表中指定的索引处插入一个值，语法格式：
list.insert(index, object)
- list：表示对 insert 输入的对象
- index：指定索引号
- object：要插入列表的对象
example：
mylist = [10, 20, 30, 40]
mylist.insert(2, 60)
print(mylist) # 输出结果：[10, 20, 60, 30, 40]
append()
append() 方法，用于在列表结尾处添加一个值，列表只占一个索引位，语法格式：
list.append(object)
- list：表示对 append 输入的对象
- object：要添加列表的对象
example：
mylist = [10, 20, 30]
mylist01 = [10, 20, 30]
mylist.append(40)
mylist01.append([40, 50])
print(mylist) # 输出结果：[10, 20, 30, 40]
print(mylist01) # 输出结果：[10, 20, 30, [40, 50]]
extend()
extend() 方法，用于合并列表，将列表中的每个元素都追加进来，语法格式：
list.extend(object)
- list：表示对 extend 输入的对象
- object：要合并列表的对象
example：
mylist = [10, 20, 30]
mylist01 = [30, 40, 50]
mylist.extend(mylist01)
print(mylist) # 输出结果：[10, 20, 30, 30, 40, 50]
列表中的元素允许重复
remove()
remove() 方法，用于删除列表指定的值，语法格式：
list.remove(object)
- list：表示对 remove 输入的对象
- object：要删除列表的对象
example：
mylist = [10, 20, 30, 40]
mylist.remove(30)
print(mylist) # 输出结果：[10, 20, 40]
pop()
pop() 方法，用于删除列表指定的索引，默认删除最后一个元素，语法格式：
list.pop(index)
- list：表示对 pop 输入的对象
- index：指定要删除列表的索引
example：
mylist = [10, 20, 30, 40]
mylist01 = [10, 20, 30, 40]
mylist02 = [10, 20, 30, 40]
mylist.pop()
mylist01.pop(1)
mylist02.pop(-1)
print(mylist) # 输出结果：[10, 20, 30]
print(mylist01) # 输出结果：[10, 30, 40]
print(mylist02) # 输出结果：[10, 20, 30]
clear()
clear() 方法，用于清空列表，并且会删除地址空间，导致这些值被清空无法存储。该列表仍然存在，但没有内容，语法格式：
list.clear()
- list：表示对 clear 输入的对象
example：
mylist = [10, 20, 30, 40]
mylist01 = []
mylist01.append(mylist)
print(mylist01) # 输出结果：[[10, 20, 30, 40]]
mylist.clear()
print(mylist) # 输出结果：[]
print(mylist01) # 输出结果：[[]]
sort()
sort() 方法，用于按字母排序，改变原有列表，语法格式：
iterable.sort([key[, reverse]])
- iterable：表示对 sort 输入可迭代对象
- key：指定带有一个参数的函数，用于从每个列表元素中提取比较键
- reverse：为一个布尔值，默认为 False。如果设为 False，实现升序排序；如果设为 True，实现降序排序
example：
mylist = ["zero", "banana", "Orange", "Kiwi", "cherry"]
mylist01 = ["zero", "banana", "Orange", "Kiwi", "cherry"]
mylist02 = ["zero", "banana", "Orange", "Kiwi", "cherry"]
mylist.sort()
y = mylist.sort()
mylist01.sort(reverse=True)
mylist02.sort(key=str.lower)
print(mylist) # 输出结果：['Kiwi', 'Orange', 'banana', 'cherry', 'zero']
print(y) # 输出结果：None
print(mylist01) # 输出结果：['zero', 'cherry', 'banana', 'Orange', 'Kiwi']
print(mylist02) # 输出结果：['banana', 'cherry', 'Kiwi', 'Orange', 'zero']
reverse()
reverse() 方法，用于将列表倒序，改变原有列表，语法格式：
list.reverse()
- list：表示对 reverse 输入的对象
example：
mylist = ["zero", "banana", "Orange", "Kiwi", "cherry"]
mylist01 = ["zero", "banana", "Orange", "Kiwi", "cherry"]
mylist.reverse()
y = mylist.reverse()
print(mylist) # 输出结果：['cherry', 'Kiwi', 'Orange', 'banana', 'zero']
print(y) # 输出结果：None
reversed()
reversed() 方法，用于将序列反转，不改变原有序列，语法格式：
type.reversed(iterable)
- type：表示对 reversed 输入的类型
- iterable：指定可迭代对象
example：
a = [20, 50, 40, 10, 30]
b = list(reversed(a))
print(list(reversed(a))) # 输出结果：[30, 10, 40, 50, 20]
print(a) # 输出结果：[20, 50, 40, 10, 30]
print(b) # 输出结果：[30, 10, 40, 50, 20]
copy()
copy() 方法，用于制作列表的副本，语法格式：
list.copy()
- list：表示对 copy 输入的对象
example：
mylist = ["zero", "banana", "Orange", "Kiwi", "cherry"]
mylist01 = mylist.copy()
print(mylist01) # 输出结果：['zero', 'banana', 'Orange', 'Kiwi', 'cherry']
count()
count() 方法，用于返回某字符出现的次数，如果字符不存在，则返回 0，语法格式：
str.count(sub[, start[, end=len(string)]])
- str：表示对 count 输入的对象
- sub：搜索的子字符串
- start：字符串开始搜索的位置。默认为第一个字符，第一个字符索引值为 0
- end：字符串中结束搜索的位置。默认为字符串的最后一个位置
example：
string = 'Hello, World ! Hello, Python !'
print(string.count('I')) # 输出结果：0
print(string.count('H')) # 输出结果：2
print(string.count('H', 1)) # 输出结果：1
print(string.count('H', 0, 20)) # 输出结果：2
index()
index() 方法，用于获取指定元素在列表中首次出现的索引位置，语法格式：
list.index(object[, start, [end]])
- list：表示对 index 输入的对象
- object：指定要查找的元素对象
- start：指定索引起始位置
- end：指定索引结束位置
mylist = [10, 20, 30, 10, 50]
num = mylist.index(10)
num01 = mylist.index(10, 1, 5)
num02 = mylist.index(10, 1, 3)
print(num) # 输出结果：0
print(num01) # 输出结果：3
print(num02) # 输出结果：报错，10 不在列表
get()
get() 方法，用于获取字典中键的值，语法格式：
dict.get(key, value)
- dict：表示对 get 输入的对象
- key：指定在字典中要返回值的键
- value：指定如果键不存在字典中时，要返回的值，默认为 None
example：
mydict = {'zhangsan': '20', 'lisi': '24'}
print(mydict.get('zhangsan')) # 输出结果：20
print(mydict.get('wangwu')) # 输出结果：None
print(mydict.get('wangwu', "字典中不存在")) # 输出结果：字典中不存在
items()
items() 方法，用于以列表返回可遍历的（键, 值）元组数组，语法格式：
dict.items()
- dict：表示对 items 输入的对象
example：
mydict = {'zhangsan': '20', 'lisi': '24'}
print(mydict.items())
for key, value in mydict.items():
print(key, "的年龄是", value)
dict_items([('zhangsan', '20'), ('lisi', '24')]) # 输出结果
zhangsan 的年龄是 20
lisi 的年龄是 24
add()
add() 方法，用于添加元素到集合中，语法格式：
set.add(object)
- set：表示对 add 输入的对象
- object：表示要添加的元素对象
example：
myset = {10, 20, 30}
myset.add(40)
print(myset) # 输出结果：{40, 10, 20, 30}
join()
join() 方法，用于合并字符串，语法格式：
strnew = string.join(iterable)
- strnew：表示合并后生成的字符串名称
- string：字符串类型，指定合并时的分隔符
- iterable：可迭代对象
example：
mylist = ['zhangsan', 'lisi', 'wangwu']
mystr01 = ' '.join(mylist)
mystr02 = '@'.join(mylist)
print(mystr01) # 输出结果：zhangsan lisi wangwu
print('@' + mystr02) # 输出结果：@zhangsan@lisi@wangwu
find()
find() 方法，用于检索是否包含指定的子字符串，如果检索的字符串不存在，则返回 -1；如果存在，则返回首次出现该字符串时的索引，语法格式：
str.find(sub[, start[, end=len(string)]])
- str：表示对 find 输入的对象
- sub：搜索的子字符串
- start：字符串开始搜索的位置。默认为第一个字符，第一个字符索引值为 0
- end：字符串中结束搜索的位置。默认为字符串的最后一个位置
example：
string = 'Hello, World ! Hello, Python !'
print(string.find('I')) # 输出结果：-1
print(string.find('H')) # 输出结果：0
print(string.find('H', 1)) # 输出结果：15
print(string.find('H', 0, 20)) # 输出结果：0
startswith()
startswith() 方法，用于检索字符串是否以指定子字符串开头，如果是则返回 True，否则返回 False，语法格式：
str.startswith(prefix[, start[, end=len(string)]])
- str：表示对 startswith 输入的对象
- prefix：搜索的子字符串
- start：字符串开始搜索的位置。默认为第一个字符，第一个字符索引值为 0
- end：字符串中结束搜索的位置。默认为字符串的最后一个位置
example：
string = 'Hello, World ! Hello, Python !'
print(string.startswith('I')) # 输出结果：False
print(string.startswith('H')) # 输出结果：True
print(string.startswith('H', 1)) # 输出结果：False
print(string.startswith('H', 0, 20)) # 输出结果：True
endswith()
endswith() 方法，用于检索字符串是否以指定子字符串结尾，如果是则返回 True，否则返回 False，语法格式：
str.endswith(suffix[, start[, end=len(string)]])
- str：表示对 endswith 输入的对象
- suffix：搜索的子字符串
- start：字符串开始搜索的位置。默认为第一个字符，第一个字符索引值为 0
- end：字符串中结束搜索的位置。默认为字符串的最后一个位置
example：
string = 'Hello, World ! Hello, Python !'
print(string.endswith('I')) # 输出结果：False
print(string.endswith('!')) # 输出结果：True
print(string.endswith('!', 14)) # 输出结果：True
print(string.endswith('!', 0, 20)) # 输出结果：False
encode()
encode() 方法，用于将字符串转换为二进制数据（即 bytes），语法格式：
str.encode([encoding="utf-8"][, error="strict"])
- str：表示对 encode 输入的字符串
- encoding=“utf-8”：用于指定进行转码时采用的字符编码，默认为 UTF-8，如果使用简体中文，则设置为 GB2312
- error：指定错误处理方式，值为 strict 时，遇到非法字符就抛出异常；值为 ignore 时，忽略非法字符；值为 replace 时，用 “？” 替换非法字符；值为 xmlcharrefreplace 时，使用 XML 的字符引用等，默认为 strict
example：
mystr = "我喜欢用 Python"
print(mystr.encode('UTF-8')) # 输出结果：b'\xe6\x88\x91\xe5\x96\x9c\xe6\xac\xa2\xe7\x94\xa8 Python'
print(mystr.encode('GB2312')) # 输出结果：b'\xce\xd2\xcf\xb2\xbb\xb6\xd3\xc3 Python'
print(mystr.encode('GBK')) # 输出结果：b'\xce\xd2\xcf\xb2\xbb\xb6\xd3\xc3 Python'
decode()
decode() 方法，将二进制数据转换为字符串，将 encode() 方法转换的结果再转换为字符串，也称为 “解码”，语法格式：
bytes.decode([encoding="utf-8"][, error="strict"])
- bytes：表示对 decode 输入的二进制数据
- encoding=“utf-8”：用于指定进行转码时采用的字符编码，默认为 UTF-8，如果使用简体中文，则设置为 GB2312
- error：指定错误处理方式，值为 strict 时，遇到非法字符就抛出异常；值为 ignore 时，忽略非法字符；值为 replace 时，用 “？” 替换非法字符；值为 xmlcharrefreplace 时，使用 XML 的字符引用等，默认为 strict
在设置解码采用的字符编码时，需要与编码时采用的字符编码一致
example：
mybytes01 = b'\xe6\x88\x91\xe5\x96\x9c\xe6\xac\xa2\xe7\x94\xa8 Python'
mybytes02 = b'\xce\xd2\xcf\xb2\xbb\xb6\xd3\xc3 Python'
mybytes03 = b'\xce\xd2\xcf\xb2\xbb\xb6\xd3\xc3 Python'
print(mybytes01.decode('UTF-8')) # 输出结果：我喜欢用 Python
print(mybytes01.decode('GB2312')) # 输出结果：UnicodeDecodeError: 'gb2312' codec can't decode byte 0xe6 in position 0: illegal multibyte sequence，GB2312 解码器无法解码
print(mybytes02.decode('GB2312')) # 输出结果：我喜欢用 Python
print(mybytes03.decode('GBK')) # 输出结果：我喜欢用 Python
__init__()
__init__() 方法，这种方法是 “构造方法”。该方法是一个特殊的方法，每当创建一个类的新实例时，Python 都会自动执行它。__init__() 方法必须包含一个 self 参数，并且必须是第一个参数。self 参数是一个指向实例本身的引用，用于访问类中属性和方法。在方法调用时会自动传递实际参数 self，因此当 __init__() 方法只有一个参数时，在创建类的实例时，就不需要指定实际参数了，语法格式：
__init__(self[, parameter[, parameter[,...]]])
- self：必须指定且必须是第一个参数，self 参数是一个指向实例本身的引用，用于访问类中属性和方法
- [, parameter[, parameter[,…]]]：可选参数，用于指定类中的属性
example：
class Dog:
def __init__(self, name, age): # 构造方法
self.name = name
self.age = age
dog = Dog("球球", 2) # 创建实例化对象，调用构造方法
print("我们家的狗狗叫：{0}，{1} 岁了。".format(dog.name, dog.age)) # 输出结果：我们家的狗狗叫：球球，2 岁了。
__str__()
__str__() 方法，该方法是一个特殊的方法，每当创建一个类的新实例时，Python 都会自动执行它。用于返回一个字符串，当做这个对象的描述，语法格式：
__str__(self[, parameter[, parameter[,...]]])
- self：必须指定且必须是第一个参数，self 参数是一个指向实例本身的引用，用于访问类中属性和方法
- [, parameter[, parameter[,…]]]：可选参数，用于指定类中的属性
__str__()方法与__init__()方法一样，首尾双下划线修饰，也是一个默认方法
作用：用于返回一个字符串，当做这个对象的描述
如果用 print 打印将会打印生成器对象，所以要用__str__()方法将对象的描述符格式化
exaple：
class Cat:
"""定义一个猫类"""
def __init__(self, new_name, new_age):
"""在创建完对象之后 会自动调用, 它完成对象的初始化的功能"""
# self.name = "汤姆"
# self.age = 20
self.name = new_name
self.age = new_age # 它是一个对象中的属性,在对象中存储,即只要这个对象还存在,那么这个变量就可以使用
# num = 100 # 它是一个局部变量,当这个函数执行完之后,这个变量的空间就没有了,因此其他方法不能使用这个变量
def __str__(self):
"""返回一个对象的描述信息"""
# print(num)
return "名字是:%s , 年龄是:%d" % (self.name, self.age)
def eat(self):
print("%s在吃鱼...." % self.name)
def drink(self):
print("%s在喝可乐..." % self.name)
def introduce(self):
# print("名字是:%s, 年龄是:%d" % (汤姆的名字, 汤姆的年龄))
# print("名字是:%s, 年龄是:%d" % (tom.name, tom.age))
print("名字是:%s, 年龄是:%d" % (self.name, self.age))
tom = Cat("汤姆", 30) # 创建了一个对象
print(tom) # 输出结果：名字是:汤姆 , 年龄是:30
tom.eat() # 输出结果：汤姆在吃鱼....
tom.drink() # 输出结果：汤姆在喝可乐...
tom.introduce() # 输出结果：名字是:汤姆 , 年龄是:30
__name__ == '__main__'
__name__ == '__main__' 方法，是用来控制 Python 文件执行的场景
Python 文件通常有两种执行方法：
- 作为脚本文件直接执行
- 作为模块 import 导入到其它的 Python 脚本中执行
if __name__ == '__main__' 中的代码只有在作为脚本文件才会被执行，而作为模块 import 导入到其它的 Python 脚本中不会执行
example：
"""
创建名为 test.py 文件
"""
print("Hello, World!")
print("__name__：", __name__)
if __name__ == '__main__':
print("Hello, Python!")
Hello, World! # 输出结果，if __name__=="__main__": 语句之前和之后的代码都被执行
__name__： __main__
Hello, Python!
"""
创建名为 test01.py 文件，将 test.py 文件作为模块导入
"""
import test
Hello, World! # 输出结果，if __name__=="__main__": 之前的语句被执行，之后的没有被执行
__name__： test
每个 Python 模块（Python 文件，也就是此处的 test.py 和 test01.py）都包含内置的变量
__name__，当该模块被直接执行的时候，__name__等于文件名（包含后缀.py）；如果该模块 import 到其他模块中，则该模块的__name__等于模块名称（不包含后缀.py），而 “__main__” 始终指当前执行模块的名称（包含后缀.py）。进而当模块被直接执行时，__name__ == '__main__'结果为假
close()
close() 方法，对打开的文件进行关闭，以免对文件造成不必要的破坏，语法格式：
file.close()
- file：为打开的文件对象
example：
file = open('test.txt', 'r', encoding='utf-8')
print(file) # 输出结果：<_io.TextIOWrapper name='test.txt' mode='r' encoding='utf-8'>
file.close()
close() 方法先刷新缓冲区中还没有写入的信息，然后再关闭文件，这样可以将没有写入到文件的内容写入到文件中，在关闭文件后，便不能再进行写入操作了
write()
write() 方法，可以向文件中写入内容，语法格式：
file.write(string)
- file：指定要打开的文件对象
- string：指定要写入的内容
在调用 write() 方法向文件中写入内容的前提是在打开文件时，指定打开模式为 w（可写）或 a（追加），否则会报错
使用 “w” 读写模式，写入内容，example：
file = open('test.txt', 'w')
file.write("Hello, World!\n")
print("写入内容")
file.close()
写入内容 # 输出结果
在写入文件后，一定要调用 close() 方法关闭文件，否则写入的内容不会保存到文件中。这是因为当我们写入文件内容时，操作系统不会立刻把数据写入到磁盘中，而是先缓存起来，只有调用 close() 方法时才会将数据写入到磁盘中
使用 “a” 追加模式写入内容，example：
file = open('test.txt', 'a')
file.write("Hello, Python!")
print("写入内容")
file.close()
read()
read() 方法，用于读取指定个数的字符，语法格式：
file.read([size])
- file：指定要读取的文件对象
- size：指定要读取字符的个数，如果省略，则读取所有内容
在调用 read() 方法读取文件内容的前提时在打开文件时，指定打开模式为 r（只读）或 r+（读写），否则会报错
example：
with open('test.txt', 'r') as file:
mystr = file.read()
print(mystr)
Hello, World! # 输出结果
Hello, Python!
seek()
seek() 方法，用于将文件的指针移动到只读位置，然后再应用 read() 方法读取，可以读取文件部分内容，语法格式：
file.seek(offset[, whence])
- file：指定已经打开的文件对象
- offset：指定移动的字符个数，具体位置与 whence 参数有关
- whence：指定从什么位置开始计算。默认为 0，值为 0 表示从文件头开始计算，值为 1 表示从当前位置开始计算，值为 2 表示从文件末尾开始计算
example：
with open('test.txt', 'r') as file:
file.seek(6)
mystr = file.read(10)
print(mystr)
World! # 输出结果
He
对于 whence 参数，如果在打开文件时，没有使用 b 模式（即 rb），那么只允许从文件头开始计算相对位置，从文件末尾计算时就会抛出异常
在使用 seek() 方法时，如果采用 GBK 编码，那么 offset 的值是按一个汉字（包括中文标点符号）占两个字符计算，采用 UTF-8 编码，则一个汉字占 3 个字符，不过无论采用何种编码英文和数字都是按一个字符计算
readline()
readline() 方法，用于每次读取一行数据，语法格式：
file.readline()
- file：指定已经打开的文件对象
example：
with open('test.txt', 'r') as file:
num = 0
while True:
num += 1
line = file.readline()
if line == '':
break
print(num, line)
1 Hello, World! # 输出结果
2 Hello, Python!
readlines()
readlines() 方法，用于读取全部行，返回的是一个字符串列表，每行内容为一个元素，语法格式：
file.readlines()
- file：指定要打开的文件对象
example：
with open('test.txt', 'r') as file:
lines = file.readlines()
print(lines) # 输出结果：['Hello, World!\n', 'Hello, Python!']
1021
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
