常用内置函数

最新推荐文章于 2024-07-12 19:06:42 发布

新知

最新推荐文章于 2024-07-12 19:06:42 发布

阅读量206

点赞数

分类专栏： python 文章标签： python

原文链接：https://www.cnblogs.com/wujiaqing/p/10709207.html

版权

python 专栏收录该内容

45 篇文章 2 订阅

订阅专栏

常用内置函数

abs()函数返回数字的绝对值。

print( abs(-45) )                  # 返回 45
print("abs(0.2):",abs(0.2))        # 返回 abs(0.2): 0.2

all() 函数用于判断给定的参数中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。

print( all( [0.1,1,-1] )  )        # 返回 True
print( all( (None,1) )  )          # 返回 False（其中一个元素为None）
print( all( [0,1,-1] )  )          # 返回 False（其中一个元素为0）
print( all( [" ","a",""] )  )      # 返回 False(第三个元素为空)

any() 函数用于判断给定的参数是否全部为False，是则返回False，如果有一个为True，则返回True。元素除了是 0、空、False外都算 TRUE。

# 参数全部不为 0、空、FALSE
print(any("-45"))                 #  True
print(any(["-45"]))               #  True
print( any( ("0","ab","") ) )     #  True（注意：第一个参数0加了双引号，表示为一个字符串）

# 参数全部为 0、空、False
print( any( (0,"") ) )            #  False
print( any( (0,"",False) ) )      #  False

bin()函数返回一个整数int或者长整数long int的二进制表示

print( bin(10) )        #  0b1010
print( bin(133) )       #  0b10000101

bool() 函数用于将给定参数转换为布尔类型，如果参数不为空或不为0，返回True；参数为0或没有参数，返回False。

print( bool(10) )                 #  True
print( bool([0]) )                #  True
print( bool(["123","s",0]) )      #  True

print( bool(0) )                  #  False
print( bool() )                   #  False

callable()函数用于检查一个对象是否可调用的。对于函数、方法、lambda函式、类以及实现了 call 方法的类实例, 它都返回 True。（可以加括号的都可以调用）

def sayhi():pass                 #  先定义一个函数sayhi()
print( callable( sayhi ) )       #  True
a = 1
print( callable( a ) )           #  False

chr()函数用一个范围在range(256)内（即0～255）的整数作参数，返回一个对应的ASCII数值。

# 把数字98在ascii码中对应的字符打印出来
print( chr(98) )                   #  返回：b

dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

print( dir() )           #  获得当前模块的属性列表
#  返回：['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print( dir([]) )         #  查看列表的方法
#  返回：['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

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

exec("for i in range(5): print('iter time is %d'%i)")      # 执行复杂的for循环
# iter time is 0
# iter time is 1
# iter time is 2
# iter time is 3
# iter time is 4

filter()用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，可用list()来转换为列表。

res = filter(lambda n:n>5,range(10))   # 过滤掉0-9中不符合n>5的数据
for i in res:                          # 循环打印符合n>5的数据
    print(i)

# 5
# 6
# 7
# 8
# 9

format()是一种格式化字符串的函数，基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。

# 位置映射
print( "{}{}".format('a','1') )
# a1

print('name:{n},url:{u}'.format(n='alex',u='www.xxxxx.com'))
# name:alex,url:www.xxxxx.com

# 元素访问
print( "{0[0]},{0[1]}".format(('baidu','com')) )                # 按顺序
# baidu,com

print( "{0[2]},{0[0]},{0[1]}".format(('baidu','com','www')) )   # 不按顺序
# www,baidu,com

hasattr() 函数用于判断对象是否包含对应的属性。如果对象有该属性返回 True，否则返回 False。

class t:
    a = 1
    b = 2
    c = 3

p = t()
print(hasattr(p,'a'))    # True
print(hasattr(p,'b'))    # True
print(hasattr(p,'x'))    # False

