目前Python可以說是非常流行,在目前的程式語言中,Python的抽象程度是最高的,是最接近自然語言的,很容易上手。你可以用它來完成很多工,比如資料科學、機器學習、Web開發、指令碼編寫、自動化等。下面就給大家分享100個Python小技巧,幫助大家更好的瞭解和學習Python。
作者:小F
公眾號:法納斯特(ID:walker398)
01 for迴圈中的else條件
這是一個for-else方法,迴圈遍歷列表時使用else語句。
下面舉個例子,比如我們想檢查一個列表中是否包含奇數。
那麼可以透過for迴圈,遍歷查詢。
numbers = [2, 4, 6, 8, 1]for number in numbers:
if number % 2 == 1:
print(number)
break
else:
print(“No odd numbers”)
如果找到了奇數,就會列印該數值,並且執行break語句,跳過else語句。
沒有的話,就不會執行break語句,而是執行else語句。
02 從列表中獲取元素,定義多個變數
my_list = [1, 2, 3, 4, 5]
one, two, three, four, five = my_list
03 使用heapq模組,獲取列表中n個最大或最小的元素
import heapqscores = [51, 33, 64, 87, 91, 75, 15, 49, 33, 82]print(heapq.nlargest(3, scores)) # [91, 87, 82]
print(heapq.nsmallest(5, scores)) # [15, 33, 33, 49, 51]
04 將列表中的所有元素作為引數傳遞給函式
我們可以使用 * 號,提取列表中所有的元素
my_list = [1, 2, 3, 4]print(my_list) # [1, 2, 3, 4]
print(*my_list) # 1 2 3 4
如此便可以將列表中的所有元素,作為引數傳遞給函式
def sum_of_elements(*arg):
total = 0
for i in arg:
total += ireturn totalresult = sum_of_elements(*[1, 2, 3, 4])
print(result) # 10
05 獲取列表的所有中間元素
_, *elements_in_the_middle, _ = [1, 2, 3, 4, 5, 6, 7, 8]
print(elements_in_the_middle) # [2, 3, 4, 5, 6, 7]
06 使用一行程式碼賦值多個變數
one, two, three, four = 1, 2, 3, 4
07 列表推導式
只用一行程式碼,便可完成對陣列的迭代以及運算。
比如,將列表中的每個數字提高一倍。
numbers = [1, 2, 3, 4, 5]
squared_numbers = [num * num for num in numbers]print(squared_numbers) # [1, 4, 9, 16, 25]
推導式不僅列表能用,字典、集合、生成器也能使用。
下面看一下,使用字典推導式,將字典的值提高一倍。
dictionary = {‘a’: 4, ‘b’: 5}
squared_dictionary = {key: num * num for (key, num) in dictionary.items()}print(squared_dictionary) # {‘a’: 16, ‘b’: 25}
08 透過Enum列舉同一標籤或一系列常量的集合
列舉是繫結到唯一的常量值的一組符號名稱(成員)。
在列舉中,成員可以透過身份進行比較,列舉本身可以迭代。
from enum import Enumclass Status(Enum):
NO_STATUS = -1
NOT_STARTED = 0
IN_PROGRESS = 1
COMPLETED = 2print(Status.IN_PROGRESS.name) # IN_PROGRESS
print(Status.COMPLETED.value) # 2
09 重複字串
name = “Banana”
print(name * 4) # BananaBananaBananaBanana
10 比較3個數字的大小
如果想比較一個值和其他兩個值的大小情況,你可以使用簡單的數學表示式。
1 < x < 10
這個是最簡單的代數表示式,在Python中也是可以使用的。
x = 3print(1 < x < 10) # True
print(1 < x and x < 10) # True
11 使用1行程式碼合併字典
first_dictionary = {‘name’: ‘Fan’, ‘location’: ‘Guangzhou’}
second_dictionary = {‘name’: ‘Fan’, ‘surname’: ‘Xiao’, ‘location’: ‘Guangdong, Guangzhou’}result = first_dictionary | second_dictionaryprint(result)
# {‘name’: ‘Fan’, ‘location’: ‘Guangdong, Guangzhou’, ‘surname’: ‘Xiao’}
12 查詢元組中元素的索引
books = (‘Atomic habits’, ‘Ego is the enemy’, ‘Outliers’, ‘Mastery’)print(books.index(‘Mastery’)) # 3
13 將字串轉換為字串列表
假設你在函式中獲得輸出,原本應該是一個列表,但實際上卻是一個字串。
input = “[1,2,3]”
你可能第一時間會想到使用索引或者正則表示式。
實際上,使用ast模組的literal_eval方法就能搞定。
import astdef string_to_list(string):
return ast.literal_eval(string)string = “[1, 2, 3]”
my_list = string_to_list(string)
print(my_list) # [1, 2, 3]string = “[[1, 2, 3],[4, 5, 6]]”
my_list = string_to_list(string)
print(my_list) # [[1, 2, 3], [4, 5, 6]]
14 計算兩數差值
計算出2個數字之間的差值。
def subtract(a, b):
return a — bprint((subtract(1, 3))) # -2
print((subtract(3, 1))) # 2
上面的這個方法,需要考慮數值的先後順序。
def subtract(a, b):
return a — bprint((subtract(a=1, b=3))) # -2
print((subtract(b=3, a=1))) # -2
使用命名引數,安排順序,這樣就不會出錯了。
15 用一個print()語句列印多個元素
print(1, 2, 3, “a”, “z”, “this is here”, “here is something else”)
16 在同一行列印多個元素
print(“Hello”, end=””)
print(“World”) # HelloWorldprint(“Hello”, end=” “)
print(“World”) # Hello Worldprint(‘words’, ‘with’, ‘commas’, ‘in’, ‘between’, sep=’, ‘)
# words, with, commas, in, between
17 列印多個值,在每個值之間使用自定義分隔符
print(“29”, “01”, “2022”, sep=”/”) # 29/01/2022print(“name”, “domain.com”, sep=”@”) # name@domain.com
18 不能在變數名的開頭使用數字
four_letters = “abcd” # this works4_letters = “abcd” # this doesn’t work
這是Python的變數命名規則。
19 不能在變數名的開頭使用運算子
+variable = “abcd” # this doesn’t work
20 數字的第一位不能是0
number = 0110 # this doesn’t work
這個確實挺神奇的。
21 在變數名的任何地方使用下劃線
a______b = “abcd” # this works
_a_b_c_d = “abcd” # this also works
這並不意味著,你可以無限使用,為了程式碼的易讀性,還是需要合理使用。
22 使用下劃線分割數值較大的數字
print(1_000_000_000) # 1000000000
print(1_234_567) # 1234567
如此,看到一大堆數字時,也能輕鬆閱讀。
23 反轉列表
my_list = [‘a’, ‘b’, ‘c’, ‘d’]my_list.reverse()print(my_list) # [‘d’, ‘c’, ‘b’, ‘a’]
24 使用步進函式對字串切片
my_string = “This is just a sentence”
print(my_string[0:5]) # This# Take three steps forward
print(my_string[0:10:3]) # Tsse
25 反向切片
my_string = “This is just a sentence”
print(my_string[10:0:-1]) # suj si sih# Take two steps forward
print(my_string[10:0:-2]) # sjs i
26 使用開始或結束索引進行切片
my_string = “This is just a sentence”
print(my_string[4:]) # is just a sentenceprint(my_string[:3]) # Thi
27 /和//的區別
print(3/2) # 1.5
print(3//2) # 1
28 ==和is的區別
◆is:檢查兩個變數是否指向同一物件記憶體中
◆==:比較兩個物件的值
first_list = [1, 2, 3]
second_list = [1, 2, 3]# 比較兩個值
print(first_list == second_list) # True# 是否指向同一記憶體
print(first_list is second_list)
# Falsethird_list = first_listprint(third_list is first_list)
# True
29 合併字典
dictionary_one = {“a”: 1, “b”: 2}
dictionary_two = {“c”: 3, “d”: 4}merged = {**dictionary_one, **dictionary_two}print(merged) # {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4}
30 檢查字串是否大於另一字串
first = “abc”
second = “def”print(first < second) # Truesecond = “ab”
print(first < second) # False
31 檢查字串是否以特定字元開頭(不使用索引)
my_string = “abcdef”
print(my_string.startswith(“b”)) # False
32 使用id()查詢變數的唯一id
print(id(1)) # 4325776624
print(id(2)) # 4325776656
print(id(“string”)) # 4327978288
33 整數、浮點數、字串、布林值和元組都是不可變的
當變數被賦值為整數、浮點數、字串、布林值、元組這些不可變型別後,該變數就會指向一個記憶體物件。
如果重新給變數再賦值,它的記憶體物件就會發生改變。
number = 1
print(id(number)) # 4325215472
print(id(1)) # 4325215472number = 3
print(id(number)) # 4325215536
print(id(1)) # 4325215472
34 字串和元組也是不可變的
此處再說明一次。
name = “Fatos”
print(id(name)) # 4422282544name = “fatos”
print(id(name)) # 4422346608
35 列表、集合和字典都是可變的
這意味著發生更改時,不會改變其記憶體物件。
cities = [“Beijing”, “Guangzhou”, “chengdu”]
print(id(cities)) # 4482699712cities.append(“Beijing”)
print(id(cities)) # 4482699712
下面是字典。
my_set = {1, 2, 3, 4}
print(id(my_set)) # 4352726176my_set.add(5)
print(id(my_set)) # 4352726176
36 把一個列表變成不可變的列表
my_set = frozenset([‘a’, ‘b’, ‘c’, ‘d’])my_set.add(“a”)
使用frozenset()後,你就無法更改了。
37 if-elif塊可以在沒有else塊的情況下存在
但是elif不能在沒有if語句之前獨立存在。
def check_number(number):
if number > 0:
return “Positive”
elif number == 0:
return “Zero”return “Negative”print(check_number(1)) # Positive
38 使用sorted()檢查2個字串是否為相同
def check_if_anagram(first_word, second_word):
first_word = first_word.lower()
second_word = second_word.lower()
return sorted(first_word) == sorted(second_word)print(check_if_anagram(“testinG”, “Testing”)) # True
print(check_if_anagram(“Here”, “Rehe”)) # True
print(check_if_anagram(“Know”, “Now”)) # False
39 獲取字元的Unicode值
print(ord(“A”)) # 65
print(ord(“B”)) # 66
print(ord(“C”)) # 66
print(ord(“a”)) # 97
40 獲取字典的鍵
dictionary = {“a”: 1, “b”: 2, “c”: 3}keys = dictionary.keys()
print(list(keys)) # [‘a’, ‘b’, ‘c’]
41 獲取字典的值
dictionary = {“a”: 1, “b”: 2, “c”: 3}values = dictionary.values()
print(list(values)) # [1, 2, 3]
42 交換字典的鍵、值位置
dictionary = {“a”: 1, “b”: 2, “c”: 3}reversed_dictionary = {j: i for i, j in dictionary.items()}
print(reversed) # {1: ‘a’, 2: ‘b’, 3: ‘c’}
43 將布林值轉換為數字
print(int(False)) # 0
print(float(True)) # 1.0
44 在算術運算中使用布林值
x = 10
y = 12result = (x — False)/(y * True)
print(result) # 0.8333333333333334
45 將任何資料型別轉換為布林值
print(bool(.0)) # False
print(bool(3)) # True
print(bool(“-”)) # True
print(bool(“string”)) # True
print(bool(“ “)) # True
46 將值轉換為複數
print(complex(10, 2)) # (10+2j)
也可以將數字轉換為十六進位制數。
print(hex(11)) # 0xb
47 在列表的第一個位置新增一個值
如果使用append(),將從列表的最後一個位置插入新值。
可以透過使用insert(),來指定插入新元素的索引和數值。
那麼列表的第一個位置為0,即下標為0。
my_list = [3, 4, 5]my_list.append(6)
my_list.insert(0, 2)
print(my_list) # [2, 3, 4, 5, 6]
48 Lambda函式只能在一行程式碼中
無法透過多行程式碼,來使用lambda函式。
comparison = lambda x: if x > 3:
print(“x > 3”)
else:
print(“x is not greater than 3”)
報錯。
49 Lambda中的條件語句應始終包含else語句
comparison = lambda x: “x > 3” if x > 3
執行上面的程式碼,報錯。
這是由於條件表示式的特性,而不是lambda的導致的。
50 使用filter(),獲得一個新物件
my_list = [1, 2, 3, 4]odd = filter(lambda x: x % 2 == 1, my_list)print(list(odd)) # [1, 3]
print(my_list) # [1, 2, 3, 4]
51 map()返回一個新物件
map()函式將給定函式應用於可迭代物件(列表、元組等),然後返回結果(map物件)。
my_list = [1, 2, 3, 4]squared = map(lambda x: x ** 2, my_list)print(list(squared)) # [1, 4, 9, 16]
print(my_list) # [1, 2, 3, 4]
52 range()的step引數
for number in range(1, 10, 3):
print(number, end=” “)
# 1 4 7
53 range()預設從0開始
def range_with_zero(number):
for i in range(0, number):
print(i, end=’ ‘)def range_with_no_zero(number):
for i in range(number):
print(i, end=’ ‘)range_with_zero(3) # 0 1 2
range_with_no_zero(3) # 0 1 2
54 不需要和0比較長度
如果長度大於0,則預設為True。
def get_element_with_comparison(my_list):
if len(my_list) > 0:
return my_list[0]def get_first_element(my_list):
if len(my_list):
return my_list[0]elements = [1, 2, 3, 4]
first_result = get_element_with_comparison(elements)
second_result = get_element_with_comparison(elements)print(first_result == second_result) # True
55 可以在同一個作用域內多次定義一個方法
但是,只有最後一個會被呼叫,覆蓋以前。
def get_address():
return “First address”def get_address():
return “Second address”def get_address():
return “Third address”print(get_address()) # Third address
56 在外部直接訪問私有屬性
在定義屬性或方法時,在屬性名或者方法名前增加兩個下劃線,定義的就是私有屬性或方法。
如果想要在外部訪問,那麼只需要在名稱前面加上 ‘_類名’ 變成 ‘_類名__名稱’。
class Engineer:
def __init__(self, name):
self.name = name
self.__starting_salary = 62000dain = Engineer(‘Dain’)
print(dain._Engineer__starting_salary) # 62000
57 檢查物件的記憶體使用情況
import sysprint(sys.getsizeof(“bitcoin”)) # 56
58 定義一個方法,可以呼叫任意個引數
def get_sum(*arguments):
result = 0
for i in arguments:
result += i
return resultprint(get_sum(1, 2, 3)) # 6
print(get_sum(1, 2, 3, 4, 5)) # 15
print(get_sum(1, 2, 3, 4, 5, 6, 7)) # 28
59 使用super()或父類的名稱呼叫父類的初始化
使用super函式呼叫父類的初始化方法。
class Parent:
def __init__(self, city, address):
self.city = city
self.address = addressclass Child(Parent):
def __init__(self, city, address, university):
super().__init__(city, address)
self.university = universitychild = Child(‘Peking University’, ‘Fudan University’, ‘Tsinghua University’)
print(child.university) # Tsinghua University
使用父類的名稱呼叫父類。
class Parent:
def __init__(self, city, address):
self.city = city
self.address = addressclass Child(Parent):
def __init__(self, city, address, university):
Parent.__init__(self, city, address)
self.university = universitychild = Child(‘Peking University’, ‘Fudan University’, ‘Tsinghua University’)
print(child.university) # Tsinghua University
60 在類中使用 + 運算子
在兩個int資料型別之間使用 + 運算子時,將得到它們的和。
而在兩個字串資料型別之間使用它時,會將其合併。
print(10 + 1) # 兩數相加
print(‘first’ + ‘second’) # 字串相加
這個就是運算子過載,你還可以在類中使用(__add__)。
class Expenses:
def __init__(self, rent, groceries):
self.rent = rent
self.groceries = groceriesdef __add__(self, other):
return Expenses(self.rent + other.rent,
self.groceries + other.groceries)april_expenses = Expenses(1000, 200)
may_expenses = Expenses(1000, 300)total_expenses = april_expenses + may_expenses
print(total_expenses.rent) # 2000
print(total_expenses.groceries) # 500
61 在類中使用 < 和 == 運算子
下面定義一個操作過載示例( < 運算子),使用__lt__方法。
class Game:
def __init__(self, score):
self.score = scoredef __lt__(self, other):
return self.score < other.scorefirst = Game(1)
second = Game(2)print(first < second) # True
同樣的,== 運算子使用__eq__方法。
class Journey:
def __init__(self, location, destination, duration):
self.location = location
self.destination = destination
self.duration = durationdef __eq__(self, other):
return ((self.location == other.location) and
(self.destination == other.destination) and
(self.duration == other.duration))first = Journey(‘Location A’, ‘Destination A’, ‘30min’)
second = Journey(‘Location B’, ‘Destination B’, ‘30min’)print(first == second)
還有一些其他的定義。
__sub__() for -
__mul__() for *
__truediv__() for /
__ne__() for !=
__ge__() for >=
__gt__() for >
62 為類的物件定義自定義的可列印版本
class Rectangle:
def __init__(self, a, b):
self.a = a
self.b = bdef __repr__(self):
return repr(‘Rectangle with area=’ + str(self.a * self.b))print(Rectangle(3, 4)) # ‘Rectangle with area=12’
63 交換字串中字元的大小寫
string = “This is just a sentence.”
result = string.swapcase()print(result) # tHIS IS JUST A SENTENCE.
64 檢查字串是否都是空格
string = “ “
result = string.isspace()print(result) # True
65 檢查字串是否都是字母或數字
name = “Password”
print(name.isalnum()) # Truename = “Secure Password “
print(name.isalnum()) # Falsename = “S3cur3P4ssw0rd”
print(name.isalnum()) # Truename = “133”
print(name.isalnum()) # True
66 檢查字串是否都是字母
string = “Name”
print(string.isalpha()) # Truestring = “Firstname Lastname”
print(string.isalpha()) # Falsestring = “P4ssw0rd”
print(string.isalpha()) # False
67 根據引數刪除字元
從右側開始。
string = “This is a sentence with “
print(string.rstrip()) # “This is a sentence with”string = “this here is a sentence…..,,,,aaaaasd”
print(string.rstrip(“.,dsa”)) # “this here is a sentence”
同樣的,左側也能操作。
string = “ffffffffFirst”
print(string.lstrip(“f”)) # First
68 檢查字串是否為數字
string = “seven”
print(string.isdigit()) # Falsestring = “1337”
print(string.isdigit()) # Truestring = “5a”
print(string.isdigit()) # Falsestring = “2**5”
print(string.isdigit()) # False
69 檢查字串是否為中文數字
# 42673
string = “四二六七三”print(string.isdigit()) # False
print(string.isnumeric()) # True
70 檢查字串是否所有單詞都是大寫開頭
string = “This is a sentence”
print(string.istitle()) # Falsestring = “10 Python Tips”
print(string.istitle()) # Truestring = “How to Print A String in Python”
# False
print(string.istitle())string = “PYTHON”
print(string.istitle()) # False
71 在元組中使用負索引
numbers = (1, 2, 3, 4)print(numbers[-1]) # 4
print(numbers[-4]) # 1
72 在元組中巢狀列表和元組
mixed_tuple = ((“a”*10, 3, 4), [‘first’, ‘second’, ‘third’])print(mixed_tuple[1]) # [‘first’, ‘second’, ‘third’]
print(mixed_tuple[0]) # (‘aaaaaaaaaa’, 3, 4)
73 快速統計元素在列表中出現的次數
names = [“Besim”, “Albert”, “Besim”, “Fisnik”, “Meriton”]print(names.count(“Besim”)) # 2
74 使用slice()獲取元素
使用slice()獲取最後n個元素。
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
slicing = slice(-4, None)
print(my_list[slicing]) # [4, 5, 6]print(my_list[-3]) # 4
使用slice()做切片任務。
string = “Data Science”slice_object = slice(5, None)
print(string[slice_object]) # Science
75 計算元素在元組中出現的次數
my_tuple = (‘a’, 1, ‘f’, ‘a’, 5, ‘a’)print(my_tuple.count(‘a’)) # 3
76 獲取元組中元素的索引
my_tuple = (‘a’, 1, ‘f’, ‘a’, 5, ‘a’)print(my_tuple.index(‘f’)) # 2
77 步進獲得元組
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)print(my_tuple[::3]) # (1, 4, 7, 10)
78 透過索引獲取子元組
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)print(my_tuple[3:]) # (4, 5, 6, 7, 8, 9, 10)
79 將列表、集合、字典中所有元素刪除
my_list = [1, 2, 3, 4]
my_list.clear()
print(my_list) # []my_set = {1, 2, 3}
my_set.clear()
print(my_set) # set()my_dict = {“a”: 1, “b”: 2}
my_dict.clear()
print(my_dict) # {}
80 合併集合
使用union()方法,返回一個新集合。
first_set = {4, 5, 6}
second_set = {1, 2, 3}print(first_set.union(second_set)) # {1, 2, 3, 4, 5, 6}
還可以使用update()方法,將第二個集合的元素插入到第一個集合中去。
first_set = {4, 5, 6}
second_set = {1, 2, 3}first_set.update(second_set)print(first_set) # {1, 2, 3, 4, 5, 6}
81 在函數里輸出結果
def is_positive(number):
print(“Positive” if number > 0 else “Negative”) # Positiveis_positive(-3)
82 if語句中的多個條件
math_points = 51
biology_points = 78
physics_points = 56
history_points = 72my_conditions = [math_points > 50, biology_points > 50,
physics_points > 50, history_points > 50]if all(my_conditions):
print(“Congratulations! You have passed all of the exams.”)
else:
print(“I am sorry, but it seems that you have to repeat at least one exam.”)
# Congratulations! You have passed all of the exams.
83 在一個if語句中,至少滿足多個條件中的一個
math_points = 40
biology_points = 78
physics_points = 56
history_points = 72my_conditions = [math_points > 50, biology_points > 50,
physics_points > 50, history_points > 50]if any(my_conditions):
print(“Congratulations! You have passed all of the exams.”)
else:
print(“I am sorry, but it seems that you have to repeat at least one exam.”)
# Congratulations! You have passed all of the exams.
84 任何非空字串都為True
print(bool(“Non empty”)) # True
print(bool(“”)) # False
85 任何非空列表、元組、字典都為True
print(bool([])) # False
print(bool(set([]))) # Falseprint(bool({})) # False
print(bool({“a”: 1})) # True
86 None、False、0都為False
print(bool(False)) # False
print(bool(None)) # False
print(bool(0)) # False
87 在函式中使用全域性變數
在函式無法直接修改全域性變數的值。
string = “string”def do_nothing():
string = “inside a method”do_nothing()print(string) # string
可透過修飾符global,修改全域性變數的值。
string = “string”def do_nothing():
global string
string = “inside a method”do_nothing()print(string) # inside a method
88 計算字串或列表中元素的數量
使用collections中的Counter計算字串或列表中元素的數量。
from collections import Counterresult = Counter(“Banana”)
print(result) # Counter({‘a’: 3, ’n’: 2, ‘B’: 1})result = Counter([1, 2, 1, 3, 1, 4, 1, 5, 1, 6])
print(result) # Counter({1: 5, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1})
89 檢查2個字串是否為相同
可以使用Counter()方法。
from collections import Counterdef check_if_anagram(first_string, second_string):
first_string = first_string.lower()
second_string = second_string.lower()
return Counter(first_string) == Counter(second_string)print(check_if_anagram(‘testinG’, ‘Testing’)) # True
print(check_if_anagram(‘Here’, ‘Rehe’)) # True
print(check_if_anagram(‘Know’, ‘Now’)) # False
可以使用sorted()方法。
def check_if_anagram(first_word, second_word):
first_word = first_word.lower()
second_word = second_word.lower()
return sorted(first_word) == sorted(second_word)print(check_if_anagram(“testinG”, “Testing”)) # True
print(check_if_anagram(“Here”, “Rehe”)) # True
print(check_if_anagram(“Know”, “Now”)) # False
90 使用itertools中的count計算元素的數量
from itertools import countmy_vowels = [‘a’, ‘e’, ‘i’, ‘o’, ‘u’, ‘A’, ‘E’, ‘I’, ‘O’, ‘U’]current_counter = count()string = “This is just a sentence.”for i in string:
if i in my_vowels:
print(f”Current vowel: {i}”)
print(f”Number of vowels found so far: {next(current_counter)}”)
輸出如下。
Current vowel: i
Number of vowels found so far: 0
Current vowel: i
Number of vowels found so far: 1
Current vowel: u
Number of vowels found so far: 2
Current vowel: a
Number of vowels found so far: 3
Current vowel: e
Number of vowels found so far: 4
Current vowel: e
Number of vowels found so far: 5
Current vowel: e
Number of vowels found so far: 6
91 對字串或列表的元素進行次數排序
collections模組的Counter(),預設情況下是不會根據元素的頻率對它們進行排序的。
from collections import Counterresult = Counter([1, 2, 3, 2, 2, 2, 2])
print(result) # Counter({2: 5, 1: 1, 3: 1})
print(result.most_common()) # [(2, 5), (1, 1), (3, 1)]
map()函式將給定函式應用於可迭代物件(列表、元組等),然後返回結果(map物件)。
92 查詢列表中出現頻率最高的元素
my_list = [‘1’, 1, 0, ‘a’, ‘b’, 2, ‘a’, ‘c’, ‘a’]print(max(set(my_list), key=my_list.count)) # a
93 copy()和deepcopy()的區別
◆淺複製: 複製父物件,但是不會複製物件的內部的子物件。
◆深複製: 複製父物件,以及其內部的子物件。
下面是一個copy()的例子。
first_list = [[1, 2, 3], [‘a’, ‘b’, ‘c’]]second_list = first_list.copy()first_list[0][2] = 831print(first_list) # [[1, 2, 831], [‘a’, ‘b’, ‘c’]]
print(second_list) # [[1, 2, 831], [‘a’, ‘b’, ‘c’]]
這裡是一個deepcopy()的例子。
import copyfirst_list = [[1, 2, 3], [‘a’, ‘b’, ‘c’]]second_list = copy.deepcopy(first_list)first_list[0][2] = 831print(first_list) # [[1, 2, 831], [‘a’, ‘b’, ‘c’]]
print(second_list) # [[1, 2, 3], [‘a’, ‘b’, ‘c’]]
94 訪問字典中不存在的鍵時,避免報錯
如果你想訪問字典一個不存在的鍵,程式碼會報錯。
my_dictonary = {“name”: “Name”, “surname”: “Surname”}
print(my_dictonary[“age”])
錯誤如下。
KeyError: ‘age’
可以透過使用defaultdict(),程式碼將不會報錯。
from collections import defaultdictmy_dictonary = defaultdict(str)
my_dictonary[‘name’] = “Name”
my_dictonary[‘surname’] = “Surname”print(my_dictonary[“age”])
95 構建迭代器
class OddNumbers:
def __iter__(self):
self.a = 1
return selfdef __next__(self):
x = self.a
self.a += 2
return xodd_numbers_object = OddNumbers()
iterator = iter(odd_numbers_object)print(next(iterator)) # 1
print(next(iterator)) # 3
print(next(iterator)) # 5
96 刪除列表的重複項
my_set = set([1, 2, 1, 2, 3, 4, 5])
print(list(my_set)) # [1, 2, 3, 4, 5]
97 列印模組的安裝位置
import pandasprint(pandas) # <module ‘torch’ from ‘/Users/…’
98 使用not in檢查一個值是否在列表中
odd_numbers = [1, 3, 5, 7, 9]
even_numbers = []for i in range(9):
if i not in odd_numbers:
even_numbers.append(i)print(even_numbers) # [0, 2, 4, 6, 8]
99 sort()和sorted()的區別
◆sort():對原始列表進行排序
◆sorted():返回一個新的排序列表
groceries = [‘milk’, ‘bread’, ‘tea’]new_groceries = sorted(groceries)
# new_groceries = [‘bread’, ‘milk’, ‘tea’]print(new_groceries)# groceries = [‘milk’, ‘bread’, ‘tea’]
print(groceries)groceries.sort()# groceries = [‘bread’, ‘milk’, ‘tea’]
print(groceries)
100 使用uuid模組生成唯一ID
UUID代表唯一識別符號。
import uuid# 根據主機ID、序列號和當前時間生成UUID
print(uuid.uuid1()) # 308490b6-afe4–11eb-95f7–0c4de9a0c5af# 生成一個隨機UUID
print(uuid.uuid4()) # 93bc700b-253e-4081-a358–24b60591076a