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))  # 输出结果<zip object at 0x00000000028FF948>
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))