当前位置：首页 > article >正文

Python之变量与数据类型总结

article 2025/4/1 12:08:31

前言

一、基本数据类型

1、整数（int）

2、浮点数（float）

3、布尔值（bool）

4、字符串（str）

二、复合数据类型

1、列表（list）

1.1、列表基础

1.1.1、列表的创建

1.1.2、常用方法详解

2、元组（tuple）

2.1、元组的创建方法

2.2、元组常用方法示例

2.3、元组的不可变性与特例

2.4、综合示例

3、字典（dict）

3.1、字典的创建方法

3.2、字典的常用方法

3.3、综合应用

4、集合（set）

4.1、集合的创建

4.2、集合的常用方法

三、特殊数据类型

四、类型之间的转换

1、显式转换函数

2、隐式转换场景

五、核心函数与方法

1、通用函数

2、字符串操作

3、容器操作

六、实际应用场景

1、用户输入处理

2、数据清洗

七、重要转换规则表

前言

这部分内容之前写过，但感觉不是特别好，不方便以后翻阅，所以重新整理。有问题欢迎随时指正。

一、基本数据类型

1、整数（int）

表示整数，如10、-5。
示例：

int_var = 10
print(f"整数: {int_var}, 类型: {type(int_var)}")  # 输出: 整数: 10, 类型: <class 'int'>

2、浮点数（float）

表示小数，如3.14、-0.5。
示例：

float_var = 3.14
print(f"浮点数: {float_var}, 类型: {type(float_var)}")  # 输出: 浮点数: 3.14, 类型: <class 'float'>

3、布尔值（bool）

表示真或假，只有两个值：True和False。
示例：

bool_var = True
print(f"布尔值: {bool_var}, 类型: {type(bool_var)}")  # 输出: 布尔值: True, 类型: <class 'bool'>

4、字符串（str）

表示文本，用单引号'或双引号"括起来。
示例：

str_var = "Hello, World!"
print(f"字符串: {str_var}, 类型: {type(str_var)}")  # 输出: 字符串: Hello, World!, 类型: <class 'str'>

二、复合数据类型

1、列表（list）

有序的可变集合，可以包含任意类型的元素。
示例：

list_var = [1, 2, 3, "a", "b", "c"]
print(f"列表: {list_var}, 类型: {type(list_var)}")  # 输出: 列表: [1, 2, 3, 'a', 'b', 'c'], 类型: <class 'list'>

1.1、列表基础

1.1.1、列表的创建

基础语法：

使用方括号 [] 直接定义元素，支持混合数据类型：

empty_list = []  # 空列表
number_list = [1, 2, 3, 4, 5]  # 数字列表
mixed_list = [1, "hello", 3.14, True]  # 混合类型列表

构造函数 list()

将可迭代对象（如字符串、元组）转换为列表：

char_list = list("hello")  # 输出 ['h', 'e', 'l', 'l', 'o']
tuple_to_list = list((1, 2, 3))  # 输出 [1, 2, 3]

range() 生成整数序列

快速生成连续整数列表：

list_range = list(range(5))  # 输出 [0, 1, 2, 3, 4]
list_step = list(range(1, 10, 2))  # 输出 [1, 3, 5, 7, 9]

列表推导式

单行生成复杂列表，支持条件过滤：

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]

使用 * 运算符重复元素

快速生成重复元素的列表：

list9 = [0] * 5                 # [0, 0, 0, 0, 0]
list10 = ["hello"] * 3          # ['hello', 'hello', 'hello']

嵌套列表（多维列表）

创建包含子列表的嵌套结构：

matrix = [[1, 2], [3, 4]]       # 二维列表 → [[1,2], [3,4]]

1.1.2、常用方法详解

添加元素
- append(obj)：在列表末尾添加单个元素。

a = [1, 2, 3]
a.append(4)                   # 结果 → [1, 2, 3, 4]
a.append([5, 6])              # 添加子列表 → [1, 2, 3, 4, [5, 6]]

extend(iterable)：将可迭代对象的元素逐个添加到列表末尾。

a = [1, 2, 3]
a.extend([4, 5])              # 结果 → [1, 2, 3, 4, 5]
a.extend("abc")               # 添加字符 → [1, 2, 3, 4, 5, 'a', 'b', 'c']

insert(index, obj)：在指定索引位置插入元素。

a = [1, 2, 3]
a.insert(0, 0)                # 在索引0插入 → [0, 1, 2, 3]
a.insert(2, "x")              # 在索引2插入 → [0, 1, 'x', 2, 3]

