>>> import ast
>>> x = '[ "A","B","C" , " D"]'
>>> x = ast.literal_eval(x)
>>> x
['A', 'B', 'C', ' D']
>>> x = [n.strip() for n in x]
>>> x
['A', 'B', 'C', 'D']

# check if two list equal
sorted(a) == sorted(b)

: is the delimiter of the slice syntax to 'slice out' sub-parts in sequences , [start:end]

[1:5] is equivalent to "from 1 to 5" (5 not included)
[1:] is equivalent to "1 to end"
[:20] from start to 20

# Python 合并两个列表
# 法一：
# Python合并两个列表, 相加是拼接
list1=[1,2,3]
list2=[4,5,6,7]
list3=list1+list2
print('list3',list3)#输出[1,2,3,4,5,6,7]

# 注意：Python合并两个NumPy数组，相加时候是对应相加
import numpy as  np
arr1=np.array([1,2,3])
arr2=np.array([4,5,6])
arr3=arr1+arr2
print(arr3)#输出[5 7 9]
#那么NumPy数组怎么拼接呢，使用concatenate
arr4=np.concatenate((arr1,arr2),axis=0)
print('arr4',arr4)

# 法二：
l3=[]
l1=[1,2,3]
l2=[4,5,6]
l3.append(l1)
l3.append(l2)
print('l3',l3)#输出[[1, 2, 3], [4, 5, 6]],注意这里是二维列表,不是我们想要的结果

# 如何才能达到我们要的结果，使用 extend
l1.extend(l2)
print('l1',l1)#[1, 2, 3, 4, 5, 6]

# 总结：
# Python合并两个列表，可用两个列表相加存入新列表，或者使用extend在原列表修改

txt = "I like bananas"

x = txt.replace("bananas", "apples")

print(x)

str_0 = str_0.replace(r"\\\\n", r"\n")

txt = "For only {price:.2f} dollars!"
print(txt.format(price = 49))

>>>a=" gho stwwl "
>>>a.lstrip()
'gho stwwl '
>>>a.rstrip()
' gho stwwl'
>>>a.strip()
'gho stwwl'

foo = {'k0': 'v0', 'k1': 'v1'}
print('k0' in foo)
print('k0' in foo.keys())
print('k2' in foo)

True
True
False

# 空的花括号代表空的 dict
empty_dict = {}
print(empty_dict)

scores = {'语文': 89, '数学': 92, '英语': 93}
# 打印所有的 key
print(scores.keys())
print(scores)

# 使用元组作为 dict 的 key
dict2 = {(20, 30):'good', 30:'bad'}
print(dict2)

# 生成一个字典
d = {'name':Tom, 'age':10, 'Tel':110}


del test_dict['Zhihu']

for key, value in dict_0.items():
    print(f"key: {key}, value: {value}")
 
>>> for key in a.keys():
print(key+':'+a[key])

a:1
b:2
c:3

for kv in dict0.items():
    print(kv)

dict_1 = {"a": 1, "b":2, "c":3}
if "a" in dict_1:
    print("Exists")
else:
    print("Does not exist")

car = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

car.clear()

print(car)

foo=set()
foo=set(1)
foo=set([1,2,3])
foo={1,2,3}

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set1.update(set2)
print(set1)
# {1, 'b', 'c', 2, 3, 'a'}

x = set([1,2,3])
y = set([3,4,5])  

print(x & y)
# {3}

print(x | y)
# {1, 2, 3, 4, 5}

print(x - y)
# {1, 2}

print(x ^ y)
# {1, 2, 4, 5}

1. < 运算符。
表示 左边是否是右边的子集。

> 运算符。
同理，表示右边是否是左边的子集。

<=和>=同理，只是加入了是否两个集合相等的判断。

myset = {"apple", "banana", "cherry"}

>>> l = set()
>>> l.add(1)
>>> l.add(2)
l.remove(1)

', '.join(set_3)

>>> x = set('spam')  
>>> y = set(['h','a','m'])  
>>> x, y
(set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))    

import copy

# 简单示例
original = [1, 2, [3, 4]]
deep_copied = copy.deepcopy(original)

# 修改深拷贝的嵌套列表
deep_copied[2][0] = 999
print(original)      # [1, 2, [3, 4]]  - 不受影响
print(deep_copied)   # [1, 2, [999, 4]] - 已修改

import copy

original = [1, 2, [3, 4]]

