寫在前面

Python簡單易學，現今非常流行。Python被用于各種場景，如數據科學、機器學習、web開發、腳本編制、自動化等等。

Python的簡單易學性在數據科學非常重要。盡管一些數據科學家有計算機科學背景或了解其他編程語言，但仍有許多數據科學家來自各類專業，如統計學、數學或其他技術學科，當他們剛進入這個行業時，可能并沒有那么多編程知識。Python語法易于理解和編寫的優勢，使它成為一種流行于快速且易于學習的編程語言。

在本文中，云朵君將和大家一起學習 40 個可以幫助你加快數據處理效率的的方法和技巧，希望對你有所幫助。

目錄

01 列表推導式

02 枚舉函數

03 通過函數返回多個值

04 像在數學中一樣比較多個數字

05 將字符串轉換為字符串列表

06 For-Else 方法

07 從列表中找到n個最大/小的元素

08 函數參數以列表值傳遞

09 重復整個字符串

10 從列表中找到元素的索引

11 在同一行中打印多個元素

12 分隔大數字以易于閱讀

13 反轉列表的切片

14 "is" 和 "==" 的區別

15 在一行代碼中合并 2 個字典

16 識別字符串是否以特定字母開頭

17 獲取字符的Unicode

18 獲取字典的鍵值對

19 在數學運算中使用布爾值

20 在列表的特定位置添加值

21 過濾器filter()函數

22 創建沒有參數邊界的函數

23 一次迭代兩個或多個列表

24 改變句子中字母的大小寫

25 檢查對象使用的內存大小

26 Map() 函數

27 反轉整個字符串

28 代碼塊的執行時間

29 刪除字符串的左側或右側字符

30 在元組或列表中查找元素的索引

31 清空列表或集合中元素

32 連接兩個集合

33 根據頻率對列表的值排序

34 從列表中刪除重復值

35 列表中元素連接為句子

36 一次從函數返回多個值

37 找出兩個列表之間的差異

38 將兩個列表合并為一個字典

39 執行字符串表示的代碼

40 字符串格式化

01 列表推導式

列表的元素可以在一行中循環遍歷。 

numbers = [1, 2, 3, 4, 5, 6, 7, 8]  
even_numbers = [number for number in numbers if number % 2 == 0]  
print(even_numbers)  

輸出

[1,3,5,7]

同樣可以使用字典、集合和生成器來完成推導式。 

dictionary = {'first_num': 1, 'second_num': 2,  
              'third_num': 3, 'fourth_num': 4}  
oddvalues = {key: value for (key, value) in dictionary.items() if value % 2 != 0}  
print(oddvalues)Output: {'first_num': 1,   
                         'third_num': 3} 

02 枚舉函數

Enumerate (枚舉) 是一個很有用的函數，用于迭代對象，如列表、字典或文件。該函數生成一個元組，其中包括通過對象迭代獲得的值以及循環計數器（從 0 的起始位置）。當希望根據索引編寫代碼時，循環計數器就派上用場了。

來看一個示例，其中第一個和最后一個元素會被區別對待。 

sentence = 'Just do It'  
lenlength = len(sentence)  
for index, element in enumerate(sentence):  
    print('{}: {}'.format(index, element))  
    if index == 0:  
        print('The first element!')  
    elif index == length - 1:  
        print('The last element!') 

輸出

0: J

The first element!

1: u

2: s

3: t

4:

5: d

6: o

7:

8: I

9: t

The last element!

也可以使用 enumerate 函數枚舉文件。在下面的示例中，在跳出循環之前打印 CSV 文件的前 10 行。并且可以在任何文件上使用該函數。 

with open('heart.csv') as f:  
    for i, line in enumerate(f):  
        if i == 10:  
            break  
        print(line) 

03 通過函數返回多個值

在設計函數時，我們經常希望返回多個值。在這里介紹兩種典型的方法。

方法一

