Python基础知识 -【标准数据类型】

Python3 中常见的数据类型有：

    Number（数字）
    String（字符串）
    bool（布尔类型）
    List（列表）
    Tuple（元组）
    Set（集合）
    Dictionary（字典）

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

    不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

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

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

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

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

1. >>> a, b, c, d = 20, 5.5, True, 4+3j
   
2. >>> print(type(a), type(b), type(c), type(d))
   
3. <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

复制代码

此外还可以用 isinstance 来判断：

实例

1. >>> a = 111
   
2. >>> isinstance(a, int)
   
3. True
   
4. >>>

复制代码

isinstance 和 type 的区别在于：

    type()不会认为子类是一种父类类型。
    isinstance()会认为子类是一种父类类型。

1. >>> class A:
   
2. ...     pass
   
3. ...
   
4. >>> class B(A):
   
5. ...     pass
   
6. ...
   
7. >>> isinstance(A(), A)
   
8. True
   
9. >>> type(A()) == A
   
10. True
    
11. >>> isinstance(B(), A)
    
12. True
    
13. >>> type(B()) == A
    
14. False

复制代码

注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。

1. >>> issubclass(bool, int)
   
2. True
   
3. >>> True==1
   
4. True
   
5. >>> False==0
   
6. True
   
7. >>> True+1
   
8. 2
   
9. >>> False+1
   
10. 1
    
11. >>> 1 is True
    
12. False
    
13. >>> 0 is False
    
14. False

复制代码

1. 在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。

复制代码

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

1. var1 = 1
   
2. var2 = 10

复制代码

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

del语句的语法是：

1. del var1[,var2[,var3[....,varN]]]

复制代码

您可以通过使用del语句删除单个或多个对象。例如：

1. del var
   
2. del var_a, var_b

复制代码

数值运算
实例

1. >>> 5 + 4  # 加法
   
2. 9
   
3. >>> 4.3 - 2 # 减法
   
4. 2.3
   
5. >>> 3 * 7  # 乘法
   
6. 21
   
7. >>> 2 / 4  # 除法，得到一个浮点数
   
8. 0.5
   
9. >>> 2 // 4 # 除法，得到一个整数
   
10. 0
    
11. >>> 17 % 3 # 取余
    
12. 2
    
13. >>> 2 ** 5 # 乘方
    
14. 32

复制代码

注意：

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

String（字符串）

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

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

1. 变量[头下标:尾下标]

复制代码

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


加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：

实例

1. #!/usr/bin/python3
   
2. 
   
3. str = 'Runoob'  # 定义一个字符串变量
   
4. 
   
5. print(str)           # 打印整个字符串
   
6. print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
   
7. print(str[0])        # 打印字符串的第一个字符
   
8. print(str[2:5])      # 打印字符串第三到第五个字符（不包含第五个字符）
   
9. print(str[2:])       # 打印字符串从第三个字符开始到末尾
   
10. print(str * 2)       # 打印字符串两次
    
11. print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

复制代码

执行以上程序会输出如下结果：

1. Runoob
   
2. Runoo
   
3. R
   
4. noo
   
5. noob
   
6. RunoobRunoob
   
7. RunoobTEST

复制代码

Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：
实例

1. >>> print('Ru\noob')
   
2. Ru
   
3. oob
   
4. >>> print(r'Ru\noob')
   
5. Ru\noob
   
6. >>>

复制代码

另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

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

实例

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

复制代码

1. 与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = 'm' 会导致错误。
   
2. 
   
3. 注意：
   
4. 
   
5.     1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
   
6.     2、字符串可以用+运算符连接在一起，用*运算符重复。
   
7.     3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
   
8.     4、Python中的字符串不能改变。

复制代码

bool（布尔类型）

布尔类型即 True 或 False。

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

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

布尔类型特点：

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

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

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

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


实例

1. a = True
   
2. b = False
   
3. 
   
4. # 比较运算符
   
5. print(2 < 3)   # True
   
6. print(2 == 3)  # False
   
7. 
   
8. # 逻辑运算符
   
9. print(a and b)  # False
   
10. print(a or b)   # True
    
11. print(not a)    # False
    
12. 
    
13. # 类型转换
    
14. print(int(a))   # 1
    
15. print(float(b)) # 0.0
    
16. print(str(a))   # "True"

复制代码

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

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

1. 变量[头下标:尾下标]

复制代码

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



加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：

实例

