新手學習Python需要知道的100個小技巧，加班一晚上終於整理出來了！

哈嘍兄弟們，今天給大家分享一下Python初學需要知道的100個小技巧~ 1、for迴圈中的else條件這是一個for-else方法，迴圈遍歷列表時使用else語句。下麵舉個例子，比如我們想檢查一個列表中是否包含奇數。那麼可以通過for迴圈，遍歷查找。 numbers = [2, 4, 6, 8, ...

哈嘍兄弟們，今天給大家分享一下Python初學需要知道的100個小技巧~

1、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語句。

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

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

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

import heapq
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)  # 1 2 3 4

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

def sum_of_elements(*arg):
    total = 0
    for i in arg:
        total += i

    return total

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

# 兄弟們學習python，有時候不知道怎麼學，從哪裡開始學。掌握了基本的一些語法或者做了兩個案例後，不知道下一步怎麼走，不知道如何去學習更加高深的知識。
# 那麼對於這些小伙伴們，我準備了大量的免費視頻，PDF電子書籍，以及源代碼！
# 直接在這個Q君羊 872937351 自取就好了

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 * 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}

8、通過Enum枚舉同一標簽或一系列常量的集合
枚舉是綁定到唯一的常量值的一組符號名稱(成員)。在枚舉中，成員可以通過身份進行比較，枚舉本身可以迭代。

from enum import Enum

class Status(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 < 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_dictionary

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

def 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 - b
print((subtract(1, 3)))  # -2
print((subtract(3, 1)))  # 2

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

def subtract(a, b):
    return a - b

print((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")  # HelloWorld
print("Hello", end=" ")
print("World")  # Hello World
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" # this works
4_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 sentence

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_list is second_list)  
# False
third_list = first_list
print(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)  # 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語句之前獨立存在。

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 = 12
result = (x - False)/(y * True)
print(result)  # 0.833333333333333

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 = 62000


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

57、檢查對象的記憶體使用情況

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

58、定義一個方法，可以調用任意個參數

def get_sum(*arguments):
    result = 0
    for i in arguments:
        result += i
    return result

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函數調用父類的初始化方法。

class Parent:
    def __init__(self, city, address):
        self.city = city
        self.address = address


class Child(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

使用父類的名稱調用父類

class Parent:
    def __init__(self, city, address):
        self.city = city
        self.address = address


class Child(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)。

class Expenses:
    def __init__(self, rent, groceries):
        self.rent = rent
        self.groceries = groceries

    def __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 = score

    def __lt__(self, other):
        return self.score < other.score

first = 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 = duration

    def __eq__(self, other):
        return ((self.location == other.location) and
                (self.destination == other.de