人工智能之编程基础 Python 入门

第六章 基础数据类型（二）

前言

本章节紧接上一章的内容学习python的可变数据类型List（列表）、Dictionary（字典）、Set（集合）。

List（列表）

在 Python 中， 列表（List） 是一种有序、可变的序列数据类型。它是 Python 最常用和最灵活的数据结构之一，可以存储任意类型的对象（整数、字符串、其他列表等），并且允许重复元素。

1. 列表的创建

# 使用方括号 []

empty_list = []

numbers = [
1, 
2, 
3, 
4, 
5]

fruits = [
"apple", 
"banana", 
"orange"]

mixed = [
1, 
"hello", 
3.14, 
True, [
1, 
2]]




# 使用 list() 构造函数

list_from_string = 
list(
"hello")        
# ['h', 'e', 'l', 'l', 'o']

list_from_range = 
list(
range(
5))        
# [0, 1, 2, 3, 4]

2. 列表的特性

3. 列表的访问

索引（Indexing）

fruits = [
"apple", 
"banana", 
"cherry"]




print(fruits[
0])    
# apple (第一个)


print(fruits[-
1])   
# cherry (最后一个)


# print(fruits[10])  # IndexError: list index out of range

切片（Slicing）

numbers = [
0, 
1, 
2, 
3, 
4, 
5, 
6, 
7, 
8, 
9]




print(numbers[
2:
5])     
# [2, 3, 4] (索引2到4)


print(numbers[:
3])      
# [0, 1, 2] (开头到索引2)


print(numbers[
5:])      
# [5, 6, 7, 8, 9] (索引5到末尾)


print(numbers[::
2])     
# [0, 2, 4, 6, 8] (每隔一个)


print(numbers[::-
1])    
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (反转)

4. 列表的修改（可变性）

修改元素

fruits[
1] = 
"blueberry"


print(fruits)  
# ['apple', 'blueberry', 'cherry']

添加元素

# append() - 在末尾添加单个元素

fruits.append(
"grape")




# insert() - 在指定位置插入元素

fruits.insert(
1, 
"kiwi")  
# 在索引1处插入




# extend() - 添加多个元素（另一个可迭代对象）

fruits.extend([
"mango", 
"pineapple"])

删除元素

# remove() - 删除第一个匹配的值

fruits.remove(
"apple")




# pop() - 删除并返回指定索引的元素（默认最后一个）

last_fruit = fruits.pop()

second_fruit = fruits.pop(
1)




# del - 删除指定索引或切片


del fruits[
0]


del fruits[
1:
3]  
# 删除索引1到2的元素




# clear() - 清空列表


# fruits.clear()

5. 常用列表方法

numbers = [
3, 
1, 
4, 
1, 
5, 
9, 
2]




# 排序

numbers.sort()           
# 升序排序（原地修改）

numbers.sort(reverse=
True)  
# 降序

sorted_numbers = 
sorted(numbers)  
# 返回新列表，不修改原列表




# 反转

numbers.reverse()        
# 原地反转

reversed_numbers = 
list(
reversed(numbers))  
# 返回迭代器




# 查找


print(numbers.index(
4))  
# 返回第一个匹配项的索引


print(numbers.count(
1))  
# 统计元素出现次数




# 复制（重要！）

original = [
1, 
2, 
3]

shallow_copy = original.copy()  
# 浅拷贝


# 或者使用切片: copy = original[:]

6. 列表操作

拼接

list1 = [
1, 
2]

list2 = [
3, 
4]

combined = list1 + list2  
# [1, 2, 3, 4]

重复

repeated = [1, 2] * 3  # [1, 2, 1, 2, 1, 2]

成员检查

if 
"apple" 
in fruits:

    
print(
"找到了苹果！")

长度

length = len(fruits)

7. 列表推导式（List Comprehension）

一种简洁创建列表的方式。

# 创建平方数列表

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


# 等价于：


# squares = []


# for x in range(10):


#     squares.append(x**2)




