▍1、for迴圈中的else條件

這是一個for-else方法，迴圈遍歷列表時使用else語句。

下面舉個例子，比如我們想檢查一個列表中是否包含奇數。

那麼可以通過for迴圈，遍歷查詢。

numbers=[2,4,6,8,1]

fornumberinnumbers:
ifnumber%2==1:
print(number)
break
else:
print("Nooddnumbers")

如果找到了奇數，就會列印該數值，並且執行break語句，跳過else語句。

沒有的話，就不會執行break語句，而是執行else語句。

▍2、從列表中獲取元素，定義多個變數

my_list=[1,2,3,4,5]
one,two,three,four,five=my_list

▍3、使用heapq模組，獲取列表中n個最大或最小的元素

importheapq

scores=[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]

▍4、將列表中的所有元素作為引數傳遞給函式

我們可以使用 * 號，提取列表中所有的元素

my_list=[1,2,3,4]

print(my_list)#[1,2,3,4]
print(*my_list)#1234

如此便可以將列表中的所有元素，作為引數傳遞給函式

defsum_of_elements(*arg):
total=0
foriinarg:
total+=i

returntotal


result=sum_of_elements(*[1,2,3,4])
print(result)#10

▍5、獲取列表的所有中間元素

_,*elements_in_the_middle,_=[1,2,3,4,5,6,7,8]
print(elements_in_the_middle)#[2,3,4,5,6,7]

▍6、使用一行程式碼賦值多個變數

one,two,three,four=1,2,3,4

▍7、列表推導式

只用一行程式碼，便可完成對陣列的迭代以及運算。

比如，將列表中的每個數字提高一倍。

numbers=[1,2,3,4,5]
squared_numbers=[num*numfornuminnumbers]

print(squared_numbers)#[1,4,9,16,25]

推導式不僅列表能用，字典、集合、生成器也能使用。

下面看一下，使用字典推導式，將字典的值提高一倍。

dictionary={'a':4,'b':5}
squared_dictionary={key:num*numfor(key,num)indictionary.items()}

print(squared_dictionary)#{'a':16,'b':25}

▍8、通過Enum列舉同一標籤或一系列常量的集合

列舉是繫結到唯一的常量值的一組符號名稱(成員)。

在列舉中，成員可以通過身份進行比較，列舉本身可以迭代。

fromenumimportEnum


classStatus(Enum):
NO_STATUS=-1
NOT_STARTED=0
IN_PROGRESS=1
COMPLETED=2


print(Status.IN_PROGRESS.name)#IN_PROGRESS
print(Status.COMPLETED.value)#2

▍9、重複字串

name="Banana"
print(name*4)#BananaBananaBananaBanana

▍10、比較3個數字的大小

如果想比較一個值和其他兩個值的大小情況，你可以使用簡單的數學表示式。

1<x<10

這個是最簡單的代數表示式，在Python中也是可以使用的。

x=3

print(1<x<10)#True
print(1<xandx<10)#True

▍11、使用1行程式碼合併字典

first_dictionary={'name':'Fan','location':'Guangzhou'}
second_dictionary={'name':'Fan','surname':'Xiao','location':'Guangdong,Guangzhou'}

result=first_dictionary|second_dictionary

print(result)
#{'name':'Fan','location':'Guangdong,Guangzhou','surname':'Xiao'}

▍12、查詢元組中元素的索引

books=('Atomichabits','Egoistheenemy','Outliers','Mastery')

print(books.index('Mastery'))#3

▍13、將字串轉換為字串列表

假設你在函式中獲得輸出，原本應該是一個列表，但實際上卻是一個字串。

input="[1,2,3]"

你可能第一時間會想到使用索引或者正則表示式。

實際上，使用ast模組的literal_eval方法就能搞定。

importast


defstring_to_list(string):
returnast.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個數字之間的差值。

defsubtract(a,b):
returna-b


print((subtract(1,3)))#-2
print((subtract(3,1)))#2

上面的這個方法，需要考慮數值的先後順序。

defsubtract(a,b):
returna-b


print((subtract(a=1,b=3)))#-2
print((subtract(b=3,a=1)))#-2

使用命名引數，安排順序，這樣就不會出錯了。

▍15、用一個print()語句列印多個元素

print(1,2,3,"a","z","thisishere","hereissomethingelse")

