价目表app制作/seoul national university

python 33个高级用法技巧

1. 列表推导式 简化了基于现有列表创建新列表的过程。

squares = [x**2 for x in range(10)]
print(squares)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2. 字典推导式 用简洁的方式创建字典。

square_dict = {x: x**2 for x in range(10)}
print(square_dict)

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

3. 集合推导式 生成没有重复值的集合。

unique_squares = {x**2 for x in range(10)}
print(unique_squares)

{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

4. 生成器表达式 创建一个按需生成值的迭代器。

gen = (x**2 for x in range(10))
print(list(gen))

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

5. Lambda 函数 创建小型匿名函数。

add = lambda x, y: x + y
print(add(3, 5))

8

6. Map 函数 将一个函数应用到输入列表的所有项目上。

squares = list(map(lambda x: x**2, range(10)))
print(squares)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

7. Filter 函数 从序列中过滤出满足条件的项目。

even_numbers = list(filter(lambda x: x % 2 == 0, range(10)))
print(even_numbers)

[0, 2, 4, 6, 8]

8. Reduce 函数 对序列中的所有元素应用累积函数。

from functools import reduce
sum_all = reduce(lambda x, y: x + y, range(10))
print(sum_all)

45

9. 链式比较 允许在一行中进行多个比较。

x = 5
result = 1 < x < 10
print(result)

True

10. 枚举 生成枚举对象，提供索引和值。

list1 = ['a', 'b', 'c']
for index, value in enumerate(list1):print(index, value)

0 a
1 b
2 c

11. 解包 从容器中提取多个值。

a, b, c = [1, 2, 3]
print(a, b, c)
print(*[1, 2, 3])

1 2 3
1 2 3

12. 链式函数调用 链式调用多个函数。

def add(x):return x + 1def multiply(x):return x * 2result = multiply(add(3))
print(result)

8

13. 上下文管理器 自动处理资源管理。

with open('file.txt', 'w') as f:f.write('Hello, World!')

14. 自定义上下文管理器 创建自定义资源管理逻辑。

class MyContext:def __enter__(self):print('Entering')return selfdef __exit__(self, exc_type, exc_value, traceback):print('Exiting')with MyContext() as m:print('Inside')

Entering
Inside
Exiting

15. 装饰器 修改函数的行为。

def my_decorator(func):def wrapper():print("Something is happening before the function is called.")func()print("Something is happening after the function is called.")return wrapper@my_decorator
def say_hello():print("Hello!")say_hello()

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

16. 类装饰器 使用类来实现装饰器。

class Decorator:def __init__(self, func):self.func = funcdef __call__(self):print("Something is happening before the function is called.")self.func()print("Something is happening after the function is called.")@Decorator
def say_hello():print("Hello!")say_hello()

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

17. 生成器函数 创建迭代器，逐个返回值。

def my_generator():for i in range(3):yield ifor value in my_generator():print(value)

0
1
2

18. 异步生成器 异步生成值。

import asyncio
import nest_asyncionest_asyncio.apply()async def my_gen():for i in range(3):yield iawait asyncio.sleep(1)async def main():async for value in my_gen():print(value)asyncio.run(main())

0
1
2

19. 元类 控制类的创建行为。

class Meta(type):def __new__(cls, name, bases, dct):print(f'Creating class {name}')return super().__new__(cls, name, bases, dct)class MyClass(metaclass=Meta):pass

Creating class MyClass

20. 数据类 简化类的定义。

from dataclasses import dataclass@dataclass
class Person:name: strage: intp = Person(name='Alice', age=30)
print(p)

Person(name='Alice', age=30)

21. NamedTuple 创建不可变的命名元组。

from collections import namedtuplePoint = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p)

Point(x=1, y=2)

22. 单例模式 确保类只有一个实例。

class Singleton:_instance = Nonedef __new__(cls, *args, **kwargs):if not cls._instance:cls._instance = super().__new__(cls, *args, **kwargs)return cls._instances1 = Singleton()
s2 = Singleton()
print(s1 is s2)

True

23. 多继承 使用多个基类创建类。

class Base1:def __init__(self):print("Base1")class Base2:def __init__(self):print("Base2")class Derived(Base1, Base2):def __init__(self):super().__init__()Base2.__init__(self)d = Derived()

Base1
Base2

24. 属性 控制属性的访问和修改。

class MyClass:def __init__(self, value):self._value = value@propertydef value(self):return [e-mail] value(self, new_value):self._value = new_valueobj = MyClass(10)
print(obj.value)
obj.value = 20
print(obj.value)

10
20

25. 自定义迭代器 创建自定义的可迭代对象。

class MyIterator:def __init__(self, data):self.data = dataself.index = 0def __iter__(self):return selfdef __next__(self):if self.index < len(self.data):result = self.data[self.index]self.index += 1return resultelse:raise StopIterationmy_iter = MyIterator([1, 2, 3])
for value in my_iter:print(value)

1
2
3

26. 上下文管理器 使用 contextlib简化上下文管理。

from contextlib import contextmanager@contextmanager
def my_context():print("Entering")yieldprint("Exiting")with my_context():print("Inside")

Entering
Inside
Exiting

27. 函数缓存 缓存函数结果以提高性能。

from functools import lru_cache@lru_cache(maxsize=32)
def fib(n):if n < 2:return nreturn fib(n-1) + fib(n-2)print([fib(n) for n in range(10)])

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

28. 多线程 使用线程并发执行任务。

import threadingdef print_numbers():for i in range(5):print(i)thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

0
1
2
3
4

29. 多进程 使用进程并发执行任务。

from multiprocessing import Processdef print_numbers():for i in range(5):print(i)process = Process(target=print_numbers)
process.start()
process.join()

0
1
2
3
4

30. 队列 使用队列在线程或进程间传递数据。

from queue import Queueq = Queue()
for i in range(5):q.put(i)while not q.empty():print(q.get())

0
1
2
3
4

31. 信号量 控制对资源的访问。

import threading# 创建一个信号量对象，初始值为2
semaphore = threading.Semaphore(2)# 定义一个访问资源的函数def access_resource():# 使用上下文管理器来获取信号量with semaphore:# 模拟资源访问的操作print("Resource accessed")# 创建4个线程，每个线程都运行access_resource函数
threads = [threading.Thread(target=access_resource) for _ in range(4)]# 启动所有线程
for thread in threads:thread.start()# 等待所有线程完成
for thread in threads:thread.join()

Resource accessed
Resource accessed
Resource accessed
Resource accessed

32. 上下文管理器协议 创建自定义资源管理逻辑。

class MyContext:def __enter__(self):print('Entering')return selfdef __exit__(self, exc_type, exc_value, traceback):print('Exiting')with MyContext() as m:print('Inside')

Entering
Inside
Exiting

33. 序列化、反序列化

import pickle# 创建一个数据字典
data = {'a': 1, 'b': 2, 'c': 3}# 将数据序列化并写入文件
with open('data.pkl', 'wb') as f:pickle.dump(data, f)

import pickle# 从文件中读取序列化的数据
with open('data.pkl', 'rb') as f:loaded_data = pickle.load(f)# 打印反序列化后的数据
print(loaded_data)

{'a': 1, 'b': 2, 'c': 3}