python编程经验、方法、随笔

class ShapeFactory:
    @staticmethod
    def create_shape(shape_type):
        if shape_type == 'circle':
            return Circle()
        elif shape_type =='rectangle':
            return Rectangle()
        else:
            return None

class Circle:
    def draw(self):
        print('Drawing a circle')

class Rectangle:
    def draw(self):
        print('Drawing a rectangle')

shape1 = ShapeFactory.create_shape('circle')
shape1.draw()  # Drawing a circle

shape2 = ShapeFactory.create_shape('rectangle')
shape2.draw()  # Drawing a rectangle

from dataclasses import dataclass

@dataclass
class Car:
    name :None
    size :None
    model:None
    color:None
    seats:None
    def __str__(self):
        return f"Name: {self.name}, Size: {self.size}, Model: {self.model}, Color: {self.color}, Seats: {self.seats}"

class CarBuilder:
    def __init__(self, name,size):
        self._config={
           'name': name ,
           'size': size ,
        }
    # 其他属性设置方法
    def set_model(self, model):
        self._config['model'] = model
        return self

    def set_color(self, color):
        self._config['color'] = color
        return self

    def set_seats(self, seats):
        self._config['seats'] = seats
        return self

    def build(self):
        return Car(**self._config)

builder = CarBuilder(name='BMW', size='S')
car1 = builder.set_model('BMW').set_color('red').set_seats(4).build()
car1.name = 'X5'

car2 = builder.set_model('Audi').set_color('blue').set_seats(2).build()
car2.name = 'A4'
print(car1)  # Name: X5, Size: S, Model: Audi, Color: blue, Seats: 2
print(car2)  # Name: A4, Size: S, Model: Audi, Color: blue, Seats: 2

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance
    def __init__(self,*args, **kwargs):
        pass

s1 = Singleton()
s2 = Singleton()
print(id(s1), id(s2))  # 140601222422480 140601222422480

import functools
def my_decorator(func):
    @functools.wraps(func)#保留原函数的名称和文档
    def wrapper(*args, **kwargs):
        print('Before calling the function')
        result = func(*args, **kwargs)
        print('After calling the function')
        return result
    return wrapper

@my_decorator
def my_function():
    print('Hello, world!')

my_function()  # 输出：Before calling the function Hello, world! After calling the function

from dataclasses import dataclass, field

@dataclass(frozen=True)
class Point:
    x: int = field(default=0, init=True)
    y: int = field(default=0, init=True, repr=False)
    z: int = field(init=False)  # z 是计算得到的字段，不在初始化时传入

    def __post_init__(self):
        if self.x < 0 or self.y < 0:
            raise ValueError('x and y must be non-negative')
        object.__setattr__(self, 'z', self.x + self.y)  # 动态设置 z 的值

p = Point(1, 2)
print(p)    # Point(x=1, z=3)
print(p.z)  # 3
print(p.x)  # 1
print(p.y)  # 2

class File:
    def __init__(self, filename, mode):
        self.file = open(filename, mode)

    def __enter__(self):
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()

with File('test.txt', 'w') as f:
    f.write('Hello, world!')

from contextlib import contextmanager

@contextmanager
def file_manager(filename, mode):
    try:
        f = open(filename, mode)
        yield f
    finally:
        f.close()

with file_manager('test.txt', 'w') as f:
    f.write('Hello, world!')

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)  # 1 2
print(p[0], p[1])  # 1 2
print(p._asdict())  # {'x': 1, 'y': 2}

import os
from dotenv import load_dotenv

load_dotenv('my.env')

# 读取环境变量
print(os.getenv('SECRET_KEY'))

import toml

config = toml.load('config.toml')
print(config['tool']['poetry']['name'])  # my-project

import pandas as pd
import pyarrow.parquet as pq
import random
df = pd.DataFrame({'dates': pd.date_range('2021-01-01', periods=1000000, freq='T'),
'categories': random.choices(['A', 'B', 'C']), 
,k=1000000})
df['categories'] = df['categories'].astype('category')]
print(df.info())
# 存入
df.to_csv('data.csv', index=False)
df.to_parquet('data.parquet', index=False)

