Python - 类型提示

from typing import Optional

# Integer type
def calculate_square_area(side_length: int) -> int:
	 	return side_length ** 2

# Float type
def calculate_circle_area(radius: float) -> float:
	 	return 3.14 * radius * radius

# String type
def greet(name: str) -> str:
	 	return f"Hello, {name}"

# Boolean type
def is_adult(age: int) -> bool:
	 	return age >= 18

# None type
def no_return_example() -> None:
	 	print("This function does not return anything")

# Optional type (Union of int or None)
def safe_divide(x: int, y: Optional[int]) -> Optional[float]:
	 	if y is None or y == 0:
	 	 	 return None
	 	else:
	 	 	 return x / y

# Example usage
print(calculate_square_area(5)) 	 	 	 	
print(calculate_circle_area(3.0)) 	 		
print(greet("Alice")) 	 	 	 	 	 	 	 		
print(is_adult(22)) 	 	 	 	 	 	 	 	 		
no_return_example() 	 	 	 	 	 	 	 	 		
print(safe_divide(10, 2)) 	 	 	 	 	 		
print(safe_divide(10, 0)) 	 	 	 	 	 		
print(safe_divide(10, None)) 	 	 	 	 	

from typing import List, Tuple, Dict, Set, Iterable, Generator

# List of integers
def process_numbers(numbers: List[int]) -> List[int]:
	 	return [num * 2 for num in numbers]

# Tuple of floats
def coordinates() -> Tuple[float, float]:
	 	return (3.0, 4.0)

# Dictionary with string keys and integer values
def frequency_count(items: List[str]) -> Dict[str, int]:
	 	freq = {}
	 	for item in items:
	 	 	 freq[item] = freq.get(item, 0) + 1
	 	return freq

# Set of unique characters in a string
def unique_characters(word: str) -> Set[str]:
	 	return set(word)

# Iterable of integers
def print_items(items: Iterable[int]) -> None:
	 	for item in items:
	 	 	 print(item)

# Generator yielding squares of integers up to n
def squares(n: int) -> Generator[int, None, None]:
	 	for i in range(n):
	 	 	 yield i * i

# Example usage
numbers = [1, 2, 3, 4, 5]
print(process_numbers(numbers)) 	 	 	 	 	 	 	 	 		

print(coordinates()) 	 	 	 	 	 	 	 	 	 	 	 	 	 	

items = ["apple", "banana", "apple", "orange"]
print(frequency_count(items)) 	 	 	 	 	 	 	 	 	 	

word = "hello"
print(unique_characters(word)) 	 	 	 	 	 	 	 	 		

print_items(range(5)) 	 	 	 	 	 	 	 	 	 	 	 	 		

gen = squares(5)
print(list(gen)) 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	

from typing import Optional

def divide(a: float, b: float) -> Optional[float]:
	 	if b == 0:
	 	 	 return None
	 	else:
	 	 	 return a / b

result1: Optional[float] = divide(10.0, 2.0) 	 # result1 will be 5.0
result2: Optional[float] = divide(10.0, 0.0) 	 # result2 will be None

print(result1) 	
print(result2) 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 		

from typing import Union

def square_root_or_none(number: Union[int, float]) -> Union[float, None]:
	 	if number >= 0:
	 	 	 return number ** 0.5
	 	else:
	 	 	 return None

result1: Union[float, None] = square_root_or_none(50) 		
result2: Union[float, None] = square_root_or_none(-50) 	

print(result1) 	
print(result2) 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 		

from typing import Any

def print_value(value: Any) -> None:
	 	print(value)

print_value(10) 	 	 	 		
print_value("hello") 	 	
print_value(True) 	 	 		
print_value([1, 2, 3]) 	
print_value({'key': 'value'}) 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 		

from typing import List, Tuple

# Define a type alias for a list of integers
Vector = List[int]

# Define a type alias for a tuple of coordinates
Coordinates = Tuple[float, float]

# Function using the type aliases
def scale_vector(vector: Vector, factor: float) -> Vector:
	 	 return [int(num * factor) for num in vector]

def calculate_distance(coord1: Coordinates, coord2: Coordinates) -> float:
	 	x1, y1 = coord1
	 	x2, y2 = coord2
	 	return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

# Using the type aliases
v: Vector = [1, 2, 3, 4]
scaled_v: Vector = scale_vector(v, 2.5)
print(scaled_v) 	

c1: Coordinates = (3.0, 4.0)
c2: Coordinates = (6.0, 8.0)
distance: float = calculate_distance(c1, c2)
print(distance) 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 		

from typing import TypeVar, List

# Define a type variable T
T = TypeVar('T')

# Generic function that returns the first element of a list
def first_element(items: List[T]) -> T:
	 	return items[0]

# Example usage
int_list = [1, 2, 3, 4, 5]
str_list = ["apple", "banana", "cherry"]

first_int = first_element(int_list) 	 	 	# first_int will be of type int
first_str = first_element(str_list) 	 	 	# first_str will be of type str

print(first_int) 	 	
print(first_str) 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	

from typing import Callable

# Define a function that takes another function as an argument
def apply_operation(x: int, y: int, operation: Callable[[int, int], int]) -> int:
	 	return operation(x, y)

# Example functions to be passed as arguments
def add(a: int, b: int) -> int:
	 	return a + b

def multiply(a: int, b: int) -> int:
	 	return a * b

# Using the apply_operation function with different operations
result1 = apply_operation(5, 3, add) 	 	 	 	# result1 will be 8
result2 = apply_operation(5, 3, multiply) 	 # result2 will be 15

print(result1) 	
print(result2) 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	

from typing import Literal

def move(direction: Literal["left", "right", "up", "down"]) -> None:
	 	print(f"Moving {direction}")

move("left") 	# Valid
move("up") 	 	# Valid 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 		

from typing import NewType

# Create new types
UserId = NewType('UserId', int)
ProductId = NewType('ProductId', int)

# Define functions that use the new types
def get_user_name(user_id: UserId) -> str:
	 	return f"User with ID {user_id}"

def get_product_name(product_id: ProductId) -> str:
	 	return f"Product with ID {product_id}"

# Example usage
user_id = UserId(42)
product_id = ProductId(101)

print(get_user_name(user_id)) 	 # Output: User with ID 42
print(get_product_name(product_id)) 	# Output: Product with ID 101