python-内置函数：

最新推荐文章于 2024-05-24 21:59:59 发布

我们的心隔着一片海

最新推荐文章于 2024-05-24 21:59:59 发布

阅读量1.9k

点赞数

分类专栏： python基础

本文链接：https://blog.csdn.net/qq_35632689/article/details/104302126

版权

python基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

阅读须知：

本文章，内置函数需自己查找，共介绍36个(eval、exec、hash、help、callable、int、float、complex、bin、oct、hex、divmod、round、pow、bytes、ord、chr、repr、all、any、print()、str()、bool()、set()、list() 、tuple() 、dict()、abs()、sum()、reversed()、zip() 、min、sorted、filter、map 、reduce)

内置函数：

函数就是以功能为导向，一个函数封装一个功能，那么Python将一些常用的功能（比如len）给我们封装成了一个一个的函数，供我们使用，他们不仅效率高（底层都是用C语言写的），而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个

1.匿名函数：

为了解决那些功能很简单的需求而设计的一句话函数
函数名 = lambda 参数：返回值
- 参数可以有多个，用逗号隔开
- 匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
- 返回值和正常的函数一样可以是任意数据类型

#这段代码
def calc(n):
    return n**n
print(calc(10))  # 100
#换成匿名函数
calc = lambda n:n**n
print(calc(10))  # 100

在这里插入图片描述
练一练：

请把以下函数变成匿名函数
def add(x,y):
    return x+y
# 匿名函数
add = lambda x,y:x+y

2.内置函数

1.eval：

剥去字符串的外衣运算里面的代码 — 执行字符串类型的代码，并返回最终结果。

s1 = '1+3'
print(s1,type(s1))  # 1+3 <class 'str'>
print(eval(s1))  # 4
# 网络传输 str input 输入，sql注入的时候等等绝对不能使用 eval
# eval('2 + 2')  # 4
n=81
eval("n + 4")  # 85
eval('print(666)')  # 666

2.exec：

exec 与eval几乎一样，处理代码流执行字符串类型的代码。

msg = '''
  for i in range(10):
      print(i)
'''
print(msg)  # 打印字符串
exec(msg)  # 执行字符串里面的代码

3.hash：

获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

# 可变（不可哈希）的数据类型：list dict set  -------修改后，原对象发生变化
# 不可变（可哈希）的数据类型： str bool int tuple(元组)  -----修改原对象，不会对原对象产生任何改变

print(hash(12322))
print(hash('123'))
print(hash('arg'))
print(hash('alex'))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

4.help：

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

print(help(list)) 
print(help(str.split))

5.callable：

用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

s1='smierwr'
def func():
    pass
print(callable(s1))  # False
print(callable(func))  # True

6.int：

用于将一个字符串或数字转换为整型。

print(int())  # 0
print(int('12'))  # 12
print(int(3.6))  # 3

7.float：

用于将整数和字符串转换成浮点数。

print(type(3.6))  # <class 'float'>
print(float(3))  # 3.0

8.complex：

函数用于创建一个值为 real + imag * j 的复数或者将一个字符串或数转化为复数。
- 如果第一个参数为字符串，则不需要指定第二个参数。

print(complex(1,2))  # (1+2j)

9.bin：

将十进制转换成二进制并返回。

print(bin(100))  # 0b(标识二进制)       1100100   字符串数据类型

10.oct：

将十进制转化成八进制字符串并返回。

print(oct(10))  # 0o                   12        字符串数据类型

11.hex：

将十进制转化成十六进制字符串并返回。

print(hex(10))  # 0x                   a       字符串数据类型
print(hex(13))  # 0x                   d       字符串数据类型

12.divmod：

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

print(divmod(10,3))  # (3,1)

13.round：

保留浮点数的小数位数，默认保留整数。
第二个参数，表示保留几位小数

print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326

14.pow：

求x**y次幂。
- （三个参数为x**y的结果对 z 取余）

print(pow(2,3))  # 两个参数为2**3次幂  # 8
print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。  # 2

15.bytes：

用于不同编码之间的转化。

s = '你好'
转换一：
bs = s.encode('utf-8')
print(bs)  # b'\xe4\xbd\xa0\xe5\xa5\xbd'
转化二：
bs = bytes(s,encoding='utf-8')
print(bs)  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

16.ord:

输入字符找该字符编码ASCII或Unicode的位置

如果字符是ASCII就找ASCII对应的
如果字符不是ASCII中的，就在Unicode中找
print(ord('a'))  # 97        ASCII
print(ord('中'))  # 20013    Unicode

17.chr:

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

print(chr(97))  # a
print(chr(20013))  # 中

18.repr:

返回一个对象的string形式

s1 = '太白'
print(s1)  # 太白
print(repr(s1))  # '太白'
msg = '我叫%s' %(s1)
print(msg)  # 我叫太白

msg1 = '我叫%r'%(s1)
print(msg1)  # 我叫'太白'

