脚本宝典收集整理的这篇文章主要介绍了Python基础:21.常用内置函数,脚本宝典觉得挺不错的,现在分享给大家,也给大家做个参考。
下图是python的内置函数:
在此只列举常用的,不常见的可以参考菜鸟教程
all() 函数用于判断给定的可迭代参数 ITerable 中的所有元素是否都为 TRUE,如果是返回 True,否则返回 False
空元组、空列表返回值为True,这里要特别注意
any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。
PRint(all(['a', 'b', 'c', 'd']))
print(all(['a', 'b', '', 'd']))
print(all(('a', 'b', '', 'd')))
print(all((0, 1, 2, 3)))
print(all([]))
print(all(()))
True
False
False
False
True
True
enumerate(sequence, [start=0])
,其中sequence为序列、迭代器或其他支持迭代对象,start是下标起始位置,默认为0
返回值:返回 enumerate(枚举) 对象,即同时列出数据和数据下标。这个返回值是一个迭代器,可以用list()转为列表
enumerate() 函数一般用在 for 循环当中,将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标
From collections.abc import Iterator
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(enumerate(seasons))
print(isinstance(enumerate(seasons), Iterator)) # 判断是否为迭代器
print(list(enumerate(seasons))) # list()将迭代器转为列表
for i, element in enumerate(seasons,start=1): # 这是常用的用法,下标自己定义
print(i, element)
<enumerate object at 0x00000225102f22D0>
True
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
1 Spring
2 Summer
3 Fall
4 Winter
help() 函数可以打印输出一个函数的说明文档
help(print)
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='n', file=Sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string apPEnded after the last value, default a newline.
flush: whether to forcibly flush the stream.
isinstance(object, classinfo)
其中object -- 实例对象,classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组
返回值:如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False
isinstance() 与 type() 区别: type() 不会认为子类是一种父类类型,不考虑继承关系。type用于求一个未知数据类型对象。 isinstance() 会认为子类是一种父类类型,考虑继承关系。isinstance用于判断一个对象是否是已知数据类型。
python基本数据类型: int,float,bool,complex,str(字符串),list,dict(字典),set,tuple
a = 2
print(isinstance (a,int))
print(isinstance (a,(str,int,list))) # 是元组中的一个也返回 True
True
True
class A:
pass
class B(A): # A是B的父类
pass
print(isinstance(A(), A)) # 实例A是否是A类的类型
print(type(A())) # 实例A的类型是什么
print(isinstance(B(), A)) # 实例B是否是A类的类型
print(type(B()) == A) # type不考虑继承
True
<class '__main__.A'>
True
False
reversed(seq)
,seq -- 要转换的序列,可以是 tuple, string, list 或 range。返回一个反转的迭代器
如果没有实例化(即未使用list函数或for循环),它并不会产生一个倒序的序列
# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
['b', 'o', 'o', 'n', 'u', 'R']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]
sorted(iterable, key=None, reverse=False)
,其中iterable--可迭代对象,reverse--排序规则,reverse = True 降序,reverse = False 升序(默认)
key指定的函数将作用于list的每一个元素上,并根据key函数返回的结果进行排序。返回值为重新排序的列表
print(sorted([36, 5, -12, 9, -21])) # 默认按照数值大小升序排列
print(sorted([36, 5, -12, 9, -21], key=abs)) # 按照指定的abs值进行升序排列
print(sorted([36, 5, -12, 9, -21], key=abs,reverse = True)) # 按照指定的abs值进行降序排列
print(sorted([36, 5, -12, 9, -21], key=lambda x:x*(-1))) # 按照指定的函数进行升序排列
[-21, -12, 5, 9, 36]
[5, 9, -12, -21, 36]
[36, -21, -12, 9, 5]
[36, 9, 5, -12, -21]
print(sorted(['bob', 'about', 'Zoo', 'Credit'])) # 字符串默认按照ASCLL大大小升序排列,'Z'<'a'
print(sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower)) # 按照指定的函数,即字符串小写字母ASCLL升序排列
print(sorted(['bob', 'about', 'Zoo', 'Credit'],key=len)) # 按照字符串长度升序排列
['Credit', 'Zoo', 'about', 'bob']
['about', 'bob', 'Credit', 'Zoo']
['bob', 'Zoo', 'about', 'Credit']
字典排序一般指定按照哪个键来排序,也会涉及到多列排序
array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
print(sorted(array,key=lambda x:x["age"])) # 按照字典中的'age'升序排列
[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
l = sorted(d1, key=lambda x:(-x['score'], x['name'])) # 先按照成绩降序排序,相同成绩的按照名字升序排序:
print(l)
[{'name': 'alice', 'score': 38}, {'name': 'christ', 'score': 28}, {'name': 'darl', 'score': 28}, {'name': 'bob', 'score': 18}]
from functools import reduce
def add(x, y):
return x + y
reduce(add, [1, 3, 5, 7, 9]) # 1+3+5+7+9
25
from collections.abc import Iterable,Iterator
def f(x):
return x*x
a = map(f,[1, 2, 3, 4, 5, 6, 7, 8, 9]) # 第一个参数是函数,另一个是可迭代的列表,返回的是一个迭代器
print(isinstance(a,Iterator))
list(a) # map返回的是一个惰性序列,要用list将其都计算出来
True
[1, 4, 9, 16, 25, 36, 49, 64, 81]
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) # 将数字转为字符
['1', '2', '3', '4', '5', '6', '7', '8', '9']
def is_odd(x): # 保留奇数
return x%2 == 1
list(filter(is_odd,[1, 2, 4, 5, 6, 9, 10, 15]))
[1, 5, 9, 15]
zip([iterable, ...])
,其中iterabl为一个或多个可迭代对象。返回一个迭代器
zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存
如果各个可迭代对象的元素个数不一致,则返回列表长度与最短的对象相同
利用*
号操作符,可以将元组解压为列表,注意符号是放置在括号内的
from collections.abc import Iterable,Iterator
a = [1,2,3]
b = [4,5,6]
c = [7,8]
zipped = zip(a,b)
print(zipped)
print(isinstance(zipped, Iterator))
print(list(zipped))
print(list(zip(a,c))) # 元素个数与最短的列表一致
<zip object at 0x00000146B7F8CD88>
True
[(1, 4), (2, 5), (3, 6)]
[(1, 7), (2, 8)]
zip()函数常用的场景是同时遍历多个序列,有时也可以和enumerate()函数一起使用
a = [1,2,3]
b = [4,5,6]
for x,y in zip(a,b): # 同时遍历a,b序列
print(x,y)
1 4
2 5
3 6
list1 = ['Spring', 'Summer', 'Fall', 'Winter']
list2 = ['bob', 'about', 'Zoo', 'Credit']
for i,(x,y) in enumerate(zip(list1,list2)): # 和enumerate()函数一起使用
print('%d:%s,%s' % (i,x,y))
0:Spring,bob
1:Summer,about
2:Fall,Zoo
3:Winter,Credit
a,b = zip(*[(1, 4), (2, 5), (3, 6)]) # 与 zip 相反,zip(*) 可理解为解压,返回二维矩阵式
a,b # 有一种将行列颠倒的感觉
((1, 2, 3), (4, 5, 6))
通过zip函数配对两个序列生成字典
key_list = [1,2,3,4,5]
value_list = ['bob', 'about', 'Zoo', 'Credit','Alex']
dict1 = dict(zip(key_list,value_list))
dict1
{1: 'bob', 2: 'about', 3: 'Zoo', 4: 'Credit', 5: 'Alex'}
str() 函数将对象转化为适于人阅读的形式 repr() 函数将对象转化为供解释器读取的形式 二者均是将任意的值转化为字符串,但函数str( )将其转化成为适于人阅读的前端样式文本,而repr(object)就是原本未处理的用于编译器阅读的后台底层代码
a = 'hello, world!n'
print(str(a))
print(repr(a))
hello, world!
'hello, world!n'
range() 函数返回的是一个可迭代对象(类型是对象),而不是列表类型,转为列表需要用list函数
语法:range(stop)
或range(start, stop[, step])
加了step,就得有start,否则不生成数据
list(range(5))
[0, 1, 2, 3, 4]
list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
list(range(10, 2)) # 得不到想要的列表
[]
slice() 函数实现切片对象,主要用在切片操作函数里的参数传递
class slice(stop)
class slice(start, stop[, step])
返回一个切片对象,返回序列中对应位置的元素
myslice1 = slice(5) # 设置截取5个元素的切片
print(myslice1)
arr = list(range(10))
print(arr)
print(arr[myslice1])
slice(None, 5, None)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
myslice2 = slice(1,20,2) # 设置截取5个元素的切片
print(myslice2)
arr = list(range(20,40))
print(arr[myslice2])
slice(1, 20, 2)
[21, 23, 25, 27, 29, 31, 33, 35, 37, 39]
以上是脚本宝典为你收集整理的Python基础:21.常用内置函数全部内容,希望文章能够帮你解决Python基础:21.常用内置函数所遇到的问题。
本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。