1. #!/usr/bin/python3
   
2. 
   
3. list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]  # 定义一个列表
   
4. tinylist = [123, 'runoob']
   
5. 
   
6. print (list)            # 打印整个列表
   
7. print (list[0])         # 打印列表的第一个元素
   
8. print (list[1:3])       # 打印列表第二到第三个元素（不包含第三个元素）
   
9. print (list[2:])        # 打印列表从第三个元素开始到末尾
   
10. print (tinylist * 2)    # 打印tinylist列表两次
    
11. print (list + tinylist)  # 打印两个列表拼接在一起的结果

复制代码

以上实例输出结果：

1. ['abcd', 786, 2.23, 'runoob', 70.2]
   
2. abcd
   
3. [786, 2.23]
   
4. [2.23, 'runoob', 70.2]
   
5. [123, 'runoob', 123, 'runoob']
   
6. ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

复制代码

与Python字符串不一样的是，列表中的元素是可以改变的：

实例

1. >>> a = [1, 2, 3, 4, 5, 6]
   
2. >>> a[0] = 9
   
3. >>> a[2:5] = [13, 14, 15]
   
4. >>> a
   
5. [9, 2, 13, 14, 15, 6]
   
6. >>> a[2:5] = []   # 将对应的元素值设置为 []
   
7. >>> a
   
8. [9, 2, 6]

复制代码

List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。

注意：

    1、列表写在方括号之间，元素用逗号隔开。
    2、和字符串一样，列表可以被索引和切片。
    3、列表可以使用 + 操作符进行拼接。
    4、列表中的元素是可以改变的。

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：



如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：

实例

1. def reverseWords(input):
   
2.      
   
3.     # 通过空格将字符串分隔符，把各个单词分隔为列表
   
4.     inputWords = input.split(" ")
   
5. 
   
6.     # 翻转字符串
   
7.     # 假设列表 list = [1,2,3,4],  
   
8.     # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
   
9.     # inputWords[-1::-1] 有三个参数
   
10.     # 第一个参数 -1 表示最后一个元素
    
11.     # 第二个参数为空，表示移动到列表末尾
    
12.     # 第三个参数为步长，-1 表示逆向
    
13.     inputWords=inputWords[-1::-1]
    
14. 
    
15.     # 重新组合字符串
    
16.     output = ' '.join(inputWords)
    
17.      
    
18.     return output
    
19. 
    
20. if __name__ == "__main__":
    
21.     input = 'I like runoob'
    
22.     rw = reverseWords(input)
    
23.     print(rw)

复制代码

输出结果为：

1. runoob like I

复制代码

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

实例

1. #!/usr/bin/python3
   
2. 
   
3. tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
   
4. tinytuple = (123, 'runoob')
   
5. 
   
6. print (tuple)             # 输出完整元组
   
7. print (tuple[0])          # 输出元组的第一个元素
   
8. print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
   
9. print (tuple[2:])         # 输出从第三个元素开始的所有元素
   
10. print (tinytuple * 2)     # 输出两次元组
    
11. print (tuple + tinytuple) # 连接元组

复制代码

以上实例输出结果：

1. ('abcd', 786, 2.23, 'runoob', 70.2)
   
2. abcd
   
3. (786, 2.23)
   
4. (2.23, 'runoob', 70.2)
   
5. (123, 'runoob', 123, 'runoob')
   
6. ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

复制代码

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。
实例

1. >>> tup = (1, 2, 3, 4, 5, 6)
   
2. >>> print(tup[0])
   
3. 1
   
4. >>> print(tup[1:5])
   
5. (2, 3, 4, 5)
   
6. >>> tup[0] = 11  # 修改元组元素的操作是非法的
   
7. Traceback (most recent call last):
   
8.   File "<stdin>", line 1, in <module>
   
9. TypeError: 'tuple' object does not support item assignment
   
10. >>>

复制代码

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

1. tup1 = ()    # 空元组
   
2. 
   
3. tup2 = (20,) # 一个元素，需要在元素后添加逗号

复制代码

如果你想创建只有一个元素的元组，需要注意在元素后面添加一个逗号，以区分它是一个元组而不是一个普通的值，这是因为在没有逗号的情况下，Python会将括号解释为数学运算中的括号，而不是元组的表示。

如果不添加逗号，如下所示，它将被解释为一个普通的值而不是元组：

1. not_a_tuple = (42)

复制代码

