math模塊

在使用前導(dǎo)入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

高級內(nèi)置函數(shù)即方法(常用)

1--map()函數(shù)

1--實例解釋

map（）會根據(jù)提供的函數(shù)對指定的序列做映射
語法： map(function,iterable)  # functuon函數(shù)腺劣，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)是一個可迭代對象肺稀，符合語法的注釋登渣，是一個函數(shù)的引用
# 通過這樣贾铝，可以使用匿名函數(shù),通過匿名函數(shù)代替func函數(shù)
print(list(map(lambda x: x**2, range(1,10))))

實例2  # 可以把列的數(shù)字變成字符串和浮點
print(list(map(int, ['1','2','4'])))  # 輸出[1,2,4]
print(list(map(str, range(1,5))))  # 輸出['1','2','3','4']

實例3  # 當(dāng)map（）里面有多個參數(shù)時
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]
# 對上的兩個列表的元素進(jìn)行從新組合x代表列表a中的元素唾那，y代表列表b的元素，對a拔恰，b的元素進(jìn)行x*10+y

print(list(map(lambda x,y: y-x, a,b)))  # 對a因谎，b的元素進(jìn)行相減
# 輸出 [3,3,3]
....以此類推有三個元素的時候

實例4  # 構(gòu)造字典
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()函數(shù)

2--實例解釋

reduce() 函數(shù)會對參數(shù)序列中元素進(jìn)行累積。
函數(shù)將一個數(shù)據(jù)集合（鏈表颜懊，元組等）中的所有數(shù)據(jù)進(jìn)行下列操作：
用傳給 reduce 中的函數(shù) function（有兩個參數(shù)）先對集合中的第 1财岔、2 個元素進(jìn)行操作，
得到的結(jié)果再與第三個數(shù)據(jù)用 function 函數(shù)運(yùn)算河爹，最后得到一個結(jié)果匠璧。
reduce() 函數(shù)語法：
reduce(function, iterable[, initializer])
function -- 函數(shù)，有兩個參數(shù)
iterable -- 可迭代對象
initializer -- 可選咸这，初始參數(shù)
返回值 ----計算結(jié)果
# python3需要導(dǎo)入 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
可以和匿名函數(shù)lambda一起使用
print(reduce(lambda(x,y:x+y,[1,2,3,4,5])))

# 可選參數(shù)
print(reduce(lambda(x,y:x+y,[1,2,3,4,5], 10)))  # 結(jié)果是計算完結(jié)果之后+10
print(reduce(lambda(x,y:x*y,[1,2,3], 5)))  # 結(jié)果是計算完結(jié)果之后*5

實例2
把[1,2,3,4,5] 轉(zhuǎn)換成12345
print(reduce(lambda x,y:x*10+y,[1,2,3,4,5]))
計算原理：(((1*10+2)*10+3)*10+4)*10+5

回顧map()函數(shù) 可以用map函數(shù)完成12345的轉(zhuǎn)換
print(''.join(list(map(str,[1,2,3,4,5]))))

3--filter()函數(shù) (俗稱過濾器)

3--實例解釋

filter()函數(shù)用于過濾序列患朱，過濾到不符合條件的元素，
返回有符合元素的組成的新列表
該接受兩個元素炊苫，第一個為函數(shù)裁厅，第二個為序列，序列的
每個元素作為參數(shù)傳遞給進(jìn)行判斷侨艾，然后返回Ture或者是False执虹，
最后將返回True的元素放到新的列表中
語法
filter(function, iterable)
function 判斷函數(shù)
iterable 可迭代對象
返回值為一個 迭代器對象

實例1 # 基本使用
def fun(x):
    x % 2 == 0
print(list(filter(fun,range(1,10))))
和匿名函數(shù)一樣使用
print(list(filter(lambda x:x%2=0, range(1,10))))

在實際的運(yùn)算中，map和filter唠梨，reduce一起組合使用會非常頻繁,在面試的時候經(jīng)常要求一行代碼解決(硬性要求)
簡單的例子
@ [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])))) # 同樣可以達(dá)成效果
在使用的記住函數(shù)嵌套的順序，每個函數(shù)的語法

4--zip()函數(shù)

4--實例解釋

zip()函數(shù)用于可迭代對象為參數(shù)当叭，將參數(shù)中對應(yīng)的元素打包成一個元組茬故，
然后返回這些元組組成的列表。
如果各個迭代器的元素不一樣蚁鳖，則返回列表的長度與最短對象相同磺芭，利用*號操作符
可以將元組解壓成列表。
語法
zip（iter...）
iterable  一個或多個可迭代對象
返回值是個列表

實例  # 基本操作
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]

print(zip(a, b))  # 輸出結(jié)果<zip object at 0x00000000028FF948>
print(list(zip(a, b)))  # 記住返回值是個列表 執(zhí)行結(jié)果[(1, 4), (2, 5), (3, 6)]
print(list(zip(a, c)))  # 執(zhí)行結(jié)果[(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()函數(shù)和當(dāng)中的key

5--實例解釋