# 读取
csv_df = pd.read_csv('data.csv')
parquet_df = pd.read_parquet('data.parquet')
print(csv_df.info())
print(parquet_df.info())

def append_to_list(lst=[]):
    lst.append(1)
    return lst

print(append_to_list())  # [1]
print(append_to_list())  # [1, 1]
print(append_to_list())  # [1, 1, 1]

from typing import Optional
def append_to_list(lst: Optional[list] = None) -> list:
    if lst is None:
        lst = []
    lst.append(1)
    return lst

print(append_to_list())  # [1]
print(append_to_list())  # [1]
print(append_to_list())  # [1]

lst = "hello, world!"
hello_slice = slice(0, 5, 1) 
hello = lst[hello_slice] #等效于hello = lst[:5]
world_slice = slice(6, None, 1)
world = lst[world_slice] #等效于world = lst[6:]

x = [w for w in range(10) if w % 2 == 0]
match x:
    case int():
        print('x is an integer')
    case str():
        print('x is a string')
    case _:
        print('x is something else')

def my_func(*args):
    print(args)

my_func(1, 2, 3)  # (1, 2, 3)   

l1 = [1, 2, 3]
l2 = [4, 5, 6]
print([*l1, *l2]) # [1, 2, 3, 4, 5, 6]

a, b, *rest = [1, 2, 3, 4, 5]
print(a, b, rest) # 1 2 [3, 4, 5]

def my_func(**kwargs):
    print(kwargs)

my_func(name='Alice', age=25)  # {'name': 'Alice', 'age': 25}

d1 = {'name': 'Alice', 'age': 25}

name, age = {'name': 'Alice', 'age': 25}.values()
print(name, age) # Alice 25 

{**d1, 'city': 'Beijing'} # {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

add = lambda x, y: x + y
print(add(1, 2))  # 3

lst1 = [1, 2, 3]
print(list(map(lambda x: x * 2, lst1)))  # [2, 4, 6]

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
result = list(zip(lst1, lst2))
print(result)  # [(1, 4), (2, 5), (3, 6)]

class MyClass:
    count = 0

class MyClass:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f'MyClass object (name: {self.name})'

    def __len__(self):
        return len(self.name)

    def __getitem__(self, key):
        return self.name[key]

    def __setitem__(self, key, value):
        self.name[key] = value
    def __delitem__(self, key):
        del self.name[key]
    # 将类的实例当作函数调用
    def __call__(self, *args, **kwargs):
        print(f'Calling {self.name} with {args} and {kwargs}')

class MyIterator:
    def __init__(self, filename):
        self.file= open(filename, 'r')

    def __iter__(self):
        return self

    def __next__(self):
        line = self.file.readline()
        while line:
            if line.strip()[0]=="target":
                return line
            line = self.file.readline()
        self.file.close()
        raise StopIteration
line_iter = MyIterator('test.txt')
for target_line in line_iter:
    print(target_line)

def my_generator(filename):
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            if line.strip()[0]=="target":
                yield line
            line = f.readline()
line_gen = my_generator('test.txt')
for target_line in line_gen:
    print(target_line)

lst = [x for x in range(10) if x % 2 == 0]

gen = (x for x in range(10) if x % 2 == 0)

tup = tuple(x for x in range(10) if x % 2 == 0)

import asyncio

async def hello():
    await asyncio.sleep(1)
    print('Hello, world!')
    return 'done'

async def main():
    start_time = asyncio.get_running_loop().time()
    tasks = [asyncio.create_task(hello()) for _ in range(3)]
    results = await asyncio.gather(*tasks)
    end_time = asyncio.get_running_loop().time()
    print(f'Results: {results}')
    print(f'Time taken: {end_time - start_time:.2f} seconds')

asyncio.run(main())
# output:
# Hello, world!
# Hello, world!
# Hello, world!
# Results: ['done', 'done', 'done']
# Time taken: 1.01 seconds

from tqdm import tqdm

for i in tqdm(range(10)):
    pass
pbar = tqdm(total=100, desc='Downloading', unit='B', unit_scale=True, unit_divisor=1024)
pbar.update(10)
sleep(0.1)
pbar.update(90)
pbar.close()