最簡單的是返回一個元組。這種方法通常只在有兩個或三個值要返回時使用。但當元組中有更多值時，很容易忘記項目的順序。

下面的代碼部分是一個示例函數，它根據學生的 ID 號將學生的名字和姓氏作為元組返回。 

# 返回元組  
def get_student(id_num):  
    if id_num == 0:  
        return '君', '云朵'  
    elif id_num == 1:  
        return '猴子', '小'  
    else:  
        raise Exception('沒有學生的id是: {}'.format(id_num)) 

當我們使用數字 0 調用函數時，我們注意到它返回一個具有兩個值的元組：'Taha' 和 'Nate' 。 

Student = get_student(0)  
print('名字: {}, 姓氏: {}'.format(Student[0],   
       Student[1])) 

輸出

名字：君，姓氏：云朵

方法二

第二個選擇是返回字典。因為字典是鍵值對，我們可以對返回的值進行命名，這比元組更直觀。

方法二的實現方式和方法一一樣，只是返回一個字典。 

# 返回字典  
def get_data(id_num):  
    if id_num == 0:  
        return {'first_name': '君',  
                'last_name': '云朵',   
                'title': '數據STUDIO', 
                'department': 'A',   
                'date_joined': '20201001'}  
    elif id_num == 1:  
        return {'first_name': '猴子',   
                'last_name': '小',   
                'title': '機器學習研習院',  
                'department': 'B',   
                'date_joined': '20201019'}  
    else:  
        raise Exception('沒有員工的id是: {}'.format(id_num)) 

當結果是字典時，通過鍵引用特定值會更容易。我們正在調用 id_num = 0 的函數。 

employee = get_data(0)  
print('first_name: {}, nlast_name: {}, ntitle: {}, ndepartment: {}, ndate_joined: {}'.format(  
      employee['first_name'], employee['last_name'],   
    employee['title'], employee['department'],   
    employee['date_joined'])) 

輸出 

first_name: 君,    
last_name: 云朵,    
title: 數據STUDIO,    
department: A,    
date_joined: 20201001 

04 像在數學中一樣比較多個數字

如果有一個值并希望將其與其他兩個值進行比較，可以使用以下基本數學表達式： 1<x<30

這就是我們在小學學到的代數表達式。同樣的語句也可以在 Python 中使用。你應該用過如下的比較方式：

1<x and x<30

在 Python 中實現上述比較方式的另一種比較方法是：1<x<30 

x = 5  
print(1<x<30)  

輸出

True

05 將字符串轉換為字符串列表

假設將函數的輸入作為字符串，但它應該是這樣的列表： 

輸入 = [[1, 2, 3], [4, 5, 6]] 

其實無需處理復雜的正則表達式，只需導入模塊'ast'并調用其函數literal_eval： 

import ast  
def string_to_list(string):  
    return ast.literal_eval(string)  
string = "[[1, 2, 3],[4, 5, 6]]"  
my_list = string_to_list(string)  
print(my_list) 

輸出

[[1, 2, 3], [4, 5, 6]]

06 For-Else 方法

此方法用于在列表上應用循環。通常，當你想遍歷你應用的列表時，可以使用 for 循環。但是在這種方法中，你可以在循環中傳遞一個 else 條件，這種情況極為罕見。其他編程語言不支持這種方法。

看看它在一般情況下是如何工作的：如果要檢查列表中是否有偶數。 

number_List = [1, 3, 7, 9,8]  
for number in number_List:  
    if number % 2 == 0:  
        print(number)  
        break  
    else:  
    print("No even numbers!!") 

輸出

8

如果找到偶數，則將打印該數字，并且 else 部分將不會執行，因為我們傳遞了一個 break 語句。如果 break 語句從不執行，則 else 塊將執行。

07 從列表中找到N個最大/小的元素

通過使用'heapq'模塊，你可以從列表中找到 n-largest 或 n-smallest 元素。 