删除元素
- remove(obj)：删除第一个匹配的元素，无匹配时报错。
  - 特点
    - 按值删除：通过值（而非索引）查找并删除元素。
    - 仅删第一个匹配项：若有多个相同值，只删除第一个出现的。
    - 无返回值：直接修改原列表，不返回被删除的值。
    - 异常风险：若值不存在，抛出 ValueError。

fruits = ["apple", "banana", "cherry", "banana"]
fruits.remove("banana")  
print(fruits)  # 输出: ['apple', 'cherry', 'banana']（删除了第一个"banana"）

# 尝试删除不存在的值会报错
try:
    fruits.remove("mango")
except ValueError:
    print("值不存在！")  # 触发异常

a = [1, 2, 3, 2]
a.remove(2)                   # 删除第一个2 → [1, 3, 2]

pop([index])：删除并返回指定索引的元素（默认最后一个）。
- 特点
  - 按索引删除：通过索引（而非值）定位元素。
  - 有返回值：返回被删除的元素。
  - 默认删除最后一个：若未指定索引，默认 index=-1（最后一个元素）。

异常风险：若索引越界，抛出 IndexError。clear()：清空列表。clear()：清空列表。

a = [1, 2, 3, 4]
a.pop()                       # 删除4 → 返回4，a变为[1, 2, 3]
a.pop(0)                     # 删除1 → 返回1，a变为[2, 3]

numbers = [10, 20, 30, 40]

# 删除最后一个元素
popped_element = numbers.pop()
print(popped_element)  # 输出: 40
print(numbers)         # 输出: [10, 20, 30]

# 删除指定索引元素
popped_element = numbers.pop(1)
print(popped_element)  # 输出: 20
print(numbers)         # 输出: [10, 30]

# 索引越界会报错
try:
    numbers.pop(5)
except IndexError:
    print("索引越界！")  # 触发异常

clear()：清空列表
- 特点
  - 无差别删除：一次性移除所有元素。
  - 无返回值：直接修改原列表，不返回任何内容。
  - 安全操作：不会因值或索引不存在而报错。

colors = ["red", "green", "blue"]
colors.clear()
print(colors)  # 输出: []

三种删除数据方式对比表格

方法	操作依据	返回值	是否修改原列表	异常场景	典型用途
`remove(obj)`	值（首个匹配）	无	是	值不存在 → `ValueError`	删除已知值的元素
`pop([index])`	索引（默认-1）	被删除的元素	是	索引越界 → `IndexError`	删除指定位置元素并获取其值
`clear()`	无	无	是	无	快速清空列表

排序与反转

1、sort(key=None, reverse=False)：原地排序（默认升序）。

a = [3, 1, 4, 2]
a.sort()                      # 升序 → [1, 2, 3, 4]
a.sort(reverse=True)          # 降序 → [4, 3, 2, 1]

2、reverse()：反转列表元素顺序。

a = [1, 3, 2]
a.reverse()                   # 结果 → [2, 3, 1]

3、sorted()：返回新排序列表（原列表不变）

umbers = [5, 2, 9, 1, 7]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 2, 5, 7, 9]
print(numbers)         # 原列表不变: [5, 2, 9, 1, 7]

查找与统计

1、index(obj, [start, end])：返回第一个匹配元素的索引，无匹配时报错。

a = [10, 20, 30, 20]
print(a.index(20))            # 输出 1
print(a.index(20, 2))         # 从索引2开始查找 → 3

2、count(obj)：统计元素出现的次数。

a = [1, 2, 2, 3, 2]
print(a.count(2))             # 输出 3

复制与合并

1、copy()：返回列表的浅拷贝。

a = [1, 2, 3]
b = a.copy()                  # b是a的独立副本
b.append(4)                   # a仍为[1,2,3]，b为[1,2,3,4]

2、extend()：用于将可迭代对象（如列表、元组、字符串、字典等）的元素逐个添加到列表的末尾。它直接修改原列表，不返回新列表

list1 = [1, 2, 3]
list1.extend([4, 5, 6])
print(list1)  # 输出: [1, 2, 3, 4, 5, 6]

list2 = [1, 2, 3]
list2.append([4, 5, 6])
print(list2)  # 输出: [1, 2, 3, [4, 5, 6]]

其他操作

1、len(list)：获取列表长度。

a = [1, 2, 3]
print(len(a))                 # 输出 3

2、切片操作：灵活截取子列表。

a = [0, 1, 2, 3, 4]
print(a[1:3])                 # 输出 [1, 2]
print(a[::-1])                # 反转 → [4, 3, 2, 1, 0]

