Python 基本数据类型

python 的变量不需要声明.每个变量在使用前必须赋值.变量在被赋值之后才会被创建.

在 Python 中变量就是变量,他没有类型,我们所熟知的"类型"只是内存中的对象的类型.

等号=用来给对象赋值,等号左边是变量名,等号右边是要赋的值.

等号(9)运算符的左边是一个变量名,等号(=)运算符的右边是存储在变量中的值.例如:

1
2
3
4
5
6
7

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

输出:

1
2
3

100
1000.0
runoob

多个变量赋值

Python 允许一次给多个变量赋值.例如:

1
2
3
4

a = b = c = 1
print (a)
print (b)
print (c)

输出:

1
2
3

1
1
1

标准数据类型

Python3 常见的类型有:

• Number（数字）
• String（字符串）
• bool (布尔值)
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中:

• 不可变数据: Number（数字）、String（字符串）、Tuple（元组）
• 可变数据: List（列表）、Dictionary（字典）、Set（集合）

此外还有一些高级的数据类型,比如字节数组类型(bytes).

Number（数字）

Python3 支持 int、float、bool、complex（复数）。

在 Python 3 里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查询变量所指的对象类型。

1
2
3
4
5
6
7
8
9

a = 1
b = 3.14
c = 1 + 5j
d = True

print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'complex'>
print(type(d))  # <class 'bool'>

当你指定一个值时，Number 对象就会被创建：

1
2
3
4

a = 1
b = 3.14
c = 1 + 5j
d = True

您也可以使用 del 语句删除一些对象引用。

1
2
3
4

del a
del b
del c
del d

数值运算

实例:

1
2
3
4
5
6
7
8
9

x = 10
y = 3

print(x + y)    # 13
print(x - y)    # 7
print(x * y)    # 30
print(x / y)    # 3.3333333333333335
print(x % y)    # 1
print(x ** y)   # 1000

注意:

1. Python 可以同时为多个变量赋值,如a,b = 1,2。
2. 一个变量可以通过赋值指向不同类型的对象.
3. 数字的除法包含两个运算符:/返回一个浮点数,//返回一个整数.
4. 在混合计算时,Python 会把整型转换为浮点型.

数字类型实例

Python3 还支持复数,复数由实数部分和虚数部分构成,可以用a+bj,或者complex(a,b)表示,复数的实部 a 和虚部 b 都是浮点型.

String（字符串）

Python 中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：

1

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号+是字符串的连接符,星号*可以复制当前字符串,与之结合的数字为复制次数,实例如下:

1
2
3
4
5
6
7
8
9

str = 'Runoob'  # 定义一个字符串变量

print(str)           # 打印整个字符串
print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])        # 打印字符串的第一个字符
print(str[2:5])      # 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:])       # 打印字符串从第三个字符开始到末尾
print(str * 2)       # 打印字符串两次
print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

输出:

1
2
3
4
5
6
7

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunooTEST

Python 使用反斜杠\转义特殊字符,如\n表示换行,\t表示制表符,\r表示回车,\b表示退格,\f表示换页.

1
2

print('Hello, \nWorld!')  # 输出 Hello,
                             #        World!

另外,反斜杠(\)可以作为续行符,表示接下来的字符串属于同一行.也可以使用 """...""" 或者 '''...''' 跨越多行。

注意:Python 没有单独的字符类型,一个字符就是长度为 1 的字符串.

1
2
3
4
5

>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = ’m' 会导致错误。

注意:

1. 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
2. 字符串可以用+运算符连接在一起，用*运算符重复。
3. Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以-1 开始。
4. Python 中的字符串不能改变。

bool (布尔值)

布尔类型即 True 或 False。

在 Python 中，True 和 False 都是关键字，表示布尔值。

布尔类型可以用来控制程序的流程，比如判断某个条件是否成立，或者在某个条件满足时执行某段代码。

布尔类型特点：

• 布尔类型只有两个值：True 和 False。

• bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1。

• 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。

• 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。

• 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。

• 可以使用 bool() 函数将其他类型的值转换为布尔值。以下值在转换为布尔值时为 False：None、False、零 (0、0.0、0j)、空序列（如 ‘'、()、[]）和空映射（如 {}）。其他所有值转换为布尔值时均为 True。

实例:

 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
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 布尔类型的值和类型
a = True
b = False
print(type(a))  # <class 'bool'>
print(type(b))  # <class 'bool'>

# 布尔类型的整数表现
print(int(True))   # 1
print(int(False))  # 0

# 使用 bool() 函数进行转换
print(bool(0))         # False
print(bool(42))        # True
print(bool(''))        # False
print(bool('Python'))  # True
print(bool([]))        # False
print(bool([1, 2, 3])) # True

# 布尔逻辑运算
print(True and False)  # False
print(True or False)   # True
print(not True)        # False

# 布尔比较运算
print(5 > 3)  # True
print(2 == 2) # True
print(7 < 4)  # False

# 布尔值在控制流中的应用
if True:
    print("This will always print")