# 浅拷贝
shallow = copy.copy(original)
shallow[2][0] = 999
print(original)  # [1, 2, [999, 4]] - 受影响！

# 深拷贝
original = [1, 2, [3, 4]]
deep = copy.deepcopy(original)
deep[2][0] = 888
print(original)  # [1, 2, [3, 4]] - 不受影响

import copy

class Person:
    def __init__(self, name, friends):
        self.name = name
        self.friends = friends  # 列表引用

# 原始对象
alice = Person("Alice", ["Bob", "Charlie"])

# 浅拷贝
alice_shallow = copy.copy(alice)
alice_shallow.friends.append("David")
print(alice.friends)  # ['Bob', 'Charlie', 'David'] - 受影响

# 深拷贝
alice = Person("Alice", ["Bob", "Charlie"])
alice_deep = copy.deepcopy(alice)
alice_deep.friends.append("Eve")
print(alice.friends)  # ['Bob', 'Charlie'] - 不受影响
print(alice_deep.friends)  # ['Bob', 'Charlie', 'Eve']

import copy

original_dict = {
    'name': 'John',
    'age': 30,
    'hobbies': ['reading', 'gaming'],
    'address': {'city': 'Beijing', 'country': 'China'}
}

# 深拷贝字典
copied_dict = copy.deepcopy(original_dict)

# 修改嵌套结构
copied_dict['hobbies'].append('swimming')
copied_dict['address']['city'] = 'Shanghai'

print(original_dict['hobbies'])  # ['reading', 'gaming'] - 不受影响
print(original_dict['address'])  # {'city': 'Beijing', 'country': 'China'} - 不受影响

import copy
import time

# 大型嵌套结构
large_list = [[i] * 100 for i in range(1000)]

# 测量深拷贝时间
start = time.time()
deep_copy = copy.deepcopy(large_list)
print(f"深拷贝耗时: {time.time() - start:.4f} 秒")

# 测量浅拷贝时间
start = time.time()
shallow_copy = copy.copy(large_list)
print(f"浅拷贝耗时: {time.time() - start:.4f} 秒")

import copy

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

# 创建循环引用
node1 = Node(1)
node2 = Node(2)
node1.next = node2
node2.next = node1  # 循环引用

# 深拷贝可以正确处理
copied_node1 = copy.deepcopy(node1)
print(copied_node1.value)  # 1
print(copied_node1.next.value)  # 2
print(copied_node1.next.next.value)  # 1

import copy

class CustomClass:
    def __init__(self, data):
        self.data = data
    
    def __deepcopy__(self, memo):
        # 自定义深拷贝逻辑
        print("执行自定义深拷贝")
        new_obj = CustomClass(copy.deepcopy(self.data, memo))
        return new_obj

original = CustomClass([1, 2, 3])
copied = copy.deepcopy(original)
# 输出: 执行自定义深拷贝

import copy

f = open('file.txt', 'r')
try:
    copied_f = copy.deepcopy(f)  # TypeError: cannot deepcopy file objects
except TypeError as e:
    print(f"错误: {e}")

import copy

# 不可变类型的深拷贝返回自身
x = (1, 2, 3)
y = copy.deepcopy(x)
print(x is y)  # True - 元组是不可变的，直接返回引用

class Class0:
    pass
    
# Student 继承 object 类
class Student(object):
    pass

bart = Student()

class Student1(object):
    # __init__ 相当于构造函数
    def __init__(self, name, score):
        self.name = name
        # public 可见 外部可以访问 无 _
        self.score = score
        # protect 不可见 外部可以访问 _(单下划线)
        self._foo = "value0"
        # private 不可见 不可访问 __ (双下划线)
        self.__bar = "value1"

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

    # 类的方法
    # 类内部访问数据的函数
    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'
    
    # 私有函数
    def __foo(self):
        pass

student = Student1()
# object to dict
vars(student)

op = hasattr(a,'getValue')

import sys

a = [1, 2, 3]
print(sys.getrefcount(a))  # 2（一个是 a，一个是传递给 getrefcount 的参数）

b = a  # 引用计数增加
print(sys.getrefcount(a))  # 3

del b  # 引用计数减少
print(sys.getrefcount(a))  # 2

import gc

# 查看当前 GC 阈值
print(gc.get_threshold())  # (700, 10, 10)
# 700: 第 0 代触发阈值
# 10: 第 1 代触发阈值
# 10: 第 2 代触发阈值

