5.Python内置函数

文章目录

1、内置函数简介
2、数据运算
3、类型转换
4、序列操作
5、Set集合
7、其他内置函数
6、综合练习
总结

1、内置函数简介

任何一门编程语言的核心操作都是操作内存中的数据，但内存中的数据又是通过编程语言的API来实现，所谓API，就是系统提供的函数，其中有一种函数是系统预先定义的函数，也就是在安装Python时自带的函数，这种函数就是内置函数(内嵌函数)。
内置函数文档传送门。

# 查看Python的内置函数的方法
for item in dir(__builtins__):print(item)

2、数据运算

数学运算内置函数：abs()、round()、pow()、divmod()、max()、min()、sum()、eval()。

# 1 abs()
# 求绝对值函数
print(abs(-119))# 若参数为复数，则返回复数的绝对值(此复数与它的共轭复数的乘积的平方根)，就是(a^2+b^2)开根
print(abs(1+1j))

# 2 round()
# 对浮点数进行近似取值，可以选择保留的位数（并非四舍五入，与Python版本有关）
print(round(3.556396, 3))

# 3 pow()
# 求幂
print(pow(2, 3))# pow(x,y,z)：表示x的y次幂后除以z的余数。
print(pow(2,4,5))

# 4 divmod()
# 求商和余数
print(divmod(7, 3))

# 5 max()
# 求最大
print(max([23, 33, 444, 56, 1234]))

# 6 min()
# 最小值
print(min([23, 33, 444, 56, 1234]))

# 7 sum()
# 求和
print(sum((2, 3, 4), 30))

# 8 eval()
# 动态执行表达式(可以是字符串)
a, b, c = 22, 12, 56
print(eval("a+b+c"))
print(eval("a*b+c-30"))print(eval("a+b+c", {'a': 11, 'b': 34, 'c': 12}))
print(eval('pow(2,32)'))def Test(a, b):c = a*breturn cprint(eval("Test(10,15)"))  # 可以调用函数执行

3、类型转换

类型转换:int()整形、float()浮点型、str()字符型、ord()字符转数字、chr()数字转字符、bool()布尔型、bin()转二进制、oct()转八进制、hex()转十六进制、list()列表型、tuple()元组型、dict()字典型、bytes()转为字节数组。

# 1 int()
# 整形
print(int(12.45))

# 2 float()
# 浮点型
print(float(112))

# 3 str()
# 字符型
print(type(str(1)))

# 4 ord()
# 字符转数字
print(ord('A'))

# 5 chr()
# 数字转字符
print(chr(65))

# 6 bool()
# 布尔型
print(bool(1))# 布尔型
print(bool([]))

# 7 bin()
# 十进制转二进制
print(bin(10))

# 8 oct()
# 十进制转八进制
print(oct(56))

# 9 hex()
# 十进制转十六进制
print(hex(28))

# 10 list()
# 元组转换为列表
a = (123, "你好", True)
li = list(a)
print(type(li))
li.append("强制转换")
print(li)

# 11 tuple()
# 列表转换为元组
a = [123, '你好', True]
tup = tuple(a)
print(type(tup))
print(tup)

# 12 dict()
# 内置函数创建字典
a = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
print(type(a))
print(a)# 内置函数创建字典
b = dict([('one', 1), ('two', 2), ('three', 3)])
print(type(b))
print(b)# 内置函数创建字典
dic = dict()
print(type(dic))
dic["name"] = "Tom"
dic["age"] = 16
print(dic)# 内置函数创建字典
dic = dict(a=1, b="hello", c=[1, 2, 3])
print(type(dic))
print(dic)

# 13 bytes()
# 转为字节数组
bytes('中国', encoding='gbk')# 转为字节数组
bytes('中国', encoding='utf-8')

4、序列操作

序列操作:all()、any()、sorted()、reversed()、range()、zip()、enumerate()。

# 1 all()
# all()函数用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE，如果是返回True，否则返回 False。 == and
# 元素除了是 0、空、None、False 外都算 True
# def all(iterable):
#     for element in iterable:
#         if not element:
#             return False
#     return Trueprint(all(['a', 'b', 'c', 'd']))
print(all((0, 1, 2, 3)))
print(all([]))

# 2 any()
# any()函数用于判断给定的可迭代参数iterable是否全部为False，则返回False，如果有一个为True，则返回True。== or
# 元素都是 0、空、FALSE 则为 False。
# def any(iterable):
#     for element in iterable:
#         if element:
#             return True
#     return Falseprint(any(['a', 'b', 'c', 'd']))
print(any(['a', 'b', '', 'd']))
print(any((0, '', False, 1)))
print(any([0, '', False]))
print(any([]))