# 带条件的列表推导式

evens = [x 
for x 
in 
range(
10) 
if x % 
2 == 
0]  
# [0, 2, 4, 6, 8]




# 字符串处理

words = [
"hello", 
"world", 
"python"]

upper_words = [word.upper() 
for word 
in words]

8. 遍历列表

# 方法1：直接遍历元素


for fruit 
in fruits:

    
print(fruit)




# 方法2：使用索引


for i 
in 
range(
len(fruits)):

    
print(
f"
{i}: 
{fruits[i]}")




# 方法3：使用 enumerate()（推荐）


for index, fruit 
in 
enumerate(fruits):

    
print(
f"
{index}: 
{fruit}")

9. 嵌套列表

列表可以包含其他列表，常用于表示二维数据（如矩阵）。

matrix = [

    [
1, 
2, 
3],

    [
4, 
5, 
6],

    [
7, 
8, 
9]

]




print(matrix[
0][
1])  
# 2 (第一行第二列)




# 遍历二维列表


for row 
in matrix:

    
for element 
in row:

        
print(element, end=
" ")

    
print()

10. 注意事项与陷阱

1. 可变对象的引用

# ❌ 错误：共享同一个列表对象

list_of_lists = [[]] * 
3

list_of_lists[
0].append(
1)


print(list_of_lists)  
# [[1], [1], [1]] 所有子列表都被修改！




# ✅ 正确：创建独立的列表

list_of_lists = [[] 
for _ 
in 
range(
3)]

list_of_lists[
0].append(
1)


print(list_of_lists)  
# [[1], [], []]

2. 修改列表时的索引问题

# ❌ 在遍历中删除元素可能导致跳过元素

numbers = [
1, 
2, 
3, 
4, 
5]


for num 
in numbers:

    
if num % 
2 == 
0:

        numbers.remove(num)  
# 危险！可能出错




# ✅ 正确的做法


# 方法1：反向遍历


for i 
in 
range(
len(numbers) - 
1, -
1, -
1):

    
if numbers[i] % 
2 == 
0:

        
del numbers[i]




# 方法2：创建新列表

numbers = [num 
for num 
in numbers 
if num % 
2 != 
0]

11. 列表 vs 元组

Dictionary（字典）

在 Python 中， 字典（Dictionary） 是一种非常强大且常用的数据结构，用于存储 键值对（key-value pairs） 。它也被称为关联数组或 哈希表。

1. 字典的创建

# 使用花括号 {}

empty_dict = {}

person = {

    
"name": 
"Alice",

    
"age": 
25,

    
"city": 
"Beijing"

}




# 使用 dict() 构造函数

dict_from_pairs = 
dict([(
"a", 
1), (
"b", 
2)])

dict_with_args = 
dict(name=
"Bob", age=
30)




# 从其他数据结构创建

keys = [
"x", 
"y", 
"z"]

values = [
1, 
2, 
3]

coordinates = 
dict(
zip(keys, values))  
# {'x': 1, 'y': 2, 'z': 3}

2. 字典的特性

3. 字典的基本操作

访问值

person = {
"name": 
"Alice", 
"age": 
25}




# 使用方括号 []


print(person[
"name"])  
# Alice




# 使用 get() 方法（推荐，更安全）


print(person.get(
"age"))     
# 25


print(person.get(
"gender"))  
# None (默认)


print(person.get(
"gender", 
"未知"))  
# "未知" (指定默认值)

添加/修改元素

# 添加新键值对

person[
"city"] = 
"Shanghai"




# 修改现有值

person[
"age"] = 
26




# 使用 update() 批量更新

person.update({
"job": 
"Engineer", 
"salary": 
10000})

删除元素

# pop() - 删除并返回指定键的值

age = person.pop(
"age")




# popitem() - 删除并返回最后一个键值对 (Python 3.7+)

last_item = person.popitem()




# del - 删除指定键


del person[
"city"]




# clear() - 清空字典


# person.clear()

4. 字典的常用方法

person = {
"name": 
"Alice", 
"age": 
25, 
"city": 
"Beijing"}




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


print(person.keys())    
# dict_keys(['name', 'age', 'city'])


print(person.values())  
# dict_values(['Alice', 25, 'Beijing'])


print(person.items())   
# dict_items([('name', 'Alice'), ('age', 25), ('city', 'Beijing')])




# 检查键是否存在


if 
"name" 
in person:

    
print(
"存在 name 键")




# 获取字典长度


print(
len(person))  
# 3




# 复制字典

shallow_copy = person.copy()

5. 遍历字典

person = {
"name": 
"Alice", 
"age": 
25, 
"city": 
"Beijing"}




# 遍历键


for key 
in person:

    
print(key)




# 或者


for key 
in person.keys():

    
print(key)




# 遍历值


for value 
in person.values():

    
print(value)




# 遍历键值对（最常用）


for key, value 
in person.items():

    
print(
f"
{key}: 
{value}")

6. 字典推导式

类似于列表推导式，可以简洁地创建字典。

# 创建平方数字典

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


# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}




# 带条件的字典推导式

even_squares = {x: x**
2 
for x 
in 
range(
10) 
if x % 
2 == 
0}


# {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}




# 转换现有字典

original = {
"a": 
1, 
"b": 
2, 
"c": 
3}

doubled = {k: v*
2 
for k, v 
in original.items()}


# {'a': 2, 'b': 4, 'c': 6}

7. 嵌套字典

字典的值可以是另一个字典，用于表示复杂的数据结构。

students = {

    
"Alice": {

        
"age": 
20,

        
"grade": 
"A",

        
"courses": [
"Math", 
"Physics"]

    },

    
"Bob": {

        
"age": 
21,

        
"grade": 
"B",

        
"courses": [
"Chemistry", 
"Biology"]

    }

}




# 访问嵌套值


print(students[
"Alice"][
"age"])           
# 20


print(students[
"Bob"][
"courses"][
0])      
# Chemistry




# 遍历嵌套字典


for name, info 
in students.items():

    
print(
f"
{name}: 
{info[
'age']}岁, 成绩
{info[
'grade']}")

8. 实用技巧和最佳实践

1. 使用  get() 防止 KeyError

# ❌ 可能出错


# value = my_dict["missing_key"]




# ✅ 安全的做法

value = my_dict.get(
"missing_key", 
"默认值")

2. 设置默认值

# setdefault() - 如果键不存在，则设置默认值

person.setdefault(
"gender", 
"未知")


# 如果"gender"键不存在，则添加并赋值"未知"




# defaultdict - 更高级的默认字典


from collections 
import defaultdict

word_count = defaultdict(
int)  
# 默认值为0

word_count[
"apple"] += 
1  
# 即使键不存在也不会报错

3. 合并字典（Python 3.9+）

dict1 = {
"a": 
1, 
"b": 
2}

dict2 = {
"c": 
3, 
"d": 
4}




# 方法1：使用 | 操作符

merged = dict1 | dict2




# 方法2：使用 |= 更新

dict1 |= dict2




# 方法3：解包（适用于所有版本）

merged = {**dict1, **dict2}

9. 注意事项

1. 可哈希的键

# ✅ 有效的键

valid_dict = {

    
"string": 
1,

    
42: 
2,

    (
1, 
2): 
3,  
# 元组可以作为键

    
None: 
4

}




# ❌ 无效的键（可变类型）


# invalid_dict = {[1, 2]: "value"}  # TypeError: unhashable type: 'list'


# invalid_dict = {{'a': 1}: "value"}  # TypeError: unhashable type: 'dict'

2. 浅拷贝问题

original = {
"a": [
1, 
2, 
3]}

copy = original.copy()

copy[
"a"].append(
4)


print(original)  
# {'a': [1, 2, 3, 4]}! 原字典也被修改了

10. 字典的应用场景

1. 1.  配置管理

config = {

    
"host": 
"localhost",

    
"port": 
8080,

    
"debug": 
True

}

1. 2.  缓存

cache = {}


def 
get_data(
key):

    
if key 
in cache:

        
return cache[key]

    
# 计算数据...

    cache[key] = result

    
return result

1. 3.  计数器

word_count = {}


for word 
in words:

    word_count[word] = word_count.get(word, 
0) + 
1

1. 4.  JSON 数据处理

import json

data = json.loads(
'{"name": "Alice", "age": 25}')

Set（集合）

在 Python 中， 集合（Set） 是一种无序、可变的容器数据类型，用于存储 唯一的元素（即不包含重复项）。集合基于数学中的集合论，支持交集、并集、差集等操作。

1. 集合的创建

# 使用花括号 {} - 注意：空集合不能用 {}

empty_set = 
set()  
# ✅ 正确


# empty_set = {}   # ❌ 错误！这是空字典




# 非空集合可以用花括号

fruits = {
"apple", 
"banana", 
"orange"}




# 使用 set() 构造函数

numbers = 
set([
1, 
2, 
3, 
2, 
1])  
# {1, 2, 3} 自动去重

chars = 
set(
"hello")             
# {'h', 'e', 'l', 'o'} 注意 'l' 只出现一次

2. 集合的特性

3. 集合的基本操作

添加元素

fruits = {
"apple", 
"banana"}




# add() - 添加单个元素

fruits.add(
"orange")




# update() - 添加多个元素（任何可迭代对象）

fruits.update([
"grape", 
"kiwi"])

fruits.update(
"xyz")  
# 添加 'x', 'y', 'z'

删除元素

# remove() - 删除指定元素，元素不存在时会报错

fruits.remove(
"banana")




# discard() - 删除指定元素，元素不存在时不会报错（推荐）

fruits.discard(
"mango")  
# 即使没有也不会报错




# pop() - 随机删除并返回一个元素（因为无序）

random_fruit = fruits.pop()




# clear() - 清空集合


# fruits.clear()

检查成员

if 
"apple" 
in fruits:

    
print(
"苹果在集合中")




if 
"mango" 
not 
in fruits:

    
print(
"没有芒果")

获取大小

size = len(fruits)

4. 集合的数学运算

集合支持丰富的集合运算：

set1 = {
1, 
2, 
3, 
4}

set2 = {
3, 
4, 
5, 
6}




# 并集 (Union) - 所有元素


print(set1 | set2)           
# {1, 2, 3, 4, 5, 6}


print(set1.union(set2))




# 交集 (Intersection) - 共同元素


print(set1 & set2)           
# {3, 4}


print(set1.intersection(set2))




# 差集 (Difference) - set1 有但 set2 没有的元素


print(set1 - set2)           
# {1, 2}


print(set1.difference(set2))




# 对称差集 (Symmetric Difference) - 只在一个集合中的元素


print(set1 ^ set2)           
# {1, 2, 5, 6}


print(set1.symmetric_difference(set2))




# 子集和超集

set3 = {
1, 
2}


print(set3 <= set1)          
# True (set3 是 set1 的子集)


print(set1 >= set3)          
# True (set1 是 set3 的超集)

5. 集合推导式

类似于列表推导式，可以简洁地创建集合。

# 创建平方数集合

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


# {0, 1, 4, 9, 16}




# 带条件的集合推导式

evens = {x 
for x 
in 
range(
10) 
if x % 
2 == 
0}


# {0, 2, 4, 6, 8}




# 从字符串创建去重字符集

unique_chars = {c 
for c 
in 
"hello world" 
if c != 
" "}


# {'h', 'e', 'l', 'o', 'w', 'r', 'd'}

6. 不可变集合：frozenset

frozenset 是集合的不可变版本，创建后不能修改，因此它是 可哈希的，可以用作字典的键或集合的元素。

# 创建 frozenset

frozen = 
frozenset([
1, 
2, 
3, 
2])


print(frozen)  
# frozenset({1, 2, 3})




# frozenset 支持所有集合运算，但不能修改


# frozen.add(4)  # ❌ AttributeError




# 用作字典的键

dict_with_frozen = {

    
frozenset([
1, 
2]): 
"group1",

    
frozenset([
3, 
4]): 
"group2"

}

7. 遍历集合

由于集合无序，遍历顺序不固定。

fruits = {
"apple", 
"banana", 
"orange"}




for fruit 
in fruits:

    
print(fruit)




# 如果需要排序输出


for fruit 
in 
sorted(fruits):

    
print(fruit)

8. 实际应用示例

1. 去除重复元素

# 最常用的用途

original_list = [
1, 
2, 
2, 
3, 
3, 
3, 
4]

unique_list = 
list(
set(original_list))


print(unique_list)  
# [1, 2, 3, 4] (顺序可能不同)

2. 成员资格测试（高效）

# 集合的查找时间复杂度为 O(1)，比列表 O(n) 迅速得多

valid_users = {
"alice", 
"bob", 
"charlie"}




def 
check_access(
username):

    
return username 
in valid_users  
# 非常迅速

3. 文本处理

text = 
"hello world python"

vowels = 
set(
"aeiou")

text_chars = 
set(text)




# 找出文本中包含的元音字母

found_vowels = text_chars & vowels


print(found_vowels)  
# {'o', 'e'}

4. 比较数据集

current_users = {
"alice", 
"bob", 
"david"}

previous_users = {
"alice", 
"charlie", 
"bob"}




# 新增用户

new_users = current_users - previous_users  
# {'david'}




# 离开用户

left_users = previous_users - current_users  
# {'charlie'}




# 活跃用户（都有的）

active_users = current_users & previous_users  
# {'alice', 'bob'}

9. 注意事项

1. 可变元素不能放入集合

# ❌ 错误：列表是可变的，不可哈希


# invalid_set = {[1, 2], [3, 4]}  # TypeError




# ✅ 正确：使用元组（不可变）

valid_set = {(
1, 
2), (
3, 
4)}

2. 集合本身不可哈希

# ❌ 错误


# dict_with_set = {{"a", "b"}: "value"}  # TypeError




# ✅ 正确：使用 frozenset

dict_with_frozen = {
frozenset([
"a", 
"b"]): 
"value"}

3. 空集合的创建

s = 
set()  
# 空集合

d = {}     
# 空字典

10. 性能特点

• • 查找、插入、删除：平均时间复杂度 O(1)
• • 空间复杂度：O(n)
• • 适合：需要迅速成员检查、去重的场景
• • 不适合：需要保持顺序或索引访问的场景

总结

本文主要对python的基本数据类型中的可变数据类型进行相关的学习，感谢大家的关注，一起努力学习。

资料关注

相关资料获取:
公众号：咚咚王

《Python编程：从入门到实践》
《利用Python进行数据分析》
《算法导论中文第三版》
《概率论与数理统计（第四版） (盛骤) 》
《程序员的数学》
《线性代数应该这样学第3版》
《微积分和数学分析引论》
《（西瓜书）周志华-机器学习》
《TensorFlow机器学习实战指南》
《Sklearn与TensorFlow机器学习实用指南》
《模式识别（第四版）》
《深度学习 deep learning》伊恩·古德费洛著 花书
《Python深度学习第二版(中文版)【纯文本】 (登封大数据 (Francois Choliet)) (Z-Library)》
《深入浅出神经网络与深度学习+(迈克尔·尼尔森（Michael+Nielsen） 》
《自然语言处理综论 第2版》
《Natural-Language-Processing-with-PyTorch》
《计算机视觉-算法与应用(中文版)》
《Learning OpenCV 4》
《AIGC：智能创作时代》杜雨+&+张孜铭
《AIGC原理与实践：零基础学大语言模型、扩散模型和多模态模型》
《从零构建大语言模型（中文版）》
《实战AI大模型》
《AI 3.0》