作者的話：

再梳理一遍Python系列知識點，夯實基礎(chǔ)，無他，唯手熟爾！

Python系列總結(jié)都是我自己平時的學習筆記，如果有不正確的地方，希望各位佬兒哥指正糾偏~

變量名命名規(guī)則 - 遵循PEP8原則

變量注解

在Python3.5之后，可以使用類型注解功能來注明變量類型，在變量后添加類型，并用冒號隔開；

算術(shù)運算符

不同類型變量之間的計算

獲取輸入的信息-input

input 輸入的數(shù)據(jù)類型都是字符串類型

格式化輸出

vb1 = 'Tom'print('hello %s' % vb1)vb2 = 5print('有符號十進制整數(shù)：%d' % vb2)print('輸出顯示位數(shù)的整數(shù)：%06d' % vb2)vb3 = 3.1415926print('保留兩位小數(shù)：%.2f' % vb3)print('保留三位小數(shù)：%.3f' % vb3)vb4 = 80print('正確率為：%d%%' % vb4)--------------------------------------------------------------------hello Tom有符號十進制整數(shù)：5輸出顯示位數(shù)的整數(shù)：000005保留兩位小數(shù)：3.14保留三位小數(shù)：3.142正確率為：80%

邏輯運算

循環(huán)-while

初始條件設(shè)置 -- 通常是重復執(zhí)行的 計數(shù)器
while 條件 1:
條件滿足時，做的事情 1
條件滿足時，做的事情 2
條件滿足時，做的事情 3
……
while 條件 2:
條件滿足時，做的事情 1
條件滿足時，做的事情 2
條件滿足時，做的事情 3
……
處理條件 2
處理條件 1

print 函數(shù)增強

在默認情況下，print 函數(shù)輸出內(nèi)容之后，會自動在內(nèi)容末尾增加換行；
如果不希望末尾增加換行，可以在 peint 函數(shù)輸出內(nèi)容的后面增加,end=''
其中''中間可以指定 print 函數(shù)輸出內(nèi)容之后，繼續(xù)希望現(xiàn)實的內(nèi)容；
語法格式如下：
print('*',end='')

轉(zhuǎn)義字符

列表

元祖

元組和列表之間的轉(zhuǎn)換

字典

Python3.6 之后的字典是有序的，如果解釋器版本沒有那么新，也可以使用 collections 模塊里的 OrderedDict 方法保證字典的有序性。
OrderedDict 與新版字典在比較上面的區(qū)別：在對比兩個內(nèi)容相同但順序不同的字典時，新版字典會返回 True，OrderedDict 則會返回 False。

字符串

字符串 - 切片

指定的區(qū)間屬于左閉右開型 [開始索引, 結(jié)束索引) => 開始索引 >= 范圍 < 結(jié)束索引
從 起始位開始，到 結(jié)束位的前一位 結(jié)束（不包含結(jié)束位本身)
從頭開始，開始索引 數(shù)字可以省略，冒號不能省略
到末尾結(jié)束，結(jié)束索引 數(shù)字可以省略，冒號不能省略
步長默認為 1，如果連續(xù)切片，數(shù)字和冒號都可以省略
索引的順序和倒序：
在 Python 中不僅支持 順序索引，同時還支持 倒序索引
所謂倒序索引就是 從右向左 計算索引
最右邊的索引值是 -1，依次遞減

字符串格式化

# 將username靠右對齊，左側(cè)補空格一共到20位username = 'Lili'print(f'{username:>20}')-------------------------------------
                Lili

集合

s1 = set([1,2,3])s2 = set([2,3,4])s1.update(s2)s1.update('hello')print(s1)------------------------{1, 2, 3, 4, 'o', 'h', 'e', 'l'}

集合的運算

集合支持集合運算，比如交集、并集、差集。所有的操作都可以用兩種方式：方法和運算符；

