Python版本之间的主要变化总结

if (thing := get_thing()) is not None:
  do_something(thing)
else:
  raise Exception(f"Something is wrong with {thing}")

def foo(a, b, /, c, d, *, e, f):
  <strong>a, b: positional only</strong>
  <strong>c, d: positional or keyword</strong>
  <strong>e, f: keyword only

<strong>Before</strong>
f"user={user}"

<strong>Now</strong>
f"{user=}"

import importlib.metadata
importlib.metadata.version("some-library")
<strong>"2.3.4"</strong>
importlib.metadata.requires("some-library")
<strong>["thing==1.2.4", "other>=5"]</strong>
importlib.metadata.files("some-library")
<strong>[...]

if header.startswith("X-Forwarded-"):
  section = header.removeprefix("X-Forwarded-")

combined_dict = dict_one | dict_two
updated_dict |= dict_three

my_int: Annotated[int, SomeRange(0, 255)] = 0

import zoneinfo
some_zone = zoneinfo.ZoneInfo("Europe/Berlin")

match command.split():
  case ["quit"]:
    print("Goodbye!")
    quit_game()
  case ["look"]:
    current_room.describe()
  case ["get", obj]:
    character.get(obj, current_room)
  case ["go", direction]:
    current_room = current_room.neighbor(direction)
  case [action]:
    ... <strong>interpret single-verb action</strong>
  case [action, obj]:
    ... <strong>interpret action, obj</strong>
  case _:
    ... <strong>anything that didn't match

<strong>Before</strong>
from typing import Optional, Union
thing: Optional[Union[str, list[str]]] = None

<strong>Now</strong>
thing: str | list[str] | None = None

from typing import Awaitable, Callable, ParamSpec, TypeVar

P = ParamSpec("P")
R = TypeVar("R")

def add_logging(f: Callable[P, R]) -> Callable[P, Awaitable[R]]:
  async def inner(*args: P.args, <strong>kwargs: P.kwargs) -> R:
    await log_to_database()
    return f(*args, </strong>kwargs)
  return inner

@add_logging
def takes_int_str(x: int, y: str) -> int:
  return x + 7

await takes_int_str(1, "A") <strong>Accepted</strong>
await takes_int_str("B", 2) <strong>Correctly rejected by the type checker

StrCache: TypeAlias = 'Cache[str]'  <strong>a type alias</strong>
LOG_PREFIX = 'LOG[DEBUG]'  <strong>a module constant

_T = TypeVar("_T")

def is_two_element_tuple(val: Tuple[_T, ...]) -> TypeGuard[Tuple[_T, _T]]:
  return len(val) == 2

def func(names: Tuple[str, ...]):
  if is_two_element_tuple(names):
    reveal_type(names)  <strong>Tuple[str, str]</strong>
  else:
    reveal_type(names)  <strong>Tuple[str, ...]

with (CtxManager() as example):
  ...

with (
  CtxManager1(), CtxManager2()
):
  ...

with (CtxManager1() as example, CtxManager2()):
  ...

with (CtxManager1(), CtxManager2() as example):
  ...

with (
  CtxManager1() as example1,
  CtxManager2() as example2,
):
  ...

​​​​​

try:
  do_something()
except BaseException as e:
  e.add_note("this happened during do_something")
  raise

class MyClass:
  @classmethod
  def from_hex(cls, s: str) -> Self:  <strong>Self means instance of cls</strong>
    return cls(int(s, 16))
        
  def frobble(self, x: int) -> Self: <strong>Self means this instance</strong>
    self.y >> x
    return self

<strong>default is required</strong>
class Movie(TypedDict):
  title: str
  year: NotRequired[int]

<strong>default is not-required</strong>
class Movie(TypedDict, total=False):
  title: Required[str]
  year: int

<strong>The create_model decorator is defined by a library.</strong>
@typing.dataclass_transform()
def create_model(cls: Type[T]) -> Type[T]:
  cls.<strong>init</strong> = ...
  cls.<strong>eq</strong> = ...
  cls.<strong>ne</strong> = ...
  return cls

<strong>The create_model decorator can now be used to create new model classes:</strong>
@create_model
class CustomerModel:
  id: int
  name: str

for x in *a, *b:
  print(x)

type Point = tuple[float, float]

<strong>Type aliases can also be generic</strong>
type Point[T] = tuple[T, T]

<strong>Can re-use quotes</strong>
f"This is the playlist: {", ".join(songs)}"

f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}" <strong>'2'</strong>

<strong>Multiline f-string with comments</strong>
f"This is the playlist: {", ".join([
  'Take me back to Eden',  <strong>My, my, those eyes like fire</strong>
  'Alkaline',              <strong>Not acid nor alkaline</strong>
  'Ascensionism'           <strong>Take to the broken skies at last</strong>
])}"

<strong>Backslashes / Unicode</strong>
f"This is the playlist: {"\n".join(songs)}"

f"This is the playlist: {"\N{BLACK HEART SUIT}".join(songs)}"

from typing import TypedDict, Unpack

class Movie(TypedDict):
  name: str
  year: int

def foo(</strong>kwargs: Unpack[Movie]):
  ...