数据类型

数据类型种类

Python 是一种动态类型的语言，它支持多种数据类型。以下是 Python 中常见的数据类型：

数据类型	type()	特点
数字（Number）	int、float	包括整数、浮点数等
字符串（String）	str	一系列字符的序列
列表（List）	list	一组有序的元素，可以修改
元组（Tuple）	tuple	一组有序的元素，不能修改
集合（Set）	set	一组无序的元素，不允许重复
字典（Dictionary）	dict	一组键-值对，键必须唯一
布尔（Boolean）	bool	代表 True 和 False 两个值
None 类型	NoneType	代表空值或缺失值

除基本数据类型之外，Python 还支持一些高级数据类型，如生成器（Generator）、迭代器（Iterator）、函数（Function）、类（Class）等。

数字

Python 有三种内置数字类型：

• 整数（int）：表示整数值，没有小数部分。例如，42、-123、0 等
• 浮点数（float）：表示实数值，可以有小数部分。例如，3.14、-0.5、2.0 等。
• 复数（complex）：表示由实数和虚数构成的数字。

下面是一些例子：

x = 42      # 整数
y = -3.14   # 浮点数
z = 2 + 3j  # 虚数

print(type(x))
# <class 'int'>
print(type(y))
# <class 'float'>
print(type(z))
# <class 'complex'>

在 Python 中，数字类型可以进行基本的算术操作，还支持比较运算符等。

类型转换

在 Python 中，可以使用内置函数将一个数字类型转换为另一个类型。下面是常用的数字类型转换函数：

• int(x)：将 x 转换为整数类型。如果 x 是浮点数，则会向下取整；如果 x 是字符串，则字符串必须表示一个整数。
• float(x)：将 x 转换为浮点数类型。如果 x 是整数，则会转换为相应的浮点数；如果 x 是字符串，则字符串必须表示一个浮点数。
• complex(x)：将 x 转换为复数类型。如果 x 是数字，则表示实部，虚部为 0；如果 x 是字符串，则字符串必须表示一个复数；如果 x 是两个参数，则分别表示实部和虚部。
• str(x)：将 x 转换为字符串类型。如果 x 是数字，则表示为字符串；如果 x 是布尔类型，则返回'True'或'False'字符串。

下面是一些例子：

x = 42.0
y = 3

# 将浮点数转换为整数
x_to_int = int(x)
print(x_to_int) # 42

# 将整数转换为浮点数
y_to_float = float(y)
print(y_to_float) # 3.0

# 将整数转换为复数
y_to_complex = complex(y)
print(y_to_complex) # (3+0j)

# 将数字转换为字符串
x_to_str = str(x)
print(x_to_str) # '42.0'

注意

如果在类型转换过程中出现了不合理的转换，例如将一个非数字字符串转换为数字类型，就会导致 ValueError 异常。

特殊数值

有很很多场合还需要用到特殊数值，比如圆周率 pi、自然对数底数 e 等等。在 Python 中，可以使用 math 模块来引入这些特殊值。

下面是一些使用例：

import math
print(math.pi) # 输出π的值
print(math.e) # 输出e的值
print(math.sqrt(2)) # 输出根号2的

除了这些特殊数值外，Math 模块还提供了许多其他数学函数，比如四舍五入 round()、上入取整数 ceil()、下舍取整数 floor()、乘幂运算 pow()、指数函数 exp()、以 e 为底数的对数 log()、以 10 为底数的对数 log10()等等。

字符串

字符串定义