fruits_1 = {'apple','orange','pineapple'}fruits_2 = {'tomato','orange','grapes','mango'}print(fruits_1 & fruits_2)-----------------------------{'orange'}

fruits_1 = {'apple','orange','pineapple'}fruits_2 = {'tomato','orange','grapes','mango'}print(fruits_1 - fruits_2)------------------------------------{'apple', 'pineapple'}

fruits_1 = {'apple','orange','pineapple'}fruits_2 = {'apple','orange','pineapple','water'}print(fruits_1.issubset(fruits_2))print(fruits_2.issubset(fruits_1))--------------------------------------------------TrueFalse

Python 循環(huán)結(jié)構(gòu)

匿名函數(shù)-lambda

類

類定義

類方法

類的三大特征

類的反射

異常處理

Python 異常處理依賴的關(guān)鍵字：
try
except
else
finally

IO 讀寫 - 文本文件

其余相關(guān)知識點附張圖吧：

多線程和多進程編程

GIL 全局解釋器鎖

什么是 GIL 全局解釋器鎖：
GIL（Global Interpreter Lock）是 Python 的一個重要特性，它是一種機制，用于保護多線程環(huán)境下共享內(nèi)存數(shù)據(jù)的完整性。它鎖定了整個解釋器，只允許一個線程同時執(zhí)行 Python 字節(jié)碼，從而避免多線程下出現(xiàn)數(shù)據(jù)競爭問題。這意味著即使使用多核 CPU，Python 程序也不能充分利用多核優(yōu)勢。GIL 在性能上可能帶來一定的影響，因此不適合處理需要大量的 CPU 運算的任務(wù)。

什么條件下會釋放 GIL：
當前活躍線程遇到 IO 等待，比如要訪問網(wǎng)絡(luò)或建立數(shù)據(jù)庫鏈接等情況;
活躍線程執(zhí)行了 100 個字節(jié)碼的程序后，GIL 也會釋放該線程的鎖，然后與其他線程參與競爭;

python 的多線程適合場景：
python 的多線程只適合于 IO 密集型應用，對于計算密集型的應用最好使用多進程或協(xié)程的方式解決；

可迭代對象

迭代器

迭代器和可迭代對象的區(qū)別

生成器

裝飾器

正則表達式

正則表達式匹配步驟：
1.import re
2.用 re.compile() 函數(shù)創(chuàng)建一個 Regex 對象（記得使用原始字符串）
3.向 Regex 對象的 search() 方法傳入想查找的字符串。它返回一個 Match 對象（一般用 mo 接收）
4.調(diào)用 Match 對象的 group() 方法，返回實際匹配的字符串
demo：

import re>>> phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')>>> mo = phoneNumRegex.search('my number is 415-555-4242.')>>> mo.group(1)'415'>>> mo.group(2)'555-4242'>>> mo.group()'415-555-4242'>>> mo.group(0)'415-555-4242'

PLus：

我在學習中，發(fā)現(xiàn)正則表達式在任何語言中都占有很大部分的占比，但正則表達式相關(guān)的知識點又過于零碎，對于榆木腦袋的我真是學一遍忘一遍。在實際工作中，我自己真正用到正則的地方并不多，再看同事，目前就發(fā)現(xiàn)前端同學有可能會用到正則去做一些事情，并且用到的時候都是度娘，一是自己真記不住，二是度娘 copy 過來的多數(shù)情況是比自己寫要嚴謹?shù)亩嗟摹?/span>

基于此，我把正則視為投入產(chǎn)出比太低的事情，僅需要記住個大概印象，真到用時能分清度娘上哪個輪子能用哪個輪子用不了就可以了。

常用模塊-math

import math

常用模塊-random

import random

常用模塊-json

常用模塊-time

import timen = time.time()print(n)n1 = round(n,3)print(n1)------------------------1675392067.29749661675392067.297

常用模塊-datetime()

