[Python知识库] Python【第六天】内置函数

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Python知识库 -> Python【第六天】内置函数 -> 正文阅读

[Python知识库]Python【第六天】内置函数

总体描述

内置函数：Python自带的函数
网站：Python自带函数总结

Python内置函数

数学运算

abs():返回数字绝对值
round():取近似值
pow():求幂运算的
divmod():求余和商的
max():求最大值
min():求最小值
sum():求和的
eval():动态执行的一个字符串表达式

abs():返回数字绝对值

i = int(input('是否需要求数字的绝对值(1:是;0:否)：'))
if i == 1:
    a = int(input('请输入数值：'))
    print('{}的绝对值为{}'.format(a,abs(a)))
    pass
else:
    print('不需要取绝对值操作！')
    pass
pass

round():取近似值

i = int(input('是否需要求数字的近似值(1:是;0:否)：'))
if i == 1:
    a = float(input('请输入数值：'))
    b = int(input('请输入保留小数位数：'))
    print('数值为{}且保留小数位数为{}的结果为{}'.format(a,b,round(a,b)))
    pass
else:
    print('不需要取近似值操作！')
    pass
pass

pow():求幂运算的

i = int(input('是否执行幂运算(1:是;0:否)：'))
if i == 1:
    a = int(input('请输入幂运算的底数'))
    b = int(input('请输入幂运算的指数：'))
    print('{}的{}次方的值为{}'.format(a,b,pow(a,b)))
    pass
else:
    print('不需要执行幂运算操作！')
    pass
pass

max():求最大值

i = int(input('是否输出最大值(1:是;0:否)：'))
if i == 1:
    li = []
    print('请输入需要比较的数：')
    for item in range(10):
        a = int(input())
        li.append(a)
    print('{}中的最大值为{}'.format(li,max(li)))
    pass
else:
    print('不需要执行求最大值操作！')
    pass
pass

min():求最小值

i = int(input('是否输出最小值(1:是;0:否)：'))
if i == 1:
    li = []
    print('请输入需要比较的数：')
    for item in range(10):
        a = int(input())
        li.append(a)
    print('{}中的最小值为{}'.format(li,min(li)))
    pass
else:
    print('不需要执行求最小值操作！')
    pass
pass

sum():求和的

i = int(input('是否求得累加和(1:是;0:否)：'))
if i == 1:
    li = []
    print('请输入需要相加的数：')
    for item in range(10):
        a = int(input())
        li.append(a)
    print('{}中的累加和为为{}'.format(li,sum(li)))
    pass
else:
    print('不需要执行求累加和操作！')
    pass
pass

eval():动态执行的

i = int(input('是否动态执行一个表达式(1:是;0:否)：'))
if i == 1:
    a,b,c = 1,2,3
    print('动态执行的函数{}'.format(eval('a-b+c*30')))
    pass
else:
    print('不需要动态执行操作！')
    pass
pass

类型转换

int() float() str() ord() chr() bool() bin() hex() oct() list() tuple() dict() bytes()

bin():转换二进制

i = int(input('是否执行二进制转换(1:是;否0:):'))

if i == 1:
    a = int(input('请输入被转换数:'))
    print('十进制数{}的二进制数数为{}'.format(a,bin(a)))
    pass
else:
    print('不需要执行二进制转换操作！')
    pass

hex():转换十六进制

i = int(input('是否执行转换成十六进制转换(1:是;否0:):'))
if i == 1:
    a = int(input('请输入被转换数:'))
    print('十进制数{}的十六进制数数为{}'.format(a,hex(a)))
    pass
else:
    print('不需要执行十六进转换操作！')
    pass

oct():转换八进制

i = int(input('是否执行转换成八进制转换(1:是;否0:):'))
if i == 1:
    a = int(input('请输入被转换数:'))
    print('十进制数{}的八进制数数为{}'.format(a,oct(a)))
    pass
else:
    print('不需要执行八进转换操作！')
    pass

list():将元组转换为列表

i = int(input('是否执行将元组转换为列表(1:是;否0:):'))
if i == 1:
    tup = (1,2,3,4,5,6)
    li = list(tup)
    # li.append('转换成功')
    print('元组{}转换为列表为：{}'.format(tup,li))
    pass
else:
    print('不需要执行元组转换为列表操作！')
    pass

tuple():转换二进制

i = int(input('是否执行将列表转换为元组(1:是;否0:):'))
if i == 1:
    li = (1,2,3,4,5,6)
    tup = tuple(li)
    print('列表{}转换为元组为：{}'.format(li,tup))
    pass
else:
    print('不需要执行列表转换为元组操作！')
    pass

dict():创建一个字典

i = int(input('是否执行创建一个字典(1:是;否0:):'))
if i == 1:
    dic = dict()
    # dic = dict(name = '小明', age = 18, sex = '男', num = 123)
    dic['name'] = '小明'
    dic['age'] = '18'
    dic['sex'] = '男'
    dic['num'] = '123'
    print('创建的字典为{}'.format(dic))
    pass
else:
    print('不需要执行创建字典操作！')
    pass

bytes():转换为字节数组

i = int(input('是否执行转换字节数组操作(1:是;否0:):'))
if i == 1:
    print(bytes('我喜欢ZCL',encoding='UTF-8'))
    pass
else:
    print('不需要执行转换字节数组操作！')
    pass

序列操作

