python中比较常用的内置函数

常用的内置函数

print(bin(8))#把十进制转换为二进制并返回
print(oct(8))#十进制转换为八进制字符串并返回
print(hex(8))#十进制转换为十六进制字符串并返回

callable：检查一个对象是否是可调用的

name = 'ziqing'
def func():
    pass
print(callable(name))  # False
print(callable(func))  # True

eval：剥去字符串的外衣运算里边的代码

eval('2 + 2')  # 4
n=81
eval("n + 4")  # 85
eval('print(666)')  # 666

exec: 执行字符串类型的代码。

s = '''
for i in [1,2,3]:
    print(i)
'''
exec(s)
#1
#2
#3

help：函数用于查看函数或模块用途的详细说明。

divmod：计算除数与被除数的结果，返回一个包含商和余数的元组（a // b , a % b）

print(divmod(10,3))
# (3, 1) 
# 10除以3等于3余1

round：保留浮点小数的小数位数（round（浮点小数，保留几位））

print(round(3.14159265357,2))
#3.14

pow：求x**y次幂（三个参数为x**y的结果对z取余）pow(x,y,z)

print(pow(2,3))  #8
print(pow(2,3,3))  #2

bytes：转化为bytes类型

#以前的方法
s = '子清'
b = s.encode('utf-8')
print(b)
#效果一样的
b = bytes(s,encoding='utf-8')
print(b)

ord：输入字符找该字符编码的位置

chr：输入位置数字找出其对应的字符

print(ord('a'))  #97
print(chr(97))  #a
#先去ASCII里找，找不到去Unicode
print(ord('清'))  #28165
print(chr(28165))  #清

repr：返回一个对象的string形式（原形毕露）。

s = '子清'

print(s)  #子清
print(repr(s))  #'子清'

print('我是%s'%(s))  #我是子清
print('我是%r'%(s))  #我是'子清'

all：可迭代对象中，全都是True才是True

any：可迭代对象中，有一个True 就是True

l1 = [1, 2, 3, 'zxc', 'J', '']
print(all(l1))

l2 = [1, '', (), {}, 0]
print(any(l2))

---

重点：（内置函数）

print：内置函数源码print(self, *args, sep=' ', end='\n', file=None)

• sep：是分隔每个元素的东西，默认是空格

print(1,2,3,4,5,6,78,9,sep='|')
print(1,2,3,4,5,6,78,9)
'''
1|2|3|4|5|6|78|9
1 2 3 4 5 6 78 9
'''

• end：默认是end=’\n‘ 是换行

abs：绝对值

print(abs(-6))
#6

sum：求和（把可迭代对象里边的数字加起来）（里边的元素必须是int类型）

• 还可以设置初始值：print（sum（l1，100））初始值为100，输出结果是l1这个可迭代对象里的数字加起来，再加上初始值100

l1 = [i for i in range(10)]
print(sum(l1))
#45
print(sum([1,2,3]))
#6

print(sum((1,2,3),100))
#106
print(sum(l1,100))
#145

reversed：返回的是一个翻转后的迭代器（reverse是列表的方法，是对列表进行翻转）（生成器）

l1 = [i for i in range(10)]

print(reversed(l1)) 
#<list_reverseiterator object at 0x00000220DA6364A8>

obj = reversed(l1)
print(list(obj))
#通过l1这个可迭代对象，产生了一个新的迭代器并且翻转了
#（不对原列表进行更改，是产生新的）
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

print(l1)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

---------------------------

l1 = [i for i in range(10)]
g = reversed(l1)
print(next(g))#9
print(next(g))#8
print(next(g))#7
print(next(g))#6
print(list(g))#[5, 4, 3, 2, 1, 0]

zip：拉链方法：函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回，（生成器）

l1 = [1, 2, 3, 4, 5, 6]
tu2 = ('zxc', 'ziqing', 'baba')
s3 = 'qwer'

obj = zip(l1, tu2, s3)
print(obj)
#<zip object at 0x000001A214D7DB88>

print(list(obj))
#[(1, 'zxc', 'q'), (2, 'ziqing', 'w'), (3, 'baba', 'e')]

for i in obj:
    print(i)
'''
(1, 'zxc', 'q')
(2, 'ziqing', 'w')
(3, 'baba', 'e')
'''

以下是最重要的

凡是可以加key的：它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中

max（求最大值），min（求最小值）

---这是以绝对值方式获取最大最小值
# num = []
# l1 = [11,-2,2143,-436]
# for i in l1:
#     num.append(abs(i))
# print(max(num))
# print(min(num))

l2 = []
l1 = [11,-2,2143,-436]
func = lambda a: abs(a)
for i in l1:
    l2.append(func(i))
print(l2)
print(max(l2))
print(min(l2))

print(min(l1,key=abs))
#-2

dic = {'a': 3, 'b': 2, 'c': 1}
print(min(dic))  #a（ASCII）   #默认按照字典的键去比较大小
print(dic[min(dic, key=lambda a:dic[a])])#1
print(min(dic, key=lambda a:dic[a]))#c

l1 = [('子清', 18), ('alex', 73), ('zxc', 35), ('爸爸', 41)]
print(min(l1,key=lambda a:a[1]))
#('子清', 18)

sorted：排序，可以加key

l1 = [('子清', 18), ('alex', 73), ('zxc', 35), ('爸爸', 41)]
l2 = sorted(l1,key=lambda a: a[1])
print(l2)
#[('子清', 18), ('zxc', 35), ('爸爸', 41), ('alex', 73)]

#用reverse倒过来排
l2 = sorted(l1,key=lambda a: a[1],reverse=True)

filter：类似于列表推导式的筛选模式（返回的是迭代器）

l1 = [4,2,87,5,9,1,9,72,63]

ret = filter(lambda a:a>10,l1)
print(ret)
print(list(ret))
#<filter object at 0x000002B6A3002390>
#[87, 72, 63]

这是列表推导式的筛选模式，和filter效果一样，不同的地方是：filter返回的是迭代器，而列表推导式返回的是列表

l2 = [i for i in l1 if i>10]
print(l2)
#[87, 72, 63]

map：类似于列表推导式的循环模式（返回的是迭代器）

ret = map(lambda a:a**2,range(1,6))
print(ret)
print(list(ret))
#<map object at 0x00000136A4A32470>
#[1, 4, 9, 16, 25]

这是列表推导式的循环模式，和map效果一样，不同的地方是：map返回的是迭代器，而列表推导式返回的是列表

l1 = [i**2 for i in range(1,6)]
print(l1)
#[1, 4, 9, 16, 25]