為什么學習Python？

• 易學易用：Python語法簡潔清晰，易于學習。
• 廣泛的應用領域：適用于Web開發、數據科學、人工智能、自動化腳本等多種場景。
• 強大的庫支持：擁有豐富的第三方庫，如NumPy、Pandas、TensorFlow等。
• 跨平臺：可在多種操作系統上運行。
• 社區支持：擁有活躍的開發者社區，易于獲取幫助和資源。

通過什么途徑學習的Python？

• 在線教程和課程：如Coursera、edX、Udemy等平臺提供的Python課程。
• 書籍：入門書籍如《Python Crash Course》和《Automate the Boring Stuff with Python》。
• 官方文檔：Python官方文檔是學習標準庫和語言特性的寶貴資源。
• 實踐項目：通過實際編寫代碼和參與項目來學習。
• 社區和論壇：Stack Overflow、Reddit等社區可以提供幫助和交流。

Python和其他語言的對比？

• Java：編譯型語言，性能較高，適用于大型企業級應用，語法相對復雜。
• PHP：主要用作服務器端腳本語言，適合Web開發，但應用范圍相對有限。
• C：底層語言，性能高，但語法復雜，沒有面向對象的特性。
• C#：由微軟開發，主要用于Windows平臺，支持.NET框架，適用于企業應用。
• C++：支持面向對象編程，性能優異，但學習曲線陡峭。

解釋型和編譯型編程語言？

• 解釋型語言：代碼在運行時逐行解釋執行，通常不需要編譯，如Python和JavaScript。
• 編譯型語言：代碼在執行前需要被編譯成機器語言，如C、C++和Java。

Python解釋器種類以及特點？

• CPython：官方Python解釋器，使用C語言編寫。
• Jython：運行在Java平臺上的Python解釋器，使用Java語言編寫。
• IronPython：.NET平臺上的Python實現，使用C#和VB編寫。
• PyPy：使用即時編譯（JIT）技術的Python解釋器，可以提供更快的執行速度。

位和字節的關系？

• 1字節（Byte）= 8位（bit）。

b、B、KB、MB、GB 的關系？

• 1B（Byte）= 8b（bit）
• 1KB（千字節）= 1024B
• 1MB（兆字節）= 1024KB
• 1GB（吉字節）= 1024MB

PEP8 規范

• Indentation: 使用4個空格進行縮進。
• Line length: 每行不超過79個字符，確保代碼可讀性。
• Blank lines: 邏輯上相關的代碼塊之間使用空行分隔。
• Imports: 每個導入應該獨占一行，并且分組順序通常是：標準庫導入、相關第三方導入、本地應用/庫特定導入。
• Variable names: 變量名使用小寫字母和下劃線分隔。
• Function names: 函數名同樣使用小寫字母和下劃線。
• Class names: 類名使用首字母大寫的駝峰式命名。
• Underscores: 單下劃線（_）前綴用于受保護的實例屬性和方法，雙下劃線（__）前綴用于私有屬性和方法。
• Documentation strings: 為每個模塊、函數、類和方法提供文檔字符串。

代碼實現轉換：

# 二進制轉十進制
v_bin_to_dec = int("0b1111011", 2)# 十進制轉二進制
v_dec_to_bin = bin(18)[2:]# 八進制轉十進制
v_oct_to_dec = int("011", 8)# 十進制轉八進制
v_dec_to_oct = oct(30)[2:]# 十六進制轉十進制
v_hex_to_dec = int("0x12", 16)# 十進制轉十六進制
v_dec_to_hex = hex(87)[2:]print(f"二進制轉十進制: {v_bin_to_dec}")
print(f"十進制轉二進制: {v_dec_to_bin}")
print(f"八進制轉十進制: {v_oct_to_dec}")
print(f"十進制轉八進制: {v_dec_to_oct}")
print(f"十六進制轉十進制: {v_hex_to_dec}")
print(f"十進制轉十六進制: {v_dec_to_hex}")

IP地址轉整數：

def ip_to_int(ip_address):parts = ip_address.split('.')integer = 0for part in parts:integer = integer * 256 + int(part)return integer# 示例
ip_address = "10.3.9.12"
print(f"IP地址 {ip_address} 轉換成整數為: {ip_to_int(ip_address)}")