使用单引号 '、双引号 "、三引号 ''' 或 """ 将字符串内容括起来即可定义字符串。其中三引号一般用来定义多行字符串。

注意，空格、标点符号都是字符串的一部分。使用加号 + 将多个字符串连接起来，使用乘号 * 复制字符串。数字字符串仅仅是文本，不能直接完成算数运算，需要转化成整数、浮点数之后才能进行算数运算。

下面是一些使用例：

str1 = 'I am learning Python!'
print(str1)

str2 = "Hello, World!"
print(str2)

str3 = 'Hello, ' + 'World!'
print(str3)
# 'Hello, World'

str4 = 'Hello, World! '
str5 = str4 * 3
print(str5)
# Hello, World! Hello, World! Hello, World! 

索引、切片

1. 索引

在 Python 中，可以通过索引 (indexing) 和切片 (slicing) 来访问和操作字符串中的单个字符、部分字符。

字符串中的每个字符都有一个对应的索引位置，索引从 0 开始递增。可以使用方括号 [] 来访问指定索引位置的字符。

可以使用负数索引来从字符串的末尾开始计算位置。例如，-1 表示倒数第一个字符，-2 表示倒数第二个字符，依此类推。

2. 切片

切片是指从字符串中提取出一部分子字符串。可以使用半角冒号 : 来指定切片的起始位置 start 和结束 end 位置。语法为 string_name[start:end]，包括 start 序号对应的字符，但是不包括 end 位置的字符，相当于“左闭右开”区间。

切片还可以指定步长 (step)，用于跳过指定数量的字符。语法为 string_name[start:end:step]。

提示

复制字符串可以采用 string_name[:] 实现。

注意

索引和切片操作不会改变原始字符串，而是返回一个新的字符串。

下面是一些使用例：

greeting_str = 'Hey, James!'

# 打印字符串长度
print('字符串的长度为：')
print(len(greeting_str))

# 单个字符索引
print(greeting_str[0])
print(greeting_str[1])
print(greeting_str[-1])
print(greeting_str[-2])

# 切片
# 取出前3个字符，序号为0、1、2
print(greeting_str[:3])
# 取出序号1、2、3、4、5，不含0，不含6
print(greeting_str[1:6])
# 指定步长2，取出第0、2、4、6
print(greeting_str[::2])
# 指定步长-1，倒序
print(greeting_str[::-1])

字符串方法

Python 提供了许多用于字符串处理的常见方法。下面是一些常见的字符串方法及其示例。

• len() 返回字符串的长度，比如下例。

string = "Hello, James!"
length = len(string)
print(length)

• lower() 和 upper() 将字符串转换为小写或大写，比如下例。

string = "Hello, James!"
lower_string = string.lower()
upper_string = string.upper()
print(lower_string) # 输出 "hello, james!"
print(upper_string) # 输出 "HELLO, JAMES!"

以下是一些常见的 Python 字符串方法及其作用：capitalize() 将字符串的第一个字符转换为大写，其他字符转换为小写。count() 统计字符串中指定子字符串的出现次数。find() 在字符串中查找指定子字符串的第一次出现，并返回索引值。isalnum() 检查字符串是否只包含字母和数字。isalpha() 检查字符串是否只包含字母。isdigit() 检查字符串是否只包含数字。join() 将字符串列表 或可迭代对象中的元素连接为一个字符串。replace() 将字符串中的指定子字符串替换为另一个字符串。split() 将字符串按照指定分隔符分割成子字符串，并返回一个列表。

列表

在 Python 中，列表 (list) 是一种非常常用的数据类型，可以存储多个元素，并且可以进行增删改查等多种操作。

下面是列表的使用例：

# 创建一个混合列表
my_list = [1, 1.0, '1', True, [1, 1.0, '1'], {1}, {1:1.0}]
print('列表长度为')
print(len(my_list))

# 列表索引
print(my_list[1])
print(my_list[-1])

# 列表切片
# 取出序号1、2、3，不含0，不含4
print(my_list[1:4])

# 指定步长2，取出第0、2、4、6
print(my_list[::2])

# 指定步长-1，倒序
print(my_list[::-1])

# 提取列表中的列表某个元素
print(my_list[4][1])

列表方法

下面是列表方法的使用例

# 创建一个混合列表
my_list = [1, 1.0, '12ab', True, [1, 1.0, '1'], {1}, {1:1.0}]
print(my_list)

# 修改某个元素
my_list[2] = '123'

# 在列表指定位置前插入元素
my_list.insert(2, 'inserted')

# 在列表尾部添加元素
my_list.append('tail')

# 通过索引删除
del my_list[-1]

# 删除某个元素
my_list.remove('123')

# 判断一个元素是否在列表中
if '123' in my_list:
    print("Yes")
else:
    print("No")
 
# 列表翻转
my_list.reverse()

# 将列表用所有字符连接，连接符为下划线 _
letters = ['J', 'a', 'm', 'e', 's']
word = '_'.join(letters)
print(word)

xxxxxxxxxx import itertools​string = 'abc'# 定义元素列表elements = list(string)​# 指定组合长度length = 2​# 生成有放回组合combos = itertools.combinations_with_replacement(elements, length)​# 遍历并打印所有组合res = []for combination_idx in combos:    res.append(''.join(combination_idx))​print(res)​# ['aa', 'ab', 'ac', 'bb', 'bc', 'cc']python

视图 vs 浅复制 vs 深复制

如果用 = 直接赋值，是非拷贝方法，结果是产生一个视图 (view)。这两个列表是等价的，修改其中任何一个都会影响到另一个。

下面是示例：

list1 = [1, 2, 3, 4]

# 赋值，视图
list2 = list1 

# 拷贝，副本 (浅拷贝)
list3 = list1.copy()

list2[0] = 'a'
list2[1] = 'b'
list3[2] = 'c'
list3[3] = 'd'

print(list1)
print(list2)
print(list3)

xxxxxxxxxx import itertools​string = 'abc'# 定义元素列表elements = list(string)​# 指定组合长度length = 2​# 生成有放回组合combos = itertools.combinations_with_replacement(elements, length)​# 遍历并打印所有组合res = []for combination_idx in combos:    res.append(''.join(combination_idx))​print(res)​# ['aa', 'ab', 'ac', 'bb', 'bc', 'cc']python

不过事情并没有这么简单。在 Python 中，列表是可变对象，因此在复制列表时会涉及到深复制和浅复制的概念。

• 浅复制（shallow copy）只对 list 的第一层元素完成拷贝，深层元素还是和原 list 共用。
• 深复制（deep copy）是创建一个完全独立的列表对象，该对象中的元素与原始列表中的元素是不同的对象。

注意

对于嵌套列表，建议采用 copy.deepcopy() 进行深复制

下面是不同复制方式的例子：

import copy

list1 = [1, 2, 3, [4, 5]]
print('原始list')
print(list1)

# 深复制，适用于嵌套列表
list_deep = copy.deepcopy(list1) 

# 只深复制一层
list2 = list1.copy() 
list3 = list1[:] 
list4 = list(list1) 
list5 = [*list1]

# 修改元素
list_deep[3][0] = 'deep'
list_deep[2] = 'worked_0'

list2[3][0] = 'abc'
list2[2] = 'worked_1'

list3[3][0] = 'X1'
list3[2] = 'worked_2'

list4[3][0] = 'X2'
list4[2] = 'worked_3'

list5[3][0] = 'X3'
list5[2] = 'worked_4'

print('新list')
print(list1)
print(list_deep)

print(list2) 
print(list3)
print(list4)
print(list5)

其它数据类型

元组

在 Python 中，元组 (tuple) 是一种不可变的序列类型，用圆括号 () 来表示。元组一旦创建就不能被修改，这意味着你不能添加或删除其中的元素。

tuple 和 list 都是序列类型，可以存储多个元素，它们都可以通过索引访问和修改元素，支持切片操作。但是，两者有明显区别，元组使用圆括号 () 表示，而列表使用方括号 [] 表示。元组是不可变的，而列表是可变的。这意味着元组的元素不能被修改、添加或删除，而列表可以进行这些操作。

提示

元组的优势在于它们比列表更轻量级，这意味着在某些情况下，它们可以提供更好的性能和内存占用。

集合

在 Python 中，集合 (set) 是一种无序的、可变的数据类型，可以用来存储多个不同的元素。使用花括号 {} 或者 set() 函数创建集合，或者使用一组元素来初始化一个集合。

number_set = {1, 2, 3, 4, 5}
fruit_set = set(["apple", "banana", "orange"])

可以使用 add() 方法向集合中添加单个元素，使用 update() 方法向集合中添加多个元素。

fruit_set = set(["apple", "banana"])
fruit_set.add("orange")
fruit_set.update(["grape", "kiwi"])

删除元素：使用 remove() 或者 discard() 方法删除集合中的元素，如果元素不存在，remove() 方法会引发 KeyError 异常，而 discard() 方法则不会。

fruit_set.remove("banana")
fruit_set.discard("orange")

集合的特点是可以用交集、并集、差集等集合操作来操作集合。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = set1 & set2 # 交集
set4 = set1 | set2 # 并集
set5 = set1 - set2 # 差集

字典

在 Python 中，字典是一种无序的键值对 (key-value pair) 集合。

可以使用大括号 {} 或者 dict() 函数创建字典，键 (key) 值 (value) 对之间用冒号 : 分隔。

下面是一些使用例：

# 使用大括号创建字典
person = {'name': 'James', 'age': 18, 'gender': 'male'}

# 使用 dict() 函数创建字典
fruits = dict(apple=3, banana=2, cherry=5)

# 访问字典中的值
print(person['name'])
print(fruits['cherry']) 

# 修改字典中的值
person['age'] = 30
print(person) 

# 添加键值对
person['city'] = 'Toronto'
print(person)

# 删除键值对
del person['gender']
print(person) 

# 获取键、值、键值对列表
print(person.keys()) 
print(person.values()) 
print(person.items())