▍16、在同一行列印多個元素

print("Hello",end="")
print("World")#HelloWorld

print("Hello",end="")
print("World")#HelloWorld

print('words','with','commas','in','between',sep=',')
#words,with,commas,in,between

▍17、列印多個值，在每個值之間使用自定義分隔符

print("29","01","2022",sep="/")#29/01/2022

print("name","domain.com",sep="@")#[email protected]

▍18、不能在變數名的開頭使用數字

four_letters="abcd"#thisworks

4_letters="abcd"#thisdoesn’twork

這是Python的變數命名規則。

▍19、不能在變數名的開頭使用運算子

+variable="abcd"#thisdoesn’twork

▍20、數字的第一位不能是0

number=0110#thisdoesn'twork

這個確實挺神奇的。

▍21、在變數名的任何地方使用下劃線

a______b="abcd"#thisworks
_a_b_c_d="abcd"#thisalsoworks

這並不意味著，你可以無限使用，為了程式碼的易讀性，還是需要合理使用。

▍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="Thisisjustasentence"
print(my_string[0:5])#This

#Takethreestepsforward
print(my_string[0:10:3])#Tsse

▍25、反向切片

my_string="Thisisjustasentence"
print(my_string[10:0:-1])#sujsisih

#Taketwostepsforward
print(my_string[10:0:-2])#sjsi

▍26、使用開始或結束索引進行切片

my_string="Thisisjustasentence"
print(my_string[4:])#isjustasentence

print(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_listissecond_list)
#False


third_list=first_list

print(third_listisfirst_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)#True

second="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))#4325215472

number=3
print(id(number))#4325215536
print(id(1))#4325215472

▍34、字串和元組也是不可變的

此處再說明一次。

name="Fatos"
print(id(name))#4422282544

name="fatos"
print(id(name))#4422346608

▍35、列表、集合和字典都是可變的

這意味著發生更改時，不會改變其記憶體物件。

cities=["Beijing","Guangzhou","chengdu"]
print(id(cities))#4482699712

cities.append("Beijing")
print(id(cities))#4482699712

下面是字典。

my_set={1,2,3,4}
print(id(my_set))#4352726176

my_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語句之前獨立存在。

defcheck_number(number):
ifnumber>0:
return"Positive"
elifnumber==0:
return"Zero"

return"Negative"


print(check_number(1))#Positive

▍38、使用sorted()檢查2個字串是否為相同

defcheck_if_anagram(first_word,second_word):
first_word=first_word.lower()
second_word=second_word.lower()
returnsorted(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:ifori,jindictionary.items()}
print(reversed)#{1:'a',2:'b',3:'c'}

▍43、將布林值轉換為數字

print(int(False))#0
print(float(True))#1.0

▍44、在算術運算中使用布林值

x=10
y=12