# 3 sorted()
# sorted() 函数对所有可迭代的对象进行排序操作。
# sort与sorted区别：sort是应用在list的方法，
#                   sorted可以对所有可迭代的对象进行排序操作。
#                   list的sort方法返回的是对已经存在的列表进行操作，无返回值，
#                   内置函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作。# 对列表进行排序操作
a = [5, 7, 6, 3, 4, 1, 2]
a.sort()     # 升序
print(a)# 对所有可迭代的对象进行排序操作。
a = [5, 7, 6, 3, 4, 1, 2]
b = sorted(a, reverse=True)  # 返回新的列表
print("列表排序之后：", b)a = (5, 7, 6, 3, 4, 1, 2)
b = sorted(a, reverse=False)
print("元组排序之后：", b)L = [('b', 2), ('a', 1), ('c', 3), ('d', 4)]
# a = sorted(L, key=lambda x: x[1])
a = sorted(L, key=lambda x: x[0])
print(a)students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
a = sorted(students, key=lambda s: s[0])            # 按年龄排序
# a = sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
print(a)dictA = {'pro': '艺术', 'school': '香港大学', 'name': '谢霆锋','age': '66', 'pos': '歌手', 'height': '175.5'}# 排序，按照key进行排序
print(sorted(dictA.items(), key=lambda d: d[0]))# 排序，按照value进行排序
print(sorted(dictA.items(), key=lambda d: d[1]))

# 4 reversed()
# 用于反向排列列表中元素。
a = [5, 7, 6, 3, 4, 1, 2]
a.reverse()
print(a)

# 5 range()
# range()函数返回的是一个可迭代对象(类型是对象)，而不是列表类型， 所以打印的时候不会打印列表。
# list()函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。print(list(range(0, 10, 2)))x = 'runoob'
for i in range(len(x)):print(x[i], end=' ')

# 6 zip()
# zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。a = [1, 2, 3]
b = ['a', 'b', 'c']
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)
print(list(zipped))  # 查看内容zipped = zip(b, c)
print(list(zipped))# 解包
a = [1, 2, 3]
b = [4, 5, 6]
zipped = zip(a, b)
print(list(zip(*zipped)))

# zip函数的使用
def PrintBookInfo():books = []book_id = input("请输入编号(以空格分割)：")book_name = input("请输入书名(以空格分割)：")book_pos = input("请输入位置(以空格分割)：")idList = book_id.split(' ')nameList = book_name.split(' ')posList = book_pos.split(' ')bookInfo = zip(idList, nameList, posList)for bookItem in bookInfo:dictInfo = {"编号": bookItem[0], "书名": bookItem[1], "位置": bookItem[2]}books.append(dictInfo)for i in books:print(i)PrintBookInfo()

# 7 enumerate()
# enumerate()函数(枚举、列举)用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
# 同时列出数据和数据下标，一般用在for循环当中。seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))print(list(enumerate(seasons, start=2))) seq = ['one', 'two', 'three']
for i, element in enumerate(seq, start=1):print(i, element) dictA = {'pro': '艺术', 'school': '香港大学', 'name': '谢霆锋','age': '66', 'pos': '歌手', 'height': '175.5'}
for item in enumerate(dictA, start=1):print(item[1])for index, item in enumerate(dictA, start=1):print(index, item)

5、Set集合

set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
不支持索引和切片，是一个无序、不重复的容器。
交集 & : x&y，返回一个新的集合，包括同时在集合 x 和y中的共同元素。
并集 | : x|y，返回一个新的集合，包括集合 x 和 y 中所有元素。
差集 - : x-y，返回一个新的集合,包括在集合 x 中但不在集合 y 中的元素。
补集 ^ : x^y，返回一个新的集合，包括集合 x 和 y 的非共同元素。
集合操作函数:add()、clear()、difference()、intersection()、union()、pop()、discard()、update()

# 创建集合
x = set('runoob')  # 强制转换为集合
y = {'g', 'o', 'o', 'g', 'l', 'e'}  # 用{}创建集合
z = set(['r', 'u', 'n', 'o', 'o', 'b'])print(type(y))
print(y)
print(type(z))
print(z)

# 1 intersection()
# x & y 交集
print(x.intersection(y))

# 2 union()
# x | y 并集
print(x.union(y))

# 3 ^
# 补集
print(x ^ y )

# 4 difference()
# x - y 差集
print(x.difference(y))

# 5 添加操作
set1 = {'g', 'o', 'o', 'g', 'l', 'e'}
set1.add("python")
print(set1)

# 6 清空操作
set1 = {'g', 'o', 'o', 'g', 'l', 'e'}
set1.clear()
print(set1)