hash() 用于获取一个对象（数字或者字符串等）的哈希值。不能直接应用于 list、set、dictionary。

print(hash(1))                  # 1
print(hash(20000))              # 20000
print(hash('123'))              # -6436280630278763230
print(hash('ab12'))             # 5468785079765213470
print(hash('ab12'))             # 5468785079765213470

hex() 函数用于将一个整数转换为十六进制数。返回一个字符串，以0x开头。

print(hex(1))        # 0x1

print(hex(-256))     # -0x100
print(type(hex(-256)))    #<class 'str'>

id()函数用于获取对象的内存地址。

a = "123"                             # 字符串
print(id(a))                          # 13870392

b = [1,2,3]                           # 列表
print(id(b))                          # 7184328

c = {'num1':1,'num2':2,'num3':3}       # 字典
print(id(c))                           # 6923656

isinstance() 函数来判断一个对象是否是一个已知的类型，返回布尔值。类似 type()。

a = 2

print(isinstance(a,int))                   #  True
print(isinstance(a,str))                   #  False
print(isinstance(a,(str,tuple,dict)))      #  False
print(isinstance(a,(str,tuple,int)))       # 是元组其中的一个则返回True

len() 方法返回对象（字符、列表、元组等）长度或元素个数。

# len()方法返回对象（字符、列表、元组等）长度或元素个数。
print(len('1234'))              # 字符串，返回字符长度4
print(len(['1234','asd',1]))    # 列表，返回元素个数3
print(len((1,2,3,4,50)))        # 元组，返回元素个数5

print(len(12))                  # 注意：整数类型不适用，否则报错
# TypeError: object of type 'int' has no len()

map()接收函数f和list，并通过把函数f依次作用在list的每个元素上，得到一个新的list并返回。

res = map(lambda n: n*2,[0,1,2,3,4,5])    # 使用 lambda 匿名函数
for i in res:
    print(i)

# 返回以下数据：
# 0
# 2
# 4
# 6
# 8
# 10

# 提供了两个列表，对相同位置的列表数据进行相加
a = map(lambda x,y : x+y,[1,2,3,4,5],[2,4,6,8,10])
for i in a:
    print(i)

# 返回以下数据：
# 3
# 6
# 9
# 12
# 15

max()函数返回给定参数的最大值，参数可以为序列。

print("max(10,20,30):" , max(10,20,30) )
# max(10,20,30): 30

print("max(10,-2,3.4):" , max(10,-2,3.4) )
# max(10,-2,3.4): 10

print("max({'b':2,'a':1,'c':0}):" , max({'b':2,'a':1,'c':0}) )   # 字典，默认按key排序
# max({'b':2,'a':1,'c':0}): c

min()函数返回给定参数的最小值，参数可以为序列。

print("min(10,20,30):" , min(10,20,30) )
# min(10,20,30): 10

print("min(10,-2,3.4):" , min(10,-2,3.4) )
# min(10,-2,3.4): -2

print("min({'b':2,'a':1,'c':0}):" , min({'b':2,'a':1,'c':0}) )   # 字典，默认按key排序
# min({'b':2,'a':1,'c':0}): a

pow()函数返回x的y次方的值。

# 通过内置的方法直接调用
print( pow(2,2) )          #  2的二次方
# 4
print( pow(2,-2) )         #  2的负二次方
# 0.5

range() 函数可创建一个整数列表，一般用在 for 循环中。语法：range(start, stop[, step])

for i in range(10):
    print(i)            # 依次打印数字0-9

for a in range(0,10,2):     # 步长为2
    print(a)            # 打印0,2,4,6,8

for b in range(10, 0, -2):  # 步长为-2
    print(b)            # 打印10,8,6,4,2

reduce() 函数会对参数序列中元素进行累积。在Python3 ，reduce()被放置在functools模块里，如果想要使用它，需要先引入functools模块。

import functools