sorted()函數(shù)對 （所有的可迭代對象） 進(jìn)行排序操作
sort與sorted的區(qū)別：
1) sort是應(yīng)用在列表上的方法钾腺，sorted可對所有的迭代對象進(jìn)行操作.
2) list的sort方法返回的是對已經(jīng)存在的列表進(jìn)行操作徙垫，而內(nèi)建函數(shù)sorted方法返回的是一個新列表。
語法
sorted(iterable[,cmp[,key[,reverse]]])
iterable 可迭代對象
cmp 比較的函數(shù)放棒，具有兩個參數(shù)姻报，參數(shù)的值都是從可迭代對象取出，此函數(shù)必須遵守的規(guī)則是：
大于則返回1间螟，小于則返回-1吴旋，等于則返回0
key 主要是用來比較元素，只有一個參數(shù)厢破，具體的函數(shù)的參數(shù)就是取自可迭代對象荣瑟，指定可迭代對象的一個元素進(jìn)行排序
reverse 排序規(guī)則， reverse=True為降序溉奕，reverse=False為升序
返回值
返回一個新列表

revese()和revesed()是把列表倒序
【revese()方法和reversed()函數(shù)基本和sort(),sorted()一樣的】
sort()和sorted()是把列表按照大小的順序排序

實例  # 基本操作
a = [4,6,3,1,9]
b = a.sort()
print(b)  #  沒有輸出
print(a) #輸出[1,3,4,6,9]  sort()對已經(jīng)存在的列表操作，改變列表
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]))
解釋 對學(xué)生列表的數(shù)字大小排序，在此用到key同波，  key=lambda x: x[2]中的x通俗點就是列表中的每個元素鳄梅，x[2]對元素進(jìn)行切片，得到數(shù)字未檩，然后sorted根據(jù)數(shù)字大小進(jìn)行排序

復(fù)雜的問題
nums_string = "2000 10003 1234000 44444444 9999 11 22 123" 對字符串的先切片得到每個數(shù)字的字符串戴尸，求和，根據(jù)大小重新排序
1 先對字符串進(jìn)行切片 new_list = nums_string.split(" ") #['2000','1003','1234000','44444444'...]
2 對得到的新列表中的數(shù)字字符串進(jìn)行相加得到結(jié)果 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()函數(shù)

6--實例解釋

enumerate()函數(shù)用于將一個可遍歷的數(shù)據(jù)對象(如列表冤狡，元組孙蒙，或者是字符串)
組合成一個索引的序列，同時列出數(shù)據(jù)和數(shù)據(jù)的下標(biāo)悲雳，一般用在For循環(huán)中
for index, item in enumerate(sequence):
    print(index, item)
語法
enumerate(sequence, [start=0])
sequence  一個序列挎峦，迭代器或者是其他支持迭代的對象
start  下標(biāo)開始的位置
返回值
返回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()函數(shù)

7--實例解釋

基本語法
sum(iterable, start)
iterable--可迭代對象合瓢，例如：列表坦胶，元組，集合
start--指定相加的對象晴楔，如果沒設(shè)定默認(rèn)為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和
求偶數(shù)之和  a = sum(range(1,101)[1::2])
求奇數(shù)之和  b = sum(range(1,101)[::2])
 根據(jù)題意： 偶數(shù)求和之后是負(fù)數(shù)  a = -sum(range(1,101)[1::2])
 然后根據(jù) 對a顿苇，b求和 sum(a,b)# 錯誤
 sum（[a,b]）
print(sum([sum(range(1,101)[::2]), -sum(range(2,101)[::2])]))

8--set()函數(shù)

8--實例解釋

set()函數(shù)創(chuàng)建一個沒有重復(fù)元素集，可以進(jìn)行關(guān)系測試税弃，刪除重復(fù)纪岁，還可以計算交集并集..
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'}  # 也會去掉重復(fù)元素

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()方法通過指定的字符串進(jìn)行切片分割，如果有num有指定的值则果，則分割num次數(shù)
基本語法
str1.split(str2, num)
str1  要分割的字符串蜂科， str2 要分割的符號顽决， num要分割的次數(shù)

實例  # 基本操作
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 -- 替換的次數(shù)
str = "this is string example...wow!!!"
str.replace('is', 'was')  # 輸出 "thwas was string example...wow!!!"

12--format()方法

12--實例解釋

# 不設(shè)置指定位置，按默認(rèn)順序
"{} & {}".format("hello", "world", "python")
'hello world'

# 設(shè)置指定位置
 >>> "{0} {1}".format("hello", "world")
'hello world'

# 設(shè)置指定位置
>>> "{1} {0} {1}".format("hello", "world")
'world hello world'

# 二進(jìn)制
>>> '{0:b}'.format(10)
'1010'

#八進(jìn)制
>>> '{0:o}'.format(10)
'12'

#16進(jìn)制
>>> '{0:x}'.format(10)
'a'

實例  # 基本操作
print('{} & {}'.format('I, Love',Python))
 輸出I, Love & Python

13--eval()函數(shù)

13--實例解釋

eval()函數(shù) 將字符串str當(dāng)成有效的表達(dá)式求值并返回結(jié)果
實例  # 基本操作
# 基本的數(shù)學(xué)計算
In [1]: eval("1 + 1")
Out[1]: 2

# 字符串重復(fù)
In [2]: eval("'*' * 10")
Out[2]: '**********

# 用eval()計算階乘
print(eval('*'.join([str(n) for n in range(1, 5)])))

# eval函數(shù)就是實現(xiàn)list导匣、dict才菠、tuple與str之間的轉(zhuǎn)化
# str函數(shù)把list，dict贡定，tuple轉(zhuǎn)為為字符串
# 字符串轉(zhuǎn)換成列表
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]]

# 字符串轉(zhuǎn)換成字典
a = "{1: 'a', 2: 'b'}"
print(type(a))  # 字符串
b = eval(a)
print(type(b))  # 字典
print(b)  # {1: 'a', 2: 'b'}

# 字符串轉(zhuǎn)換成元組
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))