Python基础一览

列表（List）:

动态数组，可以存储不同类型的元素。
支持修改、添加和删除操作。
元组（Tuple）:

不可变序列，通常用于存储多个不同类型的元素。
支持拆包操作以同时访问多个元素。
字典（Dictionary）:

键值对集合，键是唯一的而且通常是不可变的（如字符串、数值或元组）。
适用于需要快速查找、插入、删除操作的场景。
集合（Set）:

无序且唯一的元素集合。
常用于去重，以及进行集合操作（如求交集、并集和差集）。
字符串（String）:

不可变文本序列。
提供丰富的文本处理方法，如大小写转换、分割等。

def demonstrate_data_structures():
    # 列表（List）
    fruits = ['apple', 'banana', 'cherry']
    fruits.append('date')  # 添加元素
    fruits[1] = 'blueberry'  # 修改元素
    print("List:", fruits)

    # 访问列表元素
    print("First fruit:", fruits[0])
    print("Last fruit:", fruits[-1])

    # 列表迭代
    for fruit in fruits:
        print(f"List item: {fruit}")

    # 列表推导
    lengths = [len(fruit) for fruit in fruits]
    print("Lengths of fruit names:", lengths)

    # 元组（Tuple）
    dimensions = (1920, 1080)
    width, height = dimensions  # 拆包
    print("Tuple:", dimensions)
    print("Width:", width, "Height:", height)

    # 字典（Dictionary）
    fruit_colors = {'apple': 'red', 'banana': 'yellow', 'cherry': 'red'}
    fruit_colors['date'] = 'brown'  # 添加键值对
    print("Dictionary:", fruit_colors)

    # 访问字典元素
    print("Color of apple:", fruit_colors['apple'])

    # 字典迭代
    for fruit, color in fruit_colors.items():
        print(f"The {fruit} is {color}")

    # 集合（Set）
    basket = {'apple', 'orange', 'banana'}
    basket.add('cherry')  # 添加元素
    basket.discard('banana')  # 移除元素
    print("Set:", basket)

    # 集合操作
    another_basket = {'banana', 'pear', 'apple'}
    print("Union:", basket | another_basket)
    print("Intersection:", basket & another_basket)
    print("Difference:", basket - another_basket)

    # 集合迭代
    for item in basket:
        print(f"Set item: {item}")

    # 字符串（String）
    greeting = "Hello, World!"
    print("String:", greeting)
    print("Uppercase:", greeting.upper())
    print("Lowercase:", greeting.lower())
    print("Split:", greeting.split(', '))

if __name__ == '__main__':
    demonstrate_data_structures()

使用虚拟环境:## 标题

创建一个虚拟环境来安装 oss2 以避免系统全局包的冲突：
bash
python3 -m venv myenv # 创建虚拟环境
source myenv/bin/activate # 激活虚拟环境
pip install oss2 # 在虚拟环境中安装
查看 Python 和 pip 的版本:

有时候旧版本的 pip 或 Python 会导致不兼容问题。确保它们是最新的：
bash
python3 --version
pip --version
pip install --upgrade pip setuptools

查看当前激活的虚拟环境
(myenv) user@hostname:~$
如果你的终端提示符包含括号中的环境名称，这通常表示你正在一个虚拟环境中工作。

方法二：检查环境变量
在激活环境后，Python 会设置 VIRTUAL_ENV 环境变量指向虚拟环境的路径。您可以使用 Python 或命令行来检查这个变量：
echo $VIRTUAL_ENV

基础说明## 标题

def:
用于定义函数。
函数可以执行特定任务，并且可以在程序的任何地方被调用。

class:
用于定义类。类是面向对象编程的基本构建块，它封装了数据（属性）和方法（行为）。
类可以包含多个方法（通过def定义），这些方法通常操作该类实例的数据。
类还可以定义特殊的初始化方法__init__()来设置初始状态。
创建类后，可以通过这个类创建对象（实例）。

import json
class File(object):
    def __init__(self, name: str, key: str, url: str = None):
        self.name = name
        self.key = key
        self.url = url

    def __iter__(self):
        yield from {
            "name": self.name,
            "key": self.key,
            "url": self.url,
        }.items()

    def __str__(self):
        return json.dumps(dict(self), ensure_ascii=False)

    def __repr__(self):
        return self.__str__()

    def hello(self):
        print("hello")

    @staticmethod
    def _from_dict(file: dict):
        return File(
            name=file.get("name", ""),
            key=file["key"],
            url=file["url"],
        )