import gc

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

# 创建循环引用
node1 = Node(1)
node2 = Node(2)
node1.next = node2
node2.next = node1

# 删除引用
del node1
del node2

# 循环引用的对象不会立即被回收（引用计数不为 0）
# 但会在下次 GC 时被检测到并回收
gc.collect()  # 手动触发垃圾回收

import gc

# 检查 GC 是否启用
print(gc.isenabled())  # True

# 禁用自动垃圾回收
gc.disable()

# 启用自动垃圾回收
gc.enable()

import gc

# 手动执行垃圾回收，返回不可达对象数量
collected = gc.collect()
print(f"回收了 {collected} 个对象")

# 指定回收哪一代
gc.collect(0)  # 只回收第 0 代
gc.collect(1)  # 回收第 0、1 代
gc.collect(2)  # 回收所有代（完全回收）

import gc

# 获取当前阈值
thresholds = gc.get_threshold()
print(f"当前阈值: {thresholds}")  # (700, 10, 10)

# 设置新阈值
# 参数含义：(threshold0, threshold1, threshold2)
gc.set_threshold(1000, 15, 15)

# 阈值说明：
# threshold0: 当新分配对象数 - 释放对象数 > 700 时，触发第 0 代回收
# threshold1: 第 0 代回收 10 次后，触发第 1 代回收
# threshold2: 第 1 代回收 10 次后，触发第 2 代回收

import gc

# 获取每一代的对象数量
print(gc.get_count())  # (581, 7, 3)
# 581: 第 0 代对象数量
# 7: 距离上次第 1 代回收的次数
# 3: 距离上次第 2 代回收的次数

# 获取 GC 统计信息
for i, stats in enumerate(gc.get_stats()):
    print(f"第 {i} 代统计: {stats}")

import gc

# 设置调试标志
gc.set_debug(gc.DEBUG_STATS | gc.DEBUG_LEAK)

# 常用调试标志：
# gc.DEBUG_STATS: 打印回收统计信息
# gc.DEBUG_LEAK: 打印泄漏的对象
# gc.DEBUG_COLLECTABLE: 打印可回收的对象
# gc.DEBUG_UNCOLLECTABLE: 打印无法回收的对象
# gc.DEBUG_SAVEALL: 保存所有对象到 gc.garbage

# 查看所有被追踪的对象
objects = gc.get_objects()
print(f"当前追踪了 {len(objects)} 个对象")

# 查找特定类型的对象
for obj in gc.get_objects():
    if isinstance(obj, dict):
        print(f"发现字典对象: {id(obj)}")
        break

# 查看无法回收的对象（通常是循环引用）
print(gc.garbage)  # []

import gc
import time

# 对于批量处理，可以临时禁用 GC
def batch_process(data):
    gc.disable()  # 禁用 GC
    try:
        result = [process_item(item) for item in data]
    finally:
        gc.enable()  # 重新启用 GC
        gc.collect()  # 手动触发一次回收
    return result

import weakref

class Node:
    def __init__(self, value):
        self.value = value
        # 使用弱引用避免循环引用
        self._parent = None
    
    def set_parent(self, parent):
        # 使用弱引用
        self._parent = weakref.ref(parent) if parent else None
    
    def get_parent(self):
        return self._parent() if self._parent else None

from contextlib import contextmanager
import gc

@contextmanager
def no_gc():
    """临时禁用 GC 的上下文管理器"""
    gc_enabled = gc.isenabled()
    gc.disable()
    try:
        yield
    finally:
        if gc_enabled:
            gc.enable()
            gc.collect()

# 使用示例
with no_gc():
    # 在这里执行不需要 GC 的代码
    big_list = [i for i in range(1000000)]

import gc
import sys

def get_size(obj):
    """递归计算对象大小"""
    size = sys.getsizeof(obj)
    if isinstance(obj, dict):
        size += sum([get_size(v) for v in obj.values()])
        size += sum([get_size(k) for k in obj.keys()])
    elif isinstance(obj, (list, tuple, set)):
        size += sum([get_size(i) for i in obj])
    return size

# 查找内存占用最大的对象
def find_large_objects(limit=10):
    objects = gc.get_objects()
    sizes = [(obj, sys.getsizeof(obj)) for obj in objects]
    sizes.sort(key=lambda x: x[1], reverse=True)
    
    for i, (obj, size) in enumerate(sizes[:limit], 1):
        print(f"{i}. {type(obj).__name__}: {size} bytes")

