6.python------内置函数和序列操作_python运算符,内置函数,序列基本用法实验-CSDN博客

本文链接：https://blog.csdn.net/S1406793/article/details/121141956

1. 数学运算函数

abs()	取绝对值函数
round（x,[,n]）	返回浮点数x的近似值，四舍五入，n为小数点后n位
pow(x,y,[,z])	x的y次方
divmod(a,b)	求商和余数，输出元组（a//b,a%b）
max(序列)	返回给定参数的最大值，参数可以是序列
min(序列)	返回给定参数的最小值，参数可以是序列
sum(iterable[,start])	求和,iterable为可迭代对象--列表元组集合，start是指定相加的参数，没有默认为0
eval()	动态执行一个表达式---字符串类型

#绝对值函数------- abs()
print(abs(-10))       #
print(abs(-10.2344))    #10.2344


#四舍五入近似函数-----round()
print(round(5.4))   #5.4
print(round(3.63243,3))    #3.632

#求幂函数-------pow()
print(pow(2,4))     #2的4次方16
print(2**4)         #2的4次方16


#求商和余数------divmod()
print(divmod(a,b))    #返回一个包含商和余数的数组（a//b,a%b）
print(divmod(8,3))    #(2,2)

#最大值，参数是一个序列----max()
print(max([23,31,435,456,7657]))    #7657
print(max(23,235))    #235

