Python—基本数据类型

Python是一种解释型语言，非常灵活，并且具有很高的交互性，可以方便的编写、测试和调试代码；本文主要介绍Python的基本数据类型，主要包括整数、浮点数、字符串、布尔、列表、元组、集合和字典。

目前大部分是用Python进行简单的数据处理，发现处理起来数据还是很方面的，毕竟有各种各样的库供我们使用。集成开发环境用的是PyCharm。

1. 整数(int)

整数一种基本数据类型，用于表示不带小数点的数字，整数可以是正数、负数或零，在Python中，整数类型(int)没有大小限制，可以表示任意大的整数。

整数类型的常见操作包括加法、减法、乘法、除法和取模等。整数类型还支持位运算操作，例如按位与(&)、按位或(|)、按位异或(^)等。

示例1

# -*- coding: utf-8 -*-

x = 10   # 正整数
y = -20  # 负整数
z = 0    # 零

# 加法操作
sum_result = x + y
print("sum_result value is: ", sum_result)  # 输出: -10

# 减法操作
subtraction_result = x - y
print("subtraction_result value is: ", subtraction_result)  # 输出: 30

# 乘法操作
product_result = x * y
print("product_result value is: ", product_result)  # 输出: -200

# 除法操作
division_result = y / x
print("division_result value is: ", division_result)  # 输出: -2.0

# 取模操作
modulo_result = x % 3
print("modulo_result value is: ", modulo_result)  # 输出: 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输出

sum_result value is:  -10
subtraction_result value is:  30
product_result value is:  -200
division_result value is:  -2.0
modulo_result value is:  1
1
2
3
4
5

示例2

# -*- coding: utf-8 -*-

x = 1452875428754287542875428754287542875428754
y = 1452875428754287542875428754287542875428753
result = x - y

print('x type is: ',type(x))
print('result is: ', result)
1
2
3
4
5
6
7
8

输出

x type is:  <class 'int'>
result is:  1
1
2

这里不讨论针对整数类型(int)没有大小限制的内部存储结构。

2. 浮点数(float)

在Python中，float是一种内置的数据类型，用于表示带有小数点的数字。浮点数可以是正数、负数或零，并可以具有小数点以及指数部分。Python中的浮点数遵循IEEE 754标准。

以下是一些关于Python中float类型的介绍：

• 浮点数可以使用小数点表示，如3.14或-0.001；
• 浮点数可以使用科学记数法表示，如2.5e2表示250；
• 浮点数在Python中是不精确的，由于浮点数的存储方式，对于某些值的计算可能会产生舍入错误；
• 可以通过内置的float()函数将整数、字符串或其他类型的数据转换为浮点数；
• 浮点数的取值范围取决于计算机的硬件和支持的浮点数标准；

示例

# -*- coding: utf-8 -*-

import math

# 浮点数表示
float_num1 = 3.14
float_num2 = -0.001

# 科学记数法表示
scientific_notation = 2.5e2  # 表示 250.0

# 浮点数转换
integer_to_float = float(5)    # 将整数转换为浮点数，结果为 5.0
string_to_float = float("3.14")    # 将字符串转换为浮点数，结果为 3.14

# 不精确的浮点数计算
result = 0.1 + 0.2    # 期望结果为 0.3，但由于浮点数的存储方式，实际结果可能略有偏差