import datetimeimport timenow = time.time()date = datetime.datetime.fromtimestamp(now)print(now)print(date)----------------------------------------------------------------------------1675393953.08603122023-02-03 11:12:33.086031

import datetimeimport timed1 = datetime.datetime.now()time.sleep(1)d2 = datetime.datetime.now()d3 = d2 -d1print(d3)print(type(d3))------------------------------------------------0:00:01.002022<class 'datetime.timedelta'>

import datetimedt = datetime.datetime.now()print(dt)thounsandDays = datetime.timedelta(days=1000)print(thounsandDays)print(dt + thounsandDays)------------------------------------------------------------------------------2023-02-06 14:20:46.2650841000 days, 0:00:002025-11-02 14:20:46.265084

常用模塊-logging

Logging 庫是非常常用的記錄日志庫，通過 logging 模塊存儲各種格式的日志，主要用于輸出運行日志，可以設(shè)置輸出日志的等級、日志保存路徑、日志文件回滾等;

import logginglogging.basicConfig(filename='myProgramLog',format='%(levelname)s %(asctime)s: %(message)s: %(module)s',level=logging.DEBUG)logging.debug('This message should appear on the console')logging.info('So should this')logging.warning('And this, too')

常用模塊-threading

import timeimport threadingprint('Start of program.')def takeANap():
    time.sleep(5)
    print('Wake up!')threadObj = threading.Thread(target=takeANap)threadObj.start()print('End of program')----------------------------------------------------------------------------Start of program.End of programWake up!

注意：target 參數(shù)名后傳的是方法名，不加 ()，因為此處并不是調(diào)用。

import threadingd = {'name': 'Tom', 'age': 18}def b(**kwargs):
    for k, v in kwargs.items():
        print(str(k) + ':' + str(v))thread_b = threading.Thread(target=b, kwargs=d)thread_b.start()----------------------------------------------------------------------------name:Tomage:18

# 使用join，線程b需要等線程a運行完后再運行import timeimport threadingdef a():
    time.sleep(1)
    print('我是a：1/3')
    time.sleep(1)
    print('我是a：2/3')
    time.sleep(1)
    print('我是a：3/3')def b():
    print('我是b：1/2')
    print('我是b：2/2')thread_a = threading.Thread(target=a)thread_b = threading.Thread(target=b)thread_a.start()thread_a.join()thread_b.start()--------------------------------------------------------------我是a：1/3我是a：2/3我是a：3/3我是b：1/2我是b：2/2

深拷貝淺拷貝

不可變數(shù)據(jù)類型（如整型，字符串等）在 Python 中只是拷貝了值，因此在執(zhí)行淺拷貝時實際上是創(chuàng)建了一個新的副本，而不是拷貝引用。因此，對原數(shù)據(jù)的更改不會影響到拷貝后的數(shù)據(jù)。

import copya = 1000b = ac = copy.copy(a)d = copy.deepcopy(a)print(a, b, c, d)print(id(a), id(b), id(c), id(d))a += 1print(a, b, c, d)print(id(a), id(b), id(c), id(d))----------------------------------------------1000 1000 1000 10002518799374640 2518799374640 2518799374640 25187993746401001 1000 1000 10002518805613936 2518799374640 2518799374640 2518799374640

對于可變數(shù)據(jù)類型，淺拷貝只拷貝第一層中的引用，深拷貝在拷貝時，會逐層進行拷貝，直到所有的引用都是不可變對象為止。

對象的可哈希性

注意：只有可哈希對象才能被放進集合或者作為字典的鍵

sorted() 函數(shù)

sorted 函數(shù)是 Python 內(nèi)置函數(shù)，用于對可迭代對象進行排序，并返回一個新的列表。
注意：sorted 函數(shù)不會改變原來的可迭代對象，而是返回一個新的列表。如果需要改變原來的可迭代對象，可以使用 sort 方法，但它只能用于列表。
參數(shù)：

enumerate() 函數(shù)

