Python 魔法学院 - 第03篇:Python 变量与数据类型 ⭐

目录

    • 1. 引言:开启 Python 变量与数据类型的魔法之旅
    • 2. 变量:数据的魔法标签 ️
      • 2.1 什么是变量?
      • 2.2 变量的命名规则
    • 3. 数据类型:Python 的魔法工具箱
      • 3.1 数据类型示例
      • 3.2 数据类型的内存结构
        • 内存结构模拟
    • 4. Python 中的关键字和保留字
    • 5. Python 可变类型及其方法详解 ️
      • 5.1 列表(List)
        • 5.1.1 列表的创建
        • 5.1.2 列表的常用方法
        • 5.1.3 列表方法的使用示例及内存模拟
      • 5.2 集合(Set)
        • 5.2.1 集合的创建
        • 5.2.2 集合的常用方法
        • 5.2.3 集合方法的使用示例及内存模拟
      • 5.3 字典(Dict)
        • 5.3.1 字典的创建
        • 5.3.2 字典的常用方法
        • 5.3.3 字典方法的使用示例及内存模拟
    • 6. 实际开发中的案例 ️
      • 6.1 案例1:用户信息管理系统
      • 6.2 案例2:数据去重
      • 6.3 案例3:统计单词频率
    • 7. 互动练习
      • 7.1 练习题1:变量命名
      • 7.2 练习题2:数据类型转换
    • 8. 总结:掌握变量与数据类型,成为 Python 魔法师 ‍♂️


1. 引言:开启 Python 变量与数据类型的魔法之旅

欢迎来到 Python 魔法学院的第 3 篇教程!在这一篇中,我们将一起探索 Python 中的变量数据类型。无论你是编程新手,还是已经有一定经验的开发者,掌握这些基础知识都是迈向 Python 大师之路的关键一步。

我们将通过生动的案例详细的解释优雅的代码示例,帮助你轻松理解 Python 的变量与数据类型。准备好了吗?让我们一起开启这段魔法之旅吧!


2. 变量:数据的魔法标签 ️

2.1 什么是变量?

在 Python 中,变量是用来存储数据的容器。你可以把变量想象成一个魔法标签,这个标签可以贴在任何数据上。变量名是标签的名字,而变量的值就是标签所代表的数据。

x = 10
y = "Hello, World!"

在上面的代码中:

  • x 是一个变量,它存储了整数值 10
  • y 是另一个变量,它存储了字符串 "Hello, World!"

2.2 变量的命名规则

在 Python 中,变量名需要遵循以下规则:

  • 变量名必须以字母下划线 _ 开头,不能以数字开头。
  • 变量名只能包含字母数字下划线 _
  • 变量名是区分大小写的,即 myVarmyvar 是两个不同的变量。
my_var = 10  # 合法
myVar = 20   # 合法
_my_var = 30 # 合法
2nd_var = 40 # 非法(以数字开头)
my-var = 50  # 非法(包含非法字符 `-`)

3. 数据类型:Python 的魔法工具箱

Python 提供了多种数据类型,每种数据类型都有其独特的用途。以下是 Python 中最常用的数据类型:

数据类型 示例 描述
整数 10, -5 表示整数值
浮点数 3.14, -0.001 表示小数值
字符串 "Hello", 'Python' 表示文本数据
布尔值 True, False 表示真或假
列表 [1, 2, 3] 有序的可变集合
元组 (1, 2, 3) 有序的不可变集合
集合 {1, 2, 3} 无序且不重复的元素集合
字典 {'name': 'Alice'} 键值对的集合

3.1 数据类型示例

# 整数
a = 10

# 浮点数
b = 3.14

# 字符串
c = "Hello, Python!"

# 布尔值
d = True

# 列表
e = [1, 2, 3]

# 元组
f = (1, 2, 3)

# 集合
g = {1, 2, 3}

# 字典
h = {'name': 'Alice', 'age': 25}

3.2 数据类型的内存结构

让我们通过一个简单的例子来理解变量在内存中的存储方式。

x = 10
y = x

在这个例子中,xy 都指向同一个整数值 10。Python 使用引用计数来管理内存,当没有任何变量引用某个值时,该值将被垃圾回收。

内存结构模拟
变量名 | 内存地址 | 值
-------|----------|-----
x      | 0x1000   | 10
y      | 0x1000   | 10

4. Python 中的关键字和保留字

Python 有一些关键字保留字,这些单词在 Python 中有特殊的含义,不能用作变量名。以下是 Python 中的关键字和保留字:

关键字 描述
and 逻辑与
as 用于别名
assert 断言
break 跳出循环
class 定义类
continue 继续循环
def 定义函数
del 删除对象
elif 否则如果
else 否则
except 捕获异常
finally 无论是否异常都执行的代码
for 循环
from 从模块导入
global 声明全局变量
if 如果
import 导入模块
in 在…中
is 判断是否为同一对象
lambda 匿名函数
nonlocal 声明非局部变量
not 逻辑非
or 逻辑或
pass 空语句
raise 抛出异常
return 返回值
try 尝试执行代码
while 循环
with 上下文管理器
yield 生成器

5. Python 可变类型及其方法详解 ️

在 Python 中,可变类型是指可以在原地修改的数据类型,主要包括列表集合字典。下面我们将详细介绍这些可变类型的常用方法,并在每次调用方法时模拟内存结构。


5.1 列表(List)

列表是 Python 中最常用的可变数据类型之一。列表是一个有序的集合,可以存储不同类型的元素。

5.1.1 列表的创建
my_list = [1, 2, 3, "Python", True]
5.1.2 列表的常用方法
方法 描述
append() 在列表末尾添加元素
extend() 扩展列表
insert() 在指定位置插入元素
remove() 删除指定元素
pop() 删除并返回指定位置的元素
index() 返回指定元素的索引
count() 返回指定元素的出现次数
sort() 对列表进行排序
reverse() 反转列表
copy() 复制列表
5.1.3 列表方法的使用示例及内存模拟
# 创建列表
my_list = [1, 2, 3]

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [1, 2, 3]

# 添加元素
my_list.append(4)  # [1, 2, 3, 4]

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [1, 2, 3, 4]

# 扩展列表
my_list.extend([5, 6])  # [1, 2, 3, 4, 5, 6]

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [1, 2, 3, 4, 5, 6]

# 插入元素
my_list.insert(2, "Python")  # [1, 2, "Python", 3, 4, 5, 6]

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [1, 2, "Python", 3, 4, 5, 6]

# 删除元素
my_list.remove("Python")  # [1, 2, 3, 4, 5, 6]

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [1, 2, 3, 4, 5, 6]

# 删除并返回指定位置的元素
popped_element = my_list.pop(1)  # [1, 3, 4, 5, 6], popped_element = 2

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [1, 3, 4, 5, 6]

# 查找元素索引
index = my_list.index(4)  # index = 2

# 统计元素出现次数
count = my_list.count(3)  # count = 1

# 排序
my_list.sort()  # [1, 3, 4, 5, 6]

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [1, 3, 4, 5, 6]

# 反转
my_list.reverse()  # [6, 5, 4, 3, 1]

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [6, 5, 4, 3, 1]

# 复制列表
new_list = my_list.copy()  # new_list = [6, 5, 4, 3, 1]

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_list   | 0x1000   | [6, 5, 4, 3, 1]
new_list  | 0x2000   | [6, 5, 4, 3, 1]

5.2 集合(Set)

集合是一个无序且不重复的元素集合。

5.2.1 集合的创建
my_set = {1, 2, 3, "Python", True}
5.2.2 集合的常用方法
方法 描述
add() 添加元素
remove() 删除元素
discard() 删除元素(如果存在)
pop() 删除并返回任意元素
clear() 清空集合
union() 返回两个集合的并集
intersection() 返回两个集合的交集
difference() 返回两个集合的差集
symmetric_difference() 返回两个集合的对称差集
5.2.3 集合方法的使用示例及内存模拟
# 创建集合
my_set = {1, 2, 3}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_set    | 0x2000   | {1, 2, 3}

# 添加元素
my_set.add(4)  # {1, 2, 3, 4}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_set    | 0x2000   | {1, 2, 3, 4}

# 删除元素
my_set.remove(2)  # {1, 3, 4}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_set    | 0x2000   | {1, 3, 4}

# 删除元素(如果存在)
my_set.discard(5)  # {1, 3, 4}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_set    | 0x2000   | {1, 3, 4}

# 删除并返回任意元素
popped_element = my_set.pop()  # {3, 4}, popped_element = 1

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_set    | 0x2000   | {3, 4}

# 清空集合
my_set.clear()  # set()

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_set    | 0x2000   | set()

# 集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 并集
union_set = set1.union(set2)  # {1, 2, 3, 4, 5}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
union_set | 0x3000   | {1, 2, 3, 4, 5}

# 交集
intersection_set = set1.intersection(set2)  # {3}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
intersection_set | 0x4000 | {3}

# 差集
difference_set = set1.difference(set2)  # {1, 2}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
difference_set | 0x5000 | {1, 2}

# 对称差集
symmetric_difference_set = set1.symmetric_difference(set2)  # {1, 2, 4, 5}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
symmetric_difference_set | 0x6000 | {1, 2, 4, 5}

5.3 字典(Dict)

字典是一个键值对的集合,键必须是唯一的。

