Python基本数据类型详解

Python是一种动态类型语言，变量不需要声明类型。本文将详细介绍Python的基本数据类型，包括数字、字符串、布尔值、None以及各种容器类型（列表、元组、集合、字典）。

一、数据类型概述

Python的基本数据类型可以分为以下几类：

1. 数字类型
   ：整数、浮点数、复数
2. 序列类型
   ：字符串、列表、元组
3. 集合类型
   ：集合
4. 映射类型
   ：字典
5. 特殊类型
   ：布尔值、None

可以使用type()函数查看一个变量的数据类型：

x =10print(type(x))# <class 'int'>name ="Python"print(type(name))# <class 'str'>

二、数字类型

Python支持三种数字类型：整数（int）、浮点数（float）和复数（complex）。

1. 整数（int）

整数是没有小数部分的数字，可以是正数、负数或零。

特点

• Python 3中的整数可以是任意大小，不受内存限制
• 支持十进制、二进制、八进制和十六进制表示

创建方法

# 十进制整数num1 =10num2 =-5num3 =0# 二进制表示（以0b或0B开头）binary =0b1010# 十进制的10# 八进制表示（以0o或0O开头）octal =0o12# 十进制的10# 十六进制表示（以0x或0X开头）hexadecimal =0xA# 十进制的10

常用操作

# 算术运算print(10+3)# 13print(10-3)# 7print(10*3)# 30print(10/3)# 3.3333333333333335print(10//3)# 3（整数除法）print(10%3)# 1（取余）print(10**3)# 1000（幂运算）# 比较运算print(10>3)# Trueprint(10<3)# Falseprint(10==3)# False# 类型转换print(int(3.14))# 3print(int("10"))# 10

2. 浮点数（float）

浮点数是带有小数部分的数字。

特点

• 浮点数是近似值，可能存在精度问题
• 使用科学计数法表示时，用e或E表示10的幂

创建方法

# 普通浮点数float1 =3.14float2 =-0.5float3 =2.0# 科学计数法float4 =1.23e3# 1.23 * 10^3 = 1230.0float5 =1.23e-3# 1.23 * 10^-3 = 0.00123

常用操作

# 算术运算print(3.14+2.71)# 5.85print(3.14-2.71)# 0.43000000000000015（注意精度问题）print(3.14*2)# 6.28print(3.14/2)# 1.57# 比较运算print(3.14>2.71)# True# 类型转换print(float(10))# 10.0print(float("3.14"))# 3.14

3. 复数（complex）

复数由实部和虚部组成，虚部用j或J表示。

特点

• 实部和虚部都是浮点数
• 支持复数的各种数学运算

创建方法

# 直接创建complex1 =1+2jcomplex2 =-3jcomplex3 =2.5+1.5j# 使用complex()函数创建complex4 =complex(1,2)# 1+2jcomplex5 =complex(3)# 3+0j

常用操作

# 访问实部和虚部c =1+2jprint(c.real)# 1.0print(c.imag)# 2.0# 复数共轭print(c.conjugate())# (1-2j)# 算术运算c1 =1+2jc2 =3+4jprint(c1 + c2)# (4+6j)print(c1 - c2)# (-2-2j)print(c1 * c2)# (-5+10j)print(c1 / c2)# (0.44+0.08j)

三、字符串类型（str）

字符串是由字符组成的不可变序列，用于表示文本数据。

特点

• 不可变：创建后不能修改内容
• 支持索引和切片操作
• 可以包含任意Unicode字符

创建方法

