python内置函数map，lambda，数学运算，类型转换

live_for_myself

已于 2022-06-27 12:08:30 修改

阅读量1.9k

点赞数 5

分类专栏： pytorch学习文章标签： python 列表 lambda

于 2020-10-28 14:13:35 首次发布

本文链接：https://blog.csdn.net/landing_guy_/article/details/109331685

版权

pytorch学习专栏收录该内容

25 篇文章 3 订阅

订阅专栏

匿名函数

语法

lambda 参数1，参数2，参数3 ：表达式
没有名字，匿名函数冒号后的表达式有且只有一个
匿名函数自带return，而这个return的结果就是表达式计算后的结果

M = lambda x,y:x+y
print(M(1,2))   #通过变量来调用函数

map()函数

map是python内置函数，会根据提供的函数对指定的序列做映射。
map()函数的格式是：
map(function,iterable,...)
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个map类型的对象。

def square(x):
    return x ** 2
 
a = map(square,[1,2,3,4,5])
print("这是a的数据类型：{}".format(type(a))
print(list(a))
>> a的数据类型是：<class 'map'>
>> [1, 4, 9, 16, 25]

注意map用的时候是函数名，不包括括号

用lambda函数方式实现

map1 = map(lambda x, y: x+y,[1,3,5,7,9],[2,4,6,8,10])
a = list(map1)
print(a)
# 结果如下：
[3,7,11,15,19]

通过lambda函数使返回值是一个元组

a = map(lambdax, y : (x**y,x+y),[2,4,6],[3,2,1])
for i in a:
    print(type(i))
print(list(a))
>> <class 'tuple'> *3

# 结果如下
[(8,5),(16,6),(6,7)]  ???这个地方有问题，出不来这个结果

因为迭代器Iterator会调用方法next()不断指向下一个元素，直到空，报StopIteration错误

abs() 取绝对值

print(abs(-10))

round()对浮点数进行近似取值，不完全按照四舍五入的方法

print(round(2.3))
>> 2
print(round(2.675,2))
>> 2.67

pow()求幂运算

a**b #也可以

max()求最大值,参数是序列，如列表,元组，集合等

print([1,2,3,4,5])
>> 5

print(1,2,3,4,5)
>> 5

print(max((1,2,3,4,5)))
>> 5

sum() ，参数是一个可迭代对象,是列表、元组或集合类型，第二个参数是额外加的数，只加一次

print(sum([0,1,2]))
>> 3

print(sum((0,1,2)))
>> 3

print(sum([1,2],1))
>> 4

eval() 用来执行一个字符串表达式，并返回表达式的值

a,b,c = 1,2,3
print(eval('a+b+c'))
>> 6

a = eval('a+b+c',{'a':1,'b':2,'c':3})
print(a)
>> 6

等等！突然想起前年看的python教程，里面的字符去括号函数不正是eval()？？？

深化学习：

def test():
    print('我可以执行')
    pass
eval('test()')
>> 我可以执行

直接把字符串引号去掉了然后执行函数

类型转换函数

chr()数字转化为字符，参数只能是数字,可以是10进制也可以是16进制

chr(65)
>> 'A'

bin() 转为二进制

bin(52)
>> 0b110100

hex()把10进制转化为16进制

hex(32)
>> 0x20

list()可以把元组或range类型转换为列表

tup = (1,2,3,4)
print(list(tup))
>> [1,2,3,4]

tuple() 同样用tuple()也可以把列表或range类型转换为元组
dict()字典操作

单独使用时是创建一个空字典······我感觉这个是废话，前面的不是也能

dicA = dict()

dicB = dict(name='小李',age=21)。注意这时候是不带引号的 
print(dictB)
>> {'name': '小李', 'age': 21}
#当然了，直接操作也是可以的
dicB['name']='小李'
dictB['age']=21

bytes()转化为字节数组

print(bytes('学院领导捞我',encoding= 'utf-8'))
>> b'\xe5\xad\xa6\xe9\x99\xa2\xe9\xa2\x86\xe5\xaf\xbc\xe6\x8d\x9e\xe6\x88\x91'

还有一种调用方法

print(bytes('加油'.encode('gbk')))

序列操作

序列包括三个，字符串，元组，列表

all() 参数是一个可迭代参数，现在可以理解为列表或元组，除0，空，FALSE外都算True

li = [1,2,3]
print(all(li))
>> True
 
li = (0,1,2,3)
print(all(li))
>> True

注意，纯空元组或列表也输出True
2. any()如果可迭代参数都为False，则输出False，否则输出True

li = [1,2,3,0]
print(any(li))
>> True

list.sort()与sorted()

list.sort()与sorted()的区别：
sort()是应用在list上的方法，是对list本身进行排序，而sorted是对可迭代对象进行操作，元组也可以，返回的是一个新的list
例：

a = sorted((4,3,2,1))
print(a)
>> [1,2,3,4]


a = sorted([1,2,3,4,5],reverse=True)
print(a)
>> [5,4,3,2,1]


listA = [1,2,3,4,5]
listA.sort(reverse=True)
print(listA)
>> [5,4,3,2,1]

zip()用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

def printbookInfo():
    books = []# 存储所有的图书信息
    id = input('请输入编号：每个项以空格分隔')
    bookName = input('请输入书名：每个项以空格分隔')
    bookPos = input('请输入位置：每个项以空格分隔')
    id_list = id.split(' ')
    bookName_list = bookName.split(' ')
    bookPos_list = bookPos.split(' ')

    bookInfo = zip(id_list,bookName_list,bookPos_list)
    for bookItem in bookInfo:
        dictInfo = {'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}
        books.append(dictInfo)
        pass
    for item in books:
        print(item)
        pass
    pass

printbookInfo()

enumerate()适用于将一个可遍历的数据对象(如列表，元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中

语法 enumerate(sequence,start=0)
sequence 一个序列、迭代器或其他支持迭代对象
start 下标的起始位置
返回值 enumerate(枚举)对象
例：

test = ['a','b','c','d']
a = list(enumerate(test))
print(a)
>> [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]


#----------------------------------------#

test = ['a','b','c','d']
for item in enumerate(test):
    print(item)
>> (0, 'a')
   (1, 'b')
   (2, 'c')
   (3, 'd')
   
   
  #----------------------------------------------#
  
test = ['a','b','c','d']
for seq,item in enumerate(test): 
    print(seq,item)
>> 0 a
   1 b
   2 c
   3 d    

#--------------------------------------#
test = ['a','b','c','d']
for seq,item in enumerate(test,5):
    print(seq,item)
>> 5 a
   6 b
   7 c
   8 d
   
   
   
  #---------------------------------#
# test = {'a':1,'b':2,'c':3}
test = ['a','b','c','d']
for item in enumerate(test):
    print(item[0])
>>  0
    1
    2
    3
    #两种的输出是一样的，就是因为字典类型经过enumerate函数处理后只保留键key，所以返回的元组是一样的，而元组又是一个有序序列，所以可以用下标调用