python中数据类型整理及类型注解

集合、字典、列表、元组

集合（set）

集合是一种无序、可变的数据结构，用于存储唯一的元素。会自动删除重复元素。
使用花括号 {}：在 Python 中，可以使用花括号 {} 来定义一个集合，但要注意花括号内不能包含键值对，否则它会被认为是字典。

my_set = {1, 2, 3, 4}

使用 set() 函数：如果你需要从列表或其他可迭代对象中创建一个集合，可以使用 set() 函数。

my_set = set([1, 2, 3, 4])

注意，如果你使用 set() 函数创建一个空集合，必须用 set() 而不是 {}，因为 {} 会创建一个空字典。

my_empty_set = set()  # 创建空集合
my_empty_dict = {}    # 创建空字典

集合的特点：
**无序性：**集合中的元素没有特定的顺序，不能通过索引访问元素。
**唯一性：**集合中的元素是唯一的，重复的元素会被自动去除。
**可变性：**集合是可变的，你可以添加或删除元素。

my_set.add(5)       # 添加元素
my_set.remove(1)    # 删除元素

集合操作：Python 集合支持标准的集合操作，如并集、交集、差集等。

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1.union(set2)        # 并集: {1, 2, 3, 4, 5}
intersection_set = set1.intersection(set2)  # 交集: {3}
difference_set = set1.difference(set2)  # 差集: {1, 2}

**支持多种数据类型：**集合中的元素可以是不同的数据类型，但必须是可哈希的（如整数、字符串）。

字典

字典包含键值对，每个键都是唯一的，每个键对应一个值。但这个值可以是一个容器（如列表、集合或元组），从而实现一个键对应多个值的效果。

my_set = {1, 2, 3}          # 集合
my_dict = {'a': 1, 'b': 2}  # 字典

特点：
无序（Python 3.7 及以后版本实际上是有序的，保持插入顺序，但不支持索引访问元素）：
可变：可以添加、删除或修改键值对。
键唯一：每个键必须是唯一的，但值可以重复。
支持多种数据类型：键和值都可以是不同的数据类型，但键必须是可哈希的（如整数、字符串）。

创建方式：

使用花括号 {} 创建键值对：

my_dict = {"name": "Alice", "age": 30}

使用 dict() 函数：

my_dict = dict(name="Alice", age=30)

使用字典推导式：

squares = {x: x**2 for x in range(5)}

列表（List）

特点：

有序：元素有固定顺序，可以通过索引访问。
可变：可以添加、删除或修改元素。
允许重复：元素可以重复。
支持多种数据类型：列表中的元素可以是不同的数据类型。

创建方式：

使用方括号 []：

my_list = [1, 2, 3, "apple", True]

使用 list() 函数：

my_list = list([1, 2, 3])

列表推导式：

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

元组（Tuple）

特点
有序：元素有固定顺序，可以通过索引访问。
不可变：一旦创建，不能修改元素（不能添加、删除、修改）。
允许重复：元素可以重复。
支持多种数据类型：元组中的元素可以是不同的数据类型。
创建方式:
使用圆括号 ()：

my_tuple = (1, 2, 3, "apple", True)

直接使用逗号分隔元素（可以省略括号）：

my_tuple = 1, 2, 3

使用 tuple() 函数，用于将一个可迭代对象（如列表、字符串等）转换为元组。这里将列表 [1, 2, 3] 转换为一个元组。

my_tuple = tuple([1, 2, 3])

运行这行代码后，my_tuple 的值会是一个元组 (1, 2, 3)，而不是将整个列表 [1, 2, 3] 作为元组的一个元素。

创建单元素元组：

single_element_tuple = (1,)

区别和易混点

有序 vs 无序：

列表 和 元组 是有序的，可以通过索引访问元素。
集合 和 字典 是无序的（虽然从 Python 3.7 开始，字典是保持插入顺序的）。

可变 vs 不可变：

列表 和 字典 是可变的，可以修改内容。
元组 是不可变的，不能修改内容。
集合 是可变的，但集合内的元素必须是不可变（可哈希）的。

重复 vs 唯一：