2、元组（tuple）

元组是 不可变序列，用圆括号 () 定义，元素用逗号分隔。

2.1、元组的创建方法

1、直接赋值法

# 空元组
t1 = ()

# 单元素元组（必须加逗号）
t2 = (5,)
not_a_tuple = (42)            # 这是一个整数，不是元组

# 多元素元组
t3 = (1, "apple", True, 3.14)

# 省略括号（通过逗号自动识别为元组）
t4 = 1, 2, 3

2、tuple()构造函数

# 将列表转换为元组
list_to_tuple = tuple([1, 2, 3])

# 将字符串转换为元组（每个字符为元素）
string_to_tuple = tuple("hello")  # 输出：('h', 'e', 'l', 'l', 'o')

# 将字典键转换为元组
dict_keys_to_tuple = tuple({"name": "Alice", "age": 25})  # 输出：('name', 'age')

3、range()生成数值元组

# 生成10到18的偶数元组
num_tuple = tuple(range(10, 20, 2))  # 输出：(10, 12, 14, 16, 18)

4、嵌套元组

nested_tuple = ((1, 2), (3, 4), (5, 6))

2.2、元组常用方法示例

1、访问元素与切片

t = ("apple", "banana", "cherry", "date")

# 通过索引访问
print(t[0])          # 输出：apple
print(t[-1])         # 输出：date（负索引从末尾开始）

# 切片操作
print(t[1:3])        # 输出：('banana', 'cherry')
print(t[::2])        # 输出：('apple', 'cherry')（步长为2）

2、查询方法

t = (1, 3, 5, 3, 7)

# index()：返回第一个匹配项的索引
print(t.index(3))    # 输出：1

# count()：统计元素出现次数
print(t.count(3))    # 输出：2

# len()：获取元组长度
print(len(t))        # 输出：5

3、拼接与重复

t1 = (1, 2)
t2 = ("a", "b")

# 拼接元组
print(t1 + t2)       # 输出：(1, 2, 'a', 'b')

# 重复元组
print(t1 * 3)        # 输出：(1, 2, 1, 2, 1, 2)

4、存在性判断

t = (10, 20, 30)

# 检查元素是否存在
print(20 in t)       # 输出：True
print(99 in t)       # 输出：False

5、类型转换

# 元组转列表
list1 = list(t)

# 列表转元组
tuple1 = tuple(list1)

# 元组转字符串（需先转换为字符串列表）
str_list = [str(i) for i in t]
result = " | ".join(str_list)  # 输出："10 | 20 | 30"

6、元组解包

x, y, z = (10, 20, 30)
print(x, y, z)  # 输出: 10 20 30

7、其他操作

# max() 和 min()
print(max(t))        # 输出：30
print(min(t))        # 输出：10

# sorted() 返回排序后的列表
sorted_list = sorted(t)  # 输出：[10, 20, 30]

2.3、元组的不可变性与特例

1、不可变性：元组一旦创建，元素不可直接修改。

t = (1, 2, 3)
# t[1] = 4  # 会报错：TypeError

2、特例：若元组包含可变对象（如列表），可修改嵌套对象。

t = ([1, 2], 3)
t[0][0] = 99  # 合法操作
print(t)      # 输出：([99, 2], 3)

2.4、综合示例

# 创建元组
student = ("Alice", 20, ("Math", 90, "Physics", 85))

# 访问嵌套元素
print(f"姓名：{student[0]}, 年龄：{student[1]}")
print(f"数学成绩：{student[2][1]}, 物理成绩：{student[2][3]}")

# 统计课程数量
courses = student[2]
print(f"课程总数：{len(courses) // 2}")  # 输出：2（每两元素为一门课程）

# 计算平均分
scores = [courses[i] for i in range(1, len(courses), 2)]
average = sum(scores) / len(scores)
print(f"平均分：{average}")  # 输出：87.5

3、字典（dict）

3.1、字典的创建方法

字典以 键值对 形式存储数据，键必须是不可变类型（如字符串、数字、元组），值可以是任意类型。

1、空字典创建

empty_dict = {}  # 使用大括号
empty_dict = dict()  # 使用dict()函数

2、直接赋值创建

person = {'name': 'Alice', 'age': 30, 'city': '北京'}

3、关键字参数创建

student = dict(id=101, name='Bob', grade='A')

4、二元组列表转换

pairs = [('fruit', '苹果'), ('vegetable', '胡萝卜'), ('drink', '茶')]
food_dict = dict(pairs)  # {'fruit': '苹果', 'vegetable': '胡萝卜', 'drink': '茶'}