import gc
import time

def main_loop():
    gc.set_threshold(1000, 15, 15)  # 调整阈值减少 GC 频率
    
    while True:
        # 处理请求
        process_requests()
        
        # 每小时执行一次完全回收
        if time.time() % 3600 < 1:
            gc.collect(2)

import gc

def memory_intensive_task():
    # 处理大量数据时禁用 GC
    gc.disable()
    
    try:
        # 创建大量临时对象
        data = process_large_dataset()
        result = analyze_data(data)
    finally:
        # 手动清理并触发回收
        del data
        gc.enable()
        gc.collect()
    
    return result

import gc
import sys

def detect_memory_leak():
    # 强制回收所有代
    gc.collect()
    
    # 记录初始对象数
    before = len(gc.get_objects())
    
    # 执行可能泄漏的代码
    suspicious_function()
    
    # 再次回收
    gc.collect()
    
    # 检查对象数变化
    after = len(gc.get_objects())
    leaked = after - before
    
    if leaked > 100:
        print(f"警告：可能存在内存泄漏，增加了 {leaked} 个对象")
        
        # 查找新增的对象类型
        objects = gc.get_objects()[before:after]
        types = {}
        for obj in objects:
            t = type(obj).__name__
            types[t] = types.get(t, 0) + 1
        
        print("新增对象类型：")
        for t, count in sorted(types.items(), key=lambda x: x[1], reverse=True)[:10]:
            print(f"  {t}: {count}")

import gc
import json

def get_gc_config():
    """获取当前 GC 配置信息"""
    config = {
        "enabled": gc.isenabled(),
        "threshold": gc.get_threshold(),
        "count": gc.get_count(),
        "debug_flags": gc.get_debug(),
        "tracked_objects": len(gc.get_objects()),
        "garbage_objects": len(gc.garbage),
    }
    return config

# 在应用启动时记录
print("GC Configuration:", json.dumps(get_gc_config(), indent=2))

# 或者提供一个健康检查端点（Flask 示例）
from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/health/gc')
def gc_status():
    return jsonify(get_gc_config())

import gc
import signal
import sys
import json

def handle_gc_info(signum, frame):
    """信号处理器：输出 GC 配置信息"""
    info = {
        "enabled": gc.isenabled(),
        "threshold": gc.get_threshold(),
        "count": gc.get_count(),
        "stats": gc.get_stats(),
    }
    print("\n=== GC Configuration ===", file=sys.stderr)
    print(json.dumps(info, indent=2), file=sys.stderr)
    print("=" * 25 + "\n", file=sys.stderr)

# 注册信号处理器（Unix/Linux）
# SIGUSR1 (信号 10) 用于用户自定义
signal.signal(signal.SIGUSR1, handle_gc_info)

print(f"Process PID: {os.getpid()}")
print("Send SIGUSR1 to view GC info: kill -USR1 <PID>")

# 应用主循环
while True:
    # 你的应用逻辑
    time.sleep(1)

# 查找进程 PID
ps aux | grep python

# 发送信号查看 GC 配置
kill -USR1 <PID>

# 或者使用 pkill
pkill -USR1 -f "your_app.py"

# 在代码中添加远程调试入口
import pdb
import signal

def debug_handler(signum, frame):
    """信号触发调试器"""
    pdb.set_trace()

signal.signal(signal.SIGUSR2, debug_handler)

# 发送信号后在调试器中执行：
# >>> import gc
# >>> gc.isenabled()
# >>> gc.get_threshold()
# >>> gc.get_count()

# 安装 py-spy
pip install py-spy

# 查看进程信息（需要 root 权限或进程所有者）
sudo py-spy dump --pid <PID>

# 生成火焰图
sudo py-spy record -o profile.svg --pid <PID>

import gc
import logging
import threading
import time

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('gc_monitor.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger('gc_monitor')

def monitor_gc(interval=60):
    """定期监控 GC 状态"""
    while True:
        info = {
            "enabled": gc.isenabled(),
            "threshold": gc.get_threshold(),
            "count": gc.get_count(),
            "collections": gc.get_stats(),
        }
        logger.info(f"GC Status: {info}")
        time.sleep(interval)

# 启动监控线程
monitor_thread = threading.Thread(target=monitor_gc, args=(300,), daemon=True)
monitor_thread.start()

import gc
import time

def gc_callback(phase, info):
    """
    GC 回调函数
    phase: 'start' 或 'stop'
    info: 包含 generation 和 collected/uncollectable 对象数
    """
    if phase == 'stop':
        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] "
              f"GC Generation {info['generation']} completed: "
              f"collected={info['collected']}, "
              f"uncollectable={info['uncollectable']}")