# 7 pop移除
set1 = {'g', 'o', 'o', 'g', 'l', 'e'}
print(set1)
set1.pop()
print(set1)

# 8 移除指定元素
set1 = {'g', 'o', 'o', 'g', 'l', 'e'}
print(set1)
set1.discard("o")
print(set1)

7、其他内置函数

# 1
# isinstance用来判断一个对象是否为str或者unicode的实例，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。print(isinstance("Hello world", str))# bytearray()方法返回一个新字节数组。
# 这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。print(bytearray([1,2,3]))
print(bytearray('runoob', 'utf-8'))

# 2
# callable() 函数用于检查一个对象是否是可调用的。
# 如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。print(callable(0))def add(a, b):return a + b
print(callable(add))

# 3
# classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，
# 但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。class A(object):bar = 1def func1(self):print('foo')@classmethoddef func2(cls):print('func2')print(cls.bar)cls().func1()   # 调用 foo 方法A.func2()               # 不需要实例化

# 4
# compile()函数将一个字符串编译为字节代码。str = "for i in range(0,10): print(i,end=' ')"
c = compile(str, '', 'exec')
exec(c)str = "3 * 4 + 5"
a = compile(str, '', 'eval')
eval(a)

# 5
# exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""def func():y = 20exec(expr)exec(expr, {'x': 1, 'y': 2})exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})func()

# 6
# complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
# 如果第一个参数为字符串，则不需要指定第二个参数print(complex(1, 2))
print(complex("1+2j"))

# 7
# delattr 函数用于删除属性,delattr(x, 'foobar') 相等于 del x.foobarclass Coordinate:x = 10y = -5z = 0point1 = Coordinate()print('x = ', point1.x)
print('y = ', point1.y)
print('z = ', point1.z)delattr(Coordinate, 'z')print('--删除 z 属性后--')
print('x = ', point1.x)
print('y = ', point1.y)# 触发错误
print('z = ', point1.z)

# 8
# dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；
# 带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。
# 如果参数不包含__dir__()，该方法将最大限度地收集参数信息print(dir(list))

# 9
# file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，
# 它们是内置函数。参数是以字符串的形式传递的。f = open('test.txt')
f.read()
f.close()

# 10
# filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
# 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，
# 然后返回 True 或 False，最后将返回 True 的元素放到新列表中。def is_odd(n):return n % 2 == 1newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))

# 11
# str.format()，它增强了字符串格式化的功能print("{:.2f}".format(3.1415926))

# 12
# frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素a = frozenset(range(10))
print(a)

# 13
# getattr() 函数用于返回一个对象属性值class A(object):bar = 1a = A()
getattr(a, 'bar')        # 获取属性 bar 值

# 14
# globals() 函数会以字典类型返回当前位置的全部全局变量。a = 'runoob'
print(globals())

# 15
# hasattr() 函数用于判断对象是否包含对应的属性class Coordinate:x = 10y = -5z = 0point1 = Coordinate()
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))

# 16
# hash() 用于获取取一个对象（字符串或者数值等）的哈希值print(hash('test'))

# 17
# help() 函数用于查看函数或模块用途的详细说明。print(help('sys'))

# 18
# id() 函数返回对象的唯一标识符，标识符是一个整数。a = 'runoob'
print(id(a))

# 19
# input() 函数接受一个标准输入数据，返回为 string 类型。a = input("input:")
print(type(a))

# 20
# isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。print(isinstance(2, int))

# 21
# issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类class A:passclass B(A):passprint(issubclass(B, A))

# 22
# iter() 函数用来生成迭代器。lst = [1, 2, 3]
for i in iter(lst):print(i)

# 23
# len() 方法返回对象（字符、列表、元组等）长度或项目个数。str = "runoob"
print(len(str))

# 24
# locals() 函数会以字典类型返回当前位置的全部局部变量。def runoob(arg):    # 两个局部变量：arg、zz = 1print(locals())runoob(4)

# 25
# map() 会根据提供的函数对指定序列做映射。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
def square(x):         # 计算平方数return x ** 2map(square, [1, 2, 3, 4, 5])    # 计算列表各个元素的平方list(map(square, [1, 2, 3, 4, 5]))   # 使用 list() 转换为列表

# 26
# memoryview() 函数返回给定参数的内存查看对象(memory view)。v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])

# 27
# next() 返回迭代器的下一个项目。
# next() 函数要和生成迭代器的 iter() 函数一起使用。# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:try:# 获得下一个值:x = next(it)print(x)except StopIteration:# 遇到StopIteration就退出循环break