1. 这样的话，not_a_tuple 将是整数类型而不是元组类型。
   
2. 
   
3. string、list 和 tuple 都属于 sequence（序列）。
   
4. 
   
5. 注意：
   
6. 
   
7.     1、与字符串一样，元组的元素不能修改。
   
8.     2、元组也可以被索引和切片，方法一样。
   
9.     3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
   
10.     4、元组也可以使用 + 操作符进行拼接。

复制代码

Set（集合）

Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。

另外，也可以使用 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

1. parame = {value01,value02,...}

复制代码

或者

1. set(value)

复制代码

实例

1. #!/usr/bin/python3
   
2. 
   
3. sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
   
4. 
   
5. print(sites)   # 输出集合，重复的元素被自动去掉
   
6. 
   
7. # 成员测试
   
8. if 'Runoob' in sites :
   
9.     print('Runoob 在集合中')
   
10. else :
    
11.     print('Runoob 不在集合中')
    
12. 
    
13. 
    
14. # set可以进行集合运算
    
15. a = set('abracadabra')
    
16. b = set('alacazam')
    
17. 
    
18. print(a)
    
19. 
    
20. print(a - b)     # a 和 b 的差集
    
21. 
    
22. print(a | b)     # a 和 b 的并集
    
23. 
    
24. print(a & b)     # a 和 b 的交集
    
25. 
    
26. print(a ^ b)     # a 和 b 中不同时存在的元素

复制代码

以上实例输出结果：

1. {'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
   
2. Runoob 在集合中
   
3. {'b', 'c', 'a', 'r', 'd'}
   
4. {'r', 'b', 'd'}
   
5. {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
   
6. {'c', 'a'}
   
7. {'z', 'b', 'm', 'r', 'l', 'd'}

复制代码

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

实例

1. #!/usr/bin/python3
   
2. 
   
3. dict = {}
   
4. dict['one'] = "1 - 菜鸟教程"
   
5. dict[2]     = "2 - 菜鸟工具"
   
6. 
   
7. tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
   
8. 
   
9. 
   
10. print (dict['one'])       # 输出键为 'one' 的值
    
11. print (dict[2])           # 输出键为 2 的值
    
12. print (tinydict)          # 输出完整的字典
    
13. print (tinydict.keys())   # 输出所有键
    
14. print (tinydict.values()) # 输出所有值

复制代码

以上实例输出结果：

1. 1 - 菜鸟教程
   
2. 2 - 菜鸟工具
   
3. {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
   
4. dict_keys(['name', 'code', 'site'])
   
5. dict_values(['runoob', 1, 'www.runoob.com'])

复制代码

构造函数 dict() 可以直接从键值对序列中构建字典如下：

实例

1. >>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
   
2. {'Runoob': 1, 'Google': 2, 'Taobao': 3}
   
3. >>> {x: x**2 for x in (2, 4, 6)}
   
4. {2: 4, 4: 16, 6: 36}
   
5. >>> dict(Runoob=1, Google=2, Taobao=3)
   
6. {'Runoob': 1, 'Google': 2, 'Taobao': 3}

复制代码

{x: x**2 for x in (2, 4, 6)} 该代码使用的是字典推导式，更多推导式内容可以参考：Python 推导式。

另外，字典类型也有一些内置的函数，例如 clear()、keys()、values() 等。

注意：

    1、字典是一种映射类型，它的元素是键值对。
    2、字典的关键字必须为不可变类型，且不能重复。
    3、创建空字典使用 { }。

bytes 类型

在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence）。

与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

创建 bytes 对象的方式有多种，最常见的方式是使用 b 前缀：

此外，也可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码：

1. x = bytes("hello", encoding="utf-8")

复制代码

与字符串类型类似，bytes 类型也支持许多操作和方法，如切片、拼接、查找、替换等等。同时，由于 bytes 类型是不可变的，因此在进行修改操作时需要创建一个新的 bytes 对象。例如：

实例

1. x = b"hello"
   
2. y = x[1:3]  # 切片操作，得到 b"el"
   
3. z = x + b"world"  # 拼接操作，得到 b"helloworld"

复制代码

需要注意的是，bytes 类型中的元素是整数值，因此在进行比较操作时需要使用相应的整数值。例如：

实例

1. x = b"hello"
   
2. if x[0] == ord("h"):
   
3.     print("The first element is 'h'")

复制代码

其中 ord() 函数用于将字符转换为相应的整数值。