enumerate() 適用于任何'可迭代對象'，可以用于列表、元祖、字典、字符串等。

def enumerate_func():
    names = ['lily','wenwen','tom']
    for index, s in enumerate(names,start=1):
        print(index,s)---------------------------------------------1 lily2 wenwen3 tom

如果不指定 start 參數(shù)，則 index 從 0 開始

浮點數(shù)精度問題

可以使用 decimal 模塊解決浮點數(shù)精度問題：

from decimal import Decimalprint(Decimal('0.1') + Decimal('0.2'))print(type(Decimal('0.1') + Decimal('0.2')))print(type(Decimal('0.1')))---------------------------------------------------------0.3<class 'decimal.Decimal'>
<class 'decimal.Decimal'>

注意：在使用 Decimal 時要用字符串來表示數(shù)字

布爾值其實也是數(shù)字

不常用但特別好用的字符串方法

s = 'TomAndMarry's2 = s.partition('And')print(s2)--------------------------------('Tom ', 'And', ' Marry')

使用枚舉類型來替代字面量

# 用戶每日獎勵積分數(shù)量DAILY_POINTS_REWARDS = 100# VIP用戶額外獎勵20VIP_EXTRA_POINTS = 20from enum import Enumclass UserType(int, Enum):
    # VIP用戶    VIP = 3
    # 小黑屋用戶    BANNED = 13def add_daily_points(user):
    '''用戶每天第一次登錄增加積分'''
    if user.type == UserType.BANNED:
        return
    if user.type == UserType.VIP:
        user.points += DAILY_POINTS_REWARDS + VIP_EXTRA_POINTS
        return
    user.points += DAILY_POINTS_REWARDS
    return

生成器

因為每次調(diào)用生成器函數(shù)都會生成一個新的生成器對象，所以以上程序運行結(jié)果會輸出三個 apple

fruits = {'apple','orange','pineapple'}def batch(item):
    for _ in item:
        yield _g = batch(fruits)print(next(g))print(next(g))print(next(g))-------------------------------------------------pineappleappleorange

以上代碼再次驗證了'每次調(diào)用生成器函數(shù)都會生成一個新的生成器對象'結(jié)論

面向?qū)ο缶幊?/strong>

內(nèi)置類方法裝飾器

class FilePath:
    @property
    def basename(self):
        ....
    @property.setter
    def basename(self, name):
        ....
    @property.deleter
    def basename(self):
        ....

經(jīng)過@property的裝飾以后，basename 已經(jīng)從一個普通的方法變成了 property 對象，所以可以使用 basename.setter 和 basename.deleter 方法;
定義 setter 方法，該方法會在對屬性賦值是被調(diào)用;
定義 deleter 方法，該方法會在刪除屬性時被調(diào)用;

鴨子類型及其局限性

抽象類

多重繼承于MRO

學習建議

對于Python入門及進階，我推薦兩本我認為值得多次閱讀的書籍：

• 《Python編程從入門到實踐（第二版）》- 第一部分為基礎(chǔ)語法部分，建議剛接觸 Python 的同學多次閱讀并實踐，夯實基礎(chǔ)利器！

• 《Python工匠》- 整本無尿點，強烈建議多次閱讀并實踐，是Python進階的不二之選！

nums = [10, 2, 3, 21, 10, 3]def ordered_dict(member: list[int]):
    from collections import OrderedDict
    result = list(OrderedDict.fromkeys(member).keys())
    return resultprint(ordered_dict(nums))----------------------------------------------------[10, 2, 3, 21]

from itertools import productprint(list(product([1,2],[3,4])))----------------------------------------[(1, 3), (1, 4), (2, 3), (2, 4)]

# 方法1：使用enumeratedef parse_titles(filename):
    '''從各行數(shù)據(jù)文件中取數(shù)據(jù)'''
    with open(filename, 'r') as fp:
        for i, line in enumerate(fp):
            if i % 2 == 0:
                yield lineif __name__ == '__main__':
    message_generator = parse_titles('logs.txt')
    while True:
        try:
            print(next(message_generator))
        except StopIteration as e:
            break