5、zip()函数组合

keys = ['x', 'y', 'z']
values = [10, 20, 30]
coordinates = dict(zip(keys, values))
print(coordinates)  # {'x': 10, 'y': 20, 'z': 30}

6、字典推导式

squares = {num: num**2 for num in range(1, 6)}  # 输出: {1:1, 2:4, 3:9, 4:16, 5:25}

7、fromkeys()方法

keys = ['a', 'b', 'c']
score_dict = dict.fromkeys(keys, 0)  # 输出: {'a':0, 'b':0, 'c':0}

8、混合列表处理

mixed_list = ['key1', 100, 'key2', 200, 'key3', 300]
mixed_dict = dict(zip(mixed_list[::2], mixed_list[1::2]))  # 输出: {'key1':100, 'key2':200, 'key3':300}

3.2、字典的常用方法

1、获取值：get(key, default=None)安全获取值，避免 KeyError。

d = {'name': 'Alice', 'age': 25}
print(d.get('name'))       # Alice
print(d.get('gender'))     # None（键不存在）
print(d.get('gender', 'Unknown'))  # Unknown（返回默认值）

2、设置默认值：setdefault(key, default=None)若键存在则返回对应值；否则设置默认值并返回。

d = {'name': 'Alice'}
print(d.setdefault('age', 25))  # 25（设置并返回）
print(d)  # {'name': 'Alice', 'age': 25}

3、更新字典：update(iterable)合并其他字典或键值对。

d = {'name': 'Alice'}
d.update({'age': 25, 'city': 'Beijing'})
print(d)  # {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)                     # 合并后: {'a':1, 'b':3, 'c':4}
merged_dict = dict1 | dict2             # Python 3.9+支持运算符合并

4、删除元素

1、pop(key, default)：删除指定键并返回值，若键不存在可返回默认值。

d = {'name': 'Alice', 'age': 25}
age = d.pop('age')
print(age)  # 25
print(d)    # {'name': 'Alice'}

2、popitem()：删除并返回最后插入的键值对（Python 3.7+ 有序）。

d = {'name': 'Alice', 'age': 25}
item = d.popitem()
print(item)  # ('age', 25)
print(d)     # {'name': 'Alice'}

5、清空字典：clear()清空所有键值对。

d = {'name': 'Alice'}
d.clear()
print(d)  # {}

6、获取键、值、键值对视图

keys()、values()、items()：返回动态视图对象，实时反映字典变化。

d = {'a': 1, 'b': 2}
keys = d.keys()
values = d.values()
items = d.items()

d['c'] = 3
print(list(keys))   # ['a', 'b', 'c']
print(list(values)) # [1, 2, 3]
print(list(items))  # [('a', 1), ('b', 2), ('c', 3)]

7、检查键是否存在

in 关键字：判断键是否在字典中。

d = {'name': 'Alice'}
print('name' in d)  # True
print('age' in d)   # False

8、复制字典

copy()：创建字典的浅拷贝。

d1 = {'a': [1, 2]}
d2 = d1.copy()
d1['a'].append(3)
print(d2)  # {'a': [1, 2, 3]}（浅拷贝，嵌套对象共享引用）

9、遍历字典

d = {'name': 'Alice', 'age': 25}

# 遍历键
for key in d:
    print(key)          # 输出 'name', 'age'

# 遍历键值对
for key, value in d.items():
    print(f"{key}: {value}")  # name: Alice, age: 25

3.3、综合应用

# 创建字典
data = dict(zip(['a', 'b', 'c'], [1, 2, 3]))

# 修改元素
data.update({'d': 4})

# 安全访问
value = data.get('e', '默认值')

# 遍历处理
for key, val in data.items():
    print(f"{key}的平方是{val**2}")

# 清空字典
data.clear()

4、集合（`set`）

4.1、集合的创建

集合是无序的、元素唯一的容器，用 {} 或 set() 创建。

1、使用花括号 {}

# 创建空集合
empty_set = set()  # 正确方式（注意：{} 默认创建空字典）
# empty_set = {}   # 错误！这实际上创建了一个空字典

# 创建包含元素的集合
fruits = {"apple", "banana", "orange"}
numbers = {1, 2, 3, 4, 5}

2、使用 set() 构造函数

# 从列表创建集合
s3 = set([1, 2, 3, 4])
print(s3)  # 输出: {1, 2, 3, 4}

# 从字符串创建集合（字符去重）
s4 = set("hello")
print(s4)  # 输出: {'h', 'e', 'l', 'o'}

