温馨提示：这篇文章已超过469天没有更新，请注意相关的内容是否还可用！
摘要：，，本文介绍了Python中的数据类型，包括基本数据类型如整数、浮点数、字符串等，以及复杂数据类型如列表、元组、字典和集合。文章详细解释了每种数据类型的特性和用法，并强调了数据类型在编程中的重要性和作用。掌握Python的数据类型，对于编写高效、可靠的Python程序至关重要。
Python-数据类型
- ■ 类型简介
- ■ Number（数字）
- ■ String（字符串）
- ■ Python 转义字符
- ■ Python 字符串运算符
- ■ Python 字符串格式化
- ■ Python三引号
- ■ f-string
- ■ bool（布尔类型）
- ■ List（列表）
- ■ 列表索引从 0 开始，第二个索引是 1
- ■ 从尾部开始，最后一个元素的索引为 -1，往前一位为 -2
- ■ 方括号 [] 的形式截取字符
- ■ 添加列表项（append() ）
- ■ 删除列表元素（del 语句）
- ■ 脚本操作符
- ■ 列表截取与拼接
- ■ 嵌套列表
- ■ 列表比较
- ■ 列表函数&方法
- ■ tuple（元组）
- ■ 示例
- ■ 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
- ■ 元组下标索引
- ■ 访问元组
- ■ 修改元组
- ■ 删除元组
- ■ 元组运算符
- ■ 元组索引，截取
- ■ 元组内置函数
- ■ Set（集合）
- ■ 实例演示：
- ■ 添加元素 add()
- ■ 添加元素 s.update( x ) 添加元素，且参数可以是列表，元组，字典
- ■ 移除元素 s.remove( x )
- ■ 移除集合中的元素s.discard( x )
- ■ 随机删除集合中的一个元素
- ■ 计算集合元素个数 len(s)
- ■ 清空集合 s.clear()
- ■ 判断元素是否在集合中存在 （x in s）
- ■ 集合内置方法完整列表
- ■ dict （字典）Dictionary
- ■ 示例 键值 key
- ■ 键值可以是数字，数据可以取任何数据类型加粗样式
- ■ 空字典
- ■ 访问字典里的值
- ■ 修改字典
- ■ 删除字典元素
- ■ 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
- ■ 字典内置函数&方法
- ■ 数据类型函数
- ■ 数学函数
- ■ 随机数函数
- ■ 三角函数
- ■ 数学常量
- ■ type() 查询变量所指的对象类型
- ■ isinstance（）判断类型
- ■ isinstance 和 type 的区别在于：
- ■ 数字运算
- ■ 数学函数
- ■ 随机数函数
- ■ 三角函数
- ■ 数学常量
■ 类型简介
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。
#!/usr/bin/python3 counter = 100 # 整型变量 miles = 1000.0 # 浮点型变量 name = "runoob" # 字符串 print (counter) print (miles) print (name) 输出如下 100 1000.0 runoob
■ Number（数字）
支持 int、float、bool、complex（复数）。
内置的 type() 函数可以用来查询变量所指的对象类型。
Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
>>> 17 / 3 # 整数除法返回浮点型 5.666666666666667 >>> >>> 17 // 3 # 整数除法返回向下取整后的结果 5 >>> 7 // 2 3 >>> 7.0 // 2 3.0 >>> 7 // 2.0 3.0 >>> 17 % 3 # ％操作符返回除法的余数 2 >>> 5 * 3 + 2 17 操作来进行幂运算： >>> 5 ** 2 #5 的平方 25 >>> 2 ** 7 #2的7次方 128 不同类型的数混合运算时会将整数转换为浮点数： >>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5
■ String（字符串）
Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
变量[头下标:尾下标]
#!/usr/bin/python3 str = 'Runoob' # 定义一个字符串变量 print(str) # Runoob # 打印整个字符串 print(str[0:-1]) # Runoo # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符） print(str[0]) # R # 打印字符串的第一个字符 print(str[2:5]) # noo # 打印字符串第三到第五个字符（包含第五个字符） print(str[2:]) # noob # 打印字符串从第三个字符开始到末尾 print(str * 2) # RunoobRunoob # 打印字符串两次 print(str + "TEST") # RunoobTEST # 打印字符串和"TEST"拼接在一起
■ Python 转义字符
runoob
■ Python 字符串运算符
runoob
■ Python 字符串格式化
runoob
■ Python三引号
runoob
■ f-string
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去
>>> name = 'Runoob' >>> f'Hello {name}' # 替换变量 'Hello Runoob' >>> f'{1+2}' # 使用表达式 '3' >>> w = {'name': 'Runoob', 'url': 'www.runoob.com'} >>> f'{w["name"]}: {w["url"]}' 'Runoob: www.runoob.com'在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：
>>> x = 1 >>> print(f'{x+1}') # Python 3.6 2 >>> x = 1 >>> print(f'{x+1=}') # Python 3.8 x+1=2■ bool（布尔类型）
■ List（列表）
■ 列表索引从 0 开始，第二个索引是 1
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[0] ) print( list[1] ) print( list[2] ) 实例输出结果： red green blue
■ 从尾部开始，最后一个元素的索引为 -1，往前一位为 -2
list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[-1] ) print( list[-2] ) print( list[-3] ) 实例输出结果： black white yellow
■ 方括号 [] 的形式截取字符
#!/usr/bin/python3 nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] print(nums[0:4]) 以上实例输出结果： [10, 20, 30, 40]
负数索引值截取：
#!/usr/bin/python3 list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"] # 读取第二位 print ("list[1]: ", list[1]) # 从第二位开始（包含）截取到倒数第二位（不包含） print ("list[1:-2]: ", list[1:-2]) 以上实例输出结果： list[1]: Runoob list[1:-2]: ['Runoob', 'Zhihu']■ 添加列表项（append() ）
#!/usr/bin/python3 list = ['Google', 'Runoob', 1997, 2000] print ("第三个元素为 : ", list[2]) list[2] = 2001 print ("更新后的第三个元素为 : ", list[2]) 例输出结果： 第三个元素为 : 1997 更新后的第三个元素为 : 2001list1 = ['Google', 'Runoob', 'Taobao'] list1.append('Baidu') print ("更新后的列表 : ", list1) 例输出结果： 更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']■ 删除列表元素（del 语句）
#!/usr/bin/python3 list = ['Google', 'Runoob', 1997, 2000] print ("原始列表 : ", list) del list[2] print ("删除第三个元素 : ", list) 实例输出结果： 原始列表 : ['Google', 'Runoob', 1997, 2000] 删除第三个元素 : ['Google', 'Runoob', 2000]■ 脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
Python 表达式 结果 描述 len([1, 2, 3]) 3 长度 [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合 [‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 重复 3 in [1, 2, 3] True 元素是否存在于列表中 for x in [1, 2, 3]: print(x, end=" ") 1 2 3 迭代 ■ 列表截取与拼接
■ 嵌套列表
>>> a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'
■ 列表比较
# 导入 operator 模块 import operator a = [1, 2] b = [2, 3] c = [2, 3] print("operator.eq(a,b): ", operator.eq(a,b)) print("operator.eq(c,b): ", operator.eq(c,b)) 以上代码输出结果为： operator.eq(a,b): False operator.eq(c,b): True■ 列表函数&方法
■ tuple（元组）
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
■ 示例
>>> tup1 = ('Google', 'Runoob', 1997, 2000) >>> tup2 = (1, 2, 3, 4, 5 ) >>> tup3 = "a", "b", "c", "d" # 不需要括号也可以 >>> type(tup3)■ 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
>>> tup1 = (50) >>> type(tup1) # 不加逗号，类型为整型 >>> tup1 = (50,) >>> type(tup1) # 加上逗号，类型为元组
■ 元组下标索引
■ 访问元组
#!/usr/bin/python3 tup1 = ('Google', 'Runoob', 1997, 2000) tup2 = (1, 2, 3, 4, 5, 6, 7 ) print ("tup1[0]: ", tup1[0]) print ("tup2[1:5]: ", tup2[1:5]) 以上实例输出结果： tup1[0]: Google tup2[1:5]: (2, 3, 4, 5)■ 修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，
#!/usr/bin/python3 tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3) 实例输出结果： (12, 34.56, 'abc', 'xyz')■ 删除元组
#!/usr/bin/python3 tup = ('Google', 'Runoob', 1997, 2000) print (tup) del tup print ("删除后的元组 tup : ") print (tup) 输出如下所示： 删除后的元组 tup : Traceback (most recent call last): File "test.py", line 8, in print (tup) NameError: name 'tup' is not defined■ 元组运算符
■ 元组索引，截取
Python表达式 结果 描述 tup[1] ‘Runoob’ 读取第二个元素 tup[-2] ‘Weibo’ 反向读取，读取倒数第二个元素 tup[1:] (‘Runoob’, ‘Taobao’, ‘Wiki’, ‘Weibo’, ‘Weixin’) 截取元素，从第二个开始后的所有元素。 tup[1:4] (‘Runoob’, ‘Taobao’, ‘Wiki’) 截取元素，从第二个开始到第四个元素（索引为 3）。 >>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin') >>> tup[1] 'Runoob' >>> tup[-2] 'Weibo' >>> tup[1:] ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin') >>> tup[1:4] ('Runoob', 'Taobao', 'Wiki') >>>■ 元组内置函数
关于元组是不可变的
>>> tup = ('r', 'u', 'n', 'o', 'o', 'b') >>> tup[0] = 'g' # 不支持修改元素 Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment >>> id(tup) # 查看内存地址 4440687904 >>> tup = (1,2,3) >>> id(tup) 4441088800 # 内存地址不一样了从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。
■ Set（集合）
集合（set）是一个无序的不重复元素序列。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。
创建格式： parame = {value01,value02,...} 或者 set(value) 以下是一个简单实例： set1 = {1, 2, 3, 4} # 直接使用大括号创建集合 set2 = set([4, 5, 6, 7]) # 使用 set() 函数从列表创建集合 注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。■ 实例演示：
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} >>> print(basket) # 这里演示的是去重功能 {'orange', 'banana', 'pear', 'apple'} >>> 'orange' in basket # 快速判断元素是否在集合内 True >>> 'crabgrass' in basket False >>> # 下面展示两个集合间的运算. ... >>> a = set('abracadabra') >>> b = set('alacazam') >>> a {'a', 'r', 'b', 'c', 'd'} >>> a - b # 集合a中包含而集合b中不包含的元素 {'r', 'd', 'b'} >>> a | b # 集合a或b中包含的所有元素 {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'} >>> a & b # 集合a和b中都包含了的元素 {'a', 'c'} >>> a ^ b # 不同时包含于a和b的元素 {'r', 'd', 'b', 'm', 'z', 'l'}■ 添加元素 add()
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.add("Facebook") >>> print(thisset) {'Taobao', 'Facebook', 'Google', 'Runoob'}■ 添加元素 s.update( x ) 添加元素，且参数可以是列表，元组，字典
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.update({1,3}) >>> print(thisset) {1, 3, 'Google', 'Taobao', 'Runoob'} >>> thisset.update([1,4],[5,6]) >>> print(thisset) {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'} >>>■ 移除元素 s.remove( x )
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.remove("Taobao") >>> print(thisset) {'Google', 'Runoob'} >>> thisset.remove("Facebook") # 不存在会发生错误 Traceback (most recent call last): File "", line 1, in KeyError: 'Facebook' >>>■ 移除集合中的元素s.discard( x )
s.discard( x )是移除集合中的元素且如果元素不存在，不会发生错误.
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.discard("Facebook") # 不存在不会发生错误 >>> print(thisset) {'Taobao', 'Google', 'Runoob'}■ 随机删除集合中的一个元素
thisset = set(("Google", "Runoob", "Taobao", "Facebook")) x = thisset.pop() print(x) 输出结果： Runoob■ 计算集合元素个数 len(s)
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> len(thisset) 3■ 清空集合 s.clear()
清空集合 s。
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.clear() >>> print(thisset) set()■ 判断元素是否在集合中存在 （x in s）
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> "Runoob" in thisset True >>> "Facebook" in thisset False >>>■ 集合内置方法完整列表
■ dict （字典）Dictionary
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
■ 示例 键值 key
d = {key1 : value1, key2 : value2, key3 : value3 }
■ 键值可以是数字，数据可以取任何数据类型加粗样式
tinydict1 = { 'abc': 456 } tinydict2 = { 'abc': 123, 98.6: 37 }■ 空字典
emptyDict = {} # 使用大括号 {} 来创建空字典
emptyDict = dict() # 使用内建函数 dict() 创建字典
emptyDict = {} # 使用大括号 {} 来创建空字典 # emptyDict = dict() # 使用内建函数 dict() 创建字典 # 打印字典 print(emptyDict) # 查看字典的数量 print("Length:", len(emptyDict)) # 查看类型 print(type(emptyDict)) 以上实例输出结果： {} Length: 0■ 访问字典里的值
#!/usr/bin/python3 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} print ("tinydict['Name']: ", tinydict['Name']) print ("tinydict['Age']: ", tinydict['Age']) 以上实例输出结果： tinydict['Name']: Runoob tinydict['Age']: 7■ 修改字典
#!/usr/bin/python3 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} tinydict['Age'] = 8 # 更新 Age tinydict['School'] = "菜鸟教程" # 添加信息 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School']) 实例输出结果： tinydict['Age']: 8 tinydict['School']: 菜鸟教程■ 删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显式删除一个字典用del命令，如下实例：
#!/usr/bin/python3 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} del tinydict['Name'] # 删除键 'Name' tinydict.clear() # 清空字典 del tinydict # 删除字典 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School']) 但这会引发一个异常，因为用执行 del 操作后字典不再存在： Traceback (most recent call last): File "/runoob-test/test.py", line 9, in print ("tinydict['Age']: ", tinydict['Age']) NameError: name 'tinydict' is not defined■ 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
#!/usr/bin/python3 tinydict = {['Name']: 'Runoob', 'Age': 7} print ("tinydict['Name']: ", tinydict['Name']) 以上实例输出结果： Traceback (most recent call last): File "test.py", line 3, in tinydict = {['Name']: 'Runoob', 'Age': 7} TypeError: unhashable type: 'list'■ 字典内置函数&方法
■ 数据类型函数
■ 数学函数
■ 随机数函数
■ 三角函数
■ 数学常量
■ type() 查询变量所指的对象类型
>>> a, b, c, d = 20, 5.5, True, 4+3j >>> print(type(a), type(b), type(c), type(d))
■ isinstance（）判断类型
>>> a = 111 >>> isinstance(a, int) True >>>
■ isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
■ 数字运算
>>> 5 + 4 # 加法 9 >>> 4.3 - 2 # 减法 2.3 >>> 3 * 7 # 乘法 21 >>> 2 / 4 # 除法，得到一个浮点数 0.5 >>> 2 // 4 # 除法，得到一个整数 0 >>> 17 % 3 # 取余 2 使用 ** 操作来进行幂运算： >>> 2 ** 5 # 乘方 32 >>> 5 ** 2 # 5 的平方 25 >>> 2 ** 7 # 2的7次方 128 混合运算时会将整数转换为浮点数： >>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5
■ 数学函数
■ 随机数函数
■ 三角函数
■ 数学常量
文章版权声明：除非注明，否则均为VPS857原创文章，转载或复制请以超链接形式并注明出处。
还没有评论，来说两句吧...