但如果需求變更為每隔3行讀取或者每隔4行讀取，那我們按照以上的寫法應該怎么篩選呢？

如果需求變更為每隔3行讀取或者每隔4行讀取，我們只需要將 islice(seq, start, end, step) 中的 step 改成3或者4就行了

面對洋洋灑灑的知識點，我往往 “一看就會，一寫就廢”，為了更有針對性的加深知識點的印象，接下來，我將以做題的形式繼續(xù)總結(jié)Python系列，如果有不正確的地方，希望各位佬兒哥指正糾偏：

1.列表的增刪查改？

2.字典的增刪查改？

d1 = {'name': 'Tom', 'age': 25}print(d1.keys())print(type(d1.keys()))print()print(d1.values())print(type(d1.values()))print()print(d1.items())print(type(d1.items()))------------------------------------------------dict_keys(['name', 'age'])<class 'dict_keys'>

dict_values(['Tom', 25])
<class 'dict_values'>

dict_items([('name', 'Tom'), ('age', 25)])
<class 'dict_items'>

d[key] = value
d1.update(d2) ---將 d2 更新到 d1 中，相同的 key 則更改 d1 中的 value

3.元祖的增刪查改

因為元祖是不可變數(shù)據(jù)類型，所以不能不能在原元祖新增

del t ---不能 del t[idx]，否則報錯：TypeError: 'tuple' object doesn't support item deletion

t[idx] ---idx 不能越界，否則報錯：IndexError: tuple index out of range
可遍歷元祖

for _ in t:
    print(_)

t.count(value) ---返回元祖中 value 的個數(shù)，value 不存在返回 0
t.index(value) ---返回元祖中首個 value 的索引，value 不存在則報錯：ValueError: tuple.index(x): x not in tuple

元組是不可變的，因此不能修改元組中的任何元素。

4.例舉Python6種基本的數(shù)據(jù)類型，并標出哪些是不可變數(shù)據(jù)類型？

整形-int-不可變、浮點型-float-不可變、字符型-str-不可變、列表-list-可變、元祖-tuple-不可變、字典-dict-可變

5.請說明循環(huán)結(jié)構(gòu)和異常處理中的 else 在什么情況下會執(zhí)行？

在 for.else 循環(huán)結(jié)構(gòu)中，當循環(huán)提全部循環(huán)完畢后，沒有 break 或者 return 的情況下，會執(zhí)行 else 代碼段；
在異常處理中，try 下的代碼段沒有出現(xiàn)異常的情況下，會執(zhí)行 else 代碼

條件分支語句用 else 來表示'否則執(zhí)行某件事'

6.列舉python函數(shù)定義中有哪些不同的參數(shù)類型？

1.位置參數(shù)：根據(jù)參數(shù)在函數(shù)定義中的位置來確定。
2.默認參數(shù)：在函數(shù)定義中指定的參數(shù)值。
3.關(guān)鍵字參數(shù)：在調(diào)用函數(shù)時指定參數(shù)名稱和對應的值。
4.星號參數(shù)：在函數(shù)定義中使用來捕獲剩余的參數(shù)。
5.雙星號參數(shù)：在函數(shù)定義中使用* 來捕獲剩余的關(guān)鍵字參數(shù)。

7.python中==和is的區(qū)別？

==比較的是兩個對象的值，is 比較的是兩個對象的內(nèi)存地址。
不能用 is 替代==，僅當你需要判斷某個對象是否是 None、False、True 時，使用 is，其他情況下請使用==。

a = [1,2,3]b = aprint(id(a))print(id(b))print(a == b)print(a is b)---------------------20215765550722021576555072TrueTrue

額外：關(guān)于賦值或者復制后 id() 是否異同的知識點，結(jié)論：除了'='賦值，其余的 id() 都不一樣，直接舉例：

