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:空元组即可 其他容器都不相同;

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!