python从0快速上手（六）数据结构

Python学习：数据结构篇

在这个充满数据的世界里，Python的数据结构就像是我们的瑞士军刀，帮助我们切割、打孔、锯割数据，让它们变得井井有条。列表、元组、字典、集合，这些看似简单的工具，却能解决编程中的各种复杂问题。让我们一起来探索这些神奇的数据结构吧！

1. 列表（List）

列表是Python中最常用的数据结构之一，它就像是一列有序的火车车厢，每个车厢都可以装载不同的物品。

创建列表：

my_list = [1, 2, 3, 'Kimi', 'Python']

访问列表元素：
列表元素可以通过索引访问，索引从0开始。

print(my_list[0])  # 输出：1
print(my_list[4])  # 输出：Kimi

切片：
切片就像是把列表切成一片片，你可以获取列表的一部分。

print(my_list[1:3])  # 输出：[2, 3]

添加元素：
你可以在列表的末尾添加元素，就像是在火车尾部加车厢。

my_list.append('new item')
print(my_list)  # 输出：[1, 2, 3, 'Kimi', 'Python', 'new item']

删除元素：
删除元素就像是从火车上卸下车厢。

del my_list[0]  # 删除第一个元素
print(my_list)  # 输出：[2, 3, 'Kimi', 'Python', 'new item']

列表推导式：
列表推导式是一种优雅的方式，用于创建列表。

squares = [x**2 for x in range(10)]
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

实例：制作一个简单的待办事项列表

todo_list = []

def add_task(task):
    todo_list.append(task)
    print(f"任务已添加：{task}")

def remove_task(task):
    if task in todo_list:
        todo_list.remove(task)
        print(f"任务已删除：{task}")
    else:
        print("任务不存在")

add_task("学习Python")
add_task("锻炼身体")
remove_task("锻炼身体")
print("当前待办事项：", todo_list)

2. 元组（Tuple）

元组和列表类似，但它是不可变的，就像是已经被封印的列表。

创建元组：

my_tuple = (1, 2, 3, 'Kimi', 'Python')

访问元组元素：

print(my_tuple[0])  # 输出：1
print(my_tuple[4])  # 输出：Python

元组解包：
元组解包是一种将元组中的值赋给多个变量的方式。

a, b, c, d, e = my_tuple
print(a)  # 输出：1
print(e)  # 输出：Python

实例：创建一个个人资料元组

person = ("Kimi", "Moonshot", 30)

def get_full_name(first_name, last_name):
    return f"{first_name} {last_name}"

first_name, last_name, age = person
full_name = get_full_name(first_name, last_name)
print("全名：", full_name)
print("年龄：", age)

3. 字典（Dictionary）

字典是一种存储键值对的数据结构，它就像是一本书的索引，让你快速找到对应的内容。

创建字典：

my_dict = {'name': 'Kimi', 'role': 'AI Assistant', 'active': True}

访问字典元素：

print(my_dict['name'])  # 输出：Kimi

添加和修改元素：

my_dict['age'] = 30
my_dict['active'] = False
print(my_dict)  # 输出：{'name': 'Kimi', 'role': 'AI Assistant', 'active': False, 'age': 30}

删除元素：

del my_dict['age']
print(my_dict)  # 输出：{'name': 'Kimi', 'role': 'AI Assistant', 'active': False}

字典推导式：
字典推导式是一种优雅的方式，用于创建字典。

squares_dict = {x: x**2 for x in range(10)}
print(squares_dict)  # 输出：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

实例：创建一个简单的通讯录

contacts = {}

def add_contact(name, phone_number):
    contacts[name] = phone_number
    print(f"联系人已添加：{name}")

def remove_contact(name):
    if name in contacts:
        del contacts[name]
        print(f"联系人已删除：{name}")
    else:
        print("联系人不存在")