8.請描述global關(guān)鍵字在什么條件下必須被使用？

在函數(shù)局部要重新賦值全局變量之前，需要使用 global 關(guān)鍵字聲明全局變量。

9.請說明if name == 'main':語句的作用？

在 Python 中，當一個模塊被執(zhí)行時，if name == 'main':語句塊會被執(zhí)行。此語句塊可以用來測試模塊的代碼，而不會影響模塊的其他功能。
如果模塊被其他模塊導入，則name的值為該模塊的名稱，而不是main。如果該模塊是主程序，則name的值為main，此時該語句塊會被執(zhí)行。
這樣的語句使得可以在模塊被其他模塊導入時忽略測試代碼，并且只在模塊被獨立運行時執(zhí)行測試代碼。

10.面向?qū)ο缶幊逃心娜筇匦?？請說明各個特性的意義。

封裝：隱藏內(nèi)部狀態(tài)和實現(xiàn)細節(jié)，僅提供必要的接口給外部使用。
繼承：允許創(chuàng)建新的對象類型，并基于現(xiàn)有的對象類型派生，從而繼承其行為和狀態(tài)。
多態(tài)：允許不同類型的對象對相同消息做出不同的響應。

11.類反射中常用的方法及含義？

常用的類反射方法有：

type(object)：獲取對象的類型，返回一個 type 對象。
isinstance(object, classinfo)：判斷對象是否是某種類型的實例，返回布爾值。
issubclass(class, classinfo)：判斷一個類是否是另一個類的子類，返回布爾值。
getattr(object, name[, default])：獲取對象的屬性或方法，如果不存在，可以返回 default 參數(shù)指定的默認值。
hasattr(object, name)：判斷對象是否具有某個屬性或方法，返回布爾值。
setattr(object, name, value)：設(shè)置對象的屬性值。
delattr(object, name)：刪除對象的屬性。
使用類反射可以動態(tài)地獲取和操作類的信息，是動態(tài)語言的重要特性。

12.python中創(chuàng)建一個新線程有哪幾種方式？

1.使用 threading 模塊：通過定義一個繼承自 Thread 的類并重寫其 run 方法，然后通過該類的實例調(diào)用 start 方法啟動線程。
2.使用 multiprocessing 模塊：通過使用 Process 類創(chuàng)建新的進程。
3.使用協(xié)程：通過使用生成器實現(xiàn)協(xié)程，在協(xié)程內(nèi)部通過 yield 實現(xiàn)非阻塞的多任務(wù)執(zhí)行。
多線程編程是高并發(fā)編程的一種常見形式，可以提高程序的執(zhí)行效率。

13.python中GIL全局解釋器鎖在什么情況下會被釋放？

Python 中的 GIL (Global Interpreter Lock) 是一種機制，它限制任意時刻僅有一個線程可以運行在 Python 解釋器中。GIL 在以下情況下會被釋放：
解釋器在執(zhí)行 CPU 密集型任務(wù)時：例如運算，在這種情況下，GIL 會每隔一定時間被釋放，以便其他線程有機會被調(diào)度執(zhí)行。
解釋器在執(zhí)行 I/O 密集型任務(wù)時：例如讀取文件，在這種情況下，由于 I/O 操作需要等待外部設(shè)備，所以 GIL 會在 I/O 操作期間被釋放。
GIL 可能會影響多線程程序的性能，因此通常不建議在 Python 中開發(fā) CPU 密集型的多線程程序?？梢允褂枚噙M程來代替多線程以提高性能。

14.描述編寫裝飾器的原則是什么？

1.不改變原函數(shù)的內(nèi)部邏輯
2.不改變原函數(shù)的調(diào)用方法

15.現(xiàn)在有一個Animal類有初始化方法定義如下：

class Animal:
def init(self, skin, legs):
self.skin = skin
self.legs = legs