這段代碼將IP地址的每個部分轉換為整數，并按照二進制的字節順序拼接起來，計算最終的十進制整數。

Python遞歸的最大層數？

Python中遞歸的最大層數默認是1000，但可以通過sys模塊的setrecursionlimit函數進行調整。

求邏輯運算結果：

• v1 = 1 or 3?的結果是3（在Python中非0即真）。
• v2 = 1 and 3?的結果是1（在Python中and操作符會返回第一個假值，1是真值）。
• v3 = 0 and 2 and 1?的結果是0（and操作符會從左到右計算，遇到第一個假值停止計算）。
• v4 = 0 and 2 or 1?的結果是1（and操作符在第一個操作數為假時停止計算，or操作符會返回第一個真值）。
• v5 = 0 and 2 or 1 or 4?的結果是1（同上，0為假，2和1為真，4也是真，但or操作符在遇到第一個真值時停止）。
• v6 = 0 or False and 1?的結果是0（or操作符從左到右計算，and操作符在第一個操作數為假時停止計算）。

ASCII、Unicode、UTF-8、GBK的區別？

• ASCII：最早的字符編碼標準，使用7位編碼，能表示128個字符，只能表示英文字符。
• Unicode：一種國際標準，使用更多的位來編碼世界上大多數語言的字符，可以看作是字符的"字典"。
• UTF-8：Unicode的一種實現方式，是一種變長編碼，英文字符使用1字節，其他語言可能使用2-4字節。
• GBK：主要用于簡體中文的字符編碼，是GB2312的擴展，使用雙字節編碼。

字節碼和機器碼的區別？

• 字節碼：是源代碼編譯后的中間形式，是一種與平臺無關的代碼，可以在虛擬機上運行。
• 機器碼：是編譯器將源代碼轉換成的二進制指令，是CPU可以直接執行的代碼，與特定硬件平臺相關。

三元運算規則以及應用場景？

三元運算符是Python中的一種簡潔的條件表達式，格式為：a if condition else b。當條件condition為真時，表達式的結果為a，否則為b。常用于簡單的條件賦值。

Python 2和Python 3的區別？

• print語句：Python 3中print是一個函數，需要括號。
• 整數除法：Python 3中的除法/總是返回浮點數，Python 2中返回整數。
• Unicode：Python 3默認字符串為Unicode，Python 2默認為ASCII。
• 迭代器：Python 3中range返回迭代器，Python 2返回列表。
• 異常鏈：Python 3中使用raise X from Y來鏈式異常，Python 2中沒有這個語法。

一行代碼實現數值交換：

a, b = b, a

Python 3和Python 2中int和long的區別？

• 在Python 2中，int是有固定大小的整數，long是無限大小的整數。
• Python 3中，long類型被移除，所有的整數都是int類型，且int類型可以是任意大小。

xrange和range的區別？

• xrange是Python 2中的一個函數，它返回一個迭代器，逐個產生數值，節省內存。
• range在Python 2中返回一個列表，在Python 3中返回一個與xrange類似的迭代器。

文件操作時xreadlines和readlines的區別？

• xreadlines是Python 2中的一個方法，用于返回文件的所有行的迭代器。
• readlines在Python 2中讀取整個文件內容到一個列表中，可能會消耗大量內存。
• 在Python 3中，xreadlines不存在，readlines保持與Python 2中的readlines相同的行為。

Python 3鼓勵使用上下文管理器（with語句）來處理文件操作，它可以自動關閉文件，同時提供迭代文件行的能力。

布爾值為False的常見值：

• None
• 任何數值類型的零值：0,?0.0,?0j
• 空集合：(),?[],?{},?set()
• 空字符串："",?'',?b''

字符串常用方法：

• str.lower(): 轉換為小寫。
• str.upper(): 轉換為大寫。
• str.strip(): 移除首尾空白字符。
• str.split(sep=None): 按照分隔符分隔字符串。
• str.join(iterable): 將序列中的元素以字符串連接生成一個新的字符串。

列表常用方法：

