Python语言从2.7到3.14的能力变化与演进逻辑

# Python 2.7 - 字符串处理复杂
# -*- coding: utf-8 -*-
name = u"EDAS 用户"  # Unicode字符串
message = u"Hello, %s!" % name
print message.encode('utf-8')


# 字符串格式化方式有限
template = u"用户{name}在{timestamp} 登录了 EDAS 应用管理平台"
result = template.format(name, "2023-01-01")

# Python 3.0+ - 字符串处理简化
name = "EDAS用户"  # 默认Unicode
message = "Hello, {}!".format(name)


print(message)  # print变为函数

# Python 3.6+ - f-string革命 
name = "EDAS 用户"
timestamp = "2023-01-01"
message = f"Hello, {name}!"
complex_message = f"用户{name}在{timestamp}登录了 EDAS 应用管理平台"


# 支持表达式和格式化
price = 123.456
formatted = f"价格: {price:.2f}元"  # 价格: 123.46元


# 支持调试模式（Python 3.8+）
debug_info = f"{name=}, {timestamp=}"  
# name='世界', timestamp='2023-01-01'

# Python 3.4 - 基于生成器的异步编程 - for Python in EDAS
import asyncio

@asyncio.coroutine
def fetch_data(url):
    response = yield from aiohttp.get(url)
    data = yield from response.text()
    return data

@asyncio.coroutine
def main():
    tasks = []

    for url in urls:
        task = asyncio.ensure_future(fetch_data(url))
        tasks.append(task)
      
    results = yield from asyncio.gather(*tasks)
    return results

# Python 3.5+ - async/await语法 - for Python in EDAS
import asyncio
import aiohttp


async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()


async def main():
    urls = ['http://edas.console.aliyun.com', 
            'http://www.aliyun.com/product/edas' ]
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    return results


# Python 3.7+ - 更简洁的运行方式
asyncio.run(main())

# Python 3.5 - 基础类型提示 - for Python in EDAS
from typing import List, Dict, Optional, Union


def process_users(users: List[str]) -> Dict[str, int]:
    result = {}
    for user in users:
        result[user] = len(user)
    return result


def find_user(user_id: int) -> Optional[str]:
    # 可能返回None
    return database.get_user(user_id)


# 联合类型
def handle_input(value: Union[str, int]) -> str:
    return str(value)

# Python 3.9+ - 内置集合泛型
def process_data(items: list[str]) -> dict[str, int]:
    return{item: len(item) for item in items}


def merge_lists(list1: list[int], list2: list[int]) -> list[int]:
    return list1 + list2

# Python 3.10+ - 联合类型语法糖
def handle_input(value: str | int) -> str:
    returnstr(value)


def process_result(data: dict[str, str | int | None]) -> str:
    # 处理混合类型字典
    return json.dumps(data)

# 传统方式 vs pathlib方式 - for Python in EDAS
import os
import os.path
from pathlib import Path


# 传统方式
old_way = os.path.join(os.path.expanduser("~"), "documents", "EDAS-python-file.txt")
if os.path.exists(old_way):
    with open(old_way, 'r') as f:
        content = f.read()


# pathlib方式
new_way = Path.home() / "documents" / "EDAS-python-file.txt"
if new_way.exists():
    content = new_way.read_text()


# 更多pathlib优势
config_dir = Path.home() / ".config" / "myapp"
config_dir.mkdir(parents=True, exist_ok=True)


for py_file in Path(".").glob("**/*.py"):
    print(f"Python文件: {py_file}")

# 测试启动性能的脚本 - for Python in EDAS


# 标准启动时间测试
time python3 -c "import sys; print('Python', sys.version_info[:2])"


# 模块导入性能测试
time python3 -c "import json, os, re, datetime, pathlib"


# 应用启动模拟测试
time python3 -c "
import sys
import json
import os
from pathlib import Path
config = {'app': 'test', 'version': '1.0'}
log_dir = Path('logs')
log_dir.mkdir(exist_ok=True)
print('Application started')
"

# 编译启用JIT的Python 3.13
./configure --enable-experimental-jit
make -j4

# 运行JIT性能测试
python3.13 --jit benchmark_script.py

# 内存使用优化对比示例 - for Python in EDAS
import sys
import gc
from memory_profiler import profile  # 需要安装: pip install memory-profiler


classOldStyleClass:
    """传统类定义 - 内存使用较多"""
    def __init__(self, name, data):
        self.name = name
        self.data = data
        self.metadata = {}
        self.cache = {}


class OptimizedClass:
    """优化后的类定义 - 使用__slots__"""
    __slots__ = ['name', 'data', '_metadata']
    
    def __init__(self, name, data):
        self.name = name
        self.data = data
        self._metadata = None


@profile
def memory_comparison():
    """内存使用对比测试"""
    # 创建大量对象测试内存使用
    old_objects = [OldStyleClass(f"obj_{i}", list(range(10))) for i in range(1000)]
    print(f"传统类对象内存使用: {sys.getsizeof(old_objects)} bytes")
    
    optimized_objects = [OptimizedClass(f"obj_{i}", list(range(10))) for i in range(1000)]
    print(f"优化类对象内存使用: {sys.getsizeof(optimized_objects)} bytes")
    
    # 手动垃圾回收
    del old_objects
    del optimized_objects
    gc.collect()


memory_comparison()

# 编译支持自由线程的Python
./configure --disable-gil
make -j4

# 或使用预编译版本
python3.13t  # 't'表示free-threaded版本

# 字节码分析示例 - for Python in EDAS


# -*- coding: utf8
import dis
import time


def simple_function(x, y): 
    """简单函数 - 用于字节码分析"""
    result = x + y
    if result > 10:
        return result * 2
    else:        
        return result
        
def complex_function(data):
    """复杂函数 - 展示字节码优化"""
    total = 0    
    for item in data:        
        if isinstance(item, (int, float)):            
            total += item ** 2       
        elif isinstance(item, str):  
            total += len(item)   
    return total
    
print("简单函数字节码:")
dis.dis(simple_function)


print("\n复杂函数字节码:")
dis.dis(complex_function)


# 将以上的文件保存成 dis.py 之后，
# 分别以 python2 dis.py 与 python3.13 dis.py 执行完之后查看字节码优化的对比效果