基于Python實現(xiàn)一個專業(yè)的密碼強度檢測器
更新時間：2025年12月07日 09:52:52 作者：零日失眠者
這篇文章主要為大家詳細介紹了基于Python實現(xiàn)一個專業(yè)的密碼強度檢測器,可以用于評估密碼的安全性和強度,感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下
功能介紹
這是一個專業(yè)的密碼強度檢測工具，用于評估密碼的安全性和強度。該工具具備以下核心功能：
多維度強度評估：
- 長度檢測（密碼長度要求）
- 字符類型檢測（大小寫字母、數(shù)字、特殊字符）
- 字典攻擊防護（常見密碼和弱密碼檢測）
- 模式識別（鍵盤序列、重復(fù)字符等）
- 熵值計算（密碼隨機性評估）
詳細評分系統(tǒng)：
- 綜合評分機制（0-100分制）
- 分項評分展示（長度、復(fù)雜度、模式等）
- 強度等級劃分（弱、中、強、 very strong）
- 改進建議提供
自定義策略支持：
- 可配置的密碼策略
- 自定義評分權(quán)重
- 特定行業(yè)標(biāo)準(zhǔn)支持（如NIST、PCI DSS等）
- 黑名單詞匯庫
批量檢測功能：
- 支持批量密碼檢測
- 密碼文件批量分析
- 檢測結(jié)果統(tǒng)計報告
- 弱密碼列表導(dǎo)出
安全防護機制：
- 內(nèi)存安全處理（避免密碼明文存儲）
- 輸入安全驗證
- 防止暴力 破解保護
- 安全日志記錄
場景應(yīng)用
1. 系統(tǒng)管理員使用
- 檢查用戶賬戶密碼強度
- 定期審計系統(tǒng)密碼安全性
- 識別弱密碼賬戶并強制更換
- 制定和執(zhí)行密碼策略
2. 開發(fā)者集成
- 集成到用戶注冊和密碼修改流程
- 實時密碼強度提示
- 密碼策略驗證
- 用戶體驗優(yōu)化
3. 安全審計
- 企業(yè)密碼安全評估
- 合規(guī)性檢查（等保、ISO 27001等）
- 滲透測試中的密碼分析
- 安全培訓(xùn)和意識提升
4. 個人用戶
- 檢查個人賬戶密碼安全性
- 創(chuàng)建更強的密碼
- 密碼管理器集成
- 安全意識教育
報錯處理
1. 輸入驗證異常
try:
password = input("請輸入密碼: ")
if not password:
raise PasswordValidationError("密碼不能為空")
if len(password) > MAX_PASSWORD_LENGTH:
raise PasswordValidationError(f"密碼長度不能超過 {MAX_PASSWORD_LENGTH} 個字符")
except PasswordValidationError as e:
logger.error(f"密碼輸入驗證失敗: {str(e)}")
raise PasswordSecurityError(f"輸入錯誤: {str(e)}")
2. 文件操作異常
try:
with open(password_file, 'r', encoding='utf-8') as f:
passwords = f.readlines()
except FileNotFoundError:
logger.error(f"密碼文件不存在: {password_file}")
raise PasswordSecurityError(f"文件未找到: {password_file}")
except PermissionError:
logger.error(f"無權(quán)限訪問密碼文件: {password_file}")
raise PasswordSecurityError(f"文件訪問權(quán)限不足: {password_file}")
3. 內(nèi)存安全異常
try:
# 安全清除密碼變量
password = None
del password
except Exception as e:
logger.warning(f"內(nèi)存清理失敗: {str(e)}")
4. 配置文件異常
try:
with open(config_file, 'r', encoding='utf-8') as f:
config = json.load(f)
except json.JSONDecodeError as e:
logger.error(f"配置文件格式錯誤: {str(e)}")
raise PasswordSecurityError(f"配置文件無效: {str(e)}")
except FileNotFoundError:
logger.warning("配置文件不存在，使用默認配置")
config = DEFAULT_CONFIG
代碼實現(xiàn)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
密碼強度檢測器
功能：評估密碼的安全性和強度
作者：Cline
版本：1.0
"""
import argparse
import sys
import json
import logging
import os
import re
import math
from datetime import datetime
from typing import Dict, List, Tuple, Optional
import hashlib
import secrets
# 配置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('password_checker.log'),
logging.StreamHandler(sys.stdout)
]
)
logger = logging.getLogger(__name__)
class PasswordSecurityError(Exception):
"""密碼安全異常類"""
pass
class PasswordValidationError(Exception):
"""密碼驗證異常類"""
pass
class PasswordStrengthChecker:
def __init__(self, config: Dict[str, any] = None):
# 默認配置
self.default_config = {
"min_length": 8,
"max_length": 128,
"require_uppercase": True,
"require_lowercase": True,
"require_digits": True,
"require_special_chars": True,
"min_special_chars": 1,
"blacklist_words": [
"password", "123456", "qwerty", "admin", "welcome",
"login", "root", "guest", "user", "test"
],
"keyboard_patterns": [
"qwerty", "asdf", "zxcv", "1234", "abcd"
],
"scoring_weights": {
"length": 0.3,
"complexity": 0.4,
"patterns": 0.2,
"entropy": 0.1
}
}
# 合并配置
self.config = {**self.default_config, **(config or {})}
# 特殊字符集合
self.special_chars = "!@#$%^&*()_+-=[]{}|;:,.<>?"
# 檢測結(jié)果統(tǒng)計
self.stats = {
"total_checked": 0,
"strong_passwords": 0,
"medium_passwords": 0,
"weak_passwords": 0,
"very_weak_passwords": 0
}
def calculate_entropy(self, password: str) -> float:
"""計算密碼熵值"""
if not password:
return 0.0
# 計算字符集大小
charset_size = 0
if re.search(r'[a-z]', password):
charset_size += 26
if re.search(r'[A-Z]', password):
charset_size += 26
if re.search(r'[0-9]', password):
charset_size += 10
if re.search(r'[^a-zA-Z0-9]', password):
charset_size += len(self.special_chars)
# 計算熵值
if charset_size > 0:
entropy = len(password) * math.log2(charset_size)
return min(entropy, 100.0) # 限制最大值
return 0.0
def check_length(self, password: str) -> Tuple[int, str]:
"""檢查密碼長度"""
length = len(password)
min_len = self.config["min_length"]
max_len = self.config["max_length"]
if length < min_len:
return 0, f"密碼長度不足，至少需要 {min_len} 個字符"
elif length > max_len:
return 0, f"密碼長度過長，最多允許 {max_len} 個字符"
else:
# 長度評分（線性增長）
score = min(100, (length / max_len) * 100)
return int(score), f"密碼長度合適 ({length} 個字符)"
def check_complexity(self, password: str) -> Tuple[int, str]:
"""檢查密碼復(fù)雜度"""
score = 0
feedback = []
# 檢查小寫字母
if re.search(r'[a-z]', password):
score += 25
elif self.config["require_lowercase"]:
feedback.append("缺少小寫字母")
# 檢查大寫字母
if re.search(r'[A-Z]', password):
score += 25
elif self.config["require_uppercase"]:
feedback.append("缺少大寫字母")
# 檢查數(shù)字
if re.search(r'[0-9]', password):
score += 25
elif self.config["require_digits"]:
feedback.append("缺少數(shù)字")
# 檢查特殊字符
special_count = len(re.findall(r'[^a-zA-Z0-9]', password))
if special_count >= self.config["min_special_chars"]:
score += 25
elif self.config["require_special_chars"]:
feedback.append(f"特殊字符不足，至少需要 {self.config['min_special_chars']} 個")
if not feedback:
feedback_msg = "字符類型齊全"
else:
feedback_msg = "、".join(feedback)
return score, feedback_msg
def check_patterns(self, password: str) -> Tuple[int, str]:
"""檢查密碼模式"""
score = 100
feedback = []
# 檢查黑名單詞匯
password_lower = password.lower()
for word in self.config["blacklist_words"]:
if word in password_lower:
score -= 30
feedback.append(f"包含常見弱密碼詞匯: {word}")
# 檢查鍵盤序列
for pattern in self.config["keyboard_patterns"]:
if pattern in password_lower or pattern[::-1] in password_lower:
score -= 20
feedback.append(f"包含鍵盤序列: {pattern}")
# 檢查重復(fù)字符
if re.search(r'(.)\1{2,}', password):
score -= 15
feedback.append("包含過多重復(fù)字符")
# 檢查連續(xù)字符
consecutive_count = 0
for i in range(len(password) - 2):
if ord(password[i+1]) == ord(password[i]) + 1 and ord(password[i+2]) == ord(password[i]) + 2:
consecutive_count += 1
if consecutive_count > 0:
score -= 10 * consecutive_count
feedback.append(f"包含 {consecutive_count} 組連續(xù)字符")
# 確保分數(shù)不低于0
score = max(0, score)
if not feedback:
feedback_msg = "未發(fā)現(xiàn)明顯模式問題"
else:
feedback_msg = "、".join(feedback)
return score, feedback_msg
def evaluate_password_strength(self, password: str) -> Dict[str, any]:
"""評估密碼強度"""
if not password:
raise PasswordValidationError("密碼不能為空")
# 基本驗證
if len(password) > self.config["max_length"]:
raise PasswordValidationError(f"密碼長度不能超過 {self.config['max_length']} 個字符")
# 各項檢測
length_score, length_feedback = self.check_length(password)
complexity_score, complexity_feedback = self.check_complexity(password)
patterns_score, patterns_feedback = self.check_patterns(password)
entropy_score = self.calculate_entropy(password)
# 計算綜合得分
weights = self.config["scoring_weights"]
total_score = (
length_score * weights["length"] +
complexity_score * weights["complexity"] +
patterns_score * weights["patterns"] +
entropy_score * weights["entropy"]
)
# 確定強度等級
if total_score >= 80:
strength_level = "very_strong"
strength_desc = "非常強"
elif total_score >= 60:
strength_level = "strong"
strength_desc = "強"
elif total_score >= 40:
strength_level = "medium"
strength_desc = "中等"
else:
strength_level = "weak"
strength_desc = "弱"
# 更新統(tǒng)計
self.stats["total_checked"] += 1
if strength_level == "very_strong":
self.stats["strong_passwords"] += 1
elif strength_level == "strong":
self.stats["strong_passwords"] += 1
elif strength_level == "medium":
self.stats["medium_passwords"] += 1
else:
self.stats["weak_passwords"] += 1
result = {
"password": self.mask_password(password),
"score": round(total_score, 2),
"strength_level": strength_level,
"strength_description": strength_desc,
"details": {
"length": {
"score": length_score,
"feedback": length_feedback
},
"complexity": {
"score": complexity_score,
"feedback": complexity_feedback
},
"patterns": {
"score": patterns_score,
"feedback": patterns_feedback
},
"entropy": {
"score": round(entropy_score, 2),
"bits": round(math.log2(len(password) or 1), 2) if password else 0
}
},
"recommendations": self.generate_recommendations(
length_score, complexity_score, patterns_score
),
"timestamp": datetime.now().isoformat()
}
return result
def mask_password(self, password: str) -> str:
"""掩碼密碼顯示"""
if len(password) <= 4:
return "*" * len(password)
else:
return password[:2] + "*" * (len(password) - 4) + password[-2:]
def generate_recommendations(self, length_score: int, complexity_score: int, patterns_score: int) -> List[str]:
"""生成改進建議"""
recommendations = []
if length_score < 80:
recommendations.append("增加密碼長度，建議至少12個字符")
if complexity_score < 80:
recommendations.append("使用更多類型的字符（大小寫字母、數(shù)字、特殊符號）")
if patterns_score < 80:
recommendations.append("避免使用常見詞匯、鍵盤序列和重復(fù)字符")
if not recommendations:
recommendations.append("密碼強度良好，繼續(xù)保持")
return recommendations
def check_password_list(self, passwords: List[str]) -> List[Dict[str, any]]:
"""批量檢查密碼列表"""
results = []
for i, password in enumerate(passwords):
try:
result = self.evaluate_password_strength(password.strip())
results.append(result)
logger.info(f"已檢查第 {i+1} 個密碼")
except Exception as e:
logger.error(f"檢查第 {i+1} 個密碼時出錯: {str(e)}")
results.append({
"password": self.mask_password(password.strip()),
"error": str(e),
"timestamp": datetime.now().isoformat()
})
return results
def load_passwords_from_file(self, file_path: str) -> List[str]:
"""從文件加載密碼列表"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
passwords = [line.strip() for line in f if line.strip()]
logger.info(f"從文件加載了 {len(passwords)} 個密碼")
return passwords
except FileNotFoundError:
logger.error(f"密碼文件不存在: {file_path}")
raise PasswordSecurityError(f"文件未找到: {file_path}")
except Exception as e:
logger.error(f"加載密碼文件時出錯: {str(e)}")
raise PasswordSecurityError(f"文件加載失敗: {str(e)}")
def save_results(self, results: List[Dict[str, any]], output_file: str):
"""保存檢測結(jié)果"""
try:
# 確保輸出目錄存在
output_dir = os.path.dirname(output_file) if os.path.dirname(output_file) else '.'
os.makedirs(output_dir, exist_ok=True)
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(results, f, indent=2, ensure_ascii=False)
logger.info(f"檢測結(jié)果已保存到 {output_file}")
except Exception as e:
logger.error(f"保存檢測結(jié)果時出錯: {str(e)}")
raise PasswordSecurityError(f"結(jié)果保存失敗: {str(e)}")
def generate_report(self, results: List[Dict[str, any]]) -> Dict[str, any]:
"""生成檢測報告"""
weak_passwords = [r for r in results if r.get("strength_level") in ["weak", "very_weak"]]
medium_passwords = [r for r in results if r.get("strength_level") == "medium"]
strong_passwords = [r for r in results if r.get("strength_level") in ["strong", "very_strong"]]
report = {
"summary": {
"total_passwords": len(results),
"very_strong": len([r for r in results if r.get("strength_level") == "very_strong"]),
"strong": len([r for r in results if r.get("strength_level") == "strong"]),
"medium": len(medium_passwords),
"weak": len([r for r in results if r.get("strength_level") == "weak"]),
"very_weak": len([r for r in results if r.get("strength_level") == "very_weak"])
},
"statistics": self.stats,
"weak_passwords": weak_passwords[:10], # 只顯示前10個弱密碼
"recommendations": [
"定期更換密碼",
"使用密碼管理器生成和存儲復(fù)雜密碼",
"啟用多因素認證",
"避免在多個賬戶使用相同密碼"
],
"timestamp": datetime.now().isoformat()
}
return report
def print_result(self, result: Dict[str, any]):
"""打印檢測結(jié)果"""
print("\n" + "="*60)
print("密碼強度檢測結(jié)果")
print("="*60)
print(f"密碼: {result['password']}")
print(f"綜合得分: {result['score']}/100")
print(f"強度等級: {result['strength_description']}")
print("-"*60)
print("詳細分析:")
print(f" 長度檢測: {result['details']['length']['score']}/100 - {result['details']['length']['feedback']}")
print(f" 復(fù)雜度檢測: {result['details']['complexity']['score']}/100 - {result['details']['complexity']['feedback']}")
print(f" 模式檢測: {result['details']['patterns']['score']}/100 - {result['details']['patterns']['feedback']}")
print(f" 熵值檢測: {result['details']['entropy']['score']}/100 ({result['details']['entropy']['bits']} bits)")
print("-"*60)
print("改進建議:")
for i, rec in enumerate(result['recommendations'], 1):
print(f" {i}. {rec}")
print("="*60)
def print_report(self, report: Dict[str, any]):
"""打印檢測報告"""
print("\n" + "="*60)
print("密碼強度檢測報告")
print("="*60)
print(f"檢測時間: {report['timestamp']}")
print("-"*60)
print("統(tǒng)計摘要:")
print(f" 總密碼數(shù): {report['summary']['total_passwords']}")
print(f" 非常強: {report['summary']['very_strong']}")
print(f" 強: {report['summary']['strong']}")
print(f" 中等: {report['summary']['medium']}")
print(f" 弱: {report['summary']['weak']}")
print(f" 非常弱: {report['summary']['very_weak']}")
print("-"*60)
print("安全建議:")
for i, rec in enumerate(report['recommendations'], 1):
print(f" {i}. {rec}")
print("="*60)
def create_sample_config():
"""創(chuàng)建示例配置文件"""
sample_config = {
"min_length": 8,
"max_length": 128,
"require_uppercase": True,
"require_lowercase": True,
"require_digits": True,
"require_special_chars": True,
"min_special_chars": 1,
"blacklist_words": [
"password", "123456", "qwerty", "admin", "welcome",
"login", "root", "guest", "user", "test", "abc123"
],
"keyboard_patterns": [
"qwerty", "asdf", "zxcv", "1234", "abcd", "qwer"
],
"scoring_weights": {
"length": 0.3,
"complexity": 0.4,
"patterns": 0.2,
"entropy": 0.1
}
}
with open('password_checker_config.json', 'w', encoding='utf-8') as f:
json.dump(sample_config, f, indent=2, ensure_ascii=False)
logger.info("示例配置文件已創(chuàng)建: password_checker_config.json")
def generate_strong_password(length: int = 16) -> str:
"""生成強密碼"""
alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()"
password = ''.join(secrets.choice(alphabet) for _ in range(length))
return password
def main():
parser = argparse.ArgumentParser(description='密碼強度檢測器')
parser.add_argument('password', nargs='?', help='要檢測的密碼')
parser.add_argument('-f', '--file', help='包含密碼列表的文件路徑')
parser.add_argument('-o', '--output', help='輸出結(jié)果文件路徑')
parser.add_argument('-c', '--config', help='配置文件路徑')
parser.add_argument('--generate', type=int, nargs='?', const=16, help='生成指定長度的強密碼')
parser.add_argument('--sample-config', action='store_true', help='創(chuàng)建示例配置文件')
parser.add_argument('--interactive', action='store_true', help='交互式檢測模式')
args = parser.parse_args()
if args.sample_config:
create_sample_config()
return
if args.generate:
password = generate_strong_password(args.generate)
print(f"生成的強密碼: {password}")
return
# 加載配置
config = {}
if args.config and os.path.exists(args.config):
try:
with open(args.config, 'r', encoding='utf-8') as f:
config = json.load(f)
except Exception as e:
logger.error(f"加載配置文件失敗: {str(e)}")
# 創(chuàng)建檢測器實例
checker = PasswordStrengthChecker(config)
try:
if args.interactive:
# 交互式模式
while True:
try:
password = input("\n請輸入要檢測的密碼 (輸入 'quit' 退出): ")
if password.lower() == 'quit':
break
if not password:
continue
result = checker.evaluate_password_strength(password)
checker.print_result(result)
except KeyboardInterrupt:
print("\n退出交互模式")
break
except Exception as e:
logger.error(f"密碼檢測出錯: {str(e)}")
elif args.file:
# 文件批量檢測模式
passwords = checker.load_passwords_from_file(args.file)
results = checker.check_password_list(passwords)
# 保存結(jié)果
output_file = args.output or f"password_check_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
checker.save_results(results, output_file)
# 生成報告
report = checker.generate_report(results)
report_file = f"{output_file}.report.json"
with open(report_file, 'w', encoding='utf-8') as f:
json.dump(report, f, indent=2, ensure_ascii=False)
logger.info(f"檢測報告已保存到 {report_file}")
# 打印報告
checker.print_report(report)
elif args.password:
# 單密碼檢測模式
result = checker.evaluate_password_strength(args.password)
checker.print_result(result)
# 保存結(jié)果
if args.output:
checker.save_results([result], args.output)
else:
# 顯示幫助信息
parser.print_help()
except KeyboardInterrupt:
logger.info("密碼檢測被用戶中斷")
sys.exit(1)
except PasswordSecurityError as e:
logger.error(f"密碼安全錯誤: {str(e)}")
sys.exit(1)
except Exception as e:
logger.error(f"密碼檢測過程中發(fā)生未知錯誤: {str(e)}")
sys.exit(1)
if __name__ == '__main__':
main()
使用說明
1. 基本使用
# 檢測單個密碼 python password_checker.py "MyPassword123!" # 交互式檢測模式 python password_checker.py --interactive # 生成強密碼 python password_checker.py --generate python password_checker.py --generate 20 # 指定長度
2. 批量檢測
# 從文件批量檢測密碼 python password_checker.py -f passwords.txt # 指定輸出文件 python password_checker.py -f passwords.txt -o results.json
3. 配置文件使用
# 使用自定義配置文件 python password_checker.py "MyPassword123!" -c config.json # 創(chuàng)建示例配置文件 python password_checker.py --sample-config
配置文件示例
創(chuàng)建一個名為 config.json 的配置文件：
{
"min_length": 12,
"max_length": 128,
"require_uppercase": true,
"require_lowercase": true,
"require_digits": true,
"require_special_chars": true,
"min_special_chars": 2,
"blacklist_words": [
"password", "123456", "qwerty", "admin", "welcome",
"login", "root", "guest", "user", "test", "abc123",
"password123", "admin123"
],
"keyboard_patterns": [
"qwerty", "asdf", "zxcv", "1234", "abcd", "qwer",
"qazwsx", "plmokn"
],
"scoring_weights": {
"length": 0.25,
"complexity": 0.35,
"patterns": 0.25,
"entropy": 0.15
}
}
密碼文件格式
創(chuàng)建一個名為 passwords.txt 的密碼文件：
MyPassword123!
weakpassword
Admin123
qwerty123
StrongPass!@#456
testuser
SecurePassword2023$
password
12345678
MySecurePass99!
高級特性
1. 集成到應(yīng)用程序
from password_checker import PasswordStrengthChecker
# 創(chuàng)建檢測器實例
checker = PasswordStrengthChecker()
# 在用戶注冊時檢查密碼強度
def register_user(username, password):
try:
result = checker.evaluate_password_strength(password)
if result['strength_level'] in ['weak', 'very_weak']:
return False, "密碼強度不足，請使用更強的密碼"
return True, "密碼強度合格"
except Exception as e:
return False, str(e)
2. 定期安全審計
# 每周日凌晨2點執(zhí)行密碼安全審計
0 2 * * 0 /usr/bin/python3 /path/to/password_checker.py -f /path/to/user_passwords.txt -o /var/log/password_audit.json
3. 企業(yè)級部署
# 企業(yè)級密碼策略配置
enterprise_config = {
"min_length": 16,
"require_uppercase": True,
"require_lowercase": True,
"require_digits": True,
"require_special_chars": True,
"min_special_chars": 3,
"blacklist_words": ["companyname", "productname"], # 企業(yè)特定詞匯
"scoring_weights": {
"length": 0.2,
"complexity": 0.4,
"patterns": 0.3,
"entropy": 0.1
}
}
checker = PasswordStrengthChecker(enterprise_config)
性能優(yōu)化
1. 內(nèi)存管理
- 安全清除密碼變量避免內(nèi)存殘留
- 批量處理時分批加載避免內(nèi)存溢出
- 使用生成器處理大數(shù)據(jù)集
2. 檢測速度優(yōu)化
- 預(yù)編譯正則表達式提高匹配速度
- 緩存常見計算結(jié)果
- 并行處理多個密碼檢測
3. 錯誤處理優(yōu)化
- 實現(xiàn)優(yōu)雅的錯誤恢復(fù)機制
- 記錄詳細的檢測日志便于問題追蹤
- 提供友好的錯誤提示信息
安全考慮
1. 數(shù)據(jù)安全
- 密碼在內(nèi)存中安全處理，避免明文存儲
- 輸出結(jié)果中密碼被適當(dāng)掩碼
- 配置文件權(quán)限合理設(shè)置
2. 系統(tǒng)安全
- 限制處理密碼的數(shù)量和大小
- 實現(xiàn)處理超時機制
- 記錄所有操作日志便于審計
3. 隱私保護
- 不收集用戶密碼信息
- 本地處理不上傳任何數(shù)據(jù)
- 符合隱私保護法規(guī)要求
這個密碼強度檢測器是一個功能強大、安全可靠的安全工具，能夠幫助用戶和企業(yè)評估密碼的安全性，提升整體網(wǎng)絡(luò)安全水平。
以上就是基于Python實現(xiàn)一個專業(yè)的密碼強度檢測器的詳細內(nèi)容，更多關(guān)于Python密碼強度檢測器的資料請關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
這篇文章主要介紹了Python切片操作,結(jié)合實例形式較為詳細的分析了Python切片相關(guān)的正向、反向、步長等使用技巧與相關(guān)注意事項,需要的朋友可以參考下2018-03-03
python通過scapy獲取局域網(wǎng)所有主機mac地址示例
這篇文章主要介紹了python通過scapy獲取局域網(wǎng)所有主機mac地址示例,需要的朋友可以參考下2014-05-05
這篇文章主要介紹了pandas的qcut()方法詳解，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2019-07-07
python常用數(shù)據(jù)結(jié)構(gòu)集合詳解
這篇文章主要介紹了python常用數(shù)據(jù)結(jié)構(gòu)集合詳解，文章圍繞主題展開詳細的內(nèi)容介紹，具有一定的參考價值，感興趣的小伙伴可以參考一下，希望對你的學(xué)習(xí)有所幫助2022-08-08
實例講解Python中函數(shù)的調(diào)用與定義
這篇文章主要介紹了Python中函數(shù)的調(diào)用與定義,是Python入門學(xué)習(xí)中的基礎(chǔ)知識,需要的朋友可以參考下2016-03-03
這篇文章主要介紹了進一步理解Python中的函數(shù)編程,本文進一步討論了Python中函數(shù)編程的一些要點,來自IBM官方技術(shù)文檔,需要的朋友可以參考下2015-04-04
python設(shè)置環(huán)境變量路徑實現(xiàn)過程
本文介紹設(shè)置Python路徑的多種方法：臨時設(shè)置（Windows用`set`,Linux/macOS用`export`）、永久設(shè)置（系統(tǒng)屬性或shell配置文件）、動態(tài)修改（`sys.path.append`）、虛擬環(huán)境管理路徑,需注意路徑格式與系統(tǒng)一致,并重啟終端生效2025-07-07
下面小編就為大家分享一篇python opencv 圖像尺寸變換方法，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2018-04-04
Python實現(xiàn)數(shù)據(jù)庫連接池的代碼示例和最佳實踐
在現(xiàn)代Web應(yīng)用和數(shù)據(jù)密集型系統(tǒng)中,數(shù)據(jù)庫連接管理是一個關(guān)鍵的性能瓶頸,頻繁地創(chuàng)建和銷毀數(shù)據(jù)庫連接不僅消耗資源,還會導(dǎo)致應(yīng)用程序響應(yīng)時間變長,為了解決這個問題,數(shù)據(jù)庫連接池技術(shù)應(yīng)運而生,本文將深入探討Python中如何實現(xiàn)數(shù)據(jù)庫連接池,需要的朋友可以參考下2025-12-12
這篇文章主要為大家詳細介紹了python如何將項目打包成docker鏡像并運行,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下2025-09-09