# 设置回调（Python 3.3+）
gc.callbacks.append(gc_callback)

import gc
import psutil
import os

def get_memory_info():
    """获取进程内存和 GC 信息"""
    process = psutil.Process(os.getpid())
    mem_info = process.memory_info()
    
    return {
        "rss_mb": mem_info.rss / 1024 / 1024,  # 物理内存
        "vms_mb": mem_info.vms / 1024 / 1024,  # 虚拟内存
        "gc_enabled": gc.isenabled(),
        "gc_threshold": gc.get_threshold(),
        "gc_count": gc.get_count(),
        "tracked_objects": len(gc.get_objects()),
    }

# 定期输出
import json
while True:
    print(json.dumps(get_memory_info(), indent=2))
    time.sleep(60)

# 进入容器
docker exec -it <container_id> bash

# 启动 Python REPL 并附加到进程（需要 pyrasite）
pip install pyrasite
echo "import gc; print(gc.get_threshold())" | pyrasite-shell <PID>

# 或者使用 docker logs 查看输出
docker logs -f <container_id> | grep -i "gc"

# 查看进程环境变量
cat /proc/<PID>/environ | tr '\0' '\n' | grep PYTHON

# 相关环境变量：
# PYTHONGC - 控制 GC 行为
# PYTHONDEBUG - 调试模式
# PYTHONMALLOC - 内存分配器

# 使用 Datadog APM
from ddtrace import tracer, patch_all
patch_all()

# 使用 New Relic
import newrelic.agent
newrelic.agent.initialize('newrelic.ini')

# 使用 Prometheus + Python client
from prometheus_client import Gauge, start_http_server
import gc

gc_objects = Gauge('python_gc_objects_tracked', 'Number of objects tracked by GC')
gc_collections = Gauge('python_gc_collections', 'GC collection count', ['generation'])

def update_gc_metrics():
    gc_objects.set(len(gc.get_objects()))
    counts = gc.get_count()
    for gen, count in enumerate(counts):
        gc_collections.labels(generation=gen).set(count)

# 定期更新指标
start_http_server(8000)
while True:
    update_gc_metrics()
    time.sleep(10)

# 1. 使用 strace 监控系统调用（间接观察 GC 行为）
strace -p <PID> -e trace=brk,mmap,munmap

# 2. 使用 gdb 附加到进程
gdb -p <PID>
(gdb) call PyGILState_Ensure()
(gdb) call PyRun_SimpleString("import gc; print(gc.get_threshold())")

# 3. 使用 lsof 查看进程打开的文件（包括日志）
lsof -p <PID> | grep log

# 生产环境监控模板
import gc
import logging
import time
from datetime import datetime

class GCMonitor:
    def __init__(self, check_interval=300):
        self.check_interval = check_interval
        self.logger = logging.getLogger('gc_monitor')
        self.baseline = self._get_gc_snapshot()
    
    def _get_gc_snapshot(self):
        return {
            "timestamp": datetime.now().isoformat(),
            "enabled": gc.isenabled(),
            "threshold": gc.get_threshold(),
            "count": gc.get_count(),
            "stats": gc.get_stats(),
            "tracked": len(gc.get_objects()),
            "garbage": len(gc.garbage),
        }
    
    def check_and_alert(self):
        current = self._get_gc_snapshot()
        
        # 检查异常情况
        if current["garbage"] > 0:
            self.logger.warning(f"发现无法回收的对象: {current['garbage']}")
        
        tracked_increase = current["tracked"] - self.baseline["tracked"]
        if tracked_increase > 10000:
            self.logger.warning(
                f"追踪对象数异常增长: {tracked_increase}"
            )
        
        self.logger.info(f"GC Status: {current}")
        return current
    
    def run(self):
        while True:
            self.check_and_alert()
            time.sleep(self.check_interval)

# 使用示例
if __name__ == "__main__":
    monitor = GCMonitor(check_interval=300)  # 每5分钟检查一次
    monitor.run()