# 空集合必须用 set()，因为 {} 是空字典
empty_set = set()
print(empty_set)  # 输出: set()

3、使用集合推导式

s5 = {x for x in range(10) if x % 2 == 0}
print(s5)  # 输出: {0, 2, 4, 6, 8}

4.2、集合的常用方法

1、添加元素

s = {1, 2, 3}

# add(): 添加单个元素
s.add(4)
print(s)  # 输出: {1, 2, 3, 4}

# update(): 添加多个元素（可迭代对象）
s.update([5, 6, 7])
print(s)  # 输出: {1, 2, 3, 4, 5, 6, 7}

2、删除元素

s = {1, 2, 3, 4, 5}

# remove(): 删除指定元素（元素不存在会报错）
s.remove(3)
print(s)  # 输出: {1, 2, 4, 5}

# discard(): 删除指定元素（元素不存在不会报错）
s.discard(10)  # 无报错

# pop(): 随机删除一个元素（集合为空会报错）
popped = s.pop()
print("被删除的元素:", popped)  # 例如输出: 1

# clear(): 清空集合
s.clear()
print(s)  # 输出: set()

3、集合运算

a = {1, 2, 3}
b = {2, 3, 4}

# 并集: a | b 或 a.union(b)
print(a.union(b))         # 输出: {1, 2, 3, 4}
print(a | b)              # 同上

# 交集: a & b 或 a.intersection(b)
print(a.intersection(b))  # 输出: {2, 3}
print(a & b)              # 同上

# 差集: a - b 或 a.difference(b)
print(a.difference(b))    # 输出: {1}
print(a - b)              # 同上

# 对称差集（不同时存在的元素）: a ^ b 或 a.symmetric_difference(b)
print(a.symmetric_difference(b))  # 输出: {1, 4}
print(a ^ b)                      # 同上

4、集合判断

a = {1, 2, 3}
b = {2, 3}

# 子集判断: issubset()
print(b.issubset(a))     # 输出: True
print(b <= a)            # 同上

# 超集判断: issuperset()
print(a.issuperset(b))   # 输出: True
print(a >= b)            # 同上

# 是否不相交: isdisjoint()
c = {4, 5}
print(a.isdisjoint(c))   # 输出: True

# in 和 not in：检查元素是否存在。
s = {1, 2, 3}
print(2 in s)    # True
print(4 not in s) # True

5、其他方法

s = {1, 2, 3}
copied_set = s.copy()  # 复制集合
print(len(s))   # 0

三、特殊数据类型

1、None（空值）

表示没有值，常用于初始化变量或表示函数没有返回值。
示例：

none_var = None
print(f"None: {none_var}, 类型: {type(none_var)}")  # 输出: None: None, 类型: <class 'NoneType'>

四、类型之间的转换

1、显式转换函数

1、int()：将其他类型转换为整数。

print(f"int('10'): {int('10')}")  # 输出: int('10'): 10
print(f"int(3.14): {int(3.14)}")  # 输出: int(3.14): 3

2、float()：将其他类型转换为浮点数。

print(f"float(10): {float(10)}")  # 输出: float(10): 10.0
print(f"float('3.14'): {float('3.14')}")  # 输出: float('3.14'): 3.14

3、str()：将其他类型转换为字符串。

print(f"str(10): {str(10)}")  # 输出: str(10): 10
print(f"str(3.14): {str(3.14)}")  # 输出: str(3.14): 3.14

4、bool()：将其他类型转换为布尔值。

print(f"bool(0): {bool(0)}")  # 输出: bool(0): False
print(f"bool(1): {bool(1)}")  # 输出: bool(1): True

5、list()：将其他类型转换为列表。

print(f"list('abc'): {list('abc')}")  # 输出: list('abc'): ['a', 'b', 'c']
print(f"list((1, 2, 3)): {list((1, 2, 3))}")  # 输出: list((1, 2, 3)): [1, 2, 3]

6、tuple()：将其他类型转换为元组。

print(f"tuple([1, 2, 3]): {tuple([1, 2, 3])}")  # 输出: tuple([1, 2, 3]): (1, 2, 3)

7、dict()：将其他类型转换为字典。

print(f"dict([('name', 'Alice'), ('age', 25)]): {dict([('name', 'Alice'), ('age', 25)])}")  # 输出: dict([('name', 'Alice'), ('age', 25)]): {'name': 'Alice', 'age': 25}

8、set()：将其他类型转换为集合。

print(f"set([1, 2, 3]): {set([1, 2, 3])}")  # 输出: set([1, 2, 3]): {1, 2, 3}