当前位置:

首页 > 编程开发 > Python字典创建、访问、修改、删除及遍历的完整指南

Python字典创建、访问、修改、删除及遍历的完整指南

在编程中,经常需要建立一种“映射关系”——比如通过学号找到学生姓名,通过商品编号找到价格。Python 的字典(dict)正是为此而生。它是一种可变、无序(Python 3.7+ 保持插入顺序)、键唯一的映射类型,底层通过哈希表实现,平均查找速度能达到 O(1)。 1. 字典是什么? 字典是键值对(

本文目录

    在编程中,经常需要建立一种“映射关系”——比如通过学号找到学生姓名,通过商品编号找到价格。Python 的字典(dict)正是为此而生。它是一种可变、无序(Python 3.7+ 保持插入顺序)、键唯一的映射类型,底层通过哈希表实现,平均查找速度能达到 O(1)。

    Python字典创建、访问、修改、删除及遍历的完整指南

    1. 字典是什么?

    字典是键值对(key-value pair)的集合。每个键对应一个值,键必须是不可变类型(如字符串、数字、元组),值可以是任意类型。来看一个简单例子:

    # 一个简单的字典:学生信息
    student = {"name": "张三", "age": 20, "major": "计算机"}
    print(student["name"])   # 输出:张三

    这段代码创建了一个名为 student 的字典,包含三个键值对。键 "name" 对应值 "张三",键 "age" 对应整数 20,键 "major" 对应字符串 "计算机"。通过 student["name"] 即可访问对应的值。

    它的几个关键特性:

    • 键唯一:同一个字典中不能有重复键,如果重复赋值,后一个会覆盖前一个。
    • 可变:可以增、删、改键值对。
    • 从无序到有序:在 Python 3.6 之前是无序的,3.7 之后插入顺序被保留(作为语言特性)。这意味着遍历时会按照添加顺序返回。
    • 高效查找:基于哈希表,平均时间复杂度 O(1)。

    对比一下 C++ 中的实现:C++ 里类似映射可以用 std::unordered_map(哈希表,平均 O(1))或 std::map(红黑树,O(log n))。Python 字典的底层就是哈希表,因此与 unordered_map 更相似。下面是一个 C++ 示例:

    #include 
    #include 
    std::unordered_map student = {{"name", 20}, {"age", 20}};
    // 访问:student["name"] 或 student.at("name")

    主要区别在于:Python 字典的键可以是任意不可变类型(如字符串、数字、元组),而 C++ 中 unordered_map 的键类型需要在编译期确定,且必须提供哈希函数(内置类型已提供)。

    2. 创建字典

    2.1 使用花括号{}

    # 空字典
    empty = {}
    
    # 带初始值
    person = {"name": "李四", "age": 25}

    empty = {} 用一对花括号创建了一个空字典。注意:空花括号是字典,不是集合(集合需要用 set() 创建空集)。person = {"name": "李四", "age": 25} 则用逗号分隔多个键值对,每个键值对格式为 "key": value。键可以是字符串、数字等不可变类型,值任意。

    2.2 使用dict()构造函数

    # 从关键字参数创建
    person = dict(name="王五", age=30)
    
    # 从可迭代对象(如列表的元组对)创建
    items = [("name", "赵六"), ("age", 28)]
    person = dict(items)   # {'name': '赵六', 'age': 28}
    
    # 空字典
    empty = dict()

    dict(name="王五", age=30) 是关键字参数形式,键名会被当作字符串(不需要引号),这是创建字典的简洁方式。但要注意键名必须是合法的变量名(不能以数字开头,不能含空格)。dict(items) 则把列表中的每个元组第一个元素作为键,第二个作为值,构造字典。无参数调用 dict() 创建一个空字典,与 {} 等效。

    C++ 中初始化 unordered_map 可以使用初始化列表:

    std::unordered_map person = {{"name", 30}, {"age", 25}};

    从键值对序列构造时,需要遍历 vector 并插入,没有 Python 的 dict(iterable) 那么直接。

    2.3 使用zip()组合两个序列

    keys = ["a", "b", "c"]
    values = [1, 2, 3]
    d = dict(zip(keys, values))   # {'a': 1, 'b': 2, 'c': 3}

    zip(keys, values) 将两个列表打包成一系列元组:[('a',1), ('b',2), ('c',3)],然后 dict(...) 将其转换为字典。如果两个序列长度不同,zip 会以较短的为准。

    2.4 字典推导式

    见第7节详细介绍。

    3. 访问字典

    3.1 通过键访问([])

    d = {"apple": 5, "banana": 3}
    print(d["apple"])   # 5
    # print(d["orange"])  # KeyError: 'orange'

    使用方括号加键名获取对应的值。如果键不存在,会抛出 KeyError 异常,程序终止(除非捕获异常)。这种方法适合确定键一定存在的场景。

    C++ 中 unordered_map 的 operator[] 行为有所不同:如果键不存在,它会插入一个默认构造的值并返回引用,不会抛出异常。例如:

    std::unordered_map d;
    int val = d["orange"];   // 插入键 "orange" 并值为 0,val = 0

    若希望像 Python 一样不插入新键,可以使用 d.find(key) 或 d.at(key)(at 会抛出 std::out_of_range)。

    3.2 使用get()方法(安全访问)

    print(d.get("orange"))        # None(不报错)
    print(d.get("orange", 0))     # 0(指定默认值)

    d.get("orange") 尝试获取键 "orange" 的值,如果不存在则返回 None(不会抛出异常)。第二个参数可以指定默认值,适合不确定键是否存在的场景。

    C++ 中没有直接对应的 get 方法,通常使用 find 并检查迭代器:

    auto it = d.find("orange");
    int val = (it != d.end()) ? it->second : 0;

    3.3 获取所有键、值、键值对

    d = {"a": 1, "b": 2}
    print(d.keys())     # dict_keys(['a', 'b'])
    print(d.values())   # dict_values([1, 2])
    print(d.items())    # dict_items([('a', 1), ('b', 2)])

    d.keys()、d.values()、d.items() 返回的是视图对象(view)。这些视图动态反映字典的变化,如果字典后续修改,视图也会相应改变。视图对象支持迭代,可以用于 for 循环,也可以转换为列表:list(d.keys())。

    C++ 中获取所有键需要手动遍历或使用 range-based for:

    for (const auto& pair : d) {
        // pair.first 是键,pair.second 是值
    }

    3.4 setdefault()——获取值,若键不存在则设置默认值

    d = {"a": 1}
    v = d.setdefault("b", 100)   # 键 "b" 不存在,设置 d["b"]=100,并返回 100
    print(d)   # {'a': 1, 'b': 100}
    v2 = d.setdefault("a", 99)   # 键存在,返回原值 1,不修改

    setdefault 先检查键是否存在,如果存在则返回对应的值;如果不存在,则插入 key: default 键值对,并返回 default。这个方法常用于需要初始化缺失键的场景(比如构建分组字典)。C++ 中可以用 insert 配合 try_emplace 实现类似功能,但不如 Python 简洁。

    4. 修改字典

    4.1 添加或更新键值对

    d = {}
    d["name"] = "张三"   # 添加
    d["age"] = 25        # 添加
    d["age"] = 26        # 更新

    当方括号内的键不存在时,该赋值操作会在字典中添加一个新的键值对;当键已存在时,赋值会更新该键对应的值。

    C++ 中 unordered_map 的 operator[] 同样可添加或更新,但区别在于:如果键不存在,会插入默认构造的值再赋值。例如 d["age"] = 25 会先检查,若不存在则插入 int()(即0),再赋值为25。因此 C++ 中不能直接用 [] 判断是否存在。

    4.2 update()——合并另一个字典或可迭代对象

    d1 = {"a": 1, "b": 2}
    d2 = {"b": 3, "c": 4}
    d1.update(d2)        # d1 变为 {'a': 1, 'b': 3, 'c': 4}
    # 也支持关键字参数:d1.update(c=5, d=6)

    update() 接受一个字典或键值对的可迭代对象(如列表的元组),将参数中的每个键值对合并到原字典中:如果键已存在则覆盖,如果不存在则添加。C++ 中合并两个 unordered_map 需要循环插入,没有直接方法。

    5. 删除字典元素

    5.1 del语句

    d = {"a": 1, "b": 2, "c": 3}
    del d["b"]           # 删除键为 "b" 的项
    # del d["x"]         # KeyError 若键不存在

    del d["b"] 删除字典中键为 "b" 的键值对。如果键不存在,抛出 KeyError。del 也可以删除整个字典变量:del d,之后字典对象被回收。

    5.2 pop()——删除并返回指定键的值

    value = d.pop("a")   # 返回 1,d 变为 {'c': 3}
    # d.pop("x")         # KeyError
    d.pop("x", None)     # 不报错,返回 None

    pop(key) 删除指定键并返回对应的值。如果键不存在,抛出 KeyError。提供默认值后,键不存在时返回 default,不会抛出异常。C++ 中 unordered_map 的 erase 方法删除键并返回被删除元素的数量(0或1),不返回值。要获取值需先 find。

    5.3 popitem()——删除并返回最后一个键值对(Python 3.7+ 按 LIFO)

    d = {"a": 1, "b": 2}
    key, value = d.popitem()   # 返回 ('b', 2)(插入顺序的最后一个)

    在 Python 3.7+ 中,popitem() 删除并返回字典中最后插入的键值对(后进先出)。在 3.6 之前,由于字典无序,它返回任意一个键值对。返回值为一个元组 (key, value),可直接拆包。

    5.4 clear()——清空字典

    d.clear()            # {}

    删除字典中所有键值对,使字典变为空字典 {}。

    6. 遍历字典

    6.1 遍历键

    for key in d:
        print(key)
    # 或 for key in d.keys():

    直接使用 for key in d 是遍历字典最常用的方式,每次迭代获取一个键。也可以用 d.keys() 显式获取键视图。

    6.2 遍历值

    for value in d.values():
        print(value)

    d.values() 返回值的视图,用于遍历所有值。注意:值可能重复,且无法直接通过值找到对应的键(除非反向查找)。

    6.3 同时遍历键和值

    for key, value in d.items():
        print(key, value)

    d.items() 返回键值对视图,每个元素是一个 (key, value) 元组。通过拆包可以直接获取键和值。

    6.4 带条件或转换的遍历

    # 只打印值大于 10 的项
    for k, v in d.items():
        if v > 10:
            print(k, v)

    可以在循环体内加入条件判断,过滤出满足条件的键值对。

    7. 字典推导式

    与列表推导式类似,用于快速生成字典。

    # 平方映射
    squares = {x: x**2 for x in range(5)}   # {0:0, 1:1, 2:4, 3:9, 4:16}

    基本语法 {key_expr: value_expr for variable in iterable}。这里 x 是迭代变量,键是 x,值是 x**2。

    # 条件过滤:只保留偶数键
    even_squares = {x: x**2 for x in range(10) if x % 2 == 0}

    在推导式末尾加上 if 子句,只对满足条件的 x 生成键值对。

    # 交换键和值
    original = {"a": 1, "b": 2}
    inverted = {v: k for k, v in original.items()}   # {1: 'a', 2: 'b'}

    遍历原字典的 items(),将键和值互换作为新字典的键值对。注意:如果原字典有重复的值,后面的会覆盖前面的,因为键必须唯一。

    8. 嵌套字典

    字典的值可以是另一个字典,用于表示层次化数据。

    students = {
        "S001": {"name": "Alice", "score": 85},
        "S002": {"name": "Bob", "score": 92}
    }
    print(students["S001"]["name"])   # Alice

    外层字典的键是学号,值是一个内层字典(包含 name 和 score)。访问时使用两层方括号:先通过学号获取内层字典,再通过 "name" 获取姓名。安全访问嵌套时,可以逐层使用 get 或 try-except。

    9. 字典的常用方法汇总

    方法说明
    get(key, default)安全获取值,键不存在时返回默认值(默认 None)。
    setdefault(key, default)如果键存在,返回其值;否则设置 d[key]=default 并返回 default。
    update([other])用另一个字典或键值对序列更新当前字典。
    keys()返回所有键的视图。
    values()返回所有值的视图。
    items()返回所有 (键, 值) 对的视图。
    pop(key, default)删除指定键并返回其值,若不存在返回 default(若未提供则 KeyError)。
    popitem()删除并返回最后一个插入的键值对(Python 3.7+)。
    clear()清空字典。
    copy()浅拷贝。
    fromkeys(iterable, value)类方法,从可迭代对象创建字典,所有值初始为 value。

    10. 字典的性能与底层原理

    10.1 哈希表

    Python 字典底层使用哈希表(hash table)。每个键通过哈希函数计算出一个整数索引,用于快速定位存储位置。因此查找、插入、删除的平均时间复杂度为 O(1),但最坏情况(哈希冲突严重)可能退化为 O(n)。Python 通过开放地址法和伪随机探测解决冲突,并自动调整表的大小(rehash)来维持高效。

    C++ std::unordered_map 同样基于哈希表,平均 O(1),最坏 O(n)。两者都会在负载因子过高时自动 rehash。C++ std::map 基于红黑树,时间复杂度 O(log n),但内存占用相对稳定,且键有序。Python 字典的哈希函数对字符串和整数做了优化,而 C++ 需要为自定义类型特化 std::hash。

    10.2 键的要求

    • 键必须是可哈希的:即对象必须实现 __hash__() 和 __eq__() 方法,且在其生命周期中哈希值不变。
    • 不可变类型(字符串、数字、元组)通常可哈希;列表、字典、集合等可变对象不可哈希。
    • 元组中若包含可变对象,则该元组不可哈希。
    # 合法键
    d = {("a", 1): "tuple"}
    # 非法键
    # d = {["a", 1]: "list"}   # TypeError: unhashable type: 'list'

    元组 ("a", 1) 中的元素都是不可变类型,因此元组本身可哈希,可以作为键。列表 ["a", 1] 是可变的,不能作为键。

    C++ 中 unordered_map 的键也需要可哈希。内置类型已有标准哈希,自定义类型需要提供 hash 特化和 operator==,例如:

    struct MyKey {
        int a;
        std::string b;
        bool operator==(const MyKey& other) const { return a==other.a && b==other.b; }
    };
    namespace std {
        template<> struct hash {
            size_t operator()(const MyKey& k) const {
                return hash()(k.a) ^ (hash()(k.b) << 1);
            }
        };
    }

    10.3 内存占用

    字典比列表占用更多内存(约 2~3 倍),因为哈希表需要预留额外空间。

    11. 扩展:collections 模块中的字典变种

    11.1 defaultdict——带默认工厂的字典

    当访问不存在的键时,自动创建默认值,避免 KeyError。

    from collections import defaultdict
    
    # 默认值为整数 0
    dd = defaultdict(int)
    dd["a"] += 1        # 不需要先检查 "a" 是否存在
    print(dd)           # {'a': 1}

    defaultdict(int) 创建了一个默认值为 int()(即 0)的字典。当访问不存在的键时,自动调用 int() 生成默认值并插入。dd["a"] += 1 先设置 dd["a"] = 0,然后自增为 1。

    # 默认值为空列表
    dd2 = defaultdict(list)
    dd2["group"].append(10)   # 自动创建列表
    print(dd2)                # {'group': [10]}

    list 工厂函数会在键缺失时创建一个空列表,然后可以安全地 append。常见工厂还有 int、set、str 或自定义函数。

    C++ 中 unordered_map 的 operator[] 在键不存在时会插入默认值(值类型的默认构造),例如 std::unordered_map m; m["a"] += 1; 会先插入 int()(0)再自增。这与 defaultdict(int) 行为类似,但 Python 的 defaultdict 可以灵活指定任何工厂函数(如 list),而 C++ 的默认构造只适用于值类型。

    11.2 Counter——计数器

    用于统计可哈希元素出现的次数。

    from collections import Counter
    
    colors = ["red", "blue", "red", "green", "blue", "red"]
    cnt = Counter(colors)
    print(cnt)          # Counter({'red': 3, 'blue': 2, 'green': 1})
    print(cnt["red"])   # 3
    print(cnt.most_common(2))  # [('red', 3), ('blue', 2)]

    Counter(colors) 遍历列表,统计每个元素出现的次数,返回一个类似字典的对象。cnt["red"] 返回 'red' 出现的次数,对于不存在的键返回 0(不报错)。most_common(2) 返回出现次数最多的前 2 个元素及其次数,按降序排列。

    C++ 中没有 Counter 的直接对应,但可以用 unordered_map 实现计数,再借助 vector 排序获取最值。Python 的 Counter 更高级,内置了 most_common 等便捷方法。

    11.3 OrderedDict——保持插入顺序(Python 3.7+ 中普通 dict 已有序)

    在 Python 3.6 之前,字典无序,OrderedDict 用于保持插入顺序。现在普通 dict 也保持顺序,但 OrderedDict 还额外提供了 move_to_end() 等方法。

    from collections import OrderedDict
    od = OrderedDict()
    od["a"] = 1
    od["b"] = 2
    od.move_to_end("a")   # 将 "a" 移到末尾

    move_to_end(key, last=True) 将指定键移动到末尾(如果 last=False 则移动到开头)。C++ 中保持插入顺序没有标准容器直接支持,可以使用 std::vector 配合 unordered_map 来记录顺序,或使用 boost::multi_index。Python 3.7+ 普通 dict 已有序,这是比 C++ 方便的特性。

    11.4 ChainMap——将多个字典合并成一个视图

    用于查找时按顺序搜索多个字典。

    from collections import ChainMap
    d1 = {"a": 1, "b": 2}
    d2 = {"b": 3, "c": 4}
    chain = ChainMap(d1, d2)
    print(chain["b"])   # 从 d1 找到 2(取第一个)

    ChainMap(d1, d2) 创建了一个虚拟的合并字典,优先查找 d1,如果 d1 中没有再到 d2 中查找。修改 chain 会影响第一个字典 d1。C++ 无直接对应,但可用多个 map 和自定义搜索逻辑实现。

    12. 字典与列表、元组的对比

    特性字典列表元组
    容器类型映射(键值对)序列序列
    有序性Python 3.7+ 插入有序有序有序
    可变性可变可变不可变
    索引方式键(不可变类型)整数索引整数索引
    查找速度平均 O(1)O(n)O(n)
    内存占用较大中等略小于列表
    典型用途关联数据、快速查找有序序列不可变序列

    13. 字典的应用实战

    13.1 统计字符串中字符出现次数

    text = "hello world"
    freq = {}
    for ch in text:
        if ch != " ":
            freq[ch] = freq.get(ch, 0) + 1
    print(freq)

    遍历字符串中的每个字符,跳过空格。使用 freq.get(ch, 0) 获取字符当前的计数,如果不存在则返回 0,然后加 1 并赋值。更优雅的方式是使用 Counter(text)。

    13.2 使用字典实现简单缓存(记忆化)

    def fibonacci(n, cache={}):
        if n in cache:
            return cache[n]
        if n <= 1:
            return n
        cache[n] = fibonacci(n-1) + fibonacci(n-2)
        return cache[n]

    默认参数 cache={} 在函数定义时创建一次,后续调用会复用同一个字典对象(注意:可变默认参数要小心使用,但在这里正好用来实现缓存)。每次计算 fibonacci(n) 时,先检查缓存,如果已有结果则直接返回,避免重复递归。

    13.3 根据值排序字典

    d = {"apple": 3, "banana": 1, "cherry": 2}
    # 按值升序排序,得到键的列表
    sorted_keys = sorted(d, key=d.get)           # ['banana', 'cherry', 'apple']
    # 按值降序排序,得到键值对列表
    sorted_items = sorted(d.items(), key=lambda x: x[1], reverse=True)

    sorted(d, key=d.get) 以 d.get 作为键函数,对每个键获取对应的值,按值排序,结果返回键的列表。sorted(d.items(), key=lambda x: x[1]) 则对 (key, value) 元组按值排序。

    13.4 合并两个字典(Python 3.9+ 使用|)

    d1 = {"a": 1, "b": 2}
    d2 = {"b": 3, "c": 4}
    merged = d1 | d2        # {'a':1, 'b':3, 'c':4}
    d1 |= d2                # 原地更新(Python 3.9+)

    | 运算符返回一个新字典,包含两个字典的键值对,重复键以右边字典为准。|= 是原地操作,相当于 d1.update(d2)。C++ 中合并两个 unordered_map 无运算符重载,需手动循环插入。

    14. 常见陷阱与注意事项

    陷阱说明解决方案
    使用可变对象作为键列表、字典等不可哈希,会报错改用元组或字符串
    在遍历字典时修改字典会导致 RuntimeError: dictionary changed size during iteration遍历 list(d.keys()) 或 d.copy().items()
    混淆 get 和 setdefaultsetdefault 会修改字典,get 不会按需选择
    认为字典总是无序(旧代码)Python 3.7+ 插入顺序被保证,但依赖此特性的代码需要最低版本使用 OrderedDict 若需严格兼容低版本
    在 defaultdict 中传递可变对象工厂函数使用 list 而非 list(),传递可调用对象defaultdict(list) 正确,defaultdict(list()) 错误
    拷贝字典时使用 = 而非 copy二者指向同一对象,修改会互相影响浅拷贝用 d.copy(),深拷贝用 copy.deepcopy

    C++ 中同样有遍历时删除导致迭代器失效的问题,通常使用 for (auto it = m.begin(); it != m.end(); ) { if (cond) it = m.erase(it); else ++it; }。另外,C++ 的 unordered_map 默认不保留插入顺序,如果需要顺序需额外维护。

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发 Python
    相关文章 更多
    python删除一个列表里的重复元素的方法与代码示例
    python删除一个列表里的重复元素的方法与代码示例

    学习如何使用Python高效删除列表中的重复元素。本文提供5种常见方法的代码示例,涵盖保持顺序与不保持顺序的场景,适合初学者和进阶开发者参考。

    Python写接口的步骤及完整代码示例
    Python写接口的步骤及完整代码示例

    详细讲解使用Python编写Web接口的核心步骤与完整代码示例,涵盖环境准备、路由定义、数据校验、服务启动及调试测试方法。

    codex怎么读取word文档及docx文件操作教程
    codex怎么读取word文档及docx文件操作教程

    介绍如何利用编程工具读取和解析Word文档(docx格式),涵盖基础文本提取代码示例、结构化数据处理逻辑,以及处理复杂排版时的技术局限与替代方案。

    怎么在Python中调用C语言代码提升性能
    怎么在Python中调用C语言代码提升性能

    详细讲解在Python中调用C语言代码提升性能的完整实践指南,包含原理分析、编译步骤、ctypes与CFFI具体实现、性能对比及常见陷阱。

    Python与C语言的性能差异及底层原理
    Python与C语言的性能差异及底层原理

    深入解析Python与C语言在执行效率上的数量级差异,从编译机制、变量内存布局、动态类型推断到GIL锁,系统阐明底层核心原理。

    Python和C语言哪个更适合编程入门
    Python和C语言哪个更适合编程入门

    客观对比Python与C语言在心智负担、底层机制与学习反馈上的核心差异,提供清晰有据的选择标准与切实的入门学习路径。

    selenium上传文件教程本地文件路径设置方法
    selenium上传文件教程本地文件路径设置方法

    深入解析Selenium处理文件上传的技术细节,涵盖标准HTML控件的路径直接注入法与非标准控件的系统级模拟方案,提供Windows与Linux环境下的路径设置最佳实践及常见异常排查。

    大数据开发语言选型:Java对比Scala与Python的优缺点及适用场景
    大数据开发语言选型:Java对比Scala与Python的优缺点及适用场景

    针对大数据工程场景,系统对比Java、Scala与Python在执行性能、生态结合、开发效率和维护成本上的核心差异,给出清晰的架构选型依据与落地方案。

    langgraph python guide中文入门教程详解
    langgraph python guide中文入门教程详解

    本篇LangGraph Python中文入门教程详解,系统梳理StateGraph状态机定义、节点编写、边与条件路由、检查点持久化(MemorySaver)等核心机制,提供从环境安装到完整循环智能体构建的代码示例与实操指导。

    Windows 安装 Python:从官方入口到虚拟环境的可复现实践
    Windows 安装 Python:从官方入口到虚拟环境的可复现实践

    面向后端开发者,基于 Python 官方文档说明如何在 Windows 上安装 Python、创建 venv 虚拟环境及使用 pip 管理依赖。包含可复制命令、验证方法及工具选择边界,避免常见配置误区。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。