# 查看是否安装了 pip
pip --version
# archlinux install pip
pacman -S python-pip

# 使用普通用户安装包（用户级安装）
python3.14 -m pip install --user package_name

apt install python3-pip

# pip 默认安装路径是 ~.local/bin, 把它加到环境变量里
vim .zshrc
export PATH="$HOME/.local/bin:$PATH"

# install specific version
yay -S python36

# 打印包版本
pip list
pip list | grep requests

# 查看某一个包的信息
pip show django

# -r, --requirement <file>    Install from the given requirements file. This option can be used multiple times.
pip install -r requirements.txt

sudo pip install --proxy http://<usr_name>:<password>@<proxyserver_name>:<port#> <pkg_name> 

pip freeze #查看当前安装库版本

pip freeze |grep 
# 创建 requirements.txt 文件，其中包含了当前环境中所有包及各自的版本的简单列表
# 按 requirements.txt 安装依赖
pip install -r requirements.txt
# [SSL: CERTIFICATE_VERIFY_FAILED]
pip install --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org <package_name>
pip freeze > requirements.txt
pip uninstall kafka
lsvirtualenv        #列举所有的环境
cdvirtualenv        #导航到当前激活的虚拟环境的目录中，相当于 pushd 目录
cdsitepackages      #和上面的类似，直接进入到 site-packages 目录
lssitepackages      #显示 site-packages 目录中的内容

# archlinux install python3.6
yay -S python36

sudo apt update && sudo apt upgrade

wget https://www.python.org/ftp/python/3.6.15/Python-3.6.15.tgz
tar -xzf Python-3.6.15.tgz
cd Python-3.6.15

sudo apt install -y \
    build-essential \
    libssl-dev \
    zlib1g-dev \
    libncurses5-dev \
    libncursesw5-dev \
    libreadline-dev \
    libsqlite3-dev \
    libgdbm-dev \
    libdb5.3-dev \
    libbz2-dev \
    libexpat1-dev \
    liblzma-dev \
    tk-dev \
    libffi-dev \
    wget

./configure --prefix=/opt/python3.6 --with-openssl=/usr
make -j$(nproc)
sudo make install
/opt/python3.6/bin/python3.6 -V

---
./configure --with-pydebug --enable-loadable-sqlite-extensions
./configure --with-pydebug
./configure --enable-optimizations  -with-lto  --with-pydebug

# adjust for number of your CPU cores
make -j 8
sudo make altinstall

apt install python3

pip install pipdeptree
pipdeptree -p apscheduler

python -V
python --version

# archlinux install python
pacman -S python

# 安装 python 11, 默认路径  C:\Users\user_0\AppData\Local\Programs\Python\Python311
winget install Python.Python.3.11
# --location 目前不好用 winget 版本 v1.4.11071,  --verbose  在安装 python 的时候并没有输出更多日志
winget install Python.Python.3.11 --location "C:\workspace\apps\python11" --verbose
winget install -e -i --id=Python.Python.3.11
winget uninstall Python.Python.3.11

winget install Python.Python.3.6

# !/usr/bin/python
  
import os,sys
  
dir = '/home/wiloon/tmp'
  
list = os.listdir(dir)
  
print list

for line in list:

path = os.path.join(dir, line)

print path

import os
import sys
// 打开文件，只读
f = open("/root/tmp/ip.txt", "r")
// 读取文件
lines = f.readlines()
// 字符串长度
print(len(lines))
// for 循环
for line in lines:
# 去空格
    line = line.strip()
    command = "ansible '" + line + "' -m shell -a 'systemctl start filebeat'"
    print(command)
    // 等待用户 输入
    value = input("press any key to continue:")
    // 判断字符串相等
    if value == "q":
    // 退出
        sys.exit(0)
        // 执行 shwll 命令
    os.system(command)

import sys

# import module_name
# import 搜索路径 sys.path, 运行文件所在的目录

# 打印 sys.path
import sys; print(sys.path)

# Python 会在 sys.path 和运行文件目录这两个地方寻找包，然后导入包中名为module_name的模块。
# from package_name import module_name

s1 = '  shark  '
print(f"string: '{s1}'")

s1_remove_leading = s1.lstrip()
print(f"remove leading: '{s1_remove_leading}'")

s1_remove_trailing = s1.rstrip()
print(f"remove trailing: '{s1_remove_trailing}'")

s1_remove_both = s1.strip()
print(f"remove both: '{s1_remove_both}'")