result=(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=lambdax:ifx>3:
print("x>3")
else:
print("xisnotgreaterthan3")

報錯。

▍49、Lambda中的條件語句應始終包含else語句

comparison=lambdax:"x>3"ifx>3

執行上面的程式碼，報錯。

這是由於條件表示式的特性，而不是lambda的導致的。

▍50、使用filter()，獲得一個新物件

my_list=[1,2,3,4]

odd=filter(lambdax: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(lambdax:x**2,my_list)

print(list(squared))#[1,4,9,16]
print(my_list)#[1,2,3,4]

▍52、range()的step引數

fornumberinrange(1,10,3):
print(number,end="")
#147

▍53、range()預設從0開始

defrange_with_zero(number):
foriinrange(0,number):
print(i,end='')


defrange_with_no_zero(number):
foriinrange(number):
print(i,end='')


range_with_zero(3)#012
range_with_no_zero(3)#012

▍54、不需要和0比較長度

如果長度大於0，則預設為True。

defget_element_with_comparison(my_list):
iflen(my_list)>0:
returnmy_list[0]


defget_first_element(my_list):
iflen(my_list):
returnmy_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、可以在同一個作用域內多次定義一個方法

但是，只有最後一個會被呼叫，覆蓋以前。

defget_address():
return"Firstaddress"


defget_address():
return"Secondaddress"


defget_address():
return"Thirdaddress"


print(get_address())#Thirdaddress

▍56、在外部直接訪問私有屬性

在定義屬性或方法時，在屬性名或者方法名前增加兩個下劃線，定義的就是私有屬性或方法。

如果想要在外部訪問，那麼只需要在名稱前面加上 '_類名' 變成 '_類名__名稱'。

classEngineer:
def__init__(self,name):
self.name=name
self.__starting_salary=62000


dain=Engineer('Dain')
print(dain._Engineer__starting_salary)#62000

▍57、檢查物件的記憶體使用情況

importsys

print(sys.getsizeof("bitcoin"))#56

▍58、定義一個方法，可以呼叫任意個引數

defget_sum(*arguments):
result=0
foriinarguments:
result+=i
returnresult


print(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函式呼叫父類的初始化方法。

classParent:
def__init__(self,city,address):
self.city=city
self.address=address


classChild(Parent):
def__init__(self,city,address,university):
super().__init__(city,address)
self.university=university


child=Child('Peking University','Fudan University','Tsinghua University')
print(child.university)#Tsinghua University

使用父類的名稱呼叫父類。

classParent:
def__init__(self,city,address):
self.city=city
self.address=address


classChild(Parent):
def__init__(self,city,address,university):
Parent.__init__(self,city,address)
self.university=university


child=Child('Peking University','Fudan University','Tsinghua University')
print(child.university)#Tsinghua University

▍60、在類中使用 + 操作符

在兩個int資料型別之間使用 + 運算子時，將得到它們的和。

而在兩個字串資料型別之間使用它時，會將其合併。

print(10+1)# 兩數相加
print('first'+'second')#字串相加

這個就是操作符過載，你還可以在類中使用(__add__)。

classExpenses:
def__init__(self,rent,groceries):
self.rent=rent
self.groceries=groceries

def__add__(self,other):
returnExpenses(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__方法。

classGame:
def__init__(self,score):
self.score=score

def__lt__(self,other):
returnself.score<other.score


first=Game(1)
second=Game(2)

print(first<second)#True

同樣的，== 操作符使用__eq__方法。

classJourney:
def__init__(self,location,destination,duration):
self.location=location
self.destination=destination
self.duration=duration

def__eq__(self,other):
return((self.location==other.location)and
(self.destination==other.destination)and
(self.duration==other.duration))


first=Journey('LocationA','DestinationA','30min')
second=Journey('LocationB','DestinationB','30min')

print(first==second)

還有一些其他的定義。

__sub__()for-
__mul__()for*
__truediv__()for/
__ne__()for!=
__ge__()for>=
__gt__()for>

▍62、為類的物件定義自定義的可列印版本

classRectangle:
def__init__(self,a,b):
self.a=a
self.b=b

def__repr__(self):
returnrepr('Rectanglewitharea='+str(self.a*self.b))


print(Rectangle(3,4))#'Rectanglewitharea=12'

▍63、交換字串中字元的大小寫

string="Thisisjustasentence."
result=string.swapcase()

print(result)#tHISISJUSTASENTENCE.

▍64、檢查字串是否都是空格

string=""
result=string.isspace()

print(result)#True

▍65、檢查字串是否都是字母或數字

name="Password"
print(name.isalnum())#True

name="SecurePassword"
print(name.isalnum())#False

name="S3cur3P4ssw0rd"
print(name.isalnum())#True

name="133"
print(name.isalnum())#True

▍66、檢查字串是否都是字母

string="Name"
print(string.isalpha())#True

string="FirstnameLastname"
print(string.isalpha())#False

string="P4ssw0rd"
print(string.isalpha())#False

▍67、根據引數刪除字元

從右側開始。

string="Thisisasentencewith"
print(string.rstrip())#"Thisisasentencewith"

string="thishereisasentence…..,,,,aaaaasd"
print(string.rstrip(".,dsa"))#"thishereisasentence"

同樣的，左側也能操作。

string="ffffffffFirst"
print(string.lstrip("f"))#First

▍68、檢查字串是否為數字

string="seven"
print(string.isdigit())#False

string="1337"
print(string.isdigit())#True

string="5a"
print(string.isdigit())#False

string="2**5"
print(string.isdigit())#False

▍69、檢查字串是否為中文數字

#42673
string="四二六七三"

print(string.isdigit())#False
print(string.isnumeric())#True

▍70、檢查字串是否所有單詞都是大寫開頭

string="Thisisasentence"
print(string.istitle())#False

string="10PythonTips"
print(string.istitle())#True

string="HowtoPrintAStringinPython"
#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="DataScience"

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、在函式裡輸出結果

defis_positive(number):
print("Positive"ifnumber>0else"Negative")#Positive


is_positive(-3)

▍82、if語句中的多個條件

math_points=51
biology_points=78
physics_points=56
history_points=72

my_conditions=[math_points>50,biology_points>50,
physics_points>50,history_points>50]

ifall(my_conditions):
print("Congratulations!Youhavepassedalloftheexams.")
else:
print("Iamsorry,butitseemsthatyouhavetorepeatatleastoneexam.")
#Congratulations!Youhavepassedalloftheexams.

▍83、在一個if語句中，至少滿足多個條件中的一個

math_points=40
biology_points=78
physics_points=56
history_points=72

my_conditions=[math_points>50,biology_points>50,
physics_points>50,history_points>50]

ifany(my_conditions):
print("Congratulations!Youhavepassedalloftheexams.")
else:
print("Iamsorry,butitseemsthatyouhavetorepeatatleastoneexam.")
#Congratulations!Youhavepassedalloftheexams.

▍84、任何非空字串都為True

print(bool("Nonempty"))#True
print(bool(""))#False

▍85、任何非空列表、元組、字典都為True

print(bool([]))#False
print(bool(set([])))#False

print(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"


defdo_nothing():
string="insideamethod"


do_nothing()

print(string)#string

可通過修飾符global，修改全域性變數的值。

string="string"


defdo_nothing():
globalstring
string="insideamethod"


do_nothing()

print(string)#insideamethod

▍88、計算字串或列表中元素的數量

使用collections中的Counter計算字串或列表中元素的數量。

fromcollectionsimportCounter

result=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()方法。

fromcollectionsimportCounter


defcheck_if_anagram(first_string,second_string):
first_string=first_string.lower()
second_string=second_string.lower()
returnCounter(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()方法。

defcheck_if_anagram(first_word,second_word):
first_word=first_word.lower()
second_word=second_word.lower()
returnsorted(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計算元素的數量

fromitertoolsimportcount

my_vowels=['a','e','i','o','u','A','E','I','O','U']

current_counter=count()

string="Thisisjustasentence."

foriinstring:
ifiinmy_vowels:
print(f"Currentvowel:{i}")
print(f"Numberofvowelsfoundsofar:{next(current_counter)}")

輸出如下。

Currentvowel:i
Numberofvowelsfoundsofar:0
Currentvowel:i
Numberofvowelsfoundsofar:1
Currentvowel:u
Numberofvowelsfoundsofar:2
Currentvowel:a
Numberofvowelsfoundsofar:3
Currentvowel:e
Numberofvowelsfoundsofar:4
Currentvowel:e
Numberofvowelsfoundsofar:5
Currentvowel:e
Numberofvowelsfoundsofar:6

▍91、對字串或列表的元素進行次數排序

collections模組的Counter()，預設情況下是不會根據元素的頻率對它們進行排序的。

fromcollectionsimportCounter

result=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]=831

print(first_list)#[[1,2,831],['a','b','c']]
print(second_list)#[[1,2,831],['a','b','c']]

這裡是一個deepcopy()的例子。

importcopy

first_list=[[1,2,3],['a','b','c']]

second_list=copy.deepcopy(first_list)

first_list[0][2]=831

print(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()，程式碼將不會報錯。

fromcollectionsimportdefaultdict

my_dictonary=defaultdict(str)
my_dictonary['name']="Name"
my_dictonary['surname']="Surname"

print(my_dictonary["age"])

▍95、構建迭代器

classOddNumbers:
def__iter__(self):
self.a=1
returnself

def__next__(self):
x=self.a
self.a+=2
returnx


odd_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、列印模組的安裝位置

importpandas

print(pandas)#<module'torch'from'/Users/...'

▍98、使用not in檢查一個值是否在列表中

odd_numbers=[1,3,5,7,9]
even_numbers=[]

foriinrange(9):
ifinotinodd_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代表唯一識別符號。

importuuid

#根據主機ID、序列號和當前時間生成UUID
print(uuid.uuid1())#308490b6-afe4-11eb-95f7-0c4de9a0c5af

#生成一個隨機UUID
print(uuid.uuid4())#93bc700b-253e-4081-a358-24b60591076a