如果現(xiàn)在想定義一個Dog類，并繼承于這個Animal類，并想給這個Dog類增加一個nickname對象屬性，Dog類的初始化方法應該怎么定義才能保證 Dog 類和其父類均能初始化成功？

# 兩種寫法，第二種以Cat舉例class Animal:
    def __init__(self, skin, legs):
        self.skin = skin
        self.legs = legsclass Dog(Animal):
    def __init__(self, skin, legs, nickname):
        super().__init__(skin, legs)
        self.nickname = nicknameclass Cat(Animal):
    def __init__(self, skin, legs, hobby):
        Animal.__init__(self, skin, legs)
        self.hobby = hobbya = Animal(skin='sss', legs='lll')d = Dog(skin='sss', legs='lll', nickname='nnn')c = Cat(skin='sss', legs='lll', hobby='hhh')print(a.skin)print(d.nickname)print(c.hobby)print(c.skin)----------------------------------------------------------------------sssnnnhhhsss

super 方法是 Python 中的一種特殊方法，用于引用父類。它常用于多重繼承，當子類需要調(diào)用父類的方法時，就可以使用 super 方法。這個方法可以直接調(diào)用父類的方法，而無需顯式命名父類名稱。

16.文件zen.txt中保存著python之禪，請使用python代碼統(tǒng)計該文件中每個單詞出現(xiàn)的次數(shù)。

17.編寫一個裝飾器，使用該裝飾器能夠顯示任意函數(shù)運行所需時間。

def running_time(fun):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = fun(*args, **kwargs)
        end_time = time.time()
        print(f'{fun.__name__}運行花費了：{end_time-start_time:.2f} 秒。')
        return result
    return wrapper@running_timedef take_time():
    time.sleep(2)take_time()----------------------------------------------------take_time運行花費了：2.01 秒。

18.用兩種方法合并下面列表

19.計算得到列表當中長度最長的字符串words = ['Python', 'is', 'awesome']

words = ['Python', 'is', 'awesome']# 我的笨方法s = ''for _ in words:
    if len(_) > len(s):
        s = _print(s)# 標答給的方法
# 使用內(nèi)置函數(shù) max() 和 len() 計算，在 max() 函數(shù)中使用 key 參數(shù)指定了用于比較大小的函數(shù)為 len()，這樣比較的就是字符串的長度，而不是字典序。longest_word = max(words, key=len)print(longest_word)

20.將列表中的順序倒轉(zhuǎn) (2 種方法) words = ['Python', 'is', 'awesome']

21.將字典當中的鍵值對位置調(diào)換

staff = {'Data Scientist': 'Mike', 'Django Developer': 'Dylan'}

答：

staff = {'Data Scientist': 'Mike', 'Django Developer': 'Dylan'}# 我的笨方法reverse = {}for k, v in staff.items():
    reverse[v] = kprint(reverse)# 標答給的方法（字典推導式）inverted_staff = {v: k for k, v in staff.items()}print(inverted_staff)

22.將嵌套列表合并為一個列表

l = [[1, 2, 3], [4, 5], [6], [7, 8], [9]]

答：

23.列表當中數(shù)據(jù)類型的轉(zhuǎn)換

答：

l = ['1', '2', '3']l1 = [int(i) for i in l]print(l1)l2 = ['1', 2, '3.0', 4.0, '5', 6]l3 = [float(i) for i in l2]print(l3)

24.將列表轉(zhuǎn)化成字典

cars = ['Audi', 'BMW', 'Ford', 'Tesla', 'Volvo']

答：

25.將列表當中的重復元素去除

['a', 'a', 'b', 'a', 'c']

答：

l = ['a', 'a', 'b', 'a', 'c']l1 = list(set(l))print(l1)

26.從列表中篩選出特定元素 (2種方法)

cars = ['Audi', 'BMW', 'Ford', 'Tesla', 'Volvo']

答：

27.列表中的元素排序