class FooException(Exception):
    pass

def func1():
    # 相当于 java 的  throw new Exception
    raise Exception("--func1 exception--")


def main():
    try:
        func1()
    except Exception as e:
        print e


if __name__ == '__main__':
    main()

需要多个 Python 版本？        → pyenv
需要项目环境隔离？           → venv (标准) 或 virtualenv
需要完整项目管理？           → pdm 或 poetry
需要快速安装包？             → uv（替代 pip）
简单脚本？                  → pip（默认即可）

# 安装 pyenv (macOS/Linux)
curl https://pyenv.run | bash

# 配置环境变量（添加到 ~/.bashrc 或 ~/.zshrc）
export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"

# archlinux 安装 pyenv
yay -S pyenv

# 列出可安装的 Python 版本
pyenv install --list

# 列出可安装的 CPython 版本
pyenv install --list | grep "^  3\."

# 安装指定版本
pyenv install 3.12.0
pyenv install 3.11.5
pyenv install 3.10.13

# 列出已安装的版本
pyenv versions

# 查看当前使用的版本
pyenv version

# 设置全局 Python 版本（整个系统默认）
pyenv global 3.12.0

# 设置当前项目的 Python 版本（创建 .python-version 文件）
cd /path/to/project
pyenv local 3.11.0

# 设置 shell 会话的 Python 版本（临时）
pyenv shell 3.10.0

# 取消 shell 版本设置
pyenv shell --unset

# 卸载指定版本
pyenv uninstall 3.10.0

# 更新 pyenv
cd ~/.pyenv && git pull

# 项目 A 使用 Python 3.11
cd ~/projects/project-a
pyenv local 3.11.5
python --version  # Python 3.11.5

# 项目 B 使用 Python 3.12
cd ~/projects/project-b
pyenv local 3.12.0
python --version  # Python 3.12.0

# 自动切换：每次进入目录，pyenv 自动切换版本

# 在 Python 3.10 下测试
pyenv shell 3.10.13
python test.py

# 在 Python 3.11 下测试
pyenv shell 3.11.5
python test.py

# 在 Python 3.12 下测试
pyenv shell 3.12.0
python test.py

# 先用 pyenv 选择 Python 版本
pyenv local 3.11.5

# 再创建虚拟环境
python -m venv .venv
source .venv/bin/activate

# 虚拟环境使用的是 pyenv 指定的 Python 3.11.5
python --version

# Ubuntu/Debian
sudo apt update
sudo apt install -y make build-essential libssl-dev zlib1g-dev \
libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm \
libncursesw5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev \
libffi-dev liblzma-dev

# CentOS/Fedora
sudo yum install gcc zlib-devel bzip2 bzip2-devel readline-devel \
sqlite sqlite-devel openssl-devel tk-devel libffi-devel xz-devel

# macOS (需要 Homebrew)
brew install openssl readline sqlite3 xz zlib

# macOS/Linux - Git 安装方式
git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.13.1

# 配置环境变量（添加到 ~/.bashrc 或 ~/.zshrc）
. "$HOME/.asdf/asdf.sh"
. "$HOME/.asdf/completions/asdf.bash"

# macOS - Homebrew 安装
brew install asdf

# Ubuntu - 使用包管理器
sudo apt install asdf

# 验证安装
asdf --version

# 1. 安装 Python 插件
asdf plugin add python

# 2. 列出可安装的 Python 版本
asdf list all python

# 3. 安装指定版本
asdf install python 3.12.0
asdf install python 3.11.5
asdf install python 3.10.13

# 4. 设置全局版本
asdf global python 3.12.0

# 5. 设置项目本地版本
cd /path/to/project
asdf local python 3.11.5

# 6. 设置 shell 临时版本
asdf shell python 3.10.13

# 7. 列出已安装的版本
asdf list python

# 8. 查看当前版本
asdf current python

# 9. 卸载指定版本
asdf uninstall python 3.10.0

# 安装 Node.js 插件
asdf plugin add nodejs
asdf install nodejs 20.10.0
asdf global nodejs 20.10.0

# 安装 Ruby 插件
asdf plugin add ruby
asdf install ruby 3.2.0
asdf global ruby 3.2.0

# 安装 Go 插件
asdf plugin add golang
asdf install golang 1.21.5
asdf global golang 1.21.5

# 查看所有已安装的插件
asdf plugin list