import heapq  
numbers = [80, 25, 68, 77, 95, 88, 30, 55, 40, 50]  
print(heapq.nlargest(5, numbers))  
print(heapq.nsmallest(5, numbers)) 

輸出

[95, 88, 80, 77, 68] [25, 30, 40, 50, 55]

08 函數參數以列表值傳遞

可以使用'*'訪問列表的所有元素。 

def Summation(*arg):  
    sum = 0  
    for i in arg:  
        sum += i  
    return sum  
result = Summation(*[8,5,10,7])  
print(result) 

輸出

30

09 重復整個字符串

只需將字符串乘以一個數字，即希望字符串重復的次數。 

value = "數據STUDIO"  
print(value * 3)   
print("-" *31) 

輸出

數據STUDIO數據STUDIO數據STUDIO  

----------------------------

10 從列表中找到元素的索引

使用".index"從列表中查找元素的索引。 

cities= ['Vienna', 'Amsterdam', 'Paris', 'Berlin']  
print(cities.index('Berlin'))  

輸出

3

11 在同一行中打印多個元素 

print("數據", end="")  
print("STUDIO")  
print("數據", end=" ")  
print("STUDIO")  
print('Data', 'science', 'Machine',   
      'Learning', sep=', ') 

輸出

數據STUDIO  

數據 STUDIO  

Data, science, Machine, Learning

12 分隔大數字以易于閱讀

有時，當你嘗試打印一個大數字時，傳遞整個數字會非常混亂且難以閱讀。然而你可以使用下劃線，使其易于閱讀，打印結果并不會顯示下劃線。 

print(5_000_000_000_000)  
print(7_543_291_635) 

輸出

5000000000000  

7543291635

13 反轉列表的切片

當你對列表進行切片時，你需要傳遞最小、最大和步長。要以相反的順序進行切片，你只需要傳遞一個負步長。 

sentence = "數據STUDIO 云朵君"  
print(sentence[21:0:-1])  
# 向前走兩步  
print(sentence[21:0:-2]) 

輸出

君朵云 OIDUTS據

君云ODT據

14 "is" 和 "==" 的區別

如果要檢查兩個變量是否指向同一個對象，則需要使用'is'。但是如果要檢查兩個變量是否相同，則需要使用'=='。 

list1 = [7, 9, 4]  
list2 = [7, 9, 4]  
print(list1 == list2)   
print(list1 is list2)  
list3 = list1  
print(list3 is list1) 

輸出

True  

False  

True

第一個語句是 True，因為 list1 和 list2 都持有相同的值，所以它們是相等的。第二個語句為 False，因為值指向內存中的不同變量，第三個語句為 True，因為 list1 和 list3 都指向內存中的公共對象。

15 在一行代碼中合并 2 個字典 

first_dct = {"London": 1, "Paris": 2}  
second_dct = {"Tokyo": 3, "Seol": 4}  
merged = {**first_dct, **second_dct} 
print(merged) 

輸出

{‘London’: 1, ‘Paris’: 2, ‘Tokyo’: 3, ‘Seol’: 4}

16 識別字符串是否以特定字母開頭

如果你需要知道字符串是否以特定字母開頭，那么你可以使用常見的索引方法。但是你也可以使用一個名為 'startswith' 的函數，它會告訴你一個字符串是否以特定的單詞開頭。 

sentence = "Data Studio"  
print(sentence.startswith("d"))  
print(sentence.startswith("o")) 

輸出

False

True

17 獲取字符的Unicode

如果你需要知道一個字符的 Unicode，那么你需要使用一個名為'ord'的函數，并在函數中傳遞你想知道其 Unicode 的字符。 

print(ord("T"))  
print(ord("A"))   
print(ord("h"))   
print(ord("a")) 

輸出

84  

65  

104  

97

18 獲取字典的鍵值對

如果你想以不同的方式訪問字典的鍵和值，你可以使用名為'items()'的函數來實現。 

cities = {'London': 1, 'Paris': 2, 'Tokyo': 3, 'Seol': 4}  
for key, value in cities.items():  
    print(f"Key: {key} and Value: {value}") 