• list.append(x): 在列表末尾添加元素x。
• list.extend(iterable): 在列表末尾一次性追加多個元素。
• list.insert(i, x): 在指定位置i插入元素x。
• list.remove(x): 移除列表中的元素x。
• list.pop([i]): 移除列表中的一個元素（默認最后一個），并返回該元素。

元組常用方法：

• tuple.count(x): 統計元素x在元組中出現的次數。
• tuple.index(x): 返回元素x在元組中首次出現的索引。
• tuple + tuple: 連接兩個元組。
• element in tuple: 檢查元素是否在元組中。
• tuple * n: 將元組復制n次。

字典常用方法：

• dict.get(key, default=None): 獲取指定鍵的值，如果不存在返回默認值。
• dict.keys(): 返回字典中所有的鍵。
• dict.values(): 返回字典中所有的值。
• dict.items(): 返回字典中所有的鍵值對。
• dict.update(other): 將另一個字典的鍵值對更新到當前字典。

lambda表達式格式以及應用場景：

格式：lambda arguments: expression 應用場景：通常用在需要簡單函數對象的地方，如map(), filter(), sorted()函數中。

pass的作用：

pass是一個空操作符，不做任何事情。它用在語法上需要一個語句但程序邏輯不需要任何操作的地方。

*args和**kwargs作用：

• *args：可變位置參數，允許你傳遞任意數量的位置參數給函數。
• **kwargs：可變關鍵字參數，允許你傳遞任意數量的命名參數給函數。

is和==的區別：

• is：檢查兩個引用是否指向同一個對象。
• ==：比較兩個值是否相等。

Python的深淺拷貝以及應用場景：

• 淺拷貝：創建一個新集合，添加原始集合中對象的引用。適用于拷貝引用不可變類型或需要保持原始對象和拷貝對象間引用關系的場景。
• 深拷貝：創建原始對象的副本，不共享原始對象中的任何引用。適用于拷貝可變類型或需要完全獨立的對象副本的場景。

Python垃圾回收機制：

Python使用引用計數和標記-清除機制進行垃圾回收。引用計數為0的對象會被垃圾收集器回收。標記-清除機制用于處理循環引用。

Python的可變類型和不可變類型：

• 可變類型：對象的內容可以改變，如列表、字典、集合。
• 不可變類型：對象的內容不能改變，如整數、浮點數、字符串、元組。

求結果：

v = dict.fromkeys(['k1', 'k2'], [])
v['k1'].append(666)
print(v)  # 輸出: {'k1': [666], 'k2': []}
v['k1'] = 777
print(v)  # 輸出: {'k1': 777, 'k2': []}

在這個例子中，fromkeys創建了一個字典，其中的鍵是列表['k1', 'k2']中的元素，初始值是空列表[]。然后，向'k1'的值（一個空列表）中添加了666，之后將'k1'的值替換為777。

常見的內置函數：

• abs(x): 返回x的絕對值。
• all(iterable): 如果iterable中的所有元素都為真，則返回True。
• any(iterable): 如果iterable中至少有一個元素為真，則返回True。
• bool(x): 將x轉換為布爾值。
• chr(i): 將整數i轉換為對應的ASCII字符。
• enumerate(iterable): 返回一個包含元素索引和值的迭代器。
• filter(function, iterable): 過濾序列，返回使function返回值為True的元素集合。
• input([prompt]): 從用戶那里獲取輸入，返回一個字符串。
• len(s): 返回對象s的長度。
• list(iterable): 將iterable轉換為列表。
• map(function, iterable, ...): 將function應用于iterable的每個元素，并返回一個map對象。
• max(iterable, ...): 返回iterable中的最大值。
• min(iterable, ...): 返回iterable中的最小值。
• next(object): 返回迭代器的下一個項目。
• open(file, mode='r', ...): 打開一個文件并返回文件對象。
• ord(c): 將單個字符c轉換為它的整數表示。
• print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False): 打印對象。
• range(start, stop, step): 產生一個起始值為start、結束值為stop、步長的序列。
• repr(object): 獲取對象的字符串表示，通常用于調試。
• round(number[, ndigits]): 對number進行四舍五入到ndigits位小數。
• set(iterable): 將iterable轉換為集合。
• sorted(iterable, key=None, reverse=False): 返回iterable的排序列表。
• sum(iterable[, start]): 求和iterable中的元素，start是求和的初始值。
• type(object): 獲取對象的類型。
• zip(*iterables): 將多個iterables中對應的元素打包成一個個元組，然后返回由這些元組組成的迭代器。