5.3.1 字典的创建
my_dict = {'name': 'Alice', 'age': 25}
5.3.2 字典的常用方法
方法 描述
keys() 返回所有键
values() 返回所有值
items() 返回所有键值对
get() 返回指定键的值
pop() 删除并返回指定键的值
update() 更新字典
clear() 清空字典
5.3.3 字典方法的使用示例及内存模拟
# 创建字典
my_dict = {'name': 'Alice', 'age': 25}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_dict   | 0x3000   | {'name': 'Alice', 'age': 25}

# 获取所有键
keys = my_dict.keys()  # dict_keys(['name', 'age'])

# 获取所有值
values = my_dict.values()  # dict_values(['Alice', 25])

# 获取所有键值对
items = my_dict.items()  # dict_items([('name', 'Alice'), ('age', 25)])

# 获取指定键的值
name = my_dict.get('name')  # name = 'Alice'

# 删除并返回指定键的值
age = my_dict.pop('age')  # my_dict = {'name': 'Alice'}, age = 25

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_dict   | 0x3000   | {'name': 'Alice'}

# 更新字典
my_dict.update({'age': 30, 'city': 'New York'})  # {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_dict   | 0x3000   | {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 清空字典
my_dict.clear()  # {}

# 内存结构模拟
变量名    | 内存地址 |----------|----------|-----------------
my_dict   | 0x3000   | {}

6. 实际开发中的案例 ️

6.1 案例1:用户信息管理系统

假设我们需要开发一个简单的用户信息管理系统,使用列表和字典来存储用户信息。

# 用户信息列表
users = [
    {'name': 'Alice', 'age': 25},
    {'name': 'Bob', 'age': 30},
    {'name': 'Charlie', 'age': 35}
]

# 添加新用户
new_user = {'name': 'David', 'age': 40}
users.append(new_user)

# 查找用户
def find_user(name):
    for user in users:
        if user['name'] == name:
            return user
    return None

# 查找用户 'Bob'
user_bob = find_user('Bob')
print(user_bob)  # 结果为:{'name': 'Bob', 'age': 30}

6.2 案例2:数据去重

假设我们有一个包含重复数据的列表,我们需要使用集合来去重。

# 原始数据
data = [1, 2, 2, 3, 4, 4, 5]

# 使用集合去重
unique_data = set(data)

# 转换回列表
unique_list = list(unique_data)
print(unique_list)  # 结果为:[1, 2, 3, 4, 5]

6.3 案例3:统计单词频率

假设我们有一段文本,我们需要统计每个单词出现的频率。

# 文本数据
text = "Python is great. Python is easy to learn. Python is powerful."

# 将文本转换为小写并拆分为单词列表
words = text.lower().split()

# 统计单词频率
word_count = {}
for word in words:
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1

print(word_count)  # 结果为:{'python': 3, 'is': 3, 'great.': 1, 'easy': 1, 'to': 1, 'learn.': 1, 'powerful.': 1}

7. 互动练习

7.1 练习题1:变量命名

以下哪些变量名是合法的?哪些是非法的?

  1. my_var
  2. 2nd_var
  3. _my_var
  4. my-var
  5. myVar

答案:

  1. 合法
  2. 非法(以数字开头)
  3. 合法
  4. 非法(包含非法字符 -
  5. 合法

7.2 练习题2:数据类型转换

将以下数据转换为指定的数据类型:

  1. 将字符串 "123" 转换为整数。
  2. 将整数 123 转换为字符串。
  3. 将浮点数 3.14 转换为整数。

答案:

# 1. 将字符串 "123" 转换为整数
num = int("123")
print(num)  # 结果为:123

# 2. 将整数 123 转换为字符串
s = str(123)
print(s)  # 结果为:"123"

# 3. 将浮点数 3.14 转换为整数
i = int(3.14)
print(i)  # 结果为:3

8. 总结:掌握变量与数据类型,成为 Python 魔法师 ‍♂️

通过本篇教程,我们深入探讨了 Python 中的变量数据类型。我们学习了如何创建和使用变量,了解了 Python 中的各种数据类型及其内存结构。我们还详细介绍了 Python 中的关键字和保留字,以及列表、元组、集合和字典等引用类型的常用方法。

希望这篇教程能够帮助你更好地理解 Python 的变量与数据类型,并激发你继续学习 Python 的兴趣。在接下来的教程中,我们将继续探索 Python 的更多高级特性。


恭喜你完成了 Python 魔法学院的第 3 篇教程! 你已经掌握了 Python 中的变量与数据类型,这是成为一名优秀 Python 开发者的重要一步。继续加油,期待在下一篇教程中与你再次相见!

你可能感兴趣的:(《Python,魔法学院》,python,开发语言,windows,pycharm)