a = functools.reduce(lambda x,y:x+y,[1,2,3])
print(a)           # 6 ， 即从1加到3

b = functools.reduce(lambda x,y:x+y,range(10))
print(b)           # 45 ， 即从0加到9

reversed() 函数返回一个反转的迭代器。 reversed(seq)要转换的序列，可以是 tuple, string, list 或 range。

rev = reversed( [1,2,3,4,5] )       # 列表
print(list(rev))
# [5, 4, 3, 2, 1]

rev1 = reversed( "school" )         # 元组
print(tuple(rev1))
# ('l', 'o', 'o', 'h', 'c', 's')

rev2 = reversed(range(10))          # range
print(list(rev2))
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

round() 方法返回浮点数x的四舍五入值。（除非对精确度没什么要求，否则尽量避开用round()函数）

print( round(4.3))         # 只有一个参数时，默认保留到整数
# 4

print( round(2.678,2))     #  保留2位小数
#  2.68

print( round(5/3,3))     #  运算表达式并保留3位小数
#  1.667

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

b = set([1,2,3,4,5])
c = set([2,4,6,8,10])

print(b & c)     # 交集，得到结果为{2, 4}
print(b | c)     # 并集，得到结果为{1, 2, 3, 4, 5, 6, 8, 10}
print(b - c)     # 差集，得到结果为{1, 3, 5}

sorted() 函数对所有可迭代的对象进行排序（默认升序）操作。

# 对列表进行排序
print(sorted([1,2,5,30,4,22]))    # [1, 2, 4, 5, 22, 30]

# 对字典进行排序
dict = {23:42,1:0,98:46,47:-28}
print( sorted(dict) )                     # 只对key排序
# [1, 23, 47, 98]

print( sorted(dict.items()) )             # 默认按key进行排序
# [(1, 0), (23, 42), (47, -28), (98, 46)]

print( sorted(dict.items(),key=lambda x:x[1]) )      # 用匿名函数实现按value进行排序
# [(47, -28), (1, 0), (23, 42), (98, 46)]

# 利用key进行倒序排序
test1 = [1,2,5,30,4,22]
r_list = sorted(test1,key=lambda x:x*-1)
print(r_list)                     # [30, 22, 5, 4, 2, 1]

# 要进行反向排序，也可以通过传入第三个参数 reverse=True：
test2 = [1,2,5,30,4,22]
print(sorted(test2,reverse=True))    # [30, 22, 5, 4, 2, 1]

sum()函数对参数进行求和计算。

print( sum([1,2,3]) )        #  6
print( sum([1,2,3],4) )      #  列表计算总和后再加4，得到结果10
print( sum( (1,2,3),4 ) )    #  元组计算总和后再加4，得到结果10

type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

print(type(1))                   # <class 'int'>
print(type("123"))               # <class 'str'>
print(type([123,456]))           # <class 'list'>
print(type( (123,456) ) )        # <class 'tuple'>
print(type({'a':1,'b':2}) )      # <class 'dict'>

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

a = [1,2,3]
b = [4,5,6]
c = [7,8,9,10]

for i in zip(a,b):
    print(i)

# 返回结果：
# (1, 4)
# (2, 5)
# (3, 6)

print(list(zip(a,b)))       # list() 转换为列表
# [(1, 4), (2, 5), (3, 6)]

print(list(zip(b,c)))       # 元素个数与最短的列表一致
# [(4, 7), (5, 8), (6, 9)]

a1,a2 = zip(*zip(a,b))      #  用zip(*)解压
print(list(a1))         # [1, 2, 3]
print(list(a2))         # [4, 5, 6]

参考

Python 常用内置函数

新知

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用内置函数

常用内置函数abs()函数返回数字的绝对值。print( abs(-45) ) # 返回 45print("abs(0.2):",abs(0.2)) # 返回 abs(0.2): 0.2all() 函数用于判断给定的参数中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。print( all( [0.1,1,-1] ) )
复制链接

扫一扫