輸出

Key: London and Value: 1  

Key: Paris and Value: 2  

Key: Tokyo and Value: 3  

Key: Seol and Value: 4

19 在數學運算中使用布爾值

False被視為 0，True被視為 1 

x = 9  
y = 3  
outcome = (x - False)/(y * True)  
print(outcome) 

輸出

3.0

20 在列表的特定位置添加值

如果你想使用'append' 功能向列表添加值，但它會在列表的最后位置添加一個值。如果你想在列表的特定位置添加值怎么辦？你可以使用名為 'insert' 的函數在列表的特定位置插入值。

語法 

list_name.insert(position, value)  
cities = ["London", "Vienna", "Rome"]  
cities.append("Seoul")  
print("After append:", cities)  
cities.insert(0, "Berlin")  
print("After insert:", cities) 

輸出

After append: ['London', 'Vienna', 

               'Rome', 'Seoul']   

After insert: ['Berlin', 'London', 

               'Vienna', 'Rome', 'Seoul']

21 過濾器 filter() 函數

過濾器filter()函數的工作顧名思義。它通過內部傳遞的特定函數來過濾特定的迭代器。并返回一個迭代器。

語法 

filter(function, iterator)  
mixed_number = [8, 15, 25, 30,34,67,90,5,12]  
filterfiltered_value = filter(lambda x: x > 20, mixed_number)  
print(f"Before filter: {mixed_number}")  
print(f"After filter: {list(filtered_value)}") 

輸出

Before filter:[8, 15, 25, 30, 34, 67, 90, 5, 12] 

After filter:[25, 30, 34, 67, 90]

22 創建沒有參數邊界的函數

你可以無需在意參數而創建一個函數。可以在調用函數時傳遞任意數量的參數。 

def multiplication(*arguments):  
    mul = 1  
    for i in arguments:  
        mulmul = mul * i  
    return mul  
print(multiplication(3, 4, 5))  
print(multiplication(5, 8, 10, 3))  
print(multiplication(8, 6, 15, 20, 5)) 

輸出

60  

1200  

72000

23 一次迭代兩個或多個列表

你可以使用 enumerate 函數迭代單個列表，但是當你有兩個或多個列表時，你也可以使用'zip()'函數迭代它們。 

capital = ['Vienna', 'Paris', 'Seoul',"Rome"]  
countries = ['澳大利亞', '法國', '韓國',"意大利"]  
for cap, country in zip(capital, countries):  
    print(f"{cap} 是 {country} 的首都") 

輸出

Vienna 是 澳大利亞 的首都  

Paris 是 法國 的首都  

Seoul 是 韓國 的首都  

Amsterdam 是 意大利 的首都

24 改變句子中字母的大小寫

如果你想改變字母的大小寫，即大寫到小寫，小寫到大寫，那么你可以使用一個叫做'swapcase'的函數實現這一功能。 

sentence = "Data STUDIO"  
changed_sen = sentence.swapcase()  
print(changed_sen) 

輸出

dATA studio

25 檢查對象使用的內存大小

要檢查對象使用的內存，首先導入 'sys' 庫，然后使用該庫中名為 'getsizeof' 的方法。它將返回對象使用的內存大小。 

import sys 
mul = 5*6  
print(sys.getsizeof(mul)) 

輸出

28

26 Map() 函數

'Map()' 函數用于特定的功能應用到一個給定的迭代器。

語法

map(function, iterator) 

values_list = [8, 10, 6, 50]  
quotient = map(lambda x: x/2, values_list)  
print(f"Before division: {values_list}")  
print(f"After division: {list(quotient)}") 

輸出

Before division：[8, 10, 6, 50]   

After division：[4.0, 5.0, 3.0, 25.0]

27 反轉整個字符串

要反轉字符串，你可以使用切片方法。 

value = "OIDUTS ataD"  
print("Reverse is:", value[::-1]) 

