Python 函数和方法

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() 内置函数,用来判断数据类型是否是相对应的类型,它返回的是布尔值(TrueFalse),语法格式:

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 表示任何多个无名参数,它是一个 tuplelist**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)0xb0x 式十六进制 + 小写
11‘{:#X}’.format(11)0xB0x 式十六进制 + 大写

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!']
  • 8
    点赞
  • 50
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值