Python【第六天】内置函数

最新推荐文章于 2024-11-05 15:28:12 发布

囡囡呐！

最新推荐文章于 2024-11-05 15:28:12 发布

阅读量96

点赞数

分类专栏： python学习记录文章标签： python vscode

本文链接：https://blog.csdn.net/swt2000/article/details/119222033

版权

python学习记录专栏收录该内容

10 篇文章 1 订阅

订阅专栏

总体描述

内置函数：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)