2024年Python最新Python初学者必须吃透的69个内置函数(1)-CSDN博客

本文链接：https://blog.csdn.net/2401_84558091/article/details/138365393

bytearray()

**描述：**返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)

**语法：**class bytearray([source[, encoding[, errors]]])

参数：

如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

bytearray()

bytearray(b’')

bytearray([1,2,3])

bytearray(b’\x01\x02\x03’)

bytearray(‘baidu’, ‘utf-8’)

bytearray(b’baidu’)

ord()

**描述：**查看某个ascii对应的十进制数

**语法：**ord©

**参数：**c – 字符。

ord(‘A’)

ord(‘~’)

126

chr()

**描述：**chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

**语法：**chr(i)

**参数：**i – 可以是10进制也可以是16进制的形式的数字。

查看十进制整数对应的ASCII字符

chr(65)

‘A’

可以参考4案例中的表

ascii()

**描述：**ascii() 函数返回任何对象（字符串，元组，列表等）的可读版本。

ascii() 函数会将所有非 ascii 字符替换为转义字符：

å 将替换为 \xe5。

**语法：**ascii(object)

**参数：**object–对象，可以是元组、列表、字典、字符串、set()创建的集合。

ascii(‘中国’)

“‘\u4e2d\u56fd’”

ascii(‘新冠肺炎’)

"'\u65b0\u51a0\u80ba\u

ascii(“My name is Ståle”)

“‘My name is St\xe5le’”

print(ascii((1,2))) #元组

(1, 2)

print(type(ascii((1,2))))

print(ascii([1,2])) #列表

[1, 2]

print(type(ascii([1,2])))

print(ascii(‘？’)) #字符串，非 ASCII字符，转义

‘\uff1f’

print(type(ascii(“？”)))

print(ascii({1:2,‘name’:5})) #字典

{1: 2, ‘name’: 5}

print(type(ascii({1:2,‘name’:5})))

<class ’

ASCII码表具体如下所示(节选)

Bin(二进制)	Oct(八进制)	Dec(十进制)	Hex(十六进制)	缩写/字符	解释
0000 0000	00	0	0x00	NUL(null)	空字符
0010 0001	041	33	0x21	!	叹号
0010 0010	042	34	0x22	"	双引号
0010 1010	052	42	0x2A	*	星号
...	...	...	...	...	...
0111 1101	0175	125	0x7D	}	闭花括号
0111 1110	0176	126	0x7E	~	波浪号
0111 1111	0177	127	0x7F	DEL (delete)	删除

repr()

返回一个对象的string形式

03 数据结构处理相关函数

len()

**描述：**len() 函数返回对象（字符、列表、元组等）长度或项目个数。

**语法：**len(s)

**参数：**s – 对象。

#字典的长度

dic = {‘a’:1,‘b’:3}

len(dic)

#字符串长度

s=‘aasdf’

len(s)

#列表元素个数

l = [1,2,3,4,5]

len(l)

sorted()

**描述：**sorted()函数对所有可迭代的对象进行排序操作。

**语法：**sorted(iterable, key=None, reverse=False)

参数：

iterable–可迭代对象。
key–主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则,reverse=True降序 ,reverse = False升序(默认)。

a = [5,7,6,3,4,1,2]

b = sorted(a) #保留原列表

[5, 7, 6, 3, 4, 1, 2]

[1, 2, 3, 4, 5, 6, 7]

#利用key

L=[(‘b’,2),(‘a’,1),(‘c’,3),(‘d’,4)]

sorted(L, key=lambda x:x[1])

[(‘a’, 1), (‘b’, 2), (‘c’, 3), (‘d’, 4)]

#按年龄排序

students = [(‘john’, ‘A’, 15), (‘jane’, ‘B’, 12), (‘dave’, ‘B’, 10)]

sorted(students, key=lambda s: s[2])

[(‘dave’, ‘B’, 10), (‘jane’, ‘B’, 12), (‘john’, ‘A’, 15)]

#按降序

sorted(students, key=lambda s: s[2], reverse=True)

[(‘john’, ‘A’, 15), (‘jane’, ‘B’, 12), (‘dave’, ‘B’, 10)]

#降序排列

a = [1,4,2,3,1]

sorted(a,reverse=True)