# 28
# print() 方法用于打印输出，最常见的一个函数。import timeprint("---RUNOOB EXAMPLE ： Loading 效果---")print("Loading", end="")
for i in range(20):print(".", end='', flush=True)time.sleep(0.5)

# 29
# type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。type({0: 'zero'})

6、综合练习

# 求出1到10的和、20到30的和、35到45的和
sum1 = sum(range(1, 11))
sum2 = sum(range(20, 31))
sum3 = sum(range(35, 46))
print("1到10的和：{}，20到30的和：{}，35到45的和：{}".format(sum1, sum2, sum3))

def SumRange(a, b):result = sum(range(a, b+1))return resultsum1 = SumRange(1, 10)
sum2 = SumRange(20, 30)
sum3 = SumRange(35, 45)
print("1到10的和：{}，20到30的和：{}，35到45的和：{}".format(sum1, sum2, sum3))

# 100个和尚吃100个馒头，大和尚一人吃3个馒头，小和尚三人吃一个馒头
def PersonCount():'''假设大和尚a，小和尚100-a'''for a in range(1, 101):if a*3+(100-a)*(1/3) == 100:return (a, 100-a)passpassRs = PersonCount()
print("大和尚{}人，小和尚{}人".format(Rs[0], Rs[1]))

# 指定一个列表，列表里含有唯一一个只出现过一次的数字，找出这个数字
listA = [1, 2, 2, 2, 3, 44, 1, 2, 3, 44, 5]def FindOnly(seq):only = []for item in seq:a = seq.count(item)if a == 1:only.append(item)return onlyif len(only) == 0:print("没有唯一存在的元素！")F = FindOnly(listA)
print(F)

listA = [1, 2, 2, 2, 3, 44, 1, 2, 3, 44, 5]
set1 = set(listA)
print("第一次去重：", set1)
for i in set1:listA.remove(i)pass
print("第一次删除:", listA)set2 = set(listA)  # 原来listA中有重复的数字集合
print("第二次去重：", set2)
for i in set1:if i not in set2:print(i)passpass
pass

总结

简明扼要的总结了Python内置函数的简单用法。

【Python知识点梳理】5.Python内置函数相关推荐

python一些常用函数_【python】常用的一些内置函数
1.cmp cmp(A,B)函数,比较A,B的大小,如果A大于B,返回1,A小于B返回-1,A等于B返回0 print cmp(12,33) >>>-1 print cmp(&quo ...
查看python内部模块命令，内置函数，查看python已经安装的模块命令
查看python内部模块命令,内置函数,查看python已经安装的模块命令可以用dir(modules) 或者用 pip list 或者用 help('modules') 或者用 python -m ...
Python学习笔记（4）～Python基础练习之常用内置函数（1-10）
Python基础练习之常用内置函数(1-10) 1.abs() 作用求数的绝对值或者复数的模测试demo #!/usr/bin/python3 # abs: 求绝对值 or 复数的 ...
Python中这两个内置函数locals 和globals，你了解吗？
这两个函数主要提供,基于字典的访问局部和全局变量的方式. 在理解这两个函数时,首先来理解一下python中的名字空间概念.Python使用叫做名字空间的东西来记录变量的轨迹.名字空间只是一个字典,它 ...
python语言接收信息的内置函数是_Python语言接收信息的内置函数是________________...
Python语言接收信息的内置函数是________________ 答: input() 中国大学MOOC: 铁素体稳定元素倾向于奥氏体区,使共析点向方移动. 答:缩小:左上: 注射剂中热原检查 ...
python基础12_匿名_内置函数
# 二分查找示例 data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35, 36, 66]def bina ...
python列表不包含哪个内置函数_python 列表的推导器和内置函数
#++ =================================== = 列表的推导式 # li = [] # for i in range(1,11): # li.append(i) # ...
[python] 之all()和any()内置函数
在python 2.5版本以上开始引入,其基本使用方法如下: 一.all()内置函数语法:all(iter) 说明: 1. iter为可迭代对象,比如列表,元组,字符串... 2. 若iter中的每 ...
python方法和函数的格式是完全一样的_【python基础语法】常用内置函数、关键字、方法和之间的区别(小结)...
'''关键字: False:bool数据类型 True:bool数据类型 None:表示数据的内容为空 and:逻辑运算符:与 or:逻辑运算符:或 not:逻辑运算符:非 in:身份运算符,判断变量 ...
Python之lambda表达式和内置函数
lambda表达式其实就是简化的函数表达式. 它只用于处理简单逻辑, 它会自动return数据通常定义一个函数,按照以下形式: 1 2 3 4 5 def func(arg): ret ...

【Python知识点梳理】5.Python内置函数