all()
return bool
类似and
判断给定的可迭代参数中的所有元素是否都为Ture，如果是，返回Ture，否则，返回False
除了是0，空，False外都算True
空元组、空列表返回值为True
any()
return bool
类似or
判断给定的可迭代参数中的是否全部为False，则返回False，如果有一个为True，则返回True
除了是0，空，False外都算True
sorted()
对可迭代对象进行排序操作
sort与sorted的区别：
sort应用在list上的方法，sorted可以对所有可迭代的对象进行排序操作
list的sort方法返回的是对已经存在列表进行操作，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行操作
reverse()
用于反向列表中元素
range()
创建一个整数的列表，一般用在for循环中
range(start,stop,step) 其中step默认为1
zip()
就是用来打包的
将可迭代的对象作为参数，将对象中对应的元素打包成一个个对应的元组，然后返回由这些元组组成的列表
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表
enumerate()
将一个可遍历的数据对象(列表、元组、字符串)组合为一个索引序列，同时列出数据和数据下标
一般用在for循环当中

all()

li = [1,2,3]
print(all(li))
# 除了是0，空，False外都算True
print(all([1,2,3,False]))
print(all([1,2,3,0]))
print(all([]))  # 空列表返回值为True
print(all(()))  # 空元组返回值为True

any()

li = [1,2,3]
print(any(li))
# 除了是0，空，False外都算True
print(any([1,2,3,False]))
print(any([1,2,3,0]))
print(any([False,0,'']))
print(any([]))  # 空列表返回值为True
print(any(()))  # 空元组返回值为True

sorted()

li = [1,2,8,4,9]
li.sort()
print(li)
li1 = [1,2,5,4,3,6]
li2 = sorted(li1)
print(li1)
print(li2)
print(sorted([1,2,8,4,9])) # 默认为False
print(sorted([1,2,8,4,9],reverse=False)) # 默认为False
print(sorted([1,2,8,4,9],reverse=True))
print(sorted(['a','D','b','f','c','E'],key=str.lower)) #字符串无关大小写排序

range()

for i in range(1,10):
    print(i)
for i in range(1,10,1):
    print(i)
for i in range(1,10,2):
    print(i)

zip()

a = [1,2,3]
b = ['a','b','c']
c = [1,2,3,4,5]
d = ['a','b','c','d']
print(list(zip(a)))  # 压缩一个数据
x = zip(a,b)
print(list(x)) #将元组转换成列表
y = zip(c,d)
print(list(y)) #将元组转换成列表
def printBookInfo():
    '''
    使用zip打包图书信息
    '''
    books = [] #存储所有的图书信息
    id = input('请输入编号：每个向以空格分隔')
    bookName = input('请输入书名：每个向以空格分隔')
    bookPos = input('请输入位置：每个向以空格分隔')
    idList = id.split(' ')
    nameList = bookName.split(' ')
    posList = bookPos.split(' ')
    bookInfo = zip(idList,nameList,posList)
    for bookItem in bookInfo:
        '''
        遍历图书信息进行储存
        '''
        dictInfo = {'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}
        books.append(dictInfo)  # 将字典对象加入添加到list容器中
        pass
    for item in books:
        print(item)
        pass
    pass
# printBookInfo()

enumerate()

listObj = ['a','b','c']
for item in enumerate(listObj):
    print(item)
    pass
for index,item in enumerate(listObj):
    print(index)
    pass
for index,item in enumerate(listObj):
    print(item)
    pass
for index,item in enumerate(listObj):
    print(index,item)
    pass
for index,item in enumerate(listObj,5):
    print(index,item)
    pass
dicObj = {}
dicObj['name'] = 'A'
dicObj['num'] = '123'
dicObj['sax'] = '男'
for item in enumerate(dicObj):  # 默认为字典的键
    print(item)
    pass
for item in enumerate(dicObj):
    print(item[1])
    pass
for item in enumerate(dicObj.values()):
    print(item)

Set操作

set(集合)
一种数据类型，不支持索引和切片，是一个无序且不重复的元素集合
类似于字典，但是只有key，没有value
集合的创建：
     set1 = {"1","2"}      #直接创建
     list1 = ['1','5','3','4']
     set2 = set(list1)       #强制类型转换
add() 添加操作 clear() 清空操作 difference() 两个集合的差集
a.difference(b):a中存在，b中不存在等价于a-b intersection() 两个集合的交集
a.intersection(b):a中存在，b中也存在等价于a&b union() 两个集合的并集
a.union(b):包含a中元素，也包含b中元素等价于a|b pop() 随机移除某个元素并且获取那个参数，集合pop没有参数
discard() 移除指定元素 update() 更新集合

# 创建集合
set1 = {1,2,3}
# print(type(set1))
print(set1)
li = [1,2,5,8,9]
set2 = set(li)
# print(type(set2))
print(set2)
#----------------------------------add()----------------------------------
set1.add('Python')
print(set1)
#---------------------------------clear()---------------------------------
# set1.clear()
# print(set1)
#-------------------------------difference()------------------------------
set3 = set1.difference(set2)
print(set3)
print(set1-set2)
#------------------------------intersection()-----------------------------
set3 = set1.intersection(set2)
print(set3)
print(set1&set2)
#---------------------------------union()---------------------------------
set3 = set1.union(set2)
print(set3)
print(set1|set2)
#----------------------------------pop()----------------------------------
set3 = {1,2,5,6,3}
print(set3)
print(set3.pop())  # 从集合拿数据并且同时删除
print(set3)
#--------------------------------discard()--------------------------------
set3 = {1,2,5,6,3}
print(set3)
print(set3.discard(5))  # 从集合中删除指定数据
print(set3)
#---------------------------------update()--------------------------------
set1.update(set2)
print(set1)