[4, 3, 2, 1, 1

sort 与 sorted 区别：

sort 是应用在list 的方法，sorted可以对所有可迭代的对象进行排序操作；list的sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数sorted方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

reversed()

**描述：**reversed函数返回一个反转的迭代器。

**语法：**reversed(seq)

**参数：**seq – 要转换的序列，可以是 tuple, string, list 或 range。

#反转列表

rev = reversed([1,4,2,3,1])

list(rev)

[1, 3, 2, 4, 1]

#反转字符串

rev = reversed(‘我爱中国’)

list(rev)

[‘国’, ‘中’, ‘爱’, ‘我’]

‘’.join(rev)

‘国中爱我’

s = ‘我的世界开始下雪’

‘’.join(reversed(s))

'雪下始开界世的

slice()

**描述：**slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。返回一个表示由 range(start, stop, step) 所指定索引集的 slice对象

语法：

class slice(stop)
class slice(start, stop[, step])

参数：

start – 起始位置
stop – 结束位置
step – 间距

a = [1,4,2,3,1]

a[slice(0,5,2)] #等价于a[0:5:2]

[1, 2, 1]

a = list(range(10))

a[slice(3)]

[0, 1, 2

enumerate()

**描述：**enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。返回一个可以枚举的对象，该对象的next()方法将返回一个元组。enumerate在字典上是枚举、列举的意思。

**语法：**enumerate(sequence, [start=0])

**参数：**sequence – 一个序列、迭代器或其他支持迭代对象。

start – 下标起始位置。

L = [‘Spring’, ‘Summer’, ‘Fall’, ‘Winter’]

enumerate(L)

<enumerate at 0x226e1ee1138>#生成的额迭代器，无法直接查看

list(enumerate(L))#列表形式，可以看到内部结构，默认下标从0开始

[(0, ‘Spring’), (1, ‘Summer’), (2, ‘Fall’), (3, ‘Winter’)]

list(enumerate(L, start=1)) #下标从 1 开始

[(1, ‘Spring’), (2, ‘Summer’), (3, ‘Fall’), (4, ‘Winter’)]

for i,v in enumerate(L):

print(i,v)

0 Spring

1 Summer

2 Fall

3 Winter

for i,v in enumerate(L,1):

print(i,v)

1 Spring

2 Summer

3 Fall

4 Winter

s = [“a”,“b”,“c”]

for i ,v in enumerate(s,2):

print(i,v)

2 a

3 b

4 c

普通的 for 循环

i = 0

seq = [‘one’, ‘two’, ‘three’]

for element in seq:

print (i, seq[i])

i+= 1

0 one

1 two

2 three

在看一个普通循环的对比案例

for 循环使用 enumerate

seq = [‘one’, ‘two’, ‘three’]

for i, element in enumerate(seq):

print (i, element)

0 one

1 two

2 three

seq = [‘one’, ‘two’, ‘three’]

for i, element in enumerate(seq,2):

print (i, element)

2 one

3 two

4 three

all()

**描述：**接受一个迭代器，如果迭代器(元组或列表)的所有元素都为真，那么返回True，否则返回False，元素除了是0、空、None、False外都算 True。**注意：**空元组、空列表返回值为True，这里要特别注意。

**语法：**all(iterable)

**参数：**iterable – 元组或列表

案例：

all([1,0,3,6])

False

all([1,9,3,6])

True

all([‘a’, ‘b’, ‘’, ‘d’])

False

all([]) #空列表为真

True

all(()) #空元组为真

True

any()

**描述：**接受一个迭代器，如果迭代器里有一个元素为真，那么返回True，否则返回False，元素除了是 0、空、None、False 外都算 True。

**语法：**any(iterable)

**参数：**iterable – 元组或列表

any([0,0,0,[]])

False

any([0,0,1])

True

any((0, ‘’, False))

False

any([]) # 空列表

False

any(()) # 空元组

False

zip()

描述：zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，**这样做的好处是节约了不少的内存。**我们可以使用 list() 转换来输出列表。，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

**语法：**zip([iterable, …])

**参数：**iterable 一个或多个迭代器

创建一个聚合了来自每个可迭代对象中的元素的迭代器：

x = [3,2,1]

y = [4,5,6]

list(zip(y,x))

[(4, 3), (5, 2), (6, 1)]

#搭配for循环，数字与字符串组合

a = range(5)

b = list(‘abcde’)

[str(y)+str(x) for x,y in zip(a,b)]

[‘a0’, ‘b1’, ‘c2’, ‘d3’, ‘e4’]

#数数相乘

list1 = [2,3,4]

list2 = [5,6,7]

for x,y in zip(list1,list2):

print(x,'‘,y,’–',xy)

2 * 5 – 10

3 * 6 – 18

4 * 7 – 28

#元素个数与最短的列表一致

list(zip(x,b))

[(3, ‘a’), (2, ‘b’), (1, ‘c’)]s

#与 zip 相反，zip(* ) 可理解为解压，返回二维矩阵式

a1, a2 = zip(*zip(a,b))

(0, 1, 2, 3, 4)

(‘a’, ‘b’, ‘c’, ‘d’,

filter()

**描述：**filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

**语法：**filter(function, iterable)

参数：

function – 判断函数。
iterable – 可迭代对象。

fil = filter(lambda x: x>10,[1,11,2,45,7,6,13])

fil

list(fil)

[11, 45, 13]

def is_odd(n):

return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(list(newlist))

[1, 3, 5, 7, 9]

map()

描述：map() 会根据提供的函数对指定序列做映射。返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器

**语法：**map(function, iterable, …)

参数：

function – 函数
iterable – 一个或多个序列

def square(x) : # 计算平方数

return x ** 2

list(map(square, [1,2,3,4,5])) # 计算列表各个元素的平方

[1, 4, 9, 16, 25]

list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函数

[1, 4, 9, 16, 25]

提供了两个列表，对相同位置的列表数据进行相加

list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))

[3, 7, 11, 15, 19]

list(map(lambda x: x%2==1, [1,3,2,4,1]))

[True, True, False, False, True]

三、和作用域相关

locals()

**描述：**locals() 函数会以字典类型返回当前位置的全部局部变量。对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

**语法：**locals()

globals()

描述： 函数会以字典类型返回当前位置的全部全局变量。

**语法：**globals()

**参数：**无

a=‘runoob’

print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。

四、迭代器生成器

range()

**描述：**range() 函数可创建一个整数列表，一般用在 for 循环中。

**语法：**range(start, stop[, step])

参数：

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5）是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0，5）等价于 range(0, 5, 1)

案例：

list(range(10))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list(range(1, 11)) # 从 1 开始到 11

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list(range(0, 30, 5))

[0, 5, 10, 15, 20, 25]

for i in range(5):

print(i)

next()

**描述：**next() 返回迭代器的下一个项目。next() 函数要和生成迭代器的iter() 函数一起使用。

**语法：**next(iterator[, default])

参数：

iterator – 可迭代对象
default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发StopIteration异常。

不加默认值的情况，最后会报错StopIteration

it = iter([5,3,4,1])

next(it)

Traceback (most recent call last):

File “”, line 1, in

next(it)

StopIteration

加默认值的情况，最后迭代完了，会返回默认值

it = iter([0,1,2,3,4])

next(it,‘结束了’)

‘结束了’

iter()

**描述：**返回一个 iterator 对象

**语法：**iter(object[, sentinel])

参数：

object – 支持迭代的集合对象。
sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

iter([0,1,2,3,4])

<list_iterator at 0x2aa87d32988>

for i in iter([0,1,2,3,4]):

print(i)

五、字符串类型代码的执行

eval()

**描述：**将字符串str 当成有效的表达式来求值并返回计算结果取出字符串中内容

**语法：**eval(expression[, globals[, locals]])

参数：

expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

s = “1 + 3 +5”

eval(s)

#要统计图片的数量

str1 = “[‘https://ww1.sin5n.jpg’, ‘https://ww1.siqk4he.jpg’]”

len(eval(str1))

len(str1)

exec()

**描述：**执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。

**语法：**exec(object, globals, locals)

参数：

object-- 要执行的表达式。
globals – 可选。包含全局参数的字典。
locals – 可选。包含局部参数的字典。

执行字符串或compile方法编译过的字符串，没有返回值

s = “print(‘helloworld’)”

r = compile(s,“”, “exec”)

exec®

helloworld

x = 10

expr = “”"

z = 30

sum = x + y + z

print(sum)

“”"

def func():

y = 20

exec(expr)

exec(expr, {‘x’: 1, ‘y’: 2})

exec(expr, {‘x’: 1, ‘y’: 2}, {‘y’: 3, ‘z’: 4})

func()

compile()

**描述：**compile() 将 source 编译成代码或 AST 对象，将字符串类型的代码编码, 代码对象能够通过exec语句来执行或者eval()进行求值

**语法：**compile(source, filename, mode[, flags[, dont_inherit]])

参数：

source – 字符串或者AST（Abstract Syntax Trees）对象。。
filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode – 指定编译代码的种类。可以指定为 exec, eval, single。
flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志

将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译。

s = “print(‘helloworld’)”

r = compile(s,“”, “exec”)

exec®

helloworld

str = “for i in range(0,5): print(i)”

c = compile(str,‘’,‘exec’) # 编译为字节代码对象

exec©

六、输入输出

print()

**描述：**print() 方法用于打印输出，最常见的一个函数。在 Python3.3 版增加了 flush 关键字参数。print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

**语法：**print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

参数：

objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep – 用来间隔多个对象，默认值是一个空格。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file – 要写入的文件对象。
flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

print(“Hello World”)

Hello World

#设置间隔符

print(“www”,“baidu”,“com”,sep=“.”)

www.baidu.com

input()

**描述：**Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。获取用户输入内容

**语法：**input([prompt])

**参数：**prompt:–提示信息

a = input(“input:”)

input:1234

print(a)

123

七、内存相关

hash()

**描述：**返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0），hash表.用空间换的时间比较耗费内存，hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

**语法：**hash(object)

**参数：**object – 对象

在hash()对对象使用时，所得的结果不仅和对象的内容有关，还和对象的id()，也就是内存地址有关。

class Test:

def init(self, i):

self.i = i

for i in range(10):

t = Test(1)

print(hash(t), id(t))

-9223371853633304640 2931543538696

-9223371853633350840 2931542799496

-9223371853633350832 2931542799624

-9223371853633350756 2931542800840

-9223371853520958964 2933341069512

-9223371853633350668 2931542802248

-9223371853633350796 2931542800200

-9223371853633350748 2931542800968

-9223371853633350856 2931542799240

-9223371853633350880 2931542798856

**hash() 函数的用途：**hash() 函数的对象字符不管有多长，返回的hash值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则hash值和原始的hash值吻合，只要验证hash值是否匹配即可验证程序是否带木马（病毒）。

name1 = ‘正常程序代码’

name2 = ‘正常程序代码带病毒’

print(hash(name1))

-3048480827538126659

print(hash(name2))

-9065726187242961328

memoryview()

描述：memoryview() 函数返回给定参数的内存查看对象(Momory view)。返回由给定实参创建的“内存视图”对象， Python 代码访问一个对象的内部数据，只要该对象支持缓冲区协议而无需进行拷贝

**语法：**memoryview(obj)

**参数：**obj – 对象

v = memoryview(bytearray(“abcefg”, ‘utf-8’))

v[1]

v[-1]

v[1:4]

v[1:4].tobytes()

b’bce’

八、文件读写

open()

**描述：**open() 函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。所以open（）读取文件分为两步。

**语法：**open(name[, mode[, buffering]])

参数：

name : 一个包含了你要访问的文件名称的字符串值。
mode : mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。
buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

打开文件的模式：

r：打开一个文件用于只读，文件的指针将会放在文件的开头，这是默认模式。

w：打开一个文件用于写入，如果文件存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

**a：打开一个文件用于追加，**如果文件已存在，文件指针将会放在文件的结尾，如果文件不存在，创建新文件进行写入。

r+：打开一个文件用于读写，文件指针将会放在文件的开头。

w+：打开一个文件用于读写。如果该文件已存在，删除原有内容并从开头开始编辑；如果该文件不存在，创建新文件。

a+：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾，如果该文件不存在，创建新文件用于读写。

rb：以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

rb+：以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

wb：以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

wb+：以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

ab+：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

注意：当读取音视频、图片等二进制文件时，需要采用二进制的读取方法。

file对象方法

file.read([size])：size 未指定则返回整个文件，如果文件大小>2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。

file.readline()：返回一行。

file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。

for line in file: print(line)：通过迭代器访问。

**file.write()：**如果要写入字符串以外的数据,先将他转换为字符串。

**file.tell()：**返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。

**file.seek(偏移量,[起始位置])：**用来移动文件指针。偏移量: 单位为比特，可正可负；起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾

**file.close()：**关闭文件

file = open(‘test.txt’,encoding=‘utf-8’) #打开文件

file.read()#直接显示文件所有内容

file.readline#显示第一行

file.close() #关闭文件

https://docs.python.org/zh-cn/3/tutorial/inputoutput.html#tut-files

test.txt存储的的内容如下

hello

python

love you

read()方法

file = open(‘test.txt’)

file.read()

‘hello\npython\ni\nlove you’

readline(）方法

file = open(‘test.txt’)

file.readline()

‘hello\n’

readlines()方法

file= open(‘test.txt’)

file.readlines()

[‘python\n’, ‘i\n’, ‘love you’]

逐行读取

file = open(‘test.txt’)

for line in file:

print(line)

hello

python

love you

九、模块相关

import()

**描述：**该函数会导入 name 模块，有可能使用给定的 globals 和 locals 来确定如何在包的上下文中解读名称。 fromlist 给出了应该从由 name 指定的模块导入对象或子模块的名称。标准实现完全不使用其 locals 参数，而仅使用 globals 参数来确定 import 语句的包上下文。level 指定是使用绝对还是相对导入。 0 (默认值) 意味着仅执行绝对导入。

语法：__import__(name, globals=None, locals=None, fromlist=(), level=0)

**参数：**object – 对象

语句 import spam的结果将为与以下代码作用相同的字节码:

spam = import(‘spam.ham’, globals(), locals(), [], 0)

十、获取帮助