math模块
在使用前导入math模块 import math
常用方法
math.pow()方法
math.pow(x,y) 返回x的y次方
>>> math.pow(5.2)
25
math.sqrt()方法
math.sqrt(x) 返回x的平方根
>>> math.sqrt(25)
5
>>> math.sqrt(64)
8
math,factorial()方法
math.factorial(x) 返回x的阶乘
什么是阶乘 5！ 54321=120
>>> math.factorial(6)
720
>>> math.factorial(5)
120
高级内置函数即方法(常用)
1--map()函数
1--实例解释
map（）会根据提供的函数对指定的序列做映射
语法： map(function,iterable) # functuon函数，iterable可迭代的序列（一个或者是多个）
返回值；在python3中返回一个迭代器
实例1 # 一般的用法
def func(x):
return x**2
print(list(map(func,range(1,10)))) # 输出[1,4,9,16,25,36,49,64,81]
# 由于map（）返回值是一个迭代器，所以要list()输出
# range(1,10)是一个可迭代对象，符合语法的注释，是一个函数的引用
# 通过这样，可以使用匿名函数,通过匿名函数代替func函数
print(list(map(lambda x: x**2, range(1,10))))
实例2 # 可以把列的数字变成字符串和浮点
print(list(map(int, ['1','2','4']))) # 输出[1,2,4]
print(list(map(str, range(1,5)))) # 输出['1','2','3','4']
实例3 # 当map（）里面有多个参数时
a=[1,2,3] b=[4,5,6] c=[7,8,9]
print(list(map(lambda x: x+10, a))) # 输出 [11,12,13]
print(list(map(lambda x,y: x*10+y, a, b))) # 输出[14,25,36]
# 对上的两个列表的元素进行从新组合x代表列表a中的元素，y代表列表b的元素，对a，b的元素进行x*10+y
print(list(map(lambda x,y: y-x, a,b))) # 对a，b的元素进行相减
# 输出 [3,3,3]
....以此类推有三个元素的时候
实例4 # 构造字典
a='qwert'
b=range(1,6)
print(dict(map(lambda x,y:(x,y), a, b)))
# 输出{'q':1, 'w':2, 'e':3, 'r':4, 't':5}
2--reduce()函数
2--实例解释
reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：
用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，
得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
reduce() 函数语法：
reduce(function, iterable[, initializer])
function -- 函数，有两个参数
iterable -- 可迭代对象
initializer -- 可选，初始参数
返回值 ----计算结果
# python3需要导入 from functools import reduce
实例1 # 基本操作
def add(x,y):
return x+y
print(reduce(add,[1,2,3,4,5]))
# 计算原理 (((1+2)+3)+4)+5
可以和匿名函数lambda一起使用
print(reduce(lambda(x,y:x+y,[1,2,3,4,5])))
# 可选参数
print(reduce(lambda(x,y:x+y,[1,2,3,4,5], 10))) # 结果是计算完结果之后+10
print(reduce(lambda(x,y:x*y,[1,2,3], 5))) # 结果是计算完结果之后*5
实例2
把[1,2,3,4,5] 转换成12345
print(reduce(lambda x,y:x*10+y,[1,2,3,4,5]))
计算原理：(((1*10+2)*10+3)*10+4)*10+5
回顾map()函数 可以用map函数完成12345的转换
print(''.join(list(map(str,[1,2,3,4,5]))))
3--filter()函数 (俗称过滤器)
3--实例解释
filter()函数用于过滤序列，过滤到不符合条件的元素，
返回有符合元素的组成的新列表
该接受两个元素，第一个为函数，第二个为序列，序列的
每个元素作为参数传递给进行判断，然后返回Ture或者是False，
最后将返回True的元素放到新的列表中
语法
filter(function, iterable)
function 判断函数
iterable 可迭代对象
返回值为一个 迭代器对象
实例1 # 基本使用
def fun(x):
x % 2 == 0
print(list(filter(fun,range(1,10))))
和匿名函数一样使用
print(list(filter(lambda x:x%2=0, range(1,10))))
在实际的运算中，map和filter，reduce一起组合使用会非常频繁,在面试的时候经常要求一行代码解决(硬性要求)
简单的例子
@ [1,2,3,4,5]每个元素平方后，求大于9的元素的和
1 求平方后的元素 new1_list = list(map(lambda x:x**2,[1,2,3,4,5])) # 输出[1,4,9,16,25]
2 求大于9的元素 new2_list = list(filter(lambda x:x>9, new1_list)) # 输出[16,25]
3 求和 reduce(lambdax, y: x+y, mew2_list) #输出41
一行代码print(reduce(lambda x, y: x+y,filter(lambda x: x>9,map(lambda x:x**2,[1,2,3,4,5]))))
print(sum(filter(lambda x: x>9, map(lambda x: x**2,[1,2,3,4,5])))) # 同样可以达成效果
在使用的记住函数嵌套的顺序，每个函数的语法
4--zip()函数
4--实例解释
zip()函数用于可迭代对象为参数，将参数中对应的元素打包成一个元组，
然后返回这些元组组成的列表。
如果各个迭代器的元素不一样，则返回列表的长度与最短对象相同，利用*号操作符
可以将元组解压成列表。
语法
zip（iter...）
iterable 一个或多个可迭代对象
返回值是个列表
实例 # 基本操作
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
print(zip(a, b)) # 输出结果
print(list(zip(a, b))) # 记住返回值是个列表 执行结果[(1, 4), (2, 5), (3, 6)]
print(list(zip(a, c))) # 执行结果[(1, 4), (2, 5), (3, 6)] 以短的列表为主
print(dict(list(zip(a, b))))
# 如果是输出字典，就不用list,直接
print(dict(zip(a, b))) #输出{1: 4, 2: 5, 3: 6}
5--sorted()函数和当中的key
5--实例解释
sorted()函数对 （所有的可迭代对象） 进行排序操作
sort与sorted的区别：
1) sort是应用在列表上的方法，sorted可对所有的迭代对象进行操作.
2) list的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted方法返回的是一个新列表。
语法
sorted(iterable[,cmp[,key[,reverse]]])
iterable 可迭代对象
cmp 比较的函数，具有两个参数，参数的值都是从可迭代对象取出，此函数必须遵守的规则是：
大于则返回1，小于则返回-1，等于则返回0
key 主要是用来比较元素，只有一个参数，具体的函数的参数就是取自可迭代对象，指定可迭代对象的一个元素进行排序
reverse 排序规则， reverse=True为降序，reverse=False为升序
返回值
返回一个新列表
revese()和revesed()是把列表倒序
【revese()方法和reversed()函数基本和sort(),sorted()一样的】
sort()和sorted()是把列表按照大小的顺序排序
实例 # 基本操作
a = [4,6,3,1,9]
b = a.sort()
print(b) # 没有输出
print(a) #输出[1,3,4,6,9] sort()对已经存在的列表操作，改变列表
c = sorted(a)
print(c) #输出[1,3,4,6,9] sorted对存在的列表操作，返回一个新列表，原列表不变
重点对key的掌握
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave','B', 10)]
print(sorted(students, key=lambda x: x[2]))
解释 对学生列表的数字大小排序，在此用到key， key=lambda x: x[2]中的x通俗点就是列表中的每个元素，x[2]对元素进行切片，得到数字，然后sorted根据数字大小进行排序
复杂的问题
nums_string = "2000 10003 1234000 44444444 9999 11 22 123" 对字符串的先切片得到每个数字的字符串，求和，根据大小重新排序
1 先对字符串进行切片 new_list = nums_string.split(" ") #['2000','1003','1234000','44444444'...]
2 对得到的新列表中的数字字符串进行相加得到结果 sum(int(n) for n in new_list)
此时用到key
print(' '.join(sorted(nums_string.split(' '), key=lambda x, sum(int(n) for n in x))))
6--enumerate()函数
6--实例解释
enumerate()函数用于将一个可遍历的数据对象(如列表，元组，或者是字符串)
组合成一个索引的序列，同时列出数据和数据的下标，一般用在For循环中
for index, item in enumerate(sequence):
print(index, item)
语法
enumerate(sequence, [start=0])
sequence 一个序列，迭代器或者是其他支持迭代的对象
start 下标开始的位置
返回值
返回enumerate()对象
实例 # 基本操作
a=['as','qw','df','ht','re']
for (j,k) in enumerate(a):
print(j,k) # j代表的索引，k代表元素
# 输出 0 as 1 qw 2 df 3 ht 4 re
一个好玩的操作
for (j,k) in enumerate(a,3):
print(j,k) # 3表示索引起始位置
# 输出 3 as 4 qw 5 df 6 ht 7 re
7--sum()函数
7--实例解释
基本语法
sum(iterable, start)
iterable--可迭代对象，例如：列表，元组，集合
start--指定相加的对象，如果没设定默认为0
实例 # 基本操作
print(sum(range(1,11))) # 求1~10的和 --55
print(sum(range(1,11), 10)) # 求1~10的和之后 在+10 --65
#嵌套操作 # 求1-2+3-4+5-6+7-8+9-10+11......-100和
求偶数之和 a = sum(range(1,101)[1::2])
求奇数之和 b = sum(range(1,101)[::2])
根据题意： 偶数求和之后是负数 a = -sum(range(1,101)[1::2])
然后根据 对a，b求和 sum(a,b)# 错误
sum（[a,b]）
print(sum([sum(range(1,101)[::2]), -sum(range(2,101)[::2])]))
8--set()函数
8--实例解释
set()函数创建一个没有重复元素集，可以进行关系测试，删除重复，还可以计算交集并集..
set(iterable) iterable---可迭代对象
返回值----集合
实例 # 基本操作
a = set("hello") #输出--{'h','l','e','o'}
b = set("python") #输出--{'p','y','t','h','o','n'}
a & b #交集
{'h','o'}
a | b #并集
{'h', 'y', 'p', 'e', 'o', 'n', 'l', 't'} # 也会去掉重复元素
9--join()方法
9--实例解释
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
语法
join()方法语法：
str.join(sequence)
sequence -- 要连接的元素序列
返回通过指定字符连接序列中元素后生成的 新字符串!!!
实例 # 基本使用
s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print(s1.join(seq))
print(s2.join(seq))
10--split()方法
10--实例解释
split()方法通过指定的字符串进行切片分割，如果有num有指定的值，则分割num次数
基本语法
str1.split(str2, num)
str1 要分割的字符串， str2 要分割的符号， num要分割的次数
实例 # 基本操作
str = "this is string example...wow!!!"
str.split() 或者 str.split(' ') #输出 ['this','is','string','example...wow!!!']
str.split('i', 1) #输出 ['th','s is string example...wow!!!']
11--replace()方法
11--实例解释
把字符串的旧字符换成新字符
str.replace(old, new)
old -- 旧字符
new -- 新字符
num -- 替换的次数
str = "this is string example...wow!!!"
str.replace('is', 'was') # 输出 "thwas was string example...wow!!!"
12--format()方法
12--实例解释
# 不设置指定位置，按默认顺序
"{} & {}".format("hello", "world", "python")
'hello world'
# 设置指定位置
>>> "{0} {1}".format("hello", "world")
'hello world'
# 设置指定位置
>>> "{1} {0} {1}".format("hello", "world")
'world hello world'
# 二进制
>>> '{0:b}'.format(10)
'1010'
#八进制
>>> '{0:o}'.format(10)
'12'
#16进制
>>> '{0:x}'.format(10)
'a'
实例 # 基本操作
print('{} & {}'.format('I, Love',Python))
输出I, Love & Python
13--eval()函数
13--实例解释
eval()函数 将字符串str当成有效的表达式求值并返回结果
实例 # 基本操作
# 基本的数学计算
In [1]: eval("1 + 1")
Out[1]: 2
# 字符串重复
In [2]: eval("'*' * 10")
Out[2]: '**********
# 用eval()计算阶乘
print(eval('*'.join([str(n) for n in range(1, 5)])))
# eval函数就是实现list、dict、tuple与str之间的转化
# str函数把list，dict，tuple转为为字符串
# 字符串转换成列表
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
print(type(a)) # 字符串
b = eval(a) #
print(b) # [[1,2], [3,4], [5,6], [7,8], [9,0]]
# 字符串转换成字典
a = "{1: 'a', 2: 'b'}"
print(type(a)) # 字符串
b = eval(a)
print(type(b)) # 字典
print(b) # {1: 'a', 2: 'b'}
# 字符串转换成元组
a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
print(type(a)) # 字符串
b = eval(a)
print(type(b)) # 元组
print(b) # ([1,2], [3,4], [5,6], [7,8], (9,0))