Python全栈之基本数据类型
作者：熬夜泡枸杞
这篇文章主要为大家介绍了Python基本数据类型，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助
1. number类型
Number 数字类型 (int float bool complex)
1.1 int整型
# int 整型 (正整型 0 负整型) intvar = 100 print(intvar) # type 获取值得类型 res = type(intvar) print(res) # id 获取值得地址 res = id(intvar) print(res) # 二进制整型 intvar = 0b110 print(intvar) print( type(intvar) ) print( id(intvar) ) # 八进制整型 intvar = 0o127 print(intvar) print(type(intvar)) print(id(intvar)) # 十六进制 intvar = 0xff intvar = 0XFF print(intvar) print(type(intvar)) print(id(intvar)) """ 二进制 1 + 1 = `10 八进制 7 + 1 = 10 十六进制 f + 1 = 10 """
1.2 float浮点型（小数）
# 表达方式之一 floatvar = 3.6 print(floatvar , type(floatvar)) # 表达方式2 科学计数法 floatvar = 5.75e5 # 小数点右移5 floatvar = 5.7e-2 # 小数点左移2 print(floatvar, type(floatvar))
1.3 bool布尔型
# True 真的, False 假的 boolvar = True boolvar = False print(boolvar , type(boolvar))
1.4 复数类型
""" 3 + 4j 实数+虚数 实数: 3 虚数: 4j j : 如果有一个数他的平方等于-1,那么这个数就是j , 科学家认为有,表达一个高精度的类型 """ # 表达方式1 complexvar = 3 + 4j complexvar = -3j print(complexvar , type(complexvar)) # 表达方法2 """ complex(实数,虚数) => 复数 """ res = complex(3,4) print(res , type(res))
2. 字符串类型
# ### 字符串类型 str
"""
用引号引起来的就是字符串，单引号，双引号，三引号
# 转移字符 \ + 字符串类型
(1) 可以将无意义的字符变的有意义
(2) 可以将有意义的字符变的无意义
\n : 换行
\r\n : 换行
\t : 缩进（水平制表符）
\r : 将\r后面的字符串拉到了当前行的行首
"""
# 1. 单引号的字符串
strvar = '生活不知眼前的苟且'
print(strvar , type(strvar))
# 2. 双引号的字符串
strvar = "还有诗和远方的田野"
print(strvar , type(strvar))
# 可以将无意义的字符变得有意义
strvar = "还有诗和\n远方的田野"
print(strvar)
strvar = "还有诗和\r\n远方的田野"
strvar = "还有诗和\t远方的田野"
strvar = "还有诗和\r远方的田野"
strvar = "还有诗和\n远方的\r田野"
# 可以将有意义的字符变得无意义
strvar = "还有诗和\"远\"方的田野"
print(strvar)
strvar = '''
"生活就像醉酒"
表面上'不'要
身体却很诚实
'''
print(strvar)
# 元字符串 r"字符串" 原型化输出字符串
strvar = " D:\nython32_python\tay02"
strvar = r" D:\nython32_python\tay02"
print(strvar)
# 5. 字符串的格式化
"""
%d 整型占位符
%f 浮点型占位符
%s 字符串占位符
语法格式：
"字符串" % （值1，值2）
"""
# %d 整型占位符
strvar = "小明昨天买了%d风油精，洗澡" % (2)
print(strvar)
# %2d 占两位（不够两位拿空格来补位）原字符串具右
strvar = "小明昨天买了%2d风油精，洗澡" % (2)
print(strvar)
# %-2d 占两位（不够两位拿空格来补位）原字符串具左
strvar = "小明昨天买了%-2d风油精，洗澡" % (2)
print(strvar)
# %f 浮点型占位符
strvar = "小明一个月开%f工资" % (9.9)
print(strvar)
# %.2f 保留小数点后面两位小数（存在四舍五入的情况，默认保留六位小数）
strvar = "小明一个月开%.2f工资" % (9.178)
print(strvar)
# %s字符串占位符
strvar = "%s最喜欢在电影院尿尿" % ("小明")
print(strvar)
# 综合案例
strvar = "%s在水里%s被发现了，罚款%.2f元，并且做了%d俯卧撑." % ("小明","尿尿",500.129,50000)
print(strvar)
# 如果搞不清楚用什么占位符，可以无脑使用%s
strvar = "%s在水里%s被发现了，罚款%s元，并且做了%s俯卧撑." % ("小明", "尿尿", 500.129, 50000)
print(strvar)
3. 列表_元组_字符串
3.1 列表类型
"""特征: 可获取,可修改,有序""" # 1.定义一个空列表 listvar = [] print( listvar , type(listvar)) # 定义普通列表 listvar = [98,6.9,True,12-90j,"赵万里"] # 2.获取列表中的元素 # 正向索引 0 1 2 3 4 listvar = [98,6.9,True,12-90j,"赵万里"] # 逆向索引 -5 -4 -3 -2 -1 res = listvar[2] res = listvar[-2] print(res) # 通用写法 # len 获取容器类型数据中元素个数 length = len(listvar) res = listvar[length-1] print(res) # 简写 res = listvar[len(listvar)-1] print(res) # python逆向索引的特点,瞬间得到列表中最后一个元素 print(listvar[-1]) # 3.修改列表中的元素 listvar = [98,6.9,True,12-90j,"赵万里"] listvar[3] = "大象" print(listvar)
3.2 元组类型
"""特征：可获取，不可修改，有序"""
# 定义一个元组
# 正向索引 0 1 2 3
tuplevar = ("小赵","小钱","小孙","小李")
# 逆向索引 -4 -3 -2 -1
print(tuplevar[2])
print(tuplevar[-1])
# 修改元组中的元素：元组中的值不能修改
# tuple[0] = "萌不好心" error
# 注意点
""" 逗号才是区分是否是元组的标识符"""
tuplevar = (8.9,)
tuplevar = 8.1,
print(tuplevar)
print(type(tuplevar))
# 定义空元组
tuplevar = ()
print(type(tuplevar))
3.3 字符串类型
"""特征：可获取，不可修改，有序"""
# 正向索引
# 0 1 2 3 4 5 6 7 8
strvar = "看你,我就心跳加速"
# -9-8-7-6-5-4-3-2-1
# 逆向索引
# 获取字符串中的元素
print(strvar[3])
print(strvar[-6])
#不能修改字符串中的元素
#strvar[3] = "你" error
print("<=================>")
strvar = "" # 单纯定义一个字符串类型
print(strvar)
print(type(strvar))
strvar = " " # 字符串中含有3个空格字符
print(strvar[0])
print(type(strvar))
4. 集合_字典
4.1 集合类型
"""特点：无序，自动去重"""
# 1. 集合无序
setvar = {"巨石强森","史泰龙","施瓦辛格","小明"}
print(setvar,type(setvar))
# 获取集合中的元素，不可以
# setvar[0] error
# 修改集合中的元素，不可以
# setvar[2] = 111
# 2. 集合自动去重
setvar = {"巨石强森","史泰龙","史泰龙","施瓦辛格","小明"}
print(setvar , type(setvar))
# 3. 定义一个空集合
setvar = set()
print(setvar , type(setvar))
4.2 字典类型
"""
键值对存储的数据，表面上有序，本质上无序
dicvar = {键1:值1，键2:值2，...}
3.6版本之前，完全无序
3.6版本之后，存储的时候，保留了字典的字面顺序，在获取内存中数据时
重新按照字面顺序做了排序，所以看起来有序，实际上存储时还是无序
"""
# 1. 定义一个字段
dictvar = {"top":"the shy","middle":"肉鸡","bottom":"jacklove","jungle":"臭鞋","support":"水稻"}
print(dictvar, type(dictvar))
# 2. 获取字典中的值
res = dictvar["middle"]
print(res)
res = dictvar["jungle"]
print(res)
# 3. 修改字典中的值
dictvar["top"] = "the xboy"
print(dictvar)
# 4. 定义空字典
dicvar = {}
print(dicvar,type(dictvar))
"""
字典的键 和 集合的值，有数据类型上的要求：
(允许的类型范围)不可变的类型：Number(int float complex bool) str tuple
(不允许的类型)可变的类型：list set dict
哈希算法的提出目的是让数据尽量均匀的咋i内存当中分配，以减少哈希碰撞，提升存储分配的效率；
哈希算法一定是无序的散列，所以集合和字典都是无序
字典的键有要求，值没要求
字典的值可以任意换掉，但是键不可以
"""
# 允许的类型范围
dictvar = {1:"abc",4.89:111,False:333,3+90j:666,"小明":"你好帅",(1,2,3,4,5,6):9999}
print(dictvar)
print(dictvar[(1,2,3,4,5,6)])
# dictvar = {[1,2,3]:123} error
# 允许的类型范围
setvar = {1,"a",4.56,9+3j,False,(1,2,3)}
print(setvar , type(setvar))
# 总结：
"""
无论是变量缓存机制还是小数据池的驻留机制，
都是为了节省内存空间
"""
5. 变量的缓存机制
# ### 在同一文件中,变量的缓存机制 (仅仅针对python3.6版本负责) # 1.对于整型而言，-5~正无穷范围内的相同值 id一致 var1 = 5 var2 = 5 var1 = -100 var2 = -100 print(id(var1) , id(var2) ) # 2.对于浮点数而言，非负数范围内的相同值 id一致 var1 = 4.67 var2 = 4.67 var1 = -4.67 var2 = -4.67 print(id(var1) , id(var2) ) # 3.布尔值而言,值相同情况下，id一致 var1 = True var2 = True print(id(var1) , id(var2) ) # 4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外) var1 = 4 +5j var2 = 4 +5j # 5j 情况下例外 var1 = 5j var2 = 5j var1 = -5j var2 = -5j print(id(var1) ,id(var2)) # -->容器类型部分 # 5.字符串 和 空元组 相同的情况下，地址相同 var1 = "你" var2 = "你" var1 = () var2 = () print(id(var1) ,id(var2)) # 6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外] var1 = (1,2) var2 = (1,2) var1 = [1,2,3] var2 = [1,2,3] print(id(var1) ,id(var2)) # 不同文件（模块）里，部分数据驻留小数据池中（仅对python3.6负责，了解）
6. 小练习
题目如下：
1. 什么是原码反码补码 2. 计算9 + (-3) 以及 -9 + (3) 3. 什么是注释 4. 注释种类 5. 如何用注释排错 6. 如何定义变量 7. 变量命名 8. 如何交换变量 9. Python6大标准数据类型 10. 浮点型和复数的两种表达方法 11. 写出三个转义字符，含义 12. 简述如何使用字符串的格式化占位符 13. 简述容器类型各个特征 14. 以下各是什么类型：() , (1) , （"abc"） , (False,) 15. 字典的键和集合的值有什么要求 16. 用几种方式获取列表中的最后一个元素 17. 3.6版本中，变量的缓存机制有哪些
解答如下：
1.二进制表现的三种形式 原码:用来显示 补码:用来存储计算 反码:用来转换原码反码 正数 : 原码 = 反码 = 补码 负数 : 原码和补码 互为取反 + 1 2. 9 原码: 000 ... 1001 反码: 000 ... 1001 补码: 000 ... 1001 -3 原码 100 ... 011 反码 111 ... 100 补码 111 ... 101 000 ... 1001 111 ... 1101 000 ... 0110 => 6 -9 原码:100 ... 1001 反码:111 ... 0110 补码:111 ... 0111 3 原码 000 ... 011 反码 000 ... 011 补码 000 ... 011 111 ... 0111 000 ... 0011 111 ... 1010 补码 给你补码求原码 补码:111 ... 1010 反码:100 ... 0101 原码:100 ... 0110 -6 3. 注释就是对代码的解释,用来方便大家阅读代码的 4. 注释种类:单行注释 多行注释 5. 包裹代码划分范围,依次缩小范围找单行错误 6. a =1 ,b = 2,a,b = 3,4 a=b=100 7. 字母数字下划线,首字符不能为数字,严格区分大小写,不能使用关键字,变量命名有意义,且不能使用中文哦 8. (1) a,b = b,a (2)tmp = a a = bb = tmp 9. int float complex bool str list tuple set dict 10. f = 3.56 f = 3e4 f = 3e-4 c = 3+4j c = complex(3,4) 11.\n \t \r 12."字符串" % (值1,值2 ... ) %d %f %s 13.list : 可获取可修改有序 tuple/str:可获取,不可修改,有序 set:无序,自动去重 dict:键值对存储的数据,表面上有序,本质上无序 14.空元祖 整型 字符串 元组 15.可哈希不可修改的类型 Number str tuple 16.lst[-1] lst[len(lst) - 1] 17.int:-5~正无穷 float: 非负数 bool:值相同 complex:只有虚数例外,剩下都不一样 str:值相同即可 tuple:空元组即可 其他容器都不相同;
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容!