filter、map、reduce的作用：

• filter(function, iterable): 過濾出滿足條件的元素。
• map(function, iterable, ...): 對每個元素應用函數，返回一個map對象。
• reduce(function, sequence[, initial]): 將序列的元素組合為單個值，應用二元函數到元素對。

一行代碼實現9*9乘法表：

for i in range(1, 10): print(' '.join(f'{i * j}' for j in range(1, i+1)))

如何安裝第三方模塊？

使用pip工具安裝第三方模塊，命令如下：

pip install module_name

用過哪些第三方模塊？

• numpy: 科學計算。
• pandas: 數據分析。
• matplotlib: 繪圖。
• scikit-learn: 機器學習。
• flask: Web開發。
• django: Web開發框架。
• requests: HTTP庫。
• beautifulsoup4: 解析HTML和XML文檔。

至少列舉8個常用模塊：

1. sys: 與Python解釋器密切相關的變量和函數。
2. os: 操作系統接口。
3. json: JSON編碼和解碼。
4. datetime: 日期和時間類型。
5. collections: 高級數據類型，如defaultdict、namedtuple。
6. itertools: 迭代器工具。
7. math: 數學函數。
8. re: 正則表達式。

re的match和search區別？

• match: 從字符串的起始位置匹配模式，如果匹配成功則返回Match對象，否則返回None。
• search: 掃描整個字符串，查找第一個位置的匹配項，如果找到匹配項則返回Match對象，否則返回None。

什么是正則的貪婪匹配？

貪婪匹配是指正則表達式盡可能多地匹配字符。例如，正則表達式a*在字符串"aaaa"中會匹配所有'a'字符，因為它盡可能多地匹配了。

求結果：