字符串可以使用单引号'、双引号"或三引号'''/"""创建：

# 单引号字符串str1 ='Hello, World!'# 双引号字符串str2 ="Hello, World!"# 三引号字符串（支持多行）str3 ='''Hello,World!'''# 包含换行符# 三引号字符串也可以使用双引号str4 ="""Hello,World!"""

转义字符

当需要在字符串中包含特殊字符时，可以使用转义字符\：

# 转义字符示例print('He said, "Hello!"')# He said, "Hello!"print('Line 1\nLine 2')# 换行print('\tTabbed text')# 制表符print('C:\\Users\\Name')# 反斜杠print('\x41')# 十六进制转义，输出A

字符串操作

1. 字符串拼接和重复

# 字符串拼接str1 ="Hello, "str2 ="World!"str3 = str1 + str2print(str3)# Hello, World!# 字符串重复str4 ="*"*10print(str4)# **********

2. 字符串索引和切片

text ="Python"# 索引（从0开始）print(text[0])# Pprint(text[1])# yprint(text[-1])# n（从末尾开始计数）# 切片 [start:end:step]print(text[0:3])# Pyt（从索引0到3，不包含3）print(text[:3])# Pyt（从开头到索引3）print(text[3:])# hon（从索引3到末尾）print(text[::2])# Pto（步长为2）print(text[::-1])# nohtyP（反转字符串）

3. 字符串长度

text ="Hello, World!"print(len(text))# 13

4. 字符串方法

字符串提供了丰富的内置方法：

text ="Hello, World!"# 大小写转换print(text.upper())# HELLO, WORLD!print(text.lower())# hello, world!print(text.title())# Hello, World!print(text.capitalize())# Hello, world!print(text.swapcase())# hELLO, wORLD!# 字符串查找print(text.find("World"))# 7print(text.find("Python"))# -1（未找到）print(text.index("World"))# 7# print(text.index("Python"))  # 抛出ValueError# 字符串替换print(text.replace("World","Python"))# Hello, Python!# 字符串分割print(text.split(", "))# ['Hello', 'World!']# 字符串连接words =['Hello','World!']print(", ".join(words))# Hello, World!# 字符串判断print(text.startswith("Hello"))# Trueprint(text.endswith("!"))# Trueprint(text.isalpha())# False（包含非字母字符）print("123".isdigit())# Trueprint("abc123".isalnum())# Trueprint("   ".isspace())# True# 字符串格式化name ="张荣殿"age =30print(f"我的名字是{name}，今年{age}岁。")# 我的名字是张荣殿，今年30岁。print("我的名字是{}，今年{}岁。".format(name, age))# 我的名字是张荣殿，今年30岁。print("我的名字是%s，今年%d岁。"%(name, age))# 我的名字是张荣殿，今年30岁。

四、布尔类型（bool）

布尔类型表示真（True）或假（False），用于逻辑判断。

特点

• 布尔类型只有两个值：True和False
• 布尔值可以转换为整数：True == 1，False == 0

创建方法

# 直接赋值t =Truef =False# 逻辑运算结果result1 =10>5# Trueresult2 =10==5# False# 布尔转换print(bool(1))# Trueprint(bool(0))# Falseprint(bool("Hello"))# Trueprint(bool(""))# Falseprint(bool([]))# Falseprint(bool({}))# Falseprint(bool(None))# False

布尔运算

# 布尔运算示例x =Truey =Falseprint(x and y)# Falseprint(x or y)# Trueprint(not x)# False

五、None类型

None是Python中的一个特殊值，表示空值或不存在的值。

特点

• None是一个单独的类型：NoneType
• 与其他值比较时都为False（除了None本身）
• 常用于函数的默认参数或返回值

创建方法

# 直接赋值n =None# 函数返回值（无返回值时默认返回None）defno_return():passresult = no_return()print(result)# None

常用操作

# None的比较x =Noneprint(x isNone)# True（使用is判断）print(x ==None)# True（也可以使用==，但推荐使用is）# None转换为其他类型print(bool(None))# Falseprint(int(None))# TypeErrorprint(str(None))# "None"

六、列表类型（list）

列表是有序、可变的序列，可以存储不同类型的元素。

特点

• 有序：元素有固定的顺序
• 可变：可以添加、删除、修改元素
• 可嵌套：列表中可以包含其他列表
• 可以存储不同类型的元素

创建方法

# 使用方括号创建list1 =[1,2,3,4,5]list2 =["apple","banana","orange"]list3 =[1,"apple",True,3.14]# 混合类型list4 =[]# 空列表# 使用list()函数创建list5 =list()# 空列表list6 =list("Python")# ['P', 'y', 't', 'h', 'o', 'n']list7 =list(range(5))# [0, 1, 2, 3, 4]

列表操作

1. 索引和切片

fruits =["apple","banana","orange","grape"]# 索引print(fruits[0])# appleprint(fruits[-1])# grape# 切片print(fruits[0:2])# ['apple', 'banana']print(fruits[2:])# ['orange', 'grape']print(fruits[::2])# ['apple', 'orange']

2. 列表长度

fruits =["apple","banana","orange"]print(len(fruits))# 3

3. 添加元素

fruits =["apple","banana"]# append()：在末尾添加一个元素fruits.append("orange")# ['apple', 'banana', 'orange']# extend()：添加另一个可迭代对象的所有元素fruits.extend(["grape","watermelon"])# ['apple', 'banana', 'orange', 'grape', 'watermelon']# insert()：在指定位置插入元素fruits.insert(1,"pear")# ['apple', 'pear', 'banana', 'orange', 'grape', 'watermelon']

4. 删除元素

fruits =["apple","banana","orange","grape"]# pop()：删除并返回指定位置的元素（默认最后一个）removed = fruits.pop()# 删除grape，返回'grape'print(fruits)# ['apple', 'banana', 'orange']removed = fruits.pop(1)# 删除banana，返回'banana'print(fruits)# ['apple', 'orange']# remove()：删除第一个匹配的元素fruits =["apple","banana","orange","banana"]fruits.remove("banana")print(fruits)# ['apple', 'orange', 'banana']# del：删除指定位置的元素或整个列表del fruits[0]# 删除第一个元素del fruits  # 删除整个列表

5. 修改元素

fruits =["apple","banana","orange"]fruits[1]="pear"# 修改第二个元素print(fruits)# ['apple', 'pear', 'orange']

6. 列表方法

fruits =["apple","banana","orange","apple"]# count()：统计元素出现的次数print(fruits.count("apple"))# 2# index()：返回元素第一次出现的索引print(fruits.index("banana"))# 1# sort()：排序numbers =[3,1,4,1,5,9]numbers.sort()print(numbers)# [1, 1, 3, 4, 5, 9]# reverse()：反转列表fruits.reverse()print(fruits)# ['apple', 'orange', 'banana', 'apple']# copy()：复制列表fruits_copy = fruits.copy()

7. 列表推导式

列表推导式是一种简洁创建列表的方法：

# 基本语法：[表达式 for 变量 in 可迭代对象 if 条件]# 创建1-10的平方列表squares =[x**2for x inrange(1,11)]print(squares)# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]# 过滤偶数even_numbers =[x for x inrange(1,11)if x %2==0]print(even_numbers)# [2, 4, 6, 8, 10]# 嵌套列表推导式matrix =[[1,2,3],[4,5,6],[7,8,9]]flattened =[num for row in matrix for num in row]print(flattened)# [1, 2, 3, 4, 5, 6, 7, 8, 9]

七、元组类型（tuple）

元组是有序、不可变的序列，与列表类似但不能修改。

特点

• 不可变：创建后不能添加、删除或修改元素
• 可以存储不同类型的元素
• 可以嵌套
• 比列表更节省内存

创建方法

# 使用圆括号创建t1 =(1,2,3,4,5)t2 =("apple","banana","orange")t3 =(1,"apple",True)# 混合类型# 单个元素的元组需要加逗号t4 =(5,)print(type(t4))# <class 'tuple'># 省略圆括号=t5 =1,2,3print(type(t5))# <class 'tuple'># 使用tuple()函数创建t6 =tuple()# 空元组t7 =tuple([1,2,3])# (1, 2, 3)t8 =tuple("Python")# ('P', 'y', 't', 'h', 'o', 'n')

元组操作

1. 索引和切片

元组的索引和切片与列表相同：

t =(1,2,3,4,5)print(t[0])# 1print(t[-1])# 5print(t[1:3])# (2, 3)print(t[::2])# (1, 3, 5)

2. 元组长度

t =(1,2,3,4,5)print(len(t))# 5

3. 元组方法

由于元组不可变，元组的方法很少：

t =(1,2,3,2,4)# count()：统计元素出现的次数print(t.count(2))# 2# index()：返回元素第一次出现的索引print(t.index(3))# 2

4. 元组解包

元组解包是将元组的元素赋值给多个变量：

# 基本解包coordinates =(10,20,30)x, y, z = coordinatesprint(x)# 10print(y)# 20print(z)# 30# 扩展解包（Python 3+）t =(1,2,3,4,5)first,*middle, last = tprint(first)# 1print(middle)# [2, 3, 4]print(last)# 5# 交换变量a, b =1,2a, b = b, aprint(a, b)# 2 1

八、集合类型（set）

集合是无序、不重复的元素集合。

特点

• 无序：元素没有固定的顺序
• 不重复：自动去重
• 支持集合运算（并集、交集、差集等）

创建方法

# 使用花括号创建s1 ={1,2,3,4,5}s2 ={"apple","banana","orange"}# 注意：空集合不能使用{}创建，{}创建的是空字典empty_set =set()# 使用set()函数创建set_from_list =set([1,2,2,3,4,4])# {1, 2, 3, 4}（去重）set_from_str =set("Python")# {'P', 'y', 't', 'h', 'o', 'n'}

集合操作

1. 添加元素

s ={1,2,3}# add()：添加单个元素s.add(4)# {1, 2, 3, 4}# update()：添加另一个可迭代对象的所有元素s.update([4,5,6])# {1, 2, 3, 4, 5, 6}（自动去重）

2. 删除元素

s ={1,2,3,4,5}# remove()：删除指定元素，如果不存在会引发KeyErrors.remove(3)# {1, 2, 4, 5}# discard()：删除指定元素，如果不存在不会引发错误s.discard(6)# {1, 2, 4, 5}（6不存在，但不会出错）# pop()：删除并返回一个随机元素removed = s.pop()# 删除并返回1（或其他随机元素）# clear()：清空集合s.clear()# set()

3. 集合运算

s1 ={1,2,3,4}s2 ={3,4,5,6}# 并集print(s1 | s2)# {1, 2, 3, 4, 5, 6}print(s1.union(s2))# {1, 2, 3, 4, 5, 6}# 交集print(s1 & s2)# {3, 4}print(s1.intersection(s2))# {3, 4}# 差集print(s1 - s2)# {1, 2}print(s1.difference(s2))# {1, 2}# 对称差集print(s1 ^ s2)# {1, 2, 5, 6}print(s1.symmetric_difference(s2))# {1, 2, 5, 6}

4. 集合推导式

# 基本语法：{表达式 for 变量 in 可迭代对象 if 条件}# 创建1-10的平方集合squares ={x**2for x inrange(1,11)}print(squares)# {64, 1, 4, 36, 100, 9, 16, 49, 81, 25}# 去重numbers =[1,2,2,3,4,4,5]distinct ={x for x in numbers}print(distinct)# {1, 2, 3, 4, 5}

九、字典类型（dict）

字典是无序的键值对集合，键必须是唯一且不可变的。

特点

• 无序（Python 3.7+后保证插入顺序）
• 键必须是不可变类型（如字符串、数字、元组）
• 值可以是任意类型
• 查找速度快（时间复杂度为O(1)）

创建方法

# 使用花括号创建dict1 ={"name":"张荣殿","age":30,"city":"北京"}# 创建空字典dict2 ={}# 使用dict()函数创建dict3 =dict()# 空字典dict4 =dict(name="张荣殿", age=30, city="北京")dict5 =dict([("name","张荣殿"),("age",30)])# 使用字典推导式创建dict6 ={x: x**2for x inrange(1,6)}# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

字典操作

1. 访问元素

person ={"name":"张荣殿","age":30,"city":"北京"}# 使用键访问值print(person["name"])# 张荣殿# 使用get()方法访问值（更安全）print(person.get("age"))# 30print(person.get("gender","未知"))# 未知（键不存在时返回默认值）

2. 添加和修改元素

person ={"name":"张荣殿","age":30}# 添加新键值对person["city"]="北京"# {'name': '张荣殿', 'age': 30, 'city': '北京'}# 修改已有键的值person["age"]=31# {'name': '张荣殿', 'age': 31, 'city': '北京'}# 使用update()方法批量更新person.update({"gender":"男","hobby":"编程"})# {'name': '张荣殿', 'age': 31, 'city': '北京', 'gender': '男', 'hobby': '编程'}

3. 删除元素

person ={"name":"张荣殿","age":30,"city":"北京","gender":"男"}# del：删除指定键值对del person["gender"]# {'name': '张荣殿', 'age': 30, 'city': '北京'}# pop()：删除并返回指定键的值city = person.pop("city")# 返回"北京"，字典变为{'name': '张荣殿', 'age': 30}# popitem()：删除并返回最后一个键值对person.update({"city":"北京","hobby":"编程"})last_item = person.popitem()# 返回("hobby", "编程")# clear()：清空字典person.clear()# {}

4. 字典方法

person ={"name":"张荣殿","age":30,"city":"北京"}# keys()：获取所有键print(person.keys())# dict_keys(['name', 'age', 'city'])# values()：获取所有值print(person.values())# dict_values(['张荣殿', 30, '北京'])# items()：获取所有键值对print(person.items())# dict_items([('name', '张荣殿'), ('age', 30), ('city', '北京')])# 遍历字典for key in person:print(key, person[key])for key, value in person.items():print(key, value)# 复制字典person_copy = person.copy()

5. 字典推导式

# 基本语法：{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}# 创建1-5的平方字典 squares ={x: x**2for x inrange(1,6)}print(squares)# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}# 过滤偶数键even_dict ={x: x*2for x inrange(1,11)if x %2==0}print(even_dict)# {2: 4, 4: 8, 6: 12, 8: 16, 10: 20}# 从两个列表创建字典keys =["name","age","city"]values =["张荣殿",30,"北京"]dict_from_lists ={keys[i]: values[i]for i inrange(len(keys))}print(dict_from_lists)# {'name': '张荣殿', 'age': 30, 'city': '北京'}

十、数据类型转换

Python提供了各种类型转换函数，可以在不同数据类型之间进行转换：

# 类型转换示例x ="123"print(type(x))# <class 'str'># 转换为整数y =int(x)print(y,type(y))# 123 <class 'int'># 转换为浮点数z =float(y)print(z,type(z))# 123.0 <class 'float'># 转换为字符串w =str(z)print(w,type(w))# 123.0 <class 'str'># 列表转换为元组lst =[1,2,3]tpl =tuple(lst)print(tpl,type(tpl))# (1, 2, 3) <class 'tuple'>

总结

Python提供了丰富的数据类型，每种类型都有其特定的用途和特点：

1. 数字类型
   ：用于数值计算
2. 字符串类型
   ：用于文本处理
3. 布尔类型
   ：用于逻辑判断
4. None类型
   ：表示空值
5. 列表
   ：有序可变的元素集合
6. 元组
   ：有序不可变的元素集合
7. 集合
   ：无序不重复的元素集合
8. 字典
   ：键值对的集合，用于快速查找

了解并掌握这些基本数据类型是学习Python的基础，它们为更复杂的编程任务提供了坚实的基础。