# 查看所有语言的当前版本
asdf current

# 在项目根目录创建 .tool-versions 文件
cd /path/to/project
cat > .tool-versions << EOF
python 3.11.5
nodejs 20.10.0
ruby 3.2.0
EOF

# 进入项目目录，asdf 自动切换所有工具版本
cd /path/to/project
python --version  # 3.11.5
node --version    # 20.10.0
ruby --version    # 3.2.0

# 团队成员只需：
git clone <repo>
cd <repo>
asdf install  # 自动安装 .tool-versions 中的所有版本

# 项目目录
cd ~/projects/fullstack-app

# 配置版本
asdf local python 3.12.0
asdf local nodejs 20.10.0

# .tool-versions 文件内容
cat .tool-versions
# python 3.12.0
# nodejs 20.10.0

# 每次进入项目，版本自动切换
cd ~/projects/fullstack-app
python --version  # 3.12.0
node --version    # 20.10.0

# 管理各种 DevOps 工具的版本
asdf plugin add terraform
asdf plugin add kubectl
asdf plugin add helm

asdf install terraform 1.6.0
asdf install kubectl 1.28.0
asdf install helm 3.13.0

asdf global terraform 1.6.0
asdf global kubectl 1.28.0
asdf global helm 3.13.0

# Ubuntu/Debian
sudo apt update
sudo apt install -y make build-essential libssl-dev zlib1g-dev \
libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm \
libncursesw5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev \
libffi-dev liblzma-dev

# macOS
brew install openssl readline sqlite3 xz zlib

# 安装 venv (某些发行版需要)
sudo apt install -y python3-venv

# 创建虚拟环境
python3 -m venv myenv

# 创建指定 Python 版本的虚拟环境
/usr/bin/python3.6 -m venv apps/venv-36

# 激活环境 - Linux/macOS
source myenv/bin/activate

# 激活环境 - Windows
myenv\Scripts\activate.bat

# 退出环境
deactivate

# 删除环境（直接删除目录）
rm -rf myenv

# 判断当前是否在虚拟环境里
which python

# 安装 pdm
pip install --user pdm

# 初始化项目
pdm init

# 添加依赖
pdm add requests
pdm add pytest --dev  # 开发依赖
pdm add -G docs sphinx  # 添加到 docs 组

# 安装所有依赖
pdm install

# 只安装生产依赖
pdm install --prod

# 运行脚本
pdm run python script.py

# 运行自定义命令（定义在 pyproject.toml）
pdm run test
pdm run lint

# 更新依赖
pdm update
pdm update requests  # 只更新指定包

# 列出依赖
pdm list
pdm list --tree  # 树形显示依赖

# 显示依赖信息
pdm show requests

# 移除依赖
pdm remove requests

# 导出 requirements.txt
pdm export -o requirements.txt

myproject/
├── pyproject.toml      # 项目配置和依赖
├── pdm.lock           # 锁文件（确保一致性）
└── __pypackages__/    # 依赖包目录（PEP 582）

# 方案 1：pdm 使用 uv 作为安装后端
# 在 pyproject.toml 中配置
[tool.pdm]
install.cache = true
install.cache-method = "symlink"

# pdm 会自动检测并使用 uv（如果已安装）
pdm install

# 方案 2：手动结合使用
# 用 pdm 管理依赖，用 uv 安装
pdm export -o requirements.txt
uv pip install -r requirements.txt

# 方案 3：pdm 配置使用 uv
pdm config install.use-uv true

# 1. 初始化项目
pdm init

# 2. 添加依赖
pdm add fastapi uvicorn
pdm add pytest pytest-cov --dev

# 3. 配置脚本（在 pyproject.toml 中）
[tool.pdm.scripts]
start = "uvicorn main:app --reload"
test = "pytest tests/"
lint = "ruff check ."

# 4. 运行项目
pdm run start

# 5. 运行测试
pdm run test

# 6. 锁定依赖
pdm lock

# 7. 在其他环境安装（使用锁文件）
pdm install

# pip 命令               →  uv 命令
pip install requests     →  uv pip install requests
pip install -r req.txt   →  uv pip install -r req.txt
pip install -e .         →  uv pip install -e .
pip uninstall package    →  uv pip uninstall package
pip list                 →  uv pip list
pip show package         →  uv pip show package
pip freeze               →  uv pip freeze
pip search term          →  uv pip search term