#求和函数---sum(可迭代对象iterable，[,start指定相加的参数，默认为0])
print(sum([0,1,2]))   #3   给一个可迭代的对象--元组
print(sum((2,3,4),1))     #10   给一个可迭代的对象--列表
print(sum([0,1,2,3,4],2))    #12
print(sum(range(50),3)     #1225+3=1228

#执行表达式-----eval(expression,globals[,locals])
a,b,c=1,2,3
print('动态执行的函数={}'.format(eval('a+b+c')))   #执行表达式
print('动态执行的函数={}'.format(eval('a*b+c-30')))
eval('a+b+c',{'c':3,'b':2,'a':1})

def TestFun():
    print('我执行了吗？')
    pass
eval(TestFun())      #可以调用函数执行

2. 类型转换函数

bin()	二进制转换为十进制
bool()	转换为true或false
chr()	数字转字符，将数字转换为对应的字符，范围在range(256)
hex()	转换为十六进制
oct()	转换为八进制
list()	将元组转化为列表
tuple()	将列表转化为元组
dict()	创建一个字典 dict(a='我'，b='爱'，c='中国')
bytes()	转化为字节数组
str（）	将函数对象转化为字符串

#转换为二进制
print(bin(10))   #0b1010=2**3+2**1

#转换十六进制
print(hex(23))

#元组转化为列表
tup=(1,2,3,4,5)    #元组类型
li=list(tup)
print(type(li))
li.append('强制转换成功')
print(li)

#列表转化为元组
tupList=tuple(li)
print(type(tupList))


# 字典的操作  dict()
#正确操作----创建字典
dic=dict(name='小米',age=18)
print(type(dic))
print(dic)


# bytes转换
print(bytes('我喜欢python',encoding='utf-8'))   #不指定编码是不可以的
#输出
#b'\xe6\x88\x91\xe5\x96\x9c\xe6\xac\xa2python'

3. 序列操作函数

all()	用于判断给定的可迭代参数 iterable（元组和列表）中的所有元素是否都为true。如果是返回True；否则（有0、空、FALSE）返回False 。元素除了是【0、空、FALSE】外都算TRUE。空元组、空列表返回值为TRUE 有一个false就输出false 类似于and()
any()	用于判断给定的可迭代参数（元组和列表---序列）是否全部为False，如果全部为false（全部为0、空、FALSE】），则返回false；如果有一个为True，则返回True。元素除了是【0、空、FALSE】外都算TRUE 元素都是false才输出false 类似于or()
sorted()	对所有可迭代对象进行排序操作 sort用在list上的方法，sorted可以对所有可迭代对象进行排序 list的sort方法返回的是对已经存在的列表进行操作；而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作 sorted默认升序排列，对象后再加一个参数：reverse=False为升序，reverse=True为降序。 key=str,lower表示字符串无关大小写排序
reverse()	函数中用于反向列表中元素,sorted函数中用过
range()	创建一个整数列表
zip()	将可迭代的参数作为对象，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表
enumerate()	将一个可遍历的数据对象（str，list，tuple）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中

#1.-----------all()函数---------------
li=[1,2,3]   #没有0，空，FALSE   输出true
all(li)
li=[1,2,3,0]   #有0，输出false
all(li)
print(all([]))   #True
print(all(()))    #True
print(all([1,2,3,False]))   #False
print(all([1,2,3]))    #True


#2.-----------any()函数---------------
li=[1,2,3,0]
print(any(li))   #true  ,里面有三项不是false
print(any((1,2,3,0)))   #true
print(any(('',0,False)))    #False

#3.----------sort和sorted()----------
li=[2,45,3,65,75,21]    #原始对象
li.sort()   #list的排序方法----直接修改的就是原始对象，在原始列表上进行操作
print(li)   #打印原始对象（sort排序之后）

li=[2,45,3,65,75,21]    #原始对象
print('排序之前的{}'.format(li))
varList1=sorted(li)     #默认升序排列
varList2=sorted(li,reverse=True)     #降序排列
print('排序之后的{}'.format(li)) #并没有排序，说明不是在原始列表上进行操作
print(varList1)    #排序之后生成一个新的list
print(varList2)

# 元组也一样（不能用sort方法）
tupArray=(1,2,5,45,34,12)
varRs=sorted(tupArray,reverse=True)   #元组降序排列
print(varRs)

#----------zip() 打包----------
#用来打包的，会把序列中对应索引位置的元素存储为一个元组
#案例1：
print(zip([1,2,3],['a','b','c']))    #zip接收的是两个列表，属于可迭代的序列，直接通过zip函数压缩两个列表
#结果就是，按照相应的索引，组成一个个元组
a=zip([1,2,3],['a','b','c'])    #是一个zip地址，需将其转化为list才能可以查看内容
print(list(a))
#输出：
#<zip object at 0x000001E3CEFA7A00>   #这是一个zip地址，将其转化为list就可以查看内容
#[(1, 'a'), (2, 'b'), (3, 'c')]

#案例2：
s1=['a','b','c']
s2=['你','我','他']
print(list(zip(s1)))    #zip压缩之后需要转化为list查看内容，输出：[('a',), ('b',), ('c',)]
zipList=zip(s1,s2)      #将两个列表进行zip压缩
print(list(zipList))   #打印：[('a', '你'), ('b', '我'), ('c', '他')]

#案例3：如果两个列表中元素不一致，将按照元素最少的进行压缩
s1=['a','b','c']
s2=['你','我','他','hh','呵呵']
zipList=zip(s1,s2)      #将两个列表进行zip压缩
print(list(zipList))      #没有'hh'和’哈哈‘的输出，打印：[('a', '你'), ('b', '我'), ('c', '他')]

# 案例4：存储一些图书的信息，按照一定的格式进行组装，
def printBookInfo():
    '''
    zip函数的使用
    :return:
    '''
    books=[]   #用一个列表存储所有的图书信息
    id=input('请输入编号：每个项以空格分隔')     #str
    bookName = input('请输入书名：每个项以空格分隔')     #str
    bookPos= input('请输入位置：每个项以空格分隔')    #str
    # 通过空格分割，提炼出一个数组或者列表
    idList=id.split(' ')
    NameList=bookName.split(' ')
    PosList = bookPos.split(' ')   # 是三个序列数据
    # 可以通过zip函数将这三个序列进行打包，打包成一个---列表

    bookInfo=zip(idList,NameList,PosList)   #打包处理
    # 打包处理之后，是一个列表（列表中是一个个元组），可以循环列表，将其转化为一个个字典输出
    for bookItem in bookInfo:      #其中每一个bookItem是一个元组
        '''
        遍历图书信息进行存储
        '''
        dictInfo={'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}
        # 将这个字典数据 加到 数据库books中(列表)
        books.append(dictInfo)   #将字典对象添加到列表容器中
        pass
    # 已经将 数据 加到数据库books中，接下来可以遍历这个数据库(列表)
    for item in books:
        print(item)
        pass
#调用
printBookInfo()

#遍历元组、字典、列表都可以
listObj=['a','b','c']
for item in enumerate(listObj):
    print(item)
#或者用index来接收索引------使用更方便
for index,item in enumerate(listObj):
    print(index,item)
#enumerate可以控制下标开始数
for item in enumerate(listObj,5):  #下标从5开始
    print(item)

#遍历元组
dictA={}    #创建元组
dictA['name']='大雄'
dictA['age']=12
dictA['性别']='男'
#print(dictA)
for item in enumerate(dictA):
    print(item)

4. 集合操作函数

set（集合）在python中也是一种数据类型，是一个【无序】且【不重复】的元素集合，不支持索引切片。
去重操作：可以将其他类型的数据转化为集合类型，实现去重操作。

.add()	添加数据
.clear()	清空操作
.difference() 或(a-b）	取两个集合的差集，a中存在，b中不存在或（a-b）
.intetrsection()	两个集合的交集，a中存在,b中也存在
.union()或peint(a\|b)	并集操作或 ( \| )
.pop()	就是从集合中拿走数据并且同时删除
.discard()	移除指定的元素
.updata()	更新集合

创建集合方式：

#方法一：
set1={"1","2"}
#方法二：
list1=['1','2','3']
set2=set(list1)

#添加数据
set1={"1","2"}
set1.add('python')
print(set1)

#清空操作
set1.clear()
print(set1)

#取差集
a={32,12,34}
b={12,43,23}
varRs=a.difference(b)   #a中存在b中不存在的
print(varRs)
#相当于
print(a-b)

#取交集
a={32,12,34}
b={12,43,23}
varRs=a.intersection(b)
print(varRs)

#取并集
a={32,12,34}
b={12,43,23}
a.union(b)
# 或
print(a|b)

#从集合中随即拿走一个元素并同时删除这个元素
set1={'1','2','3'}
qudata=set1.pop()
print(qudata)
print(set1)

# 移除指定元素
set1={'1','2','3'}
set1.discard('3')   #指定移除元素3
print(set1)

#更新集合
a={'1','2','3'}
b={'4','5','6'}
a.update(b)
print(a)