print(repr('{"name":"alex"}'))  # '{"name":"alex"}'
print('{"name":"alex"}')  # {"name":"alex"}

19.all：

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

# 可迭代对象：str  list   tuple  dic  set  range 文件句柄
# int bool 不是可迭代对象
print(all([1, 2, True, 0]))  # False

20.any：

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

l1 = [0,'太白',False,[],'',()]
print(any(l1))  # True

21.print()

''' 源码分析        print
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
'''

# sep:
print(1,2,3,4)  # 1 2 3 4
print(1,2,3,4,sep='|')  # 1|2|3|4
# end:
print(1,end=' ')
print(2)  # 1 2

22.str()

s = 'RUNOOB'
print(str(s))  # RUNOOB
dict = {'runoob': 'runoob.com', 'google': 'google.com'};
print(str(dict))  # {'runoob': 'runoob.com', 'google': 'google.com'}

23.bool()

用于将给定参数转换为布尔类型，如果没有参数，返回 False。
bool 是 int 的子类。

>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int)  # bool 是 int 子类
True

24.set()

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

# 可变（不可哈希）的数据类型：list dict set  -------修改后，原对象发生变化
# 不可变（可哈希）的数据类型： str bool int tuple-----修改原对象，不会对原对象产生任何改变**


# 集合 set。容器型的数据类型，它要求它里面的 元素 是 不可变 的数据，
# 但是它本身是可变的数据类型。集合是无序的。 {}。

# 集合的创建：
set1 = {1, 3, '太白金星', 4, 'alex', False, '武大'}
print(set1)

# 空集合：
print({}, type({}))  # 空字典
set1 = set()
print(set1)

# 集合的有效性测试-------   str bool int tuple
set1 = {[1,2,3], 3, {'name': 'alex'}}
print(set1)  # TypeError: unhashable type: 'list'  TypeError: unhashable type: 'dict'
'''增删'''
set1 = {'太白金星', '景女神',  '武大', '三粗', 'alexsb', '吴老师'}

'''增：'''
add
set1.add('xx')
print(set1)

update    迭代着增加
set1.update('fdsafgsd')
print(set1)

'''删'''
remove
remove 按照元素删除
set1.remove('alexsb')
print(set1)

# pop 随机删除
set1.pop()
print(set1)

'''变相改值'''
set1.remove('太白金星')
set1.add('男神')
print(set1)

'''关系测试'''
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
'''交集'''
print(set1 & set2)  # {4, 5}
# 并集：
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}
# 差集 -        即set1独有
print(set1 - set2)  # {1, 2, 3}
# 反交集
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
# 子集
print(set1 < set2)  # True
# # 超集
print(set2 > set1)  # True

'''列表的去重'''
l1 = [1,'太白', 1, 2, 2, '太白',2, 6, 6, 6, 3, '太白', 4, 5, ]
set1 = set(l1)
print(set1)  # {1, 2, 3, 4, 5, 6, '太白'}
l1 = list(set1)
print(l1)  # [1, 2, 3, 4, 5, 6, '太白']
# 用处：数据之间的关系，列表去重

25.list()

将一个可迭代对象转换成列表

l1 = [1,2,3,4]
l2 = list()  # 空列表  [] 
l3 = list('reioweroier')  # 传递一个可迭代对象  ['r', 'e', 'i', 'o', 'w', 'e', 'r', 'o', 'i', 'e', 'r']

26.tuple()

将一个可迭代对象转换成元组

list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)
print(tuple1)  # ('Google', 'Taobao', 'Runoob', 'Baidu')

27.dict()

通过相应的方式创建字典。

dic1 = dict([(1,'one'),(2,'two'),(3,'three')])
print(dic1)  # {1: 'one', 2: 'two', 3: 'three'}
#     方式二：键值对的方式
dic2 = dict(one=1,two=2)
print(dic2)  # {'one': 1, 'two': 2}

28.abs()

返回绝对值

i = -5
print(abs(i))  # 5

29.sum()

求和

sum(iterable)  # 可迭代对象
print(sum([1,2,3]))  # 6
l1 = [i for i in range(10)]
print(sum(l1))  # 45
# 设置初始值
print(sum(l1,100))  # 145
# 错误
s1 = '123456'
print(sum(s1))  # TypeError: unsupported operand type(s) for +: 'int' and 'str'

30.reversed()

将一个序列翻转, 返回翻转序列的迭代器

reverse
l1 = [5, 4, 3, 7, 8, 6, 1, 9]
l1.reverse()  # 反转,对原列表进行反转
print(l1)  # [9, 1, 6, 8, 7, 3, 4, 5]

reversed   # 将可迭代对象翻转, 返回翻转序列的迭代器
l1 = [i for i in range(10)]
obj = reversed(l1)
print(obj)  # 迭代器  # <list_reverseiterator object at 0x0000017453B0EFA0>
print(list(obj))  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