輸出

Reverse is: Data STUDIO

28 代碼塊的執行時間

當你訓練機器學習或深度學習模型，或者只是運行一個代碼塊時，獲取需要檢查運行代碼塊花費了多少時間。你可以選擇在代碼塊的頂部使用一個魔法函數'%%time'。它將顯示運行代碼塊所花費的時間。 

%%time  
sentence = " Data STUDIO."  
changed_sen = sentence.swapcase()  
print(changed_sen)  

輸出

  dATA studio.  

 CPU times: user 145 µs, sys: 578 µs, 

 total: 723 µs  

 Wall time: 1.04 ms

29 刪除字符串的左側或右側字符

有兩個函數稱為 'rstrip()' 和 'lstrip()','rstrip()' 用于從字符串右側刪除某個字符，而 'lstrip()' 用于從字符串左側刪除某個字符。兩個函數的默認值都是空格。但是你可以傳遞你的特定字符以將它們從字符串中刪除。 

sentence1 = "Data STUDIO     "  
print(f"After removing the right space: {sentence1.rstrip()}")   
sentence2 = "        Data STUDIO"  
print(f"After removing the left space: {sentence2.lstrip()}")  
sentence3 = "Data STUDIO .,bbblllg"  
print("After applying rstrip:", sentence3.rstrip(".,blg")) 

輸出 

After removing the right space: Data STUDIO    
After removing the left space: Data STUDIO    
After applying rstrip: Data STUDIO  
你可以通過在其中運行 for 循環來計算元素在列表中出現的次數。但是你可以更輕松地做到這一點，只需調用名為'count'的列表中的方法即可。  
cities= ["Amsterdam", "Berlin", "New York",   
         "Seoul", "Tokyo", "Paris", "Paris", 
         "Vienna","Paris"] 
print("Paris appears", cities.count("Paris"), "times in the list") 

輸出

Paris appears 3 times in the list

30 在元組或列表中查找元素的索引

只需在該元組或列表上調用一個名為'index'的簡單方法，就可以在該元組或列表中找到元素的索引。 

cities_tuple = ("Berlin", "Paris", 5, "Vienna", 10)  
print(cities_tuple.index("Paris"))   
cities_list = ['Vienna', 'Paris', 'Seoul',"Amsterdam"]  
print(cities_list.index("Amsterdam")) 

輸出

1  

3

31 清空列表或集合中元素

可以通過在列表或集合上應用稱為'clear'的方法從列表或集合中刪除所有元素。 

cities_list = ['Vienna', 'Paris', 'Seoul',"Amsterdam"]  
print(f"Before removing from the list: {cities_list}")  
cities_list.clear()  
print(f"After removing from the list: {cities_list}")  
cities_set = {'Vienna', 'Paris', 'Seoul',"Amsterdam"}  
print(f"Before removing from the set: {cities_set}")  
cities_set.clear() 
print(f"After removing from the set: {cities_set}") 

輸出

Before removing from the list: ['Vienna', 

              'Paris', 'Seoul', 'Amsterdam']  

After removing from the list: []  

Before removing from the set: {'Seoul', 

              'Amsterdam', 'Paris', 'Vienna'}  

After removing from the set: set()

32 連接兩個集合

要加入兩個集合，你可以應用稱為union()的方法。它將加入你應用該方法的兩個列表。 

set1 = {'Vienna', 'Paris', 'Seoul'}  
set2 = {"Tokyo", "Rome",'Amsterdam'}  
print(set1.union(set2)) 

輸出

{'Seoul', 'Rome', 'Paris', 

 'Amsterdam', 'Tokyo', 'Vienna'}

33 根據頻率對列表的值排序

首先，使用名為 collections 的模塊中的'counter'來測量每個值的頻率，然后對計數器的結果應用名為'most_common'的方法，根據頻率對列表中的值進行排序。 

from collections import Counter  
count = Counter([7, 6, 5, 6, 8, 6, 6, 6])  
print(count)  
print("根據頻率對值進行排序:", count.most_common()) 