if not False:
    print("This will also always print")

x = 10
if x:
    print("x is non-zero and thus True in a boolean context")

注意: 在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。因此，在进行布尔类型转换时，需要注意数据类型的真假性。

List（列表）

列表是 Python 中最常用的数据类型。列表可以包含不同类型的数据，可以是整数、字符串、浮点数等。列表是一种有序的集合，可以随时添加或删除元素。

列表的创建方式有两种：

• 使用方括号 [] 创建空列表。
• 使用方括号 [] 后面跟着逗号分隔的元素列表来创建非空列表。

1
2
3
4
5

# 创建空列表
my_list = []

# 创建非空列表
my_list = [1, 2, 3, 'a', 'b', 'c']

列表的索引从 0 开始，可以从左到右访问列表中的元素，也可以从右到左访问。

1
2
3
4
5
6
7
8
9

my_list = [1, 2, 3, 'a', 'b', 'c']

# 访问列表中的元素
print(my_list[0])  # 1
print(my_list[4])  # 'b'

# 访问列表中的元素（从右到左）
print(my_list[-1])  # 'c'
print(my_list[-3])  # 2

列表的切片操作可以从列表中获取一部分元素。

1
2
3
4
5
6

my_list = [1, 2, 3, 'a', 'b', 'c']

# 切片操作
print(my_list[1:4])  # [2, 3, 'a']
print(my_list[3:])   # ['a', 'b', 'c']
print(my_list[:3])   # [1, 2, 3]

列表的常用操作：

• len(list)：返回列表的长度。
• list.append(obj)：在列表末尾添加一个对象。
• list.insert(index, obj)：在指定位置插入一个对象。
• list.pop([index])：删除并返回指定位置的对象，默认删除最后一个对象。
• list.remove(obj)：删除第一个匹配的对象。
• list.index(obj)：返回第一个匹配的对象的索引。
• list.count(obj)：返回指定对象在列表中出现的次数。
• list.sort()：对列表进行排序。
• list.reverse()：反转列表。

Tuple（元组）

元组与列表类似，不同之处在于元组的元素不能修改。元组创建方式也与列表相同。

1
2
3
4
5

# 创建空元组
my_tuple = ()

# 创建非空元组
my_tuple = (1, 2, 3, 'a', 'b', 'c')

元组的索引和切片操作与列表相同。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

my_tuple = (1, 2, 3, 'a', 'b', 'c')

# 访问元组中的元素
print(my_tuple[0])  # 1
print(my_tuple[4])  # 'b'

# 访问元组中的元素（从右到左）
print(my_tuple[-1])  # 'c'
print(my_tuple[-3])  # 2

# 切片操作
print(my_tuple[1:4])  # (2, 3, 'a')
print(my_tuple[3:])   # ('a', 'b', 'c')
print(my_tuple[:3])   # (1, 2, 3)

Set（集合）

集合是一个无序不重复元素的集。集合是由一个或多个元素组成的，这些元素可以是数字、字符串、元组等。集合可以进行集合运算，比如并集、交集、差集等。

集合的创建方式有两种：

• 使用花括号 {} 创建空集合。
• 使用花括号 {} 后面跟着逗号分隔的元素列表来创建非空集合。

1
2
3
4
5

# 创建空集合
my_set = set()

# 创建非空集合
my_set = {1, 2, 3, 'a', 'b', 'c'}

集合的元素不能重复，因此集合中不会出现重复的元素。

集合的常用操作：

• len(set)：返回集合的长度。
• set.add(obj)：添加一个元素到集合中。
• set.remove(obj)：删除一个元素。
• set.pop()：随机删除一个元素。
• set.union(set2)：返回两个集合的并集。
• set.intersection(set2)：返回两个集合的交集。
• set.difference(set2)：返回两个集合的差集。
• set.symmetric_difference(set2)：返回两个集合的对称差集。

Dictionary（字典）

字典是 Python 中另一种非常有用的内置数据类型。字典是一种映射类型，它存储键值对。字典的每个键值对用冒号 : 分割，每个键和值用逗号 , 分割。

字典的创建方式有两种：

• 使用花括号 {} 创建空字典。
• 使用花括号 {} 后面跟着逗号分隔的键值对列表来创建非空字典。

1
2
3
4
5

# 创建空字典
my_dict = {}

# 创建非空字典
my_dict = {'name': 'runoob', 'age': 18, 'city': 'beijing'}

字典的键必须是不可变类型，如字符串、数字、元组等。值可以是任意类型。

字典的常用操作：

• len(dict)：返回字典的长度。
• dict[key]：返回指定键的值。
• dict[key] = value：设置或修改指定键的值。
• del dict[key]：删除指定键的值。
• key in dict：判断字典中是否存在指定键。
• dict.keys()：返回字典所有键组成的列表。
• dict.values()：返回字典所有值组成的列表。
• dict.items()：返回字典所有键值对组成的列表。

总结

Python 3 共有六种基本数据类型：Number（数字）、String（字符串）、bool (布尔值)、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）。