一文詳解Python中itertools模塊的使用方法
itertools — 為高效循環(huán)而創(chuàng)建迭代器的函數(shù)
accumulate(iterable: Iterable, func: None, initial:None)
iterable：需要操作的可迭代對象
func：對可迭代對象需要操作的函數(shù)，必須包含兩個參數(shù)
initial: 累加的開始值
對可迭代對象進行累計或者通過func實現(xiàn)雙目運算，當指定func的時候需要兩個參數(shù)。返回的是迭代器，與這個方法類似的就是functools下的reduce，reduce和accumulate都是累計進行操作，不同的是reduce只會返回最后的元素，而accumulate會顯示所有的元素，包含中間的元素，對比如下：
| 區(qū)別 | reduce | accumulate |
|---|---|---|
| 返回值 | 返回的是一個元素 | 返回的是一個迭代器（包含中間處理的元素） |
| 所屬模塊 | functools | itertools |
| 性能 | 略差 | 比reduce好一些 |
| 初始值 | 可以設置初始值 | 可以設置初始值 |
import time
from itertools import accumulate
from functools import reduce
l_data = [1, 2, 3, 4]
data = accumulate(l_data, lambda x, y: x + y, initial=2)
print(list(data))
start = time.time()
for i in range(100000):
data = accumulate(l_data, lambda x, y: x + y, initial=2)
print(time.time() - start)
start = time.time()
for i in range(100000):
data = reduce(lambda x, y: x + y, l_data)
print(time.time() - start)
#輸出
[2, 3, 5, 8, 12]
0.027924537658691406
0.03989362716674805
由上述結果可知，accumulate比reduce性能稍好一些，而且還能輸出中間的處理過程。
chain(*iterables)
iterables:接收多個可迭代對象
依次返回多個迭代對象的元素，返回的是一個迭代器,對于字典輸出元素時，默認會輸出字典的key
from itertools import chain
import time
list_data = [1, 2, 3]
dict_data = {"a": 1, "b": 2}
set_data = {4, 5, 6}
print(list(chain(list_data, dict_data, set_data)))
list_data = [1, 2, 3]
list_data2 = [4, 5, 6]
start = time.time()
for i in range(100000):
chain(list_data, list_data2)
print(time.time() - start)
start = time.time()
for i in range(100000):
list_data.extend(list_data2)
print(time.time() - start)
#輸出
[1, 2, 3, 'a', 'b', 4, 5, 6]
0.012955427169799805
0.013965129852294922
combinations(iterable: Iterable, r)
iterable:需要操作的可迭代對象
r: 抽取的子序列元素的個數(shù)
操作可迭代對象，根據(jù)所需抽取的子序列個數(shù)返回子序列，子序列中的元素也是有序、不可重復并且是以元組的形式呈現(xiàn)的。
from itertools import combinations
data = range(5)
print(tuple(combinations(data, 2)))
str_data = "asdfgh"
print(tuple(combinations(str_data, 2)))
#輸出
((0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4))
(('a', 's'), ('a', 'd'), ('a', 'f'), ('a', 'g'), ('a', 'h'), ('s', 'd'), ('s', 'f'), ('s', 'g'), ('s', 'h'), ('d', 'f'), ('d', 'g'), ('d', 'h'), ('f', 'g'), ('f', 'h'), ('g', 'h'))
combinations_with_replacement(iterable: Iterable, r)
與上述的combinations(iterable: Iterable, r)類似，不過區(qū)別在于，combinations_with_replacement的子序列的元素可以重復，也是有序的，具體如下：
from itertools import combinations_with_replacement
data = range(5)
print(tuple(combinations_with_replacement(data, 2)))
str_data = "asdfgh"
print(tuple(combinations_with_replacement(str_data, 2)))
#輸出
((0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4))
(('a', 'a'), ('a', 's'), ('a', 'd'), ('a', 'f'), ('a', 'g'), ('a', 'h'), ('s', 's'), ('s', 'd'), ('s', 'f'), ('s', 'g'), ('s', 'h'), ('d', 'd'), ('d', 'f'), ('d', 'g'), ('d', 'h'), ('f', 'f'), ('f', 'g'), ('f', 'h'), ('g', 'g'), ('g', 'h'), ('h', 'h'))
compress(data: Iterable, selectors: Iterable)
data:需要操作的可迭代對象
selectors:判斷真值的可迭代對象，不能時str，最好是列表、元組、之類的
根據(jù)selectors中的元素是否為true來輸出data中對應索引的元素，以最短的為準，返回一個迭代器。
from itertools import compress data = "asdfg" list_data = [1, 0, 0, 0, 1, 4] print(list(compress(data, list_data))) #輸出 ['a', 'g']
count(start, step)
start: 開始的元素
step: 自開始元素增長的步長
返回一個迭代器，從start按照步長遞增，不會一次性生成，最好使用next()進行元素的遞歸的獲取。
from itertools import count c = count(start=10, step=20) print(next(c)) print(next(c)) print(next(c)) print(next(c)) print(c) #輸出 10 30 50 70 count(90, 20)
cycle(iterable)
iterable： 需要循環(huán)輸出的可迭代對象
返回一個迭代器，循環(huán)輸出可迭代對象的元素。于count一樣，最好不要將結果轉換為可迭代對象，因為是循環(huán)，所以建議使用next()或者for循環(huán)獲取元素。
from itertools import cycle a = "asdfg" data = cycle(a) print(next(data)) print(next(data)) print(next(data)) print(next(data)) #輸出 a s d f
dropwhile(predicate, iterable)
predicate:是否舍棄元素的標準
iterable: 可迭代對象
返回一個迭代器,根據(jù)predicate是否為True來舍棄元素。當predicate為False時，后面的元素不管是否為True都會輸出。
from itertools import dropwhile list_data = [1, 2, 3, 4, 5] print(list(dropwhile(lambda i: i < 3, list_data))) print(list(dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1]))) #輸出 [3, 4, 5] [6, 4, 1]
filterfalse(predicate, iterable)
predicate:是否舍棄元素的標準
iterable: 可迭代對象
返回一個迭代器, 根據(jù)predicate是否為False判斷輸出，對所有元素進行操作。類似于filter方法，但是是filter的相反的.
import time
from itertools import filterfalse
print(list(filterfalse(lambda i: i % 2 == 0, range(10))))
start = time.time()
for i in range(100000):
filterfalse(lambda i: i % 2 == 0, range(10))
print(time.time() - start)
start = time.time()
for i in range(100000):
filter(lambda i: i % 2 == 0, range(10))
print(time.time() - start)
#輸出
[1, 3, 5, 7, 9]
0.276653528213501
0.2768676280975342
由上述結果看出，filterfalse與filter性能相差不大
groupby(iterable, key=None)
iterable: 可迭代對象
key: 可選，需要對元素進行判斷的條件, 默認為x == x。
返回一個迭代器,根據(jù)key返回連續(xù)的鍵和組（連續(xù)符合key條件的元素）。
注意使用groupby進行分組前需要對其進行排序。
from itertools import groupby
str_data = "babada"
for k, v in groupby(str_data):
print(k, list(v))
str_data = "aaabbbcd"
for k, v in groupby(str_data):
print(k, list(v))
def func(x: str):
print(x)
return x.isdigit()
str_data = "12a34d5"
for k, v in groupby(str_data, key=func):
print(k, list(v))
#輸出
b ['b']
a ['a']
b ['b']
a ['a']
d ['d']
a ['a']
a ['a', 'a', 'a']
b ['b', 'b', 'b']
c ['c']
d ['d']
1
2
a
True ['1', '2']
3
False ['a']
4
d
True ['3', '4']
5
False ['d']
True ['5']
islice(iterable, stop)\islice(iterable, start, stop[, step])
iterable: 需要操作的可迭代對象
start： 開始操作的索引位置
stop: 結束操作的索引位置
step: 步長
返回一個迭代器。類似于切片，但是其索引不支持負數(shù)。
from itertools import islice
import time
list_data = [1, 5, 4, 2, 7]
#學習中遇到問題沒人解答？小編創(chuàng)建了一個Python學習交流群：725638078
start = time.time()
for i in range(100000):
data = list_data[:2:]
print(time.time() - start)
start = time.time()
for i in range(100000):
data = islice(list_data, 2)
print(time.time() - start)
print(list(islice(list_data, 1, 3)))
print(list(islice(list_data, 1, 4, 2)))
#輸出
0.010963201522827148
0.01595783233642578
[5, 4]
[5, 2]
0.010963201522827148
0.01595783233642578
[5, 4]
[5, 2]
由上述結果可以看出，切片性能比islice性能稍好一些。
pairwise(iterable)
需要操作的可迭代對象
返回一個迭代器, 返回可迭代對象中的連續(xù)重疊對，少于兩個返回空。
from itertools import pairwise
str_data = "asdfweffva"
list_data = [1, 2, 5, 76, 8]
print(list(pairwise(str_data)))
print(list(pairwise(list_data)))
#輸出
[('a', 's'), ('s', 'd'), ('d', 'f'), ('f', 'w'), ('w', 'e'), ('e', 'f'), ('f', 'f'), ('f', 'v'), ('v', 'a')]
[(1, 2), (2, 5), (5, 76), (76, 8)]
permutations(iterable, r=None)
iterable： 需要操作的可迭代對象
r: 抽取的子序列
與combinations類似，都是抽取可迭代對象的子序列，不過，permutations是不可重復,無序的， 與combinations_with_replacement剛好相反。
from itertools import permutations
data = range(5)
print(tuple(permutations(data, 2)))
str_data = "asdfgh"
print(tuple(permutations(str_data, 2)))
#輸出
((0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3))
(('a', 's'), ('a', 'd'), ('a', 'f'), ('a', 'g'), ('a', 'h'), ('s', 'a'), ('s', 'd'), ('s', 'f'), ('s', 'g'), ('s', 'h'), ('d', 'a'), ('d', 's'), ('d', 'f'), ('d', 'g'), ('d', 'h'), ('f', 'a'), ('f', 's'), ('f', 'd'), ('f', 'g'), ('f', 'h'), ('g', 'a'), ('g', 's'), ('g', 'd'), ('g', 'f'), ('g', 'h'), ('h', 'a'), ('h', 's'), ('h', 'd'), ('h', 'f'), ('h', 'g'))
product(*iterables, repeat=1)
iterables: 可迭代對象，可以為多個
repeat: 可迭代對象的重復次數(shù)，也就是復制的次數(shù)
返回迭代器。生成可迭代對象的笛卡爾積, 類似于兩個或多個可迭代對象的排列組合。與zip函數(shù)很像，但是zip是元素的一對一對應關系，而product則是一對多的關系。
from itertools import product list_data = [1, 2, 3] list_data2 = [4, 5, 6] print(list(product(list_data, list_data2))) print(list(zip(list_data, list_data2))) # 如下兩個含義是一樣的，都是將可迭代對象復制一份， 很方便的進行同列表的操作 print(list(product(list_data, repeat=2))) print(list(product(list_data, list_data))) # 同上述含義 print(list(product(list_data, list_data2, repeat=2))) print(list(product(list_data, list_data2, list_data, list_data2))) #輸出 [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)] [(1, 4), (2, 5), (3, 6)] [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)] [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)] [(1, 4, 1, 4), (1, 4, 1, 5), (1, 4, 1, 6), (1, 4, 2, 4), (1, 4, 2, 5), (1, 4, 2, 6), (1, 4, 3, 4), (1, 4, 3, 5), (1, 4, 3, 6), (1, 5, 1, 4), (1, 5, 1, 5), (1, 5, 1, 6), (1, 5, 2, 4), (1, 5, 2, 5), (1, 5, 2, 6), (1, 5, 3, 4), (1, 5, 3, 5), (1, 5, 3, 6), (1, 6, 1, 4), (1, 6, 1, 5), (1, 6, 1, 6), (1, 6, 2, 4), (1, 6, 2, 5), (1, 6, 2, 6), (1, 6, 3, 4), (1, 6, 3, 5), (1, 6, 3, 6), (2, 4, 1, 4), (2, 4, 1, 5), (2, 4, 1, 6), (2, 4, 2, 4), (2, 4, 2, 5), (2, 4, 2, 6), (2, 4, 3, 4), (2, 4, 3, 5), (2, 4, 3, 6), (2, 5, 1, 4), (2, 5, 1, 5), (2, 5, 1, 6), (2, 5, 2, 4), (2, 5, 2, 5), (2, 5, 2, 6), (2, 5, 3, 4), (2, 5, 3, 5), (2, 5, 3, 6), (2, 6, 1, 4), (2, 6, 1, 5), (2, 6, 1, 6), (2, 6, 2, 4), (2, 6, 2, 5), (2, 6, 2, 6), (2, 6, 3, 4), (2, 6, 3, 5), (2, 6, 3, 6), (3, 4, 1, 4), (3, 4, 1, 5), (3, 4, 1, 6), (3, 4, 2, 4), (3, 4, 2, 5), (3, 4, 2, 6), (3, 4, 3, 4), (3, 4, 3, 5), (3, 4, 3, 6), (3, 5, 1, 4), (3, 5, 1, 5), (3, 5, 1, 6), (3, 5, 2, 4), (3, 5, 2, 5), (3, 5, 2, 6), (3, 5, 3, 4), (3, 5, 3, 5), (3, 5, 3, 6), (3, 6, 1, 4), (3, 6, 1, 5), (3, 6, 1, 6), (3, 6, 2, 4), (3, 6, 2, 5), (3, 6, 2, 6), (3, 6, 3, 4), (3, 6, 3, 5), (3, 6, 3, 6)] [(1, 4, 1, 4), (1, 4, 1, 5), (1, 4, 1, 6), (1, 4, 2, 4), (1, 4, 2, 5), (1, 4, 2, 6), (1, 4, 3, 4), (1, 4, 3, 5), (1, 4, 3, 6), (1, 5, 1, 4), (1, 5, 1, 5), (1, 5, 1, 6), (1, 5, 2, 4), (1, 5, 2, 5), (1, 5, 2, 6), (1, 5, 3, 4), (1, 5, 3, 5), (1, 5, 3, 6), (1, 6, 1, 4), (1, 6, 1, 5), (1, 6, 1, 6), (1, 6, 2, 4), (1, 6, 2, 5), (1, 6, 2, 6), (1, 6, 3, 4), (1, 6, 3, 5), (1, 6, 3, 6), (2, 4, 1, 4), (2, 4, 1, 5), (2, 4, 1, 6), (2, 4, 2, 4), (2, 4, 2, 5), (2, 4, 2, 6), (2, 4, 3, 4), (2, 4, 3, 5), (2, 4, 3, 6), (2, 5, 1, 4), (2, 5, 1, 5), (2, 5, 1, 6), (2, 5, 2, 4), (2, 5, 2, 5), (2, 5, 2, 6), (2, 5, 3, 4), (2, 5, 3, 5), (2, 5, 3, 6), (2, 6, 1, 4), (2, 6, 1, 5), (2, 6, 1, 6), (2, 6, 2, 4), (2, 6, 2, 5), (2, 6, 2, 6), (2, 6, 3, 4), (2, 6, 3, 5), (2, 6, 3, 6), (3, 4, 1, 4), (3, 4, 1, 5), (3, 4, 1, 6), (3, 4, 2, 4), (3, 4, 2, 5), (3, 4, 2, 6), (3, 4, 3, 4), (3, 4, 3, 5), (3, 4, 3, 6), (3, 5, 1, 4), (3, 5, 1, 5), (3, 5, 1, 6), (3, 5, 2, 4), (3, 5, 2, 5), (3, 5, 2, 6), (3, 5, 3, 4), (3, 5, 3, 5), (3, 5, 3, 6), (3, 6, 1, 4), (3, 6, 1, 5), (3, 6, 1, 6), (3, 6, 2, 4), (3, 6, 2, 5), (3, 6, 2, 6), (3, 6, 3, 4), (3, 6, 3, 5), (3, 6, 3, 6)]
repeat(object[, times])
object：任意合法對象
times: 可選，object對象生成的次數(shù), 當不傳入times，則無限循環(huán)
返回一個迭代器，根據(jù)times重復生成object對象。
from itertools import repeat
str_data = "assd"
print(repeat(str_data))
print(list(repeat(str_data, 4)))
list_data = [1, 2, 4]
print(repeat(list_data))
print(list(repeat(list_data, 4)))
dict_data = {"a": 1, "b": 2}
print(repeat(dict_data))
print(list(repeat(dict_data, 4)))
#輸出
repeat('assd')
['assd', 'assd', 'assd', 'assd']
repeat([1, 2, 4])
[[1, 2, 4], [1, 2, 4], [1, 2, 4], [1, 2, 4]]
repeat({'a': 1, 'b': 2})
[{'a': 1, 'b': 2}, {'a': 1, 'b': 2}, {'a': 1, 'b': 2}, {'a': 1, 'b': 2}]
starmap(function, iterable)
function: 作用域迭代器對象元素的函數(shù)
iterable: 可迭代對象
返回一個迭代器, 將函數(shù)作用與可迭代對象的所有元素（所有元素必須要是可迭代對象，即使只有一個值，也需要使用可迭代對象包裹，例如元組(1, )）中,與map函數(shù)類似；當function參數(shù)與可迭代對象元素一致時，使用元組代替元素，例如pow(a, b)，對應的是[(2,3), (3,3)]。
map與starmap的區(qū)別在于，map我們一般會操作一個function只有一個參數(shù)的情況，starmap可以操作function多個參數(shù)的情況。
from itertools import starmap
list_data = [1, 2, 3, 4, 5]
list_data2 = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]
list_data3 = [(1,), (2,), (3,), (4,), (5,)]
print(list(starmap(lambda x, y: x + y, list_data2)))
print(list(map(lambda x: x * x, list_data)))
print(list(starmap(lambda x: x * x, list_data)))
print(list(starmap(lambda x: x * x, list_data3)))
#輸出
[2, 4, 6, 8, 10]
[1, 4, 9, 16, 25]
Traceback (most recent call last):
File "c:\Users\ts\Desktop\2022.7\2022.7.22\test.py", line 65, in <module>
print(list(starmap(lambda x: x * x, list_data)))
TypeError: 'int' object is not iterable
takewhile(predicate, iterable)
predicate：判斷條件，為真就返回
iterable: 可迭代對象
當predicate為真時返回元素，需要注意的是，當?shù)谝粋€元素不為True時，則后面的無論結果如何都不會返回，找的前多少個為True的元素。
from itertools import takewhile #學習中遇到問題沒人解答？小編創(chuàng)建了一個Python學習交流群：725638078 list_data = [1, 5, 4, 6, 2, 3] print(list(takewhile(lambda x: x > 0, list_data))) print(list(takewhile(lambda x: x > 1, list_data)))
zip_longest(*iterables, fillvalue=None)
iterables：可迭代對象
fillvalue：當長度超過時，缺省值、默認值， 默認為None
返回迭代器, 可迭代對象元素一一對應生成元組，當兩個可迭代對象長度不一致時，會按照最長的有元素輸出并使用fillvalue補充，是zip的反向擴展，zip為最小長度輸出。
from itertools import zip_longest
list_data = [1, 2, 3]
list_data2 = ["a", "b", "c", "d"]
print(list(zip_longest(list_data, list_data2, fillvalue="-")))
print(list(zip_longest(list_data, list_data2)))
print(list(zip(list_data, list_data2)))
[(1, 'a'), (2, 'b'), (3, 'c'), ('-', 'd')]
[(1, 'a'), (2, 'b'), (3, 'c'), (None, 'd')]
[(1, 'a'), (2, 'b'), (3, 'c')]
總結
accumulate(iterable: Iterable, func: None, initial:None)：
進行可迭代對象元素的累計運算，可以設置初始值，類似于reduce，相比較reduce,accumulate可以輸出中間過程的值，reduce只能輸出最后結果，且accumulate性能略好于reduce。
chain(*iterables)
依次輸出迭代器中的元素，不會循環(huán)輸出，有多少輸出多少。對于字典輸出元素時，默認會輸出字典的key；對于列表來說相當于是extend。
combinations(iterable: Iterable, r)：
抽取可迭代對象的子序列，其實就是排列組合，不過只返回有序、不重復的子序列，以元組形式呈現(xiàn)。
combinations_with_replacement(iterable: Iterable, r)
抽取可迭代對象的子序列，與combinations類似，不過返回無序、不重復的子序列，以元組形式呈現(xiàn)。
compress(data: Iterable, selectors: Iterable)
根據(jù)selectors中的元素是否為True或者False返回可迭代對象的合法元素，selectors為str時，都為True，并且只會決定長度。
count(start, step)：
從start開始安裝step不斷生成元素，是無限循環(huán)的，最好控制輸出個數(shù)或者使用next(),send()等獲取、設置結果
cycle(iterable)
依次輸出可迭代對象的元素，是無限循環(huán)的，相當于是chain的循環(huán)。最好控制輸出個數(shù)或者使用next(),send()等獲取、設置結果。
dropwhile(predicate, iterable)
根據(jù)predicate是否為False來返回可迭代器元素，predicate可以為函數(shù)， 返回的是第一個False及之后的所有元素，不管后面的元素是否為True或者False。適用于需要舍棄迭代器或者可迭代對象的前面一部分內(nèi)容，例如在寫入文件時忽略文檔注釋
filterfalse(predicate, iterable)
依據(jù)predicate返回可迭代對象的所有predicate為True的元素，類似于filter方法。
groupby(iterable, key=None)
輸出連續(xù)符合key要求的鍵值對，默認為x == x。
islice(iterable, stop)\islice(iterable, start, stop[, step])
對可迭代對象進行切片，和普通切片類似，但是這個不支持負數(shù)。適用于可迭代對象內(nèi)容的切割，例如你需要獲取一個文件中的某幾行的內(nèi)容
pairwise(iterable)
返回連續(xù)的重疊對象（兩個元素）， 少于兩個元素返回空，不返回。
permutations(iterable, r=None)
從可迭代對象中抽取子序列，與combinations類似，不過抽取的子序列是無序、可重復。
product(*iterables, repeat=1)
輸出可迭代對象的笛卡爾積，類似于排序組合，不可重復,是兩個或者多個可迭代對象進行操作，當是一個可迭代對象時，則返回元素，以元組形式返回。
repeat(object[, times])
重復返回object對象，默認時無限循環(huán)
starmap(function, iterable)
批量操作可迭代對象中的元素，操作的可迭代對象中的元素必須也要是可迭代對象，與map類似，但是可以對類似于多元素的元組進行操作。
takewhile(predicate, iterable)
返回前多少個predicate為True的元素，如果第一個為False，則直接輸出一個空。
zip_longest(*iterables, fillvalue=None)
將可迭代對象中的元素一一對應，組成元組形式存儲，與zip方法類似，不過zip是取最短的，而zip_longest是取最長的，缺少的使用缺省值。
到此這篇關于一文詳解Python中itertools模塊的使用方法的文章就介紹到這了,更多相關Python itertools模塊內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
python創(chuàng)建學生成績管理系統(tǒng)
這篇文章主要為大家詳細介紹了python創(chuàng)建學生成績管理系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2019-11-11
Python3使用tracemalloc實現(xiàn)追蹤mmap內(nèi)存變化
這篇文章主要為大家詳細介紹了在Python3中如何使用tracemalloc實現(xiàn)追蹤mmap內(nèi)存變化，文中的示例代碼講解詳細，感興趣的可以了解一下2023-03-03
這篇文章主要為大家介紹了如何使用pip安裝清華大學鏡像源步驟詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-10-10
Python 模擬生成動態(tài)產(chǎn)生驗證碼圖片的方法
這篇文章主要介紹了Python 模擬生成動態(tài)產(chǎn)生驗證碼圖片的方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-02-02
Pandas.DataFrame重置Series的索引index(reset_index)
本文主要介紹了Pandas.DataFrame重置Series的索引index(reset_index)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2023-02-02
這篇文章主要介紹了Django 自定義分頁器的實現(xiàn)代碼，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-11-11
這篇文章主要介紹了打開并讀取npy文件,查看文件內(nèi)容方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-02-02
這篇文章主要介紹了將python程序打包成DLL的三種方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-02-02
大家好，本篇文章主要講的是Python實現(xiàn)一個簡單的QQ截圖，感興趣的同學趕快來看一看吧，對你有幫助的話記得收藏一下的相關資料2022-02-02
這篇文章主要介紹了Python常用的數(shù)據(jù)清洗方法,在數(shù)據(jù)處理的過程中，一般都需要進行數(shù)據(jù)的清洗工作，如數(shù)據(jù)集是否存在重復、是否存在缺失、數(shù)據(jù)是否具有完整性和一致性、數(shù)據(jù)中是否存在異常值等,需要的朋友可以參考下2023-07-07