Python 函数和方法

• Python 函数和方法
  • Python 函数
    • print()
    • input()
    • len()
    • range()
    • type()
    • isinstance()
    • id()
    • list()
    • tuple()
    • str()
    • bool()
    • max()
    • min()
    • enumerate()
    • lambda
    • sum()
    • sorted()
    • zip()
    • set()
    • round()
    • filter()
    • map()
    • super()
    • dir()
    • chr()
    • ord()
    • open()
  • Python 方法
    • upper()
    • lower()
    • strip()
    • lstrip()
    • rstrip()
    • replace()
    • split()
    • format()
    • insert()
    • append()
    • extend()
    • remove()
    • pop()
    • clear()
    • sort()
    • reverse()
    • reversed()
    • copy()
    • count()
    • index()
    • get()
    • items()
    • add()
    • join()
    • find()
    • startswith()
    • endswith()
    • encode()
    • decode()
    • init()
    • str()
      • name == 'main'
    • close()
    • write()
    • read()
    • seek()
    • readline()
    • readlines()

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 X(object):
    a = 1


X = type('X', (object,), dict(a=1))

print(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))    # 输出结果：
print(b)    # 输出结果：[10, 20, 30]
print(type(b))    # 输出结果：

tuple()

tuple() 内置函数，用于将序列转换为元组，语法格式：

tuple(object)

• object：待转换为元组的数据类型

example：

a = [10, 20, 30]
b = tuple(a)

print(type(a))    # 输出结果：
print(b)    # 输出结果：(10, 20, 30)
print(type(b))    # 输出结果：

str()

str() 内置函数，用于将序列转换为字符串，语法格式：

str(object)

• object：待转换为字符串的数据类型

example：

a = 2135
b = str(a)

print(type(a))    # 输出结果：
print(b)    # 输出结果：2135
print(type(b))    # 输出结果：

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)    # 输出结果：
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)    # 输出结果：
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!']