Python 类型注释及自定义类型

from typing import Iterable  

def print_items(items: Iterable):  

    for item in items:  

        print(item)  

print_items([1,2,3])  

print_items({4, 5, 6})  

print_items({"A": 1, "B": 2, "C": 3})

def find_workers_available_for_time(open_time: datetime.datetime) -> list[str]:

number: int = 0  

text: str = "useless"  

values: list[float] = [1.2, 3.4, 6.0]  

worker: Worker = Worker()

ratio = get_ratio(5,3) # type: float  

def get_workers(open): # type: (datetime.datetime) -> List[str]

from typing import Optional  

maybe_a_string: Optional[str] = "abcdef" # This has a value  

maybe_a_string: Optional[str] = None # This is the absence of a value

from typing import Literal  

@dataclass  

class Error:  

    error_code: Literal[1,2,3,4,5]  

    disposed_of: bool  

@dataclass  

class Snack:  

    name: Literal["Pretzel", "Hot Dog", "Veggie Burger"]  

    condiments: set[Literal["Mustard", "Ketchup"]]

x: Annotated[int, ValueRange(3,5)]  

y: Annotated[str, MatchesRegex('[0-9]{4}')]

from typing import NewType  

class HotDog:  

    ''' Used to represent an unservable hot dog'''  

    # ... snip hot dog class implementation ...  

ReadyToServeHotDog = NewType("ReadyToServeHotDog", HotDog)  

def dispense_to_customer(hot_dog: ReadyToServeHotDog):  

    # ...

def prepare_for_serving(hot_dog: HotDog) -> ReadyToServeHotDog:  

    assert not hot_dog.is_plated(), "Hot dog should not already be plated"  

    hot_dog.put_on_plate()  

    hot_dog.add_napkins()  

    return ReadyToServeHotDog(hot_dog)

def make_snack():  

    serve_to_customer(ReadyToServeHotDog(HotDog()))

VENDOR_NAME: Final[str] = "Viafore's Auto-Dog"

def display_vendor_information():  

    vendor_info = "Auto-Dog v1.0"  

    # whoops, copy-paste error, this code should be vendor_info += VENDOR_NAME  

    VENDOR_NAME += VENDOR_NAME  

    print(vendor_info)

def create_author_count_mapping(cookbooks: list) -> dict:  

    counter = defaultdict(lambda: 0)  

    for book in cookbooks:  

        counter[book.author] += 1  

    return counter

AuthorToCountMapping = dict[str, int] 

def create_author_count_mapping(cookbooks: list[Cookbook]) -> AuthorToCountMapping:  

    counter = defaultdict(lambda: 0)  

    for book in cookbooks:  

        counter[book.author] += 1  

    return counter

Ingredient = tuple[str, int, str] # (name, quantity, units)  

Recipe = list[Union[int, Ingredient]] # the list can be servings or ingredients  

def adjust_recipe(recipe: Recipe, servings):  

# ...

Cookbook = tuple[str, int] # name, page count

food_lab = {  

    "name": "The Food Lab",  

    "page_count": 958  

}

from typing import TypedDict  

class Range(TypedDict):  

    min: float  

    max: float

class NutritionInformation(TypedDict):  

    value: int  

    unit: str  

    confidenceRange95Percent: Range  

    standardDeviation: float

class RecipeNutritionInformation(TypedDict):  

    recipes_used: int  

    calories: NutritionInformation  

    fat: NutritionInformation  

    protein: NutritionInformation  

    carbs: NutritionInformation

nutrition_information:RecipeNutritionInformation = \  

    get_nutrition_from_spoonacular(recipe_name)

def reverse(coll: list) -> list:  

    return coll[::-1]

from typing import TypeVar  

T = TypeVar('T')  

def reverse(coll: list[T]) -> list[T]:  

    return coll[::-1]

from collections import defaultdict  

from typing import Generic, TypeVar

Node = TypeVar("Node")  

Edge = TypeVar("Edge")

# directed graph  

class Graph(Generic[Node, Edge]):  

    def __init__(self):  

        self.edges: dict[Node, list[Edge]] = defaultdict(list)

    def add_relation(self, node: Node, to: Edge):  

        self.edges[node].append(to)

    def get_relations(self, node: Node) -> list[Edge]:  

        return self.edges[node]

cookbooks: Graph[Cookbook, Cookbook] = Graph()  

recipes: Graph[Recipe, Recipe] = Graph()  

cookbook_recipes: Graph[Cookbook, Recipe] = Graph()  

recipes.add_relation(Recipe('Pasta Bolognese'),  

                    Recipe('Pasta with Sausage and Basil'))  

cookbook_recipes.add_relation(Cookbook('The Food Lab'),  

                            Recipe('Pasta Bolognese'))

def get_nutrition_info(recipe: str) -> Union[NutritionInfo, APIError]:  

# ...  

def get_ingredients(recipe: str) -> Union[list[Ingredient], APIError]:  

#...  

def get_restaurants_serving(recipe: str) -> Union[list[Restaurant], APIError]:  

# ...

T = TypeVar("T")  

APIResponse = Union[T, APIError]  

def get_nutrition_info(recipe: str) -> APIResponse[NutritionInfo]:  

    # ...  

def get_ingredients(recipe: str) -> APIResponse[list[Ingredient]]:  

    #...  

def get_restaurants_serving(recipe: str) -> APIResponse[list[Restaurant]]:  

    # ...

class NutritionalInformation(dict):  

    def __getitem__(self, key):  

    try:  

        return super().__getitem__(key)  

    except KeyError:  

        pass  

    for alias in get_aliases(key):  

        try:  

            return super().__getitem__(alias)  

        except KeyError:  

            pass  

    raise KeyError(f"Could not find {key} or any of its aliases")

from collections import UserDict  

class NutritionalInformation(UserDict):  

    def __getitem__(self, key):  

        try:  

            return self.data[key]  

        except KeyError:  

            pass  

        for alias in get_aliases(key):  

            try:  

                return self.data[alias]  

            except KeyError:  

                pass  

        raise KeyError(f"Could not find {key} or any of its aliases")

import collections  

class AliasedIngredients(collections.abc.Set):  

    def __init__(self, ingredients: set[str]):  

        self.ingredients = ingredients  

    def __contains__(self, value: str):  

        return value in self.ingredients or any(alias in self.ingredients for alias in get_aliases(value))  

    def __iter__(self):  

        return iter(self.ingredients)  

    def __len__(self):  

        return len(self.ingredients)

>>> ingredients = AliasedIngredients({'arugula', 'eggplant', 'pepper'})  

>>> for ingredient in ingredients:  

>>> print(ingredient)  

'arugula'  

'eggplant'  

'pepper'

>>> print(len(ingredients))  

3  

>>> print('arugula' in ingredients)  

True  

>>> print('rocket' in ingredients)  

True  

>>> list(ingredients | AliasedIngredients({'garlic'}))  

['pepper', 'arugula', 'eggplant', 'garlic']

def print_items(items: collections.abc.Iterable):  

    for item in items:  

        print(item)