add_contact("Kimi", "1234567890")
add_contact("Moonshot", "0987654321")
remove_contact("Moonshot")
print("当前通讯录：", contacts)

4. 集合（Set）

集合是一个无序且不包含重复元素的数据结构，它就像是一袋子不同的石头，每个石头都是独一无二的。

创建集合：

my_set = {1, 2, 3, 'Kimi', 'Python'}

添加元素：

my_set.add('new item')
print(my_set)  # 输出：{1, 2, 3, 'Kimi', 'Python', 'new item'}

删除元素：

my_set.discard('new item')
print(my_set)  # 输出：{1, 2, 3, 'Kimi', 'Python'}

集合运算：
集合提供了丰富的运算，如并集、交集、差集等。

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# 并集
print(set_a | set_b)  # 输出：{1, 2, 3, 4, 5, 6}

# 交集
print(set_a & set_b)  # 输出：{3, 4}

# 差集
print(set_a - set_b)  # 输出：{1, 2}

实例：找出两组数据的共同点和不同点

set_a = {'apple', 'banana', 'cherry'}
set_b = {'banana', 'kiwi', 'cherry'}

common_items = set_a & set_b
unique_to_a = set_a - set_b
unique_to_b = set_b - set_a

print("共同点：", common_items)
print("A独有的：", unique_to_a)
print("B独有的：", unique_to_b)

实例演练

让我们通过一些有趣的实例来加深理解。

实例1：创建一个函数来找出列表中的前三个素数

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

def find_first_three_primes(numbers):
    primes = []
    for number in numbers:
        if is_prime(number):
            primes.append(number)
        if len(primes) == 3:
            break
    return primes

numbers = [10, 15, 23, 45, 11, 13, 17]
print("前三个素数：", find_first_three_primes(numbers))

实例2：编写一个函数来计算两个字典的共同键和不同的键

def compare_dictionaries(dict1, dict2):
    common_keys = set(dict1.keys()) & set(dict2.keys())
    unique_to_dict1 = set(dict1.keys()) - set(dict2.keys())
    unique_to_dict2 = set(dict2.keys()) - set(dict1.keys())
    return common_keys, unique_to_dict1, unique_to_dict2

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 2, 'c': 3, 'd': 4}

common, unique_to_dict1, unique_to_dict2 = compare_dictionaries(dict1, dict2)
print("共同键：", common)
print("Dict1独有的键：", unique_to_dict1)
print("Dict2独有的键：", unique_to_dict

实例3：创建一个函数来合并两个列表并去除重复元素

def merge_lists去除重复元素(list1, list2):
    combined_list = list1 + list2
    unique_list = []
    seen = set()
    for item in combined_list:
        if item not in seen or seen.add(item):
            unique_list.append(item)
    return unique_list

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
print("合并后去除重复的列表：", merge_lists去除重复元素(list1, list2))

实例4：编写一个函数来找出一组数字中的最大和最小值

def find_max_and_min(numbers):
    if not numbers:
        return None, None
    max_val = min_val = numbers[0]
    for number in numbers:
        if number > max_val:
            max_val = number
        if number < min_val:
            min_val = number
    return max_val, min_val

numbers = [10, 20, 30, 40, 50, 60]
max_val, min_val = find_max_and_min(numbers)
print("最大值：", max_val)
print("最小值：", min_val)

小结

列表、元组、字典、集合，这些数据结构就像是我们的编程工具箱，帮助我们以不同的方式组织和处理数据。通过这些基础的数据结构，我们可以构建出复杂的数据模型和算法。记住，选择合适的数据结构是解决编程问题的关键。

现在，你已经掌握了Python数据结构的基础。但是，这只是冰山一角。在编程的世界里，还有更多高级的概念等着你去探索。编程就像是一场冒险，而你已经迈出了第一步。祝你在编程的世界里旅途愉快！🐍💻

原文地址：https://blog.csdn.net/weixin_39346529/article/details/142874645

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！