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

chr(65)
bin() 转为二进制
 
bin(52)
>> 0b110100
hex()把10进制转化为16进制
 
hex(32)
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))
li = (0,1,2,3)
print(all(li))
注意，纯空元组或列表也输出True
 2. any()如果可迭代参数都为False，则输出False，否则输出True
 
li = [1,2,3,0]
print(any(li))
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)
    for item in books:
        print(item)
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)
#--------------------------------------#
test = ['a','b','c','d']
for seq,item in enumerate(test,5):
    print(seq,item)
  #---------------------------------#
# test = {'a':1,'b':2,'c':3}
test = ['a','b','c','d']
for item in enumerate(test):
    print(item[0])
    #两种的输出是一样的，就是因为字典类型经过enumerate函数处理后只保留键key，所以返回的元组是一样的，而元组又是一个有序序列，所以可以用下标调用
				
我们知道map() 会根据提供的函数对指定序列做映射。 第一个参数 function 以参数序列中的每一个元素调用 function
函数，返回包含每次 function 函数返回值的新列表。
先看一下map()在python2和3中的区别 
在python2中：
a = [1,2,3];b = [2,3,4]
c = map(lambda x,y:s+y,a,b)
[3, 5, 7]
返回的是list
在python3中：
a = [1,2,3];b = [2,3,4]
c = map(lambda x,y:s+y,a,b)
<map at 
				
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。 
# 1、调用function函数，返回一个list
>>> def add100(x):
    return x+100    
>>> hh = [11,22,33]
>>> map(add100,hh)
[111, 122, 133]# 2、多个参数之间的并行运算
				
map()函数
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。Python 2.x 返回列表。Python 3.x 返回迭代器。
map(function, iterable, ...)
function -- 函数
iterable -- 一个或多个序列
pytho...
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。
把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list,而是返回一个新list。
map()函数实例：
list1=[1,2,3,4,5]
map(float,list1)