a. [ i % 2 for i in range(10) ]? ????????結果：[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

b. ( i % 2 for i in range(10) ) ????????結果：這是一個生成器表達式，不會立即求值，而是每次迭代時計算下一個值。

c. 1 or 2 ????????結果：1（因為1在布爾上下文中為真，所以不會評估or右邊的表達式）

d. 1 and 2 ????????結果：2（因為1在布爾上下文中為真，and操作符會返回最后一個真值）

e. 1 < (2==2) ????????結果：False（因為2==2為真，類型轉換為整數是1，1小于1不成立）

f. 1 < 2 == 2 ????????結果：True（這是鏈式比較，首先2 == 2為真，然后1 < True，布爾值True在比較時相當于1）

求結果：

a. 1 or 2 結果：1（因為1為真值，在布爾上下文中or操作符會返回第一個真值） b. 1 and 2 結果：2（因為1和2都為真值，在布爾上下文中and操作符會返回最后一個真值） c. 1 < (2==2) 結果：False（因為2==2為真，即True，而1 < True在布爾上下文中等同于1 < 1，結果為False） d. 1 < 2 == 2 結果：True（這是Python中的鏈式比較，等同于(1 < 2) and (2 == 2)，結果為True）

def func(a, b=[])?這種寫法的坑：

• 將列表作為函數的默認參數值，如果函數被多次調用，列表會被重復使用，之前的修改都會保留。

如何實現?"1,2,3"?變成?['1','2','3']？

s = "1,2,3" result = s.split(',')

如何實現?['1','2','3']?變成?[1,2,3]？

lst = ['1', '2', '3'] result = [int(item) for item in lst]

比較?a = [1,2,3]?和?b = [(1),(2),(3)]?以及?b = [(1,),(2,),(3,)]?的區別：

• a?是一個列表，包含整數1, 2, 3。
• b = [(1),(2),(3)]?是一個列表，包含三個元組，每個元組中只有一個元素1, 2, 3。
• b = [(1,),(2,),(3,)]?同樣是包含三個單元素元組的列表，但每個元組后面都有一個逗號，這是Python中單元素元組的語法要求。

如何用一行代碼生成?[1,4,9,16,25,36,49,64,81,100]？

result = [i**2 for i in range(1, 11)]

一行代碼實現刪除列表中重復的值？

result = list(set([1, 2, 2, 3, 4, 4, 5]))

如何在函數中設置一個全局變量？

在函數內部使用global關鍵字聲明變量，使其引用的是全局作用域中的變量。

x = 10 def func(): global x x = 20 func() print(x) # 輸出20

logging模塊的作用以及應用場景：

logging模塊用于記錄程序運行時的信息，可以配置不同的日志級別（DEBUG, INFO, WARNING, ERROR, CRITICAL），并輸出到不同的目的地（控制臺、文件等）。常用于調試、記錄程序運行狀態、審計等。

用代碼簡答實現stack：

class Stack:def __init__(self):self.items = []def is_empty(self):return len(self.items) == 0def push(self, item):self.items.append(item)def pop(self):if not self.is_empty():return self.items.pop()raise IndexError("pop from empty stack")

常用字符串格式化：

• 百分號格式化：'%s: %d' % (name, num)
• str.format()?方法：'{}: {}'.format(name, num)
• f-string（Python 3.6+）：f'{name}: {num}'

生成器、迭代器、可迭代對象

1. 可迭代對象（Iterable）：

   • 是可以被for循環迭代的對象，如列表、元組、字典、集合以及字符串。
   • 它們實現了__iter__()方法，返回一個迭代器。

2. 迭代器（Iterator）：

   • 是一個有__next__()和__iter__()方法的對象，用于逐個訪問可迭代對象中的元素。
   • 迭代器允許你遍歷容器中的內容而不需要關心容器的內部實現。

3. 生成器（Generator）：

   • 是一種特殊的迭代器，通過使用yield語句返回一個值并記住產生值時的狀態。
   • 生成器非常適合于大數據集的懶加載（lazy evaluation），因為它不需要一次性將所有數據加載到內存中。

應用場景：

• 當你需要逐個處理數據集中的元素時，使用迭代器。
• 當你想懶加載大量數據或創建自定義的迭代邏輯時，使用生成器。
• 當你需要一個可以重復訪問的元素集合時，使用可迭代對象。

二分查找函數實現：

def binary_search(arr, x):low = 0high = len(arr) - 1mid = 0while low <= high:mid = (high + low) // 2if arr[mid] < x:low = mid + 1elif arr[mid] > x:high = mid - 1else:return midreturn -1

閉包的理解：

閉包是一個函數，它記住了其創建環境中的變量。即使函數在外部作用域被調用，它仍然可以訪問這些變量。在Python中，閉包通常通過在函數內部定義另一個函數來實現，內層函數引用了外層函數的變量。

os和sys模塊的作用：

• os模塊：

  • 提供了一種方便的方式來使用操作系統依賴的功能。
  • 可以執行路徑操作、文件系統操作、環境變量訪問等。

• sys模塊：

  • 與Python解釋器及其環境交互。
  • 可以訪問命令行參數、執行環境變量、退出程序等。

生成一個隨機數：

import random random_number = random.randint(1, 10) # 生成1到10之間的隨機整數

使用Python刪除文件：

import os os.remove('file_name.txt') # 刪除指定的文件

面向對象的理解：

面向對象編程（OOP）是一種編程范式，它使用“對象”來設計軟件。對象可以包含數據（屬性）和代碼（方法）。面向對象的核心概念是數據和功能的封裝、繼承和多態。

繼承的特點：

• 允許新創建的類（子類）繼承現有類（父類）的屬性和方法。
• 子類可以擴展或修改父類的行為。
• 支持代碼復用。

面向對象深度優先和廣度優先：

• 深度優先：

  • 在繼承層次結構中，先完全探索一個分支，然后再轉到下一個分支。
  • 在方法解析順序（MRO）中，先查找子類的方法，然后逐級向上查找父類的方法。

• 廣度優先：

  • 在繼承層次結構中，先探索同一繼承層級的類，然后再逐級向下探索。
  • 在實際的Python類繼承中不常見，因為Python通常采用深度優先的策略。

super的作用：

super()函數用于調用父類的方法。在子類覆蓋父類的方法時，可以使用super()來保持父類方法的調用，確保繼承鏈中方法的正確執行。這在多重繼承的情況下特別有用，可以明確指定調用哪個父類的方法。

使用過functools模塊嗎？它的作用是什么？

functools模塊是Python的一個內置模塊，提供了一系列高階函數和函數工具，用于操作或擴展函數的功能。例如：

• partial: 用于固定函數的某些參數，創建一個新的函數。
• reduce: 對序列的元素進行累積，并返回一個單一的值。
• lru_cache: 為函數提供自動緩存機制，避免重復計算。
• total_ordering: 快速實現類的比較魔術方法。
• cmp_to_key: 將比較函數轉換為key函數，用于排序。

面向對象中帶下劃線的特殊方法：

• __new__(cls, ...): 創建實例的方法，返回一個實例。
• __init__(self, ...): 初始化實例的方法，設置初始狀態。
• __del__(self): 實例銷毀時調用的方法。
• __str__(self): 當使用print()或str()時調用，返回對象的字符串表示。
• __repr__(self): 當使用repr()時調用，返回對象的官方字符串表示，便于調試。
• __len__(self): 當使用len()時調用，返回容器類型的長度。
• __getitem__(self, key): 用于索引，如obj[key]。
• __setitem__(self, key, value): 用于賦值索引，如obj[key] = value。
• __delitem__(self, key): 用于刪除索引，如del obj[key]。
• __iter__(self): 返回對象的迭代器，用于迭代操作，如for x in obj。
• __next__(self): 返回迭代器的下一個元素。
• __call__(self, ...): 允許一個對象像函數那樣被調用，如obj()。

如何判斷是函數還是方法？

在Python中，可以通過檢查self參數來區分函數和方法。方法定義時通常包含self作為第一個參數，而函數則沒有。可以使用inspect模塊的isfunction()和ismethod()函數來判斷：

import inspectdef my_function():passclass MyClass:def my_method(self):passprint(inspect.isfunction(my_function))  # 輸出: True
print(inspect.ismethod(MyClass.my_method))  # 輸出: True

靜態方法和類方法的區別？

• 靜態方法（使用@staticmethod裝飾器）：

  • 不接收類或實例的引用作為第一個參數。
  • 可以看作是類內部的普通函數。

• 類方法（使用@classmethod裝飾器）：

  • 第一個參數是類本身，通常命名為cls。
  • 可以用來訪問類的屬性或調用類的方法。

面向對象中的特殊成員以及應用場景：

• __init__: 構造器，用于初始化新創建的對象。
• __del__: 析構器，用于在對象被銷毀前進行清理。
• __str__?和?__repr__: 分別用于返回對象的非正式和正式字符串表示，常用于調試。
• __len__: 當對象用作for循環或len()函數時調用，返回對象的長度。
• __getitem__,?__setitem__,?__delitem__: 用于支持索引操作，如獲取、設置和刪除元素。
• __iter__?和?__next__: 支持迭代協議，允許對象在for循環中被迭代。

1、2、3、4、5 組成的互不相同且無重復的三位數數量：

這是一個排列問題，因為有4個數字（1, 2, 3, 4, 5），要選出3個數字組成三位數，每個數字只能使用一次，所以有P(4, 3) = 4! / (4-3)! = 24種排列方式。

什么是反射？以及應用場景？

反射是指程序在運行時能夠訪問、檢查和修改它自己的行為或結構的能力。在Python中，反射可以通過type(), isinstance(), getattr(), setattr(), dir()等內置函數實現。應用場景包括：

• 動態創建對象或調用方法。
• 讀取和修改類的屬性。
• 實現依賴注入框架。

metaclass作用？以及應用場景？

Metaclass是類的“類”，即用于創建類的類。它定義了類的創建和行為方式。應用場景包括：

• 自定義類的創建過程，例如修改類屬性或方法。
• 實現單例模式或其他特殊的類模式。
• 創建ORM（對象關系映射）框架，自動將類映射到數據庫表。

實現單例模式的方法：

1. 使用模塊： 模塊級別的變量可以確保全局只有一個實例。

2. 使用裝飾器： 創建一個裝飾器，用于封裝類，確保只有一個實例被創建。

3. 使用__new__方法： 在類的__new__方法中控制實例的創建。

4. 使用類屬性： 類屬性用于存儲類的唯一實例。

5. 使用局部變量： 在類內部使用局部變量存儲實例。

裝飾器的寫法以及應用場景：

裝飾器是一個函數，它接受一個函數作為參數并返回一個函數。裝飾器可以用來修改或增強函數的行為。

def my_decorator(func):def wrapper(*args, **kwargs):# 執行一些操作result = func(*args, **kwargs)# 執行一些操作return resultreturn wrapper# 使用裝飾器
@my_decorator
def my_function():pass

應用場景包括：

• 日志記錄：在函數執行前后添加日志。
• 性能測試：測量函數執行時間。
• 事務處理：確保數據庫操作的原子性。
• 權限檢查：在函數執行前檢查用戶權限。

異常處理寫法及主動拋出異常：

異常處理使用try...except語句。可以主動拋出異常使用raise關鍵字。

try:# 嘗試執行的代碼result = 10 / 0
except ZeroDivisionError as e:# 處理特定異常print("發生錯誤：", e)
finally:# 無論是否發生異常都會執行的代碼print("這是 finally 子句")# 主動拋出異常
if some_condition:raise ValueError("這是一個主動拋出的異常")

應用場景：當某個條件不滿足時，需要終止程序流程并通知調用者有錯誤發生。

面向對象的 MRO（Method Resolution Order）：

MRO 是解析方法查找順序的算法，用于確定在多繼承情況下，應該按照什么順序查找方法。Python 使用 C3 線性化算法來實現 MRO。

isinstance?作用及應用場景：

isinstance(object, classinfo) 用于判斷一個對象是否是一個類或類的子類的實例。

if isinstance(obj, list):# 如果 obj 是 list 類型或其子類的實例pass

應用場景：需要對不同類型的對象執行不同操作時，進行類型檢查。

尋找兩個數的索引：

def two_sum(nums, target):num_to_index = {}for i, num in enumerate(nums):complement = target - numif complement in num_to_index:return [num_to_index[complement], i]num_to_index[num] = ireturn []# 示例
nums = [2, 7, 11, 15]
target = 9
print(two_sum(nums, target))  # 輸出: [0, 1]

JSON 序列化支持的數據類型及定制：

JSON 序列化可以處理以下數據類型：

• 字符串
• 整數
• 浮點數
• 布爾值
• 列表
• 字典
• None

定制支持 datetime 類型：

import json
from datetime import datetimedef datetime_handler(obj):if isinstance(obj, datetime):return obj.isoformat()raise TypeError("Unknown type")json_str = json.dumps({'date': datetime.now()}, default=datetime_handler)

JSON 序列化保留中文：

在序列化時指定 ensure_ascii=False 參數：

json_str = json.dumps(data, ensure_ascii=False)

斷言：

assert 語句用于調試目的，檢查條件是否為真，如果為假，則拋出 AssertionError。

assert condition, "錯誤信息"

應用場景：確保程序在某個條件下滿足預期，通常用于開發和測試階段。

with?statement：

with 語句用于包裹執行代碼的上下文，確保資源的正確管理，如文件操作。

with open('file.txt', 'r') as file:data = file.read()# 文件會在 with 代碼塊結束時自動關閉

好處：自動管理資源，無需手動關閉文件或其他資源。

查看列舉目錄下的所有文件：

import osdirectory = '/path/to/directory'
for filename in os.listdir(directory):filepath = os.path.join(directory, filename)if os.path.isfile(filepath):print(filepath)

yield?和?yield from?關鍵字：

• yield?用于在函數中產生一個值，該函數就變成了一個生成器。每次迭代調用?next()?時執行到?yield?表達式，返回一個值并暫停，直到下一次迭代。

def my_generator():yield 1yield 2

• yield from?用于在生成器中委派給另一個生成器或迭代器，將另一個生成器的輸出合并到當前生成器中。

def my_outer_generator():yield from my_generator()yield 3

使用 yield from 可以簡化嵌套生成器的實現。