print("浮点数示例:")
print("浮点数1:", float_num1)
print("浮点数2:", float_num2)
print("科学记数法表示:", scientific_notation)
print("整数转换为浮点数:", integer_to_float)
print("字符串转换为浮点数:", string_to_float)
print("不精确的浮点数计算结果:", result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输出

浮点数示例:
浮点数1: 3.14
浮点数2: -0.001
科学记数法表示: 250.0
整数转换为浮点数: 5.0
字符串转换为浮点数: 3.14
不精确的浮点数计算结果: 0.30000000000000004
1
2
3
4
5
6
7

如何解决 result = 0.1 + 0.2 # 期望结果为 0.3，但由于浮点数的存储方式，实际结果可能略有偏差

处理浮点数精度问题的方法之一是使用 decimal 模块中的 Decimal 类。Decimal 类提供了更精确的浮点数表示和运算，可以减少舍入误差。

示例

# -*- coding: utf-8 -*-

import math
from decimal import Decimal

# 使用 Decimal 类来表示浮点数
num1 = Decimal('0.1')
num2 = Decimal('0.2')

# 进行精确的加法运算
result = num1 + num2

print("精确的浮点数计算结果:", result)
1
2
3
4
5
6
7
8
9
10
11
12
13

输出

精确的浮点数计算结果: 0.3
1

float类型位数的保留
要保留浮点数的小数点后四位，可以使用格式化字符串或者 round() 函数；

示例

# -*- coding: utf-8 -*-

import math
from decimal import Decimal

# 方法一
num = 3.141592653589793
formatted_num = "{:.4f}".format(num)
print(type(formatted_num))
print(formatted_num)  # 输出: 3.1416

# 方法二
num = 3.141592653589793
rounded_num = round(num, 4)
print(type(rounded_num))
print(rounded_num)  # 输出: 3.1416
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出

<class 'str'>
3.1416

<class 'float'>
3.1416
1
2
3
4
5

格式化字符串的方法输出的类型为 ‘str’
round() 函数的方法输出的类型为 ‘float’

3. 字符串(str)

Python 中的字符串是不可变的序列，用于存储文本数据,可以使用单引号 (')、双引号 (") 或三引号 (''' 或 """) 来创建字符串。

下面是一些关于 Python 字符串的常见操作和特性：

3.1 创建字符串

可以使用单引号或双引号来创建字符串。如果字符串中包含引号，你可以在引号前加上反斜杠 (\) 进行转义。

str1 = 'Hello, World!'
str2 = "Python Programming"
str3 = "It's a beautiful day."
str4 = "My name is 'Tom'"       # 输出：My name is 'Tom'
str5 = "My name is \"Tom\""     # 输出：My name is "Tom"
1
2
3
4
5

str1 = 'apple ' \
      'banana ' \
      'orange'

str2 = '''
apple
banana
orange
'''

print(str1)
print(len(str1))
print(str2)
print(len(str2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

apple banana orange
19

apple
banana
orange

21
1
2
3
4
5
6
7
8

在str1中有2个空格，分别在apple和banana之后；
在str2中有4个空格，分别在apple、banana和orange之后以及apple之前；

3.2 访问字符

可以使用索引来访问字符串中的单个字符，索引从 0 开始，也可以使用切片来访问子字符串。

s = "Python"
print(s[0])     # 输出: P
print(s[-1])    # 输出: n
print(s[1:4])   # 输出: yth
1
2
3
4

3.3 字符串拼接

可以使用加号 (+) 来拼接字符串。

s1 = "Hello"
s2 = "World"
result = s1 + " " + s2
print(result)   # 输出: Hello World
1
2
3
4

3.4 字符串格式化

可以使用 % 格式化字符串或者 .format() 方法进行字符串格式化。

name = "Alice"
age = 30
formatted_string = "My name is %s and I am %d years old." % (name, age)
print(formatted_string)

#使用 .format() 方法
formatted_string = "My name is {} and I am {} years old.".format(name, age)
print(formatted_string)
1
2
3
4
5
6
7
8

3.5 常见字符串方法

Python 提供了许多字符串方法来处理和操作字符串，如 split()、join()、strip()、replace() 等。

s = "   Hello, World!   "
print(s.strip())           # 去除首尾空白字符
print(s.split(","))        # 分割字符串
print(s.replace("Hello", "Hi"))  # 替换字符串中的子串
1
2
3
4

4. 布尔(bool)

在Python中，bool 类型用于表示逻辑值，即真 (True) 或假 (False)。bool 类型通常用于条件表达式和控制流语句中，例如 if 语句和 while 循环。

以下是关于 Python 中 bool 类型的一些重要特点和示例：

4.1 创建 bool 类型变量

可以直接将 True 或 False 分配给变量来创建 bool 类型变量。

x = True
y = False
1
2

4.2 逻辑运算

Python 提供了常见的逻辑运算符，如 and、or 和 not，用于组合和操作 bool 类型的值。

a = True
b = False

print(a and b)  # 输出: False
print(a or b)   # 输出: True
print(not a)    # 输出: False
1
2
3
4
5
6

4.3 比较运算符返回 bool 类型

比较运算符（如 ==、!=、<、<=、>、>=）用于比较两个值，并返回 True 或 False。

x = 5
y = 10

print(x < y)    # 输出: True
print(x == y)   # 输出: False
1
2
3
4
5

4.4 bool() 函数

使用 bool() 函数将其他数据类型转换为 bool 类型。通常，0、空序列（如空字符串、空列表、空元组）和 None 被视为 False，其他值被视为 True。

print(bool(0))        # 输出: False
print(bool(10))       # 输出: True
print(bool([]))       # 输出: False
print(bool([1, 2, 3]))  # 输出: True
1
2
3
4

5. bool 类型在条件语句中的使用：bool 类型常用于条件语句（如 if 语句）中，根据条件的真假执行不同的代码块。

is_sunny = True

if is_sunny:
    print("It's a sunny day!")
else:
    print("It's not sunny today.")
1
2
3
4
5
6

5. 列表(list)

Python 中的列表是一种有序、可变的数据集合，用于存储多个元素。列表使用方括号 ([]) 表示，其中的元素可以是任意数据类型，并且允许重复元素。

以下是关于 Python 列表的一些常见操作和特性：

5.1 创建列表

使用方括号来创建列表，其中的元素用逗号分隔，列表中的元素类型可以不同。

my_list = [1, 2, 3, 4, 5]
mixed_list = [1, "hello", True, 3.14]
empty_list = []
1
2
3

5.2 访问列表元素

使用索引来访问列表中的单个元素，索引从 0 开始，也可以使用切片来访问子列表。

my_list = [10, 20, 30, 40, 50]
print(my_list[0])    # 输出: 10
print(my_list[-1])   # 输出: 50
print(my_list[1:3])  # 输出: [20, 30]
1
2
3
4

5.3 列表操作

Python 提供了丰富的列表操作，如添加元素、删除元素、更新元素等。

my_list = [1, 2, 3]

# 添加元素
my_list.append(4)        # 在末尾添加元素
print(my_list)           # 输出: [1, 2, 3, 4]

# 删除元素
my_list.remove(2)        # 删除指定值的元素
print(my_list)           # 输出: [1, 3, 4]

# 更新元素
my_list[0] = 10          # 更新指定位置的元素值
print(my_list)           # 输出: [10, 3, 4]
1
2
3
4
5
6
7
8
9
10
11
12
13

删除列表中指定位置的元素，可以使用 del 语句或者 pop() 方法。下面是两种方法的示例：

使用 del 语句：

my_list = [1, 2, 3, 4, 5]
del my_list[2]  # 删除索引为 2 的元素
print(my_list)  # 输出: [1, 2, 4, 5]
1
2
3

使用 pop() 方法：

my_list = [1, 2, 3, 4, 5]
removed_element = my_list.pop(2)  # 删除索引为 2 的元素，并返回删除的元素
print("Removed element:", removed_element)  # 输出: Removed element: 3
print(my_list)  # 输出: [1, 2, 4, 5]
1
2
3
4

使用 del 语句会直接在列表上删除指定位置的元素，而 pop() 方法则会返回被删除的元素，并且原列表会被修改。

5.4 列表方法

Python 提供了许多方法来操作列表，如 append()、insert()、pop()、sort()、reverse() 等。

my_list = [3, 1, 2]

my_list.append(4)       # 在末尾添加元素
print(my_list)          # 输出: [3, 1, 2, 4]

my_list.sort()          # 对列表进行排序
print(my_list)          # 输出: [1, 2, 3, 4]

my_list.reverse()       # 反转列表元素
print(my_list)          # 输出: [4, 3, 2, 1]
1
2
3
4
5
6
7
8
9
10

5.5 列表的拷贝

在 Python 中，拷贝列表时存在浅拷贝和深拷贝两种方式。这两种拷贝方式的区别在于拷贝后的对象是否与原始对象共享内部对象的引用。

浅拷贝（Shallow Copy）：

浅拷贝创建了一个新的列表对象，但是该新列表中的元素仍然是原始列表中元素的引用。换句话说，浅拷贝只会拷贝原始列表的一层结构。

你可以使用切片操作符 [:]、=、copy() 方法或 list() 构造函数来执行浅拷贝。

original_list = [[1, 2, 3], [4, 5, 6]]
shallow_copy = original_list[:]

# 或
shallow_copy = original_list

# 或
shallow_copy = original_list.copy()

# 或
shallow_copy = list(original_list)
1
2
3
4
5
6
7
8
9
10
11

对原始列表进行修改，会影响到浅拷贝：

original_list[0][0] = -1
print(shallow_copy)  # 输出: [[-1, 2, 3], [4, 5, 6]]
1
2

深拷贝（Deep Copy）：

深拷贝创建了一个全新的列表对象，并且递归地拷贝原始列表中的所有内部对象，包括嵌套的列表和其他可变对象。

你可以使用 copy.deepcopy() 函数执行深拷贝。

import copy

original_list = [[1, 2, 3], [4, 5, 6]]
deep_copy = copy.deepcopy(original_list)
1
2
3
4

对原始列表进行修改，不会影响到深拷贝：

original_list[0][0] = -1
print(deep_copy)  # 输出: [[1, 2, 3], [4, 5, 6]]
1
2

总之，浅拷贝只会拷贝一层对象结构，而深拷贝会递归地拷贝所有内部对象，使得拷贝后的对象完全独立于原始对象。

问题和思考

示例

original_list = [[1, 2, 3], [4, 5, 6]]
shallow_copy = original_list[:]
original_list[0][0] = -1
print(shallow_copy) 

original_list = [1, 2, 3]
shallow_copy = original_list[:]
original_list[0] = -1
print(shallow_copy)
1
2
3
4
5
6
7
8
9

输出

[[-1, 2, 3], [4, 5, 6]]
[1, 2, 3]
1
2

解析
在第一个示例中，original_list 是一个包含两个列表的列表，即嵌套列表。当你执行 shallow_copy = original_list[:] 时，shallow_copy 被创建为 original_list 的浅拷贝。这意味着 shallow_copy 是一个新的列表对象，但是它的元素仍然是原始列表中元素的引用。因此，修改原始列表中的嵌套列表的元素也会影响到浅拷贝。

在第二个示例中，original_list 是一个简单的列表，包含整数元素。同样地，当你执行 shallow_copy = original_list[:] 时，shallow_copy 被创建为 original_list 的浅拷贝。由于 original_list 中的元素都是不可变的整数，它们在内存中是独立的，因此修改 original_list 中的元素不会影响到浅拷贝。

所以区别在于，对于包含可变对象的列表（如嵌套列表），浅拷贝会共享内部对象的引用，因此修改原始列表中的内部对象会影响到浅拷贝。而对于简单的列表，浅拷贝会创建新的独立对象，因此修改原始列表不会影响到浅拷贝。

6. 元组(tuple)

在 Python 中，元组（tuple）是一种有序、不可变的数据类型，用于存储任意数量的不可变对象。元组可以包含不同类型的元素，例如整数、浮点数、字符串、元组等。

元组的主要特点包括：

6.1 **不可变性（Immutable）

一旦创建，元组的内容就不能被修改、添加或删除。这使得元组在需要确保数据不被修改的情况下非常有用。

my_tuple = (1, 2, 3)
my_tuple[0] = 4  # 这将引发TypeError: 'tuple' object does not support item assignment
1
2

6.2 有序性（Ordered）

元组中的元素按照其插入顺序进行排列，并且可以通过索引访问每个元素。

my_tuple = ('apple', 'banana', 'cherry', 'date')

# 通过索引访问元组中的元素
print(my_tuple[0])  # 输出: apple
print(my_tuple[2])  # 输出: cherry

# 使用负数索引访问元组中的元素（从末尾开始计数）
print(my_tuple[-1])  # 输出: date
print(my_tuple[-2])  # 输出: cherry

# 切片操作
print(my_tuple[1:3])  # 输出: ('banana', 'cherry')
print(my_tuple[:2])   # 输出: ('apple', 'banana')
print(my_tuple[2:])   # 输出: ('cherry', 'date')

# 反向切片
print(my_tuple[::-1])  # 输出: ('date', 'cherry', 'banana', 'apple')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6.3 可以包含任意类型的对象

元组可以包含各种类型的对象，包括其他元组，甚至是可变对象，如列表。

# 创建元组
my_tuple = (1, 2, 3, 'a', 'b', 'c')
# 访问元组元素
print(my_tuple[0])  # 输出: 1
print(my_tuple[-1])  # 输出: 'c'
1
2
3
4
5

6.4 支持元组解包和元组合并

通过元组解包，可以将元组中的元素分配给多个变量。而元组合并则是将多个元组合并为一个更大的元组。

# 元组解包
x, y, z, *rest = my_tuple
print(x, y, z)  # 输出: 1 2 3
print(rest)     # 输出: ['a', 'b', 'c']

# 元组合并
tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
merged_tuple = tuple1 + tuple2
print(merged_tuple)  # 输出: (1, 2, 3, 'a', 'b', 'c')
1
2
3
4
5
6
7
8
9
10
11

元组在很多情况下都比列表更合适，例如用作函数的参数、用于不可变的常量集合等。
元组的不可变性使得它们在某些情况下比列表更安全，因为你可以确信元组中的数据不会被意外地修改。

7. 集合(set)

在Python中，集合（set）是一种无序且不重复的数据集合。集合可以用于存储不同类型的元素，例如整数、浮点数、字符串等。集合的主要特点包括：

7.1 无序性（Unordered）

集合中的元素是无序的，即不保留插入顺序，也不支持通过索引访问元素。

# 创建空集合，不能使用{}，{}创建的是字典
empty_set = set()

# 创建集合
my_set = {1, 2, 3, 4, 5}

# 添加元素
my_set.add(6)
print(my_set)  # 输出: {1, 2, 3, 4, 5, 6}

# 删除元素
my_set.remove(3)
print(my_set)  # 输出: {1, 2, 4, 5, 6}

# 遍历集合
for element in my_set:
    print(element)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

示例

a = []
b = {}
c = set()
d = dict()

print(type(a))
print(type(b))
print(type(c))
print(type(d))
1
2
3
4
5
6
7
8
9

输出

<class 'list'>
<class 'dict'>
<class 'set'>
<class 'dict'>
1
2
3
4

7.2 唯一性（Uniqueness）

集合中不允许重复的元素，每个元素在集合中只能出现一次。

my_set = {1, 2, 2, 3, 3, 3}
print(my_set)  # 输出: {1, 2, 3}
1
2

7.3 可变性（Mutable）

集合是可变的数据类型，可以通过添加、删除元素来修改集合。

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}

my_set.remove(2)
print(my_set)  # 输出: {1, 3, 4}
1
2
3
4
5
6

7.4 可迭代性（Iterable）

集合可以被迭代，即可以使用循环来遍历集合中的元素。

my_set = {1, 2, 3}
for element in my_set:
    print(element)
1
2
3

7.5 支持数学集合操作

集合支持各种数学集合操作，如并集、交集、差集等。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1 | set2  # 并集
intersection = set1 & set2  # 交集
difference = set1 - set2  # 差集
difference1 = set2 - set1  # 差集
print("Union:", union)  # 输出: Union: {1, 2, 3, 4, 5}
print("Intersection:", intersection)  # 输出: Intersection: {3}
print("Difference:", difference)  # 输出: Difference: {1, 2}
print("Difference1:", difference1)  # 输出: Difference: {4, 5}
1
2
3
4
5
6
7
8
9
10

集合在Python中常用于去除重复元素、检查成员资格等操作。它们的无序性和唯一性使得它们在处理某些问题时非常有用。

8. 字典(dict)

在Python中，字典（Dictionary）是一种无序的数据类型，用于存储键值对（key-value pairs）。字典的主要特性包括：

8.1 键值对存储

字典中的数据以键值对的形式存储，每个键都唯一，并与一个值相关联。

# 创建字典
my_dict = {'apple': 3, 'banana': 5, 'cherry': 2}

# 创建空字典
empty_dict = {}

# 或者使用 dict() 函数
empty_dict = dict()
1
2
3
4
5
6
7
8

8.2 无序性

字典中的元素是无序的，即不保留插入顺序，也不支持通过索引访问元素。 Python会自动选择最有效的方式来存储和检索字典中的元素，而不考虑插入顺序。

8.3 键的唯一性

字典中的键必须是唯一的，但值可以不唯一。

# 创建一个字典，包含重复的键和值
my_dict = {'a': 1, 'b': 2, 'c': 1, 'd': 2}

print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 1, 'd': 2}

# 尝试添加一个重复的键，会覆盖原有的值
my_dict['c'] = 3
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 2}

# 尝试添加一个不同的键，但值相同
my_dict['e'] = 3
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 2, 'e': 3}
1
2
3
4
5
6
7
8
9
10
11
12

8.4 可变性

字典是可变的数据类型，可以通过添加、删除键值对来修改字典。

# 添加新键值对
my_dict['date'] = 7
print(my_dict)  # 输出: {'apple': 3, 'banana': 5, 'cherry': 2, 'date': 7}

# 修改值
my_dict['banana'] = 6
print(my_dict)  # 输出: {'apple': 3, 'banana': 6, 'cherry': 2, 'date': 7}

# 删除键值对
del my_dict['cherry']
print(my_dict)  # 输出: {'apple': 3, 'banana': 6, 'date': 7}

# 使用键来访问值
print(my_dict['banana'])  # 输出: 6

# 遍历字典的键值对
for key, value in my_dict.items():
    print(key, "->", value)

# 检查键的成员资格
print('banana' in my_dict)  # 输出: True
print('grape' in my_dict)   # 输出: False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

字典在Python中常用于映射一组唯一键到其对应的值，它们的灵活性和高效性使得它们在各种情况下都非常有用。