輸出：

Counter({6: 5, 7: 1, 5: 1, 8: 1})  

根據頻率對值進行排序:[(6, 5), (7, 1), (5, 1), (8, 1)]

34 從列表中刪除重復值

首先將列表轉換為集合，這將刪除重復值，因為集合不包含重復值。然后再次將集合轉換為列表，這樣就可以輕松地從列表中刪除重復的值。 

cities_list = ['Vienna', 'Paris', 'Seoul',  
               "Amsterdam","Paris","Amsterdam", "Paris"]  
cities_list = set(cities_list)  
print("從列表中刪除重復值后:", list(cities_list)) 

輸出

從列表中刪除重復值后:['Vienna', 'Amsterdam', 

                   'Seoul', 'Paris']

35 列表中元素連接為句子

通過使用稱為'join'的方法，可以連接列表的所有單個元素并生成單個字符串或句子。 

words_list = ["數據", "STUDIO", "云朵君"]  
print(" ".join(words_list)) 

輸出

數據STUDIO云朵君

36 一次從函數返回多個值

可以在 python 中做到一次從一個函數返回多個值。 

def calculation(number):  
    mul = number*2  
    div = number/2  
    summation = number+2  
    subtract = number-2  
    return mul, div, summation, subtract  
mul, div, summation, subtract = calculation(10) 
 print("乘法:", mul) 
print("除法:", div)  
print("加法:", summation)  
print("減法:", subtract) 

輸出

乘法: 20  

除法: 5.0   

加法: 12  

減法: 8

37 找出兩個列表之間的差異

首先，將列表轉換為集合，然后對這些集合應用稱為'symmetric_difference'的方法。這將返回這兩個列表之間的差異。 

cities_list1 = ['Vienna', 'Paris', 'Seoul',"Amsterdam", "Berlin", "London"]  
cities_list2 = ['Vienna', 'Paris', 'Seoul',"Amsterdam"]  
cities_set1 = set(cities_list1)  
cities_set2 = set(cities_list2)  
difference = list(cities_set1.symmetric_difference(cities_set2))  
print(difference) 

輸出

['Berlin', 'London']

38 將兩個列表合并為一個字典

首先，在這兩個列表上應用 zip 函數，然后將 zip 函數的輸出轉換為字典。你的工作已完成，將兩個列表轉換為一個字典就是這么容易。 

number = [1, 2, 3]  
cities = ['維也納', '巴黎', '首爾']  
result = dict(zip(number, cities))  
print(result) 

輸出

{1:'維也納', 2:'巴黎', 3:'首爾'}

39 執行字符串表示的代碼

將字符串編譯成python能識別或可執行的代碼，也可以將文字讀成字符串再編譯。 

s  = "print('helloworld')"  
r = compile(s,"<string>", "exec")  
exec(r) 

輸出

helloworld

40 字符串格式化

格式化輸出字符串，format(value, format_spec)實質上是調用了value的format(format_spec)方法。 

print("i am {0},age{1}".format("tom",18))  

輸出

i am tom,age18

3.1415926	{:.2f}	3.14	保留小數點后兩位
3.1415926	{:+.2f}	3.14	帶符號保留小數點后兩位
-1	{:+.2f}	-1	帶符號保留小數點后兩位
2.71828	{:.0f}	3	不帶小數
5	{:0>2d}	5	數字補零 (填充左邊, 寬度為2)
5	{:x<4d}	5xxx	數字補x (填充右邊, 寬度為4)
10	{:x<4d}	10xx	數字補x (填充右邊, 寬度為4)
1000000	{:,}	1,000,000	以逗號分隔的數字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00E+09	指數記法
18	{:>10d}	' 18'	右對齊 (默認, 寬度為10)
18	{:<10d}	'18 '	左對齊 (寬度為10)
18	{:^10d}	' 18 '	中間對齊 (寬度為10)