作者:黑馬程序員Python
鏈接:https://www.zhihu.com/question/67206574/answer/2571909581
來源:知乎
著作權歸作者所有.商業轉載請聯系作者獲得授權,非商業轉載請注明出處.
Python 允許我們在一行中為多個變量賦值.變量可以用逗號分隔.在一行中為變量多重賦值有很多好處.它可用於為多個變量分配多個值,或為單個變量分配多個值.讓我們來看一個問題陳述,其中,我們必須給變量 a 和 b 賦值 50 和 60.通常的代碼如下所示:
a = 50
b = 60
print(a,b)
print(type(a))
print(type(b))
輸出
50 60
<class 'int'>
<class 'int'>
條件 I:等於變量的值
當變量和多個賦值的值相等時,每個值將存儲在所有變量中.
a , b = 50 , 60
print(a,b)
print(type(a))
print(type(b))
輸出
50 60
<class 'int'>
<class 'int'>
這兩個代碼都給出了相同的結果.這就是使用一行賦值的好處.
條件 II:大於變量的值
讓我們嘗試增加前一個代碼中的值的數量.可以將多個值賦給單個變量.將多個值賦給一個變量時,必須在變量名前使用星號.
a , *b = 50 , 60 , 70
print(a)
print(b)
print(type(a))
print(type(b))
輸出
50
[60, 70]
<class 'int'>
<class 'list'>
第一個值將分配給第一個變量,第二個變量將從給定值中獲取一組值.這將創建一個列表類型對象.
條件 III:一個值分配給多個變量
我們可以將一個值賦給多個變量.每個變量將使用等號來分隔.
a = b = c = 50
print(a,b,c)
print(type(a))
print(type(b))
print(type(c))
輸出
50 50 50
<class 'int'>
<class 'int'>
<class 'int'>
交換是兩個變量的值相互交換的過程.這在計算機科學的許多操作中都很有用.在這裡,我編寫了程序員用來交換值以及最佳解決方案的兩個主要方法.
方法 I:使用臨時變量
此方法使用一個臨時變量來存儲一些數據.以下代碼是用臨時變量名編寫的.
a , b = 50 , 60
print(a,b)
temp = a+b #a=50 b=60 temp=110
b = a #a=50 b=50 temp=110
a = temp-b #a=60 b=50 temp=110
print("After swapping:",a,b)
輸出
50 60
After swapping: 60 50
方法 II:不使用臨時變量
下面的代碼是在不使用臨時變量的情況下交換變量.
a , b = 50 , 60
print(a,b)
a = a+b #a=110 b=60
b = a-b #a=110 b=50
a = a-b #a=60 b=50
print("After swapping:",a,b)
輸出
50 60
After swapping: 60 50
方法 III:Python 中的最佳解決方案
這是使用 Python 交換變量的另一種方法.在上個技巧中,我們已經了解了多重賦值我們可以使用交換的概念.
a , b = 50 , 60
print(a,b)
a , b = b , a
print("After swapping",a,b)
輸出
50 60
After swapping 60 50
在 Python 中反轉字符串還有一個很酷的技巧.用於反轉字符串的概念成為字符串切片.任何字符串都可以在變量名之後使用符號 [::-1] 進行反轉.
my_string = "MY STRING"
rev_string = my_string[::-1]
print(rev_string)
輸出
GNIRTS YM
在一行中拆分單詞不需要特殊的算法.為此,我們可以使用關鍵字 split().在這裡,我編寫了兩種拆分單詞的方法.
方法 I:使用迭代
my_string = "This is a string in Python"
start = 0
end = 0
my_list = []
for x in my_string:
end=end+1
if(x==' '):
my_list.append(my_string[start:end])
start=end+1
my_list.append(my_string[start:end+1])
print(my_list)
輸出
['This ', 'is ', 'a ', 'string ', 'in ', 'Python']
方法 II:使用 split 函數
my_string = "This is a string in Python"
my_list = my_string.split(' ')
print(my_list)
輸出
['This ', 'is ', 'a ', 'string ', 'in ', 'Python']
這是與上一個部分相反的過程中.在這個部分中,我們將使用 join 函數將單詞列表轉換為單行.下面給出了使用 join 函數的語法.
語法:"".join(string)
my_list = ['This' , 'is' , 'a' , 'string' , 'in' , 'Python']
my_string = " ".join(my_list)
輸出
This is a string in Python
我們可以使用乘法運算符多次打印字符串.這是重復字符串的一種非常有效的方法.
n = int(input("How many times you need to repeat:"))
my_string = "Python\n"
print(my_string*n)
輸出
How many times you need to repeat:3
Python
Python
Python
可以在不使用 join 函數的情況下連接各種字符串.我們可以使用加法運算符(+)來完成這個操作.
a = "I Love "
b = "Python"
print(a+b)
輸出
I Love Python
在一個程序中結合兩個或多個條件運算符,我們可以使用邏輯運算符.但是,通過連接操作符也可以得到同樣的結果.例如,當一個變量的值大於 10 且小於 20 時,打印某些內容,則代碼將如下所示:
a = 15
if (a>10 and a<20):
print("Hi")
取而代之的是,我們可以將條件運算符組合成單個表達式:
a = 15
if (10 < a < 20):
print("Hi")
輸出
Hi
在列表中出現次數最多的元素,那麼它將是列表中最頻繁的元素.下面的代碼片段將幫助你從列表中獲取最頻繁的元素.
my_list = [1,2,3,1,1,4,2,1]
most_frequent = max(set(my_list),key=my_list.count)
print(most_frequent)
輸出
1
前面的代碼將給出最頻繁的值.如果需要知道列表中所有唯一元素的出現次數,那麼可以使用 collections 模塊.collections 是 Python 中一個非常棒的模塊,它提供了很多特性.Counter 方法提供了一個包含元素和出現項對的字典.
from collections import Counter
my_list = [1,2,3,1,4,1,5,5]
print(Counter(my_list))
輸出
Counter({1: 3, 5: 2, 2: 1, 3: 1, 4: 1})
如果一個字符串由另一個字符串中的字符組成,那麼這兩個字符串就是易位構詞(Anagram).我們可以使用來自 collections 模塊的相同的 Counter 方法.
from collections import Counter
my_string_1 = "RACECAR"
my_string_2 = "CARRACE"
if(Counter(my_string_1) == Counter(my_string_2)):
print("Anagram")
else:
print("Not Anagram")
輸出
Anagram
函數 range() 對於創建數字序列很有用.它在許多代碼片段中都很有用.Range 函數的語法如下:
語法:range(start, end, step)
讓我們試著創建一個偶數列表.
my_list = list(range(2,20,2))
print(my_list)
輸出
[2, 4, 6, 8, 10, 12, 14, 16, 18]
與字符串乘法類似,我們可以使用乘法運算符多次創建一個用元素填充的列表.
my_list = [3]
my_list = my_list*5
print(my_list)
輸出
[3, 3, 3, 3, 3]
在大多數情況下,我們在 Python 中使用嵌套的條件結構.可以用三元運算符代替單行,而不是使用嵌套結構.語法如下所示.
語法:Statement1 if True else Statement2
age = 25
print("Eligible") if age>20 else print("Not Eligible")
輸出
Eligible
列表理解(List Comprehension)是從另一個列表中創建列表的一種非常緊湊的方式.請看以下代碼.第一個是使用簡單迭代編寫的,第二個是使用列表理解創建的.
square_list = []
for x in range(1,10):
temp = x**2
square_list.append(temp)
print(square_list)
輸出
[1, 4, 9, 16, 25, 36, 49, 64, 81]
使用列表理解
square_list = [x**2 for x in range(1,10)]
print(square_list)
輸出
[1, 4, 9, 16, 25, 36, 49, 64, 81]
函數 frozenset()用於將可變迭代對象轉換為不可變對象.使用這個函數,我們可以凍結一個對象,而不改變它的值.
my_list = [1,2,3,4,5]
my_list = frozenset(my_list)
my_list[3]=7
print(my_list)
輸出
Traceback (most recent call last):
File "<string>", line 3, in <module>
TypeError: 'frozenset' object does not support item assignment
當我們在列表中應用 frozenset() 函數時,項目分配是受限的.
Floor 和 Ceil 是數學函數,可用於浮點數.Floor 函數返回小於浮點值的整數,而 Ceil 函數返回大於浮點值的整數.要是用這個函數,我們必須導入 math 模塊.
import math
my_number = 18.7
print(math.floor(my_number))
print(math.ceil(my_number))
輸出
18
19
有時我們必須通過檢查某些參數的條件來返回布爾值.我們可以直接返回條件,而不是寫 if else 語句.下面的代碼將產生相同的輸出.
方法 I:使用 If Else 條件
def function(n):
if(n>10):
return True
else:
return False
n = int(input())
if(function(n)):
print("Eligible")
else:
print("Not Eligible")
方法 II:不使用 If Else 條件
def function(n):
return n>10
n = int(input())
print("Eligible") if function(n) else print("Not Eligible")
輸出
11
Eligible
Lambda 是 Python 中的一個匿名函數,它可以在一行中創建函數.下面給出了使用 Lambda 函數的語法.
語法:lambda arguments: expression
x = lambda a,b,c : a+b+c
print(x(10,20,30))
輸出
60
Map 是一個高階函數,它為列表中所有元素應用特定的函數.
語法:map(function, iterable)
my_list = ["felix", "antony"]
new_list = map(str.capitalize,my_list)
print(list(new_list))
輸出
['Felix', 'Antony']
這個函數可以用 Python 中的 Lambda 函數替換.下面的代碼用於創建數字列表的平方.
my_list = [1, 2, 3, 4, 5]
new_list = map(lambda x: x*x, my_list)
print(list(new_list))
輸出
[1, 4, 9, 16, 25]
一個 Python 函數可以返回多個值,而不需要任何額外的需求.我們可以通過逗號分隔這些來返回值.
def function(n):
return 1,2,3,4
a,b,c,d = function(5)
print(a,b,c,d)
輸出
1 2 3 4
Filter 函數用於過濾可迭代對象中的一些值.Filter 函數的語法如下所示.
語法:filter(function, iterable)
def eligibility(age):
return age>=24
list_of_age = [10, 24, 27, 33, 30, 18, 17, 21, 26, 25]
age = filter(eligibility, list_of_age)print(list(age))
輸出
[24, 27, 33, 30, 26, 25]
在 Python 中,我們可以合並兩個字典,而不需要任何特定的方法.下面的代碼是合並兩個字典的示例.
dict_1 = {'One':1, 'Two':2}
dict_2 = {'Two':2, 'Three':3}
dictionary = {**dict_1, **dict_2}
print(dictionary)
輸出
{'One': 1, 'Two': 2, 'Three': 3}
內存的大小根據對象的類型的不同而不同.我們可以使用 sys 模塊中的 getsizeof() 函數來獲取對象的內存.
import sys
a = 5
print(sys.getsizeof(a))
輸出
28
Zip 函數在 Python 中有很多優點,使用 zip 函數,可以從兩個列表中創建詞典.
list_1 = ["One","Two","Three"]
list_2 = [1,2,3]
dictionary = dict(zip(list_1, list_2))
print(dictionary)
輸出
{'Two': 2, 'One': 1, 'Three': 3}
Time 是 Python 中另一個有用的模塊,可以用來計算執行時間.
import time
start = time.clock()
for x in range(1000):
pass
end = time.clock()
total = end - start
print(total)
輸出
0.00011900000000000105
出現多次的元素稱為重復元素.我們可以簡單地使用 typecasting 來刪除重復的元素.
my_list = [1,4,1,8,2,8,4,5]
my_list = list(set(my_list))
print(my_list)
輸出
[8, 1, 2, 4, 5]
Calendar 模塊有許多與日期的操作相關的功能.我們可以使用以下代碼來打印月歷.
import calendar
print(calendar.month("2020","06"))
輸出
June 2020
Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30
Zip 函數支持使用循環迭代多個可迭代的過程.在下面的代碼中,兩個列表同時被迭代.
list_1 = ['a','b','c']
list_2 = [1,2,3]
for x,y in zip(list_1, list_2):
print(x,y)
輸出
a 1
b 2
c 3