列表 和 元组 允许重复的元素。
集合 和 字典 的键不允许重复。

索引访问：

列表 和 元组 可以通过索引访问。
集合 和 字典 不能通过索引访问（字典可以通过键访问对应的值）。

总结

**列表：**有序、可变、允许重复元素，适合需要修改数据的场景。
**元组：**有序、不可变、允许重复元素，适合需要不变数据的场景。
**集合：**无序、可变、元素唯一，适合去重和集合操作。
**字典：**无序（Python 3.7+ 为插入顺序）、可变、键唯一，适合键值对数据

类型注解

python类型注解，通常用在定义函数方法的位置，对函数方法传入的参数进行解释说明。

在 Python 中，类型注解（type annotations）是一种为函数参数、返回值以及变量等添加类型信息的方式。类型注解可以帮助提高代码的可读性和可维护性，并且与静态类型检查工具（如 mypy）结合使用时，可以提前发现潜在的类型错误。

1、基本数据类型注解

int: 整数类型

def add(x: int, y: int) -> int:
    return x + y

float: 浮点数类型。

def divide(x: float, y: float) -> float:
    return x / y

str: 字符串类型。

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

bool: 布尔类型。

def is_even(n:int) -> bool:
    return n % 2 == 0 

2、容器类型注解

用于表示像列表、元组、字典等容器类型

List: 表示列表，通常还需要指定列表中元素的类型。

from typing import List

def sum_of_elements(elements: List[int]) -> int:
    return sum(elements)

Tuple: 表示元组，可以指定元组中每个元素的类型。

from typing import Tuple

def get_point() ->Tuple[int, int]:
	return (10, 20)

Dict: 表示字典，通常需要指定键和值的类型。

from typing import Dict

def count_words(text:str) ->Dict[str, int]:
	words = text.split()
	return {word: word.count(word) for word in set(words)}
	return (10, 20)

Set: 表示集合，可以指定集合中元素的类型。

from typing import Set

def unique_numbers(numbers: List[int] -> Set[int]):
	return set(numbers)

3. 特殊类型注解

一些用于处理更复杂的类型或特殊场景的注解。

Optional: 表示参数或返回值可以是某种类型或 None。

from typing import Optional

def find_element(elements: List[int], target: int) -> Optional[int]:
    try:
        return elements.index(target)
    except ValueError:
        return None

Any: 表示可以是任意类型，用于不确定具体类型的情况下。

from typing import Any

def process_data(data: Any) -> None:
    print(data)

Union: 表示参数或返回值可以是多种类型中的一种。

from typing import Union

def to_string(value: Union[int, float, str]) -> str:
    return str(value)

Callable: 表示一个可调用对象（如函数），可以指定参数和返回值的类型。

from typing import Callable

def apply_function(func: Callable[[int, int], int], x: int, y: int) -> int:
    return func(x, y)

Literal: 用于限定某个变量只能取特定的值（Python 3.8+）。

from typing import Literal

def choose_direction(direction: Literal['left', 'right', 'up', 'down']) -> str:
    return f"Moving {direction}"

4. 泛型类型注解

用于处理通用的数据结构。

TypeVar: 创建一个通用类型变量，用于类型注解中的泛型编程。

from typing import TypeVar, List

T = TypeVar('T')

def first_element(elements: List[T]) -> T:
    return elements[0]

5. 自定义类型注解

可以使用 NewType 创建一种新类型，表示逻辑上的不同类型，即使它们的底层类型相同。

from typing import NewType

UserId = NewType('UserId', int)

def get_user_name(user_id: UserId) -> str:
    # 实际代码中会使用 user_id 进行查询
    return "John Doe"

6. 注解变量类型

不仅可以在函数签名中使用类型注解，还可以在普通变量声明时使用。

name: str = "Alice"
age: int = 30

7. 返回值为 None

对于不返回值的函数，通常用 -> None 进行注解。

def print_message(message: str) -> None:
    print(message)

总结

类型注解在 Python 中是一种可选的、非强制性的语法，用于提升代码的可读性和可维护性。它们不仅适用于函数定义中的参数和返回值，还可以用于变量声明、泛型编程等场景。