value = 3.1415926   
print(round(value, 2))  # 這樣寫并不會(huì)報(bào)錯(cuò)，但有更好的方式

print(f"{value:.2f}")  # 格式化字符串，簡潔又直觀

import numpy as np   
data = [1, 2, 3, 4]   
data_np = np.array(data)   
max_value = max(data_np)  # 這里用了 Python 內(nèi)置的 max，而不是 NumPy 的

max_value = np.max(data_np)  # 充分利用 NumPy 的優(yōu)化

filename = "C:\\Users\\Admin\\Documents\\file.txt"   
folder = "C:\\Users\\Admin\\Documents"   
path = folder + "\\" + "file.txt"  # 這樣拼接路徑很容易出錯(cuò)

from pathlib 
import Path   
folder = Path("C:/Users/Admin/Documents")   
path = folder / "file.txt"  # 使用 Pathlib 更安全、可讀性更高

def save_data(path, data):       
with open(path, "w") as f:           
f.write(data)

def save_data(file_obj, data):       
file_obj.write(data)

result = ""   
for i in range(100):       
result += str(i)  # 每次拼接都會(huì)創(chuàng)建新字符串，效率極低

from io 
import StringIO   
buffer = StringIO()   
for i in range(100):       
buffer.write(str(i))   
result = buffer.getvalue()  # 這樣不會(huì)頻繁創(chuàng)建新字符串

result = "".join(str(i) for i in range(100))  # 使用 join 拼接更高效

data = "{'name': 'Alice', 'age': 25}"   
parsed = eval(data)  # 有安全風(fēng)險(xiǎn)！

evil_data = "__import__('os').system('rm -rf /')"   
eval(evil_data)  # 可能導(dǎo)致災(zāi)難性后果！

import json   
parsed = json.loads(data.replace("'", '"'))  # 更安全的解析方式

result = None  # 全局變量   
def compute(x, y):       
global result      
result = x + y  # 改變?nèi)肿兞?，增加了函?shù)的副作用

def compute(x, y):       
return x + y  # 讓函數(shù)返回值，而不是改寫全局變量

result = compute(3, 5)

result = 5 or 10  # 你以為 result 是 True？錯(cuò)，它是 5

print(5 or 10)  # 輸出 5，因?yàn)?5 是真值，or 不再繼續(xù)判斷   
print(0 or 10)  # 輸出 10，因?yàn)?0 是假值，or 繼續(xù)檢查 10   
print(5 and 10)  # 輸出 10，因?yàn)?and 需要所有條件都為真   
print(0 and 10)  # 輸出 0，因?yàn)?and 發(fā)現(xiàn) 0 是假值，直接返回

is_valid = bool(5 or 10)  # 這樣才是標(biāo)準(zhǔn)布爾值

def calc(a, b, c):       
d = a * b + c       
return d

def calc(price, quantity, discount):       
total = price * quantity + discount       
return total

quotient = 17 // 5   
remainder = 17 % 5

quotient, remainder = divmod(17, 5)  # 代碼更簡潔

class Person:       
def __init__(self, name):           
self._name = name          
def get_name(self):           
return self._name          
def set_name(self, value):           
self._name = value

class Person:       
def __init__(self, name):           
self._name = name          
@property       
def name(self):           
return self._name          
@name.setter       
def name(self, value):           
self._name = value

p = Person("Alice")   
print(p.name)  # 直接訪問，像變量一樣   
p.name = "Bob"  # 直接賦值

class Circle:       
def __init__(self, radius):           
self.radius = radius          
@property       
def area(self):           
print("Calculating area...")  # 這行會(huì)頻繁執(zhí)行           
return 3.14 * self.radius ** 2

c = Circle(10)  
 print(c.area)  # 每次訪問都計(jì)算一次面積   
 print(c.area)  # 計(jì)算了兩次，浪費(fèi)性能

from functools 
import cached_property      
class Circle:       
def __init__(self, radius):           
self.radius = radius          
@cached_property       
def area(self):           
print("Calculating area...")  # 只計(jì)算一次           
return 3.14 * self.radius ** 2

numbers = [1, 2, 3, 4, 5]   
for num in numbers:       
if num % 2 == 0:           
numbers.remove(num)

numbers = [1, 2, 4, 5]   
for num in numbers:       
if num % 2 == 0:           
numbers.remove(num)   
print(numbers)  # 結(jié)果為 [1, 4，5]（漏刪 4）

numbers = [1, 2, 3, 4, 5]   
numbers = [num for num in numbers if num % 2 != 0]  # 直接用列表推導(dǎo)式   
print(numbers)  # [1, 3, 5]

for num in numbers[:]:       
if num % 2 == 0:           
numbers.remove(num)

numbers = [1, 2, 3, 4, 5]   
squared = list(map(lambda x: x ** 2, numbers))   
evens = list(filter(lambda x: x % 2 == 0, numbers))

squared = [x ** 2 for x in numbers]  # 代碼更簡潔   
evens = [x for x in numbers if x % 2 == 0]  # 也更易讀

class Person:       
def __init__(self, name):           
self.name = name          
def __iadd__(self, other):           
print(f"{self.name} 和 {other.name} 成為了朋友！")           
return self

p1 = Person("Alice")   
p2 = Person("Bob")   
p1 += p2  # 這真的合適嗎？？

class Person:       
def __init__(self, name):           
self.name = name           
self.friends = []          
def add_friend(self, other):           
print(f"{self.name} 和 {other.name} 成為了朋友！")           
self.friends.append(other)

p1.add_friend(p2)  # 這樣更直觀

import re   html = "<div><p>Hello, world!</p></div>"   
match = re.search(r"<p>(.*?)</p>", html)   
print(match.group(1))  # 這樣做并不靠譜

from bs4 import BeautifulSoup   
html = "<div><p>Hello, world!</p></div>"   
soup = BeautifulSoup(html, "html.parser")   
print(soup.p.text)  # 這樣解析才靠譜

pattern = "\\d+\\.\\d+"  # 正則表達(dá)式匹配浮點(diǎn)數(shù)   
print(re.findall(pattern, "The price is 3.14"))

pattern = r"\d+\.\d+"  # 使用原始字符串

class A:       
deff(self):          
print("A.f")      
classB(A):       
deff(self):           
print("B.f")           
super().f()      
classC(B):  # 正確繼承順序：C -> B -> A       
deff(self):           
print("C.f")           
super().f()      
c = C()   
c.f()  # 輸出順序?yàn)?C.f -> B.f -> A.f    

print(C.mro())  # 用 .mro() 確認(rèn)方法解析順序

def process_data(data):       
return data["name"].upper(), data["age"] + 1     
person = {"name": "Alice", "age": 25}   
print(process_data(person))

from dataclasses 
import dataclass      
@dataclass   
class Person:       
name: str       
age: int      
def process_data(person: Person):       
return person.name.upper(), person.age + 1      
p = Person("Alice", 25)   
print(process_data(p))

from collections 
import namedtuple   
Person = namedtuple("Person", ["name", "age"])

from typing 
import NamedTuple      
class Person(NamedTuple):       
name: str       
age: int

# utils.py   
print("Utils module loaded!")  # 只要 import 這個(gè)模塊，就會(huì)執(zhí)行這行代碼

import utils  # 這里會(huì)自動(dòng)輸出 "Utils module loaded!"

def main():       
print("Utils module loaded!")      
if __name__ == "__main__":       
main()  # 只有直接運(yùn)行這個(gè)文件時(shí)才執(zhí)行