# This is a sample Python script.
import os

from file import File


#函数可以执行特定任务，并且可以在程序的任何地方被调用
def print_hi(name):
    print(f'Hi, {name}')  # Press ⌘F8 to toggle the breakpoint.

# Press the green button in the gutter to run the script.
if __name__ == '__main__':
    print_hi('PyCharm')
    f=File("name1","key1")
    print(f.name)

    File.key = "New Company"  # 更改类变量
    print(f.key)
    print(f.__iter__)
    print(f.__str__())
    print(f.__repr__)

    # 列表（list，“数组”通常指的是Python中的列表）
    my_list = [1, 'two', 3.0]
    # 元组    与列表相似，不过元组内的数据是不能修改的，以（）为标识。（因为压根就没有提供修改元素的方法）
    # 函数返回多个值时可以使用元组来返回这些值。元组还可以作为字典的键值对的一部分，或者在格式化字符串时使用。由于元组是不可变的，因此可以确保元组内的元素不被意外修改。
    tup = ('张三', '李四', '王五')

    # 创建一个空字典
    flights = {}
    flights[("Beijing", "Shanghai")] = 1200
    flights[("Shanghai", "Guangzhou")] = 900
    flights[("Beijing", "Guangzhou")] = 1500

    # 打印整个字典
    print(flights)

    # 访问特定键对应的值
    print(f"Price from Beijing to Shanghai: {flights[('Beijing', 'Shanghai')]}")

    # 集合是一个无序且不重复的元素集，使用花括号 {} 或者 set() 函数来定义，
    my_set = {1, 2, 3, 4}

    # 字典
    file_dict = {
        "name": "example.txt",
        "key": "123456",
        "url": "http://example.com/files/123456"
    }
    file_obj = File._from_dict(file_dict)
    print(file_obj.name)  # 输出: example.txt

    print(isinstance("11",File))
    try:
       print(1/0)
    except Exception as e:
        print({e})

基本架构
my_project/
│
├── README.md # 项目说明文档
├── setup.py # 包配置文件
├── requirements.txt # 依赖包列表
├── tests/ # 测试代码存放目录
│ └── test_example.py
├── docs/ # 文档
│ └── index.rst
├── my_project/ # 主代码库
│ ├── init.py # 初始化模块
│ ├── main.py # 主运行脚本
│ └── module1.py # 其他模块
└── .gitignore # Git忽略文件配置

编写规范建议
命名规则:

变量名应简洁明了，尽量使用小写字母加下划线的形式（如user_name）。
类名首字母大写（如Person）。
常量全大写（如PI = 3.14）。
注释:

对于复杂的逻辑或算法添加必要的注释。
使用文档字符串（docstring）为函数和类提供描述性信息。
代码格式:

遵循PEP 8风格指南：https://www.python.org/dev/peps/pep-0008/
使用空格而不是制表符进行缩进，通常是4个空格。
每行不超过79个字符。
错误处理:
合理使用异常处理机制，确保程序健壮性和用户体验。
测试:
编写单元测试来验证代码功能正确无误。
尽可能覆盖所有边界情况。

python使用线程池
在 Python 中，concurrent.futures 模块提供了一种方便的方式使用线程池来执行并行任务。通过使用 ThreadPoolExecutor，你可以创建一个线程池来管理和运行多个线程。

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

# 定义一个简单的任务函数
def task(n):
    print(f'Task {n} is starting...')
    time.sleep(n)  # 模拟耗时操作
    result = n * n
    print(f'Task {n} is complete with result: {result}')
    return result

# 使用线程池执行任务
def main():
    # 创建一个包含3个线程的线程池
    with ThreadPoolExecutor(max_workers=3) as executor:
        # 提交多个并行任务
        futures = [executor.submit(task, i) for i in range(5)]

        # 等待任务完成并获取结果
        for future in as_completed(futures):
            try:
                result = future.result()
                print(f'Result from task: {result}')
            except Exception as e:
                print(f'Task generated an exception: {e}')

if __name__ == "__main__":
    main()