31.zip() 拉链方法:

 类似于生成器
    函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,
    然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回
    
    zip(a,b)函数分别从a和b中取一个元素组成元组，再次将组成的元组组合成一个新的迭代器。
    a与b的位数相同时，正常组合对应位置的元素。当a与b行或列数不同时，取两者中的最小的行列数。

l1 = [1,2,3,4,5]
tu1 = ('太白','b哥','德刚')
s1 = 'abcd'
obj = zip(l1,tu1,s1)
print(obj)  # <zip object at 0x0000021E9EB42540>  # 一个zip对象---迭代器

for i in obj:
    print(i)
>>>(1, '太白', 'a')
>>>(2, 'b哥', 'b')
>>>(3, '德刚', 'c')

32.min

求最小值

l1 = [33,2,1,54,7,-1,-9]
print(min(l1))  # -9

# 按照绝对值方法取最小值
l2 = []
func = lambda a : abs(a)
for i in l1:
    l2.append(func(i))
print(min(l2))  # 1

# 方法二：
l1 = [33,2,1,54,7,-1,-9]
def abss(a):
    return abs(a)
print(min(l1,key=abss))   # 1           key = 函数名
# 凡是可以加 key 的，
# 它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中，
# 以返回值比较大小

练习：

# 求出值最小的键
dic={'a':3,'b':2,'c':1}
print(min(dic))  # 默认按照字典的键去比较大小   a
    # 方法一：
dic={'a':3,'b':2,'c':1}
def func(a):
    return dic[a]
print(min(dic,key=func))  # c
    # 方法二：匿名函数：
dic={'a':3,'b':2,'c':1}
print(min(dic,key=lambda a:dic[a]))  # c

l2 = [('太白',18),('alex',73),('wusir',35),('口天昊',41)]
print(min(l2,key=lambda x:x[1]))  # 传入x  返回x[1]进行比较  ('太白', 18)

33.sorted

sorted排序函数
sorted(iterable,key=None,reverse=False)
reverse :是否是倒叙,True 倒叙 False 正序
- 默认升序
- 原列表不会改变

l2 = [('太白',76),('alex',70),('wusir',94),('口天昊',98),('b哥',96)]
print(sorted(l2))  # [('alex', 73), ('wusir', 35), ('口天昊', 41), ('太白', 18)]
从低到高
print(sorted(l2,key=lambda x:x[1]))  # [('alex', 70), ('太白', 76), ('wusir', 94), ('b哥', 96), ('口天昊', 98)]
从高到低
print(sorted(l2,key=lambda x:x[1],reverse=True))  # [('口天昊', 98), ('b哥', 96), ('wusir', 94), ('太白', 76), ('alex', 70)]

# 定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']

# 计算字符串的长度
def func(s):
    return len(s)
print(sorted(lst,key=func))  # ['西游记', '红楼梦', '天龙八部', '三国演义']

lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key=lambda s:len(s)))  # ['西游记', '红楼梦', '天龙八部', '三国演义']

34.filter

筛选过滤
- 类似于列表推导式的筛选模式
语法: filter(function,iterable)
语法: filter(function,iterable)
- 用来筛选的函数,在filter中会自动的把iterable(可迭代对象)中的元素传递给function,
  然后根据function返回的True或者False来判断是否保留此项数据

l1 = [2,3,4,1,6,7,8]

# 把 小于3 的去除
   # 方法一：列表推导式
print([i for i in l1 if i >= 3])  # [3, 4, 6, 7, 8]

    # 方法二
def func(a):
    return a>=3
ret = filter(func,l1)
print(list(ret))  # [3, 4, 6, 7, 8]

# 相当于
ret = filter(lambda x:x>=3,l1)  # 返回的是迭代器
print(ret)  # <filter object at 0x0000023A1EBCE790>   迭代器
print(list(ret))  # [3, 4, 6, 7, 8]

35.map

列表推导式的循环模式
map(function,iterable)
- 可以对可迭代对象中的每一个元素进映射,分别取执行function
  计算列表中每个元素的平方,返回新列表

计算列表中每个元素的平方,返回新列表

l1 = [1,4,9,16,25]
print([i*i for i in range(1,6,1)])  # [1, 4, 9, 16, 25]
ret = map(lambda x:x**2,range(1,6))  # <map object at 0x000001D4F819E640>
print(ret)
print(list(ret))  # [1, 4, 9, 16, 25]

36.reduce

reduce(函数名,可迭代对象) # 这两个参数必须都要有,缺一个不行
reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着, 接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推

from functools import reduce
def func(x,y):
    return x * 10 + y
    # 第一次的时候 x是1 y是2  x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
    # 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
    # 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了
l = reduce(func,[1,2,3,4])
print(l)

# 匿名函数版
l = reduce(lambda x,y:x*10+y,[1,2,3,4])
print(l)