numbers = [55, -30, 28, -36, 48, 20]
cars = ['Ford', 'Tesla', 'BMW', 'Volvo', 'Audi']

答：

numbers.sort()print(numbers)cars.sort()print(cars)

28.合并集合

set1 = {'1', '2', '5'}
set2 = {'4', '6', '7'}

答：

29.根據(jù)鍵來對字典進行排序

d = {'one': 1, 'three': 4, 'five': 8, 'six': 10, 'two': 2}

答：

sorted_dict = sorted(d.items(), key=lambda x: x[0])print(sorted_dict)

30.根據(jù)鍵值來對字典進行排序

d = {'one': 1, 'three': 4, 'five': 8, 'six': 10, 'two': 2}

答：

31.替換字符串

s = 'Python is a programming language. Python is awesome'# 字符類型是不可變數(shù)據(jù)類型，str.replace()方法不會改變原字符串，會生成新值ss = s.replace('P','p')print(ss)

32.計算指定字符串出現(xiàn)的次數(shù)

a = 'python is a programming language. python is python.'

答：

33.將矩陣轉(zhuǎn)置

a = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]

答：

b = [list(s) for s in zip(*a)]print(b)

34.生成斐波那契數(shù)列

斐波那契數(shù)列是一個數(shù)列，其中的每個數(shù)都是前兩個數(shù)的和。

答：

35.冒泡排序

def bubble(l):
    for i in range(len(l) - 1):
        for j in range(len(l) - 1 - i):
            if l[j] > l[j + 1]:
                l[j], l[j + 1] = l[j + 1], l[j]
    return l

36.Python的解包是什么？

解包是 Python 里的一種特殊賦值語句，可以把可迭代對象 (列表，元祖，字典，字符串) 一次性賦給多個值。

a, b = b, a

注意：

37.有一個key為姓名，value為年齡的字典，根據(jù)年齡正序排列姓名，并輸出姓名列表，若沒有年齡，則放在最后；

users = {'tom': 19, 'jerry': 13, 'jack': None, 'andrew': 43}

答：
知識點：在排序前將年齡為 None 的值變更為正無窮大；

# 我想到的方法：
# 先將字典中年齡為None的值變更成正無窮大def key_func(users):
    for key in users.keys():
        if users[key] is None:
            users[key] = float('inf')# 根據(jù)年齡進行正序排序，最后以列表形式輸入排序好的姓名def sort_user(user: dict):
    sort_item_for_v = sorted(user.items(), key=lambda x: x[1])
    return [user[0] for user in sort_item_for_v]key_func(users)print(sort_user(users))-------------------------------------------------------------------------------['jerry', 'tom', 'andrew', 'jack']

38.合并字典的多種方式？

d1 = {'name': 'Lili', 'score': 90}d2 = {'name': 'Tom', 'hobby': 'run'}d1.update(d2)print(d1)-----------------------------{'name': 'Tom', 'score': 90, 'hobby': 'run'}# 這種方法會改變d1的原始值

d1 = {'name': 'Lili', 'score': 90}d2 = {'name': 'Tom', 'hobby': 'run'}print({**d1, **d2})print({**d2, **d1})print(d1)print(d2)--------------------------------------{'name': 'Tom', 'score': 90, 'hobby': 'run'}{'name': 'Lili', 'hobby': 'run', 'score': 90}{'name': 'Lili', 'score': 90}{'name': 'Tom', 'hobby': 'run'}

39.json和Python中的dict有什么區(qū)別？

40.Python列表和字符串的相互轉(zhuǎn)換？

第一種類型：

s = '1,2,3,4,5'l = s.split(',')print(l)l2 = [int(i) for i in l]print(l2)--------------------['1', '2', '3', '4', '5'][1, 2, 3, 4, 5]

第二種類型：

第三種類型：

l2 = [1,2,3]s2 = ','.join([str(i) for i in l2])print(s2)-----------------------------1,2,3

作者以往文章：