1. number类型
Number 数字类型 (int float bool complex)
1.1 int整型
|
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
|
# int 整型 (正整型 0 负整型)intvar = 100print(intvar)# type 获取值得类型res = type(intvar)print(res)# id 获取值得地址res = id(intvar)print(res)# 二进制整型intvar = 0b110print(intvar)print( type(intvar) )print( id(intvar) )# 八进制整型intvar = 0o127print(intvar)print(type(intvar))print(id(intvar))# 十六进制intvar = 0xffintvar = 0XFFprint(intvar)print(type(intvar))print(id(intvar))"""二进制 1 + 1 = `10八进制 7 + 1 = 10十六进制 f + 1 = 10""" |
1.2 float浮点型（小数）
|
1
2
3
4
5
6
7
|
# 表达方式之一floatvar = 3.6print(floatvar , type(floatvar))# 表达方式2 科学计数法floatvar = 5.75e5 # 小数点右移5floatvar = 5.7e-2 # 小数点左移2print(floatvar, type(floatvar)) |
1.3 bool布尔型
|
1
2
3
4
|
# True 真的, False 假的boolvar = Trueboolvar = Falseprint(boolvar , type(boolvar)) |
1.4 复数类型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
"""3 + 4j实数+虚数实数: 3虚数: 4jj : 如果有一个数他的平方等于-1,那么这个数就是j , 科学家认为有,表达一个高精度的类型"""# 表达方式1complexvar = 3 + 4jcomplexvar = -3jprint(complexvar , type(complexvar))# 表达方法2 """complex(实数,虚数) => 复数"""res = complex(3,4)print(res , type(res)) |
2. 字符串类型
|
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
# ### 字符串类型 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)# 如果搞不清楚用什么占位符，可以无脑使用%sstrvar = "%s在水里%s被发现了，罚款%s元，并且做了%s俯卧撑." % ("小明", "尿尿", 500.129, 50000)print(strvar) |
3. 列表_元组_字符串
3.1 列表类型
|
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
|
"""特征: 可获取,可修改,有序"""# 1.定义一个空列表listvar = []print( listvar , type(listvar))# 定义普通列表listvar = [98,6.9,True,12-90j,"赵万里"]# 2.获取列表中的元素# 正向索引 0 1 2 3 4listvar = [98,6.9,True,12-90j,"赵万里"]# 逆向索引 -5 -4 -3 -2 -1res = 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 元组类型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
"""特征：可获取，不可修改，有序"""# 定义一个元组# 正向索引 0 1 2 3tuplevar = ("小赵","小钱","小孙","小李")# 逆向索引 -4 -3 -2 -1print(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 字符串类型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
"""特征：可获取，不可修改，有序"""# 正向索引# 0 1 2 3 4 5 6 7 8strvar = "看你,我就心跳加速"# -9-8-7-6-5-4-3-2-1# 逆向索引# 获取字符串中的元素print(strvar[3])print(strvar[-6])#不能修改字符串中的元素#strvar[3] = "你" errorprint("<=================>")strvar = "" # 单纯定义一个字符串类型print(strvar)print(type(strvar))strvar = " " # 字符串中含有3个空格字符print(strvar[0])print(type(strvar)) |
4. 集合_字典
4.1 集合类型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
"""特点：无序，自动去重"""# 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 字典类型
|
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
40
41
42
43
|
"""键值对存储的数据，表面上有序，本质上无序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. 变量的缓存机制
|
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
40
41
|
# ### 在同一文件中,变量的缓存机制 (仅仅针对python3.6版本负责)# 1.对于整型而言，-5~正无穷范围内的相同值 id一致var1 = 5var2 = 5var1 = -100var2 = -100print(id(var1) , id(var2) )# 2.对于浮点数而言，非负数范围内的相同值 id一致var1 = 4.67var2 = 4.67var1 = -4.67var2 = -4.67print(id(var1) , id(var2) )# 3.布尔值而言,值相同情况下，id一致var1 = Truevar2 = Trueprint(id(var1) , id(var2) )# 4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)var1 = 4 +5jvar2 = 4 +5j# 5j 情况下例外var1 = 5jvar2 = 5jvar1 = -5jvar2 = -5jprint(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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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
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
40
41
42
43
44
45
46
47
48
49
50
51
52
|
1.二进制表现的三种形式原码:用来显示 补码:用来存储计算 反码:用来转换原码反码正数 : 原码 = 反码 = 补码负数 : 原码和补码 互为取反 + 12.9原码: 000 ... 1001 反码: 000 ... 1001 补码: 000 ... 1001 -3原码 100 ... 011反码 111 ... 100补码 111 ... 101000 ... 1001 111 ... 1101000 ... 0110 => 6-9原码:100 ... 1001 反码:111 ... 0110补码:111 ... 01113原码 000 ... 011反码 000 ... 011补码 000 ... 011111 ... 0111000 ... 0011111 ... 1010 补码给你补码求原码补码:111 ... 1010反码:100 ... 0101原码:100 ... 0110 -63. 注释就是对代码的解释,用来方便大家阅读代码的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 = tmp9. int float complex bool str list tuple set dict10.f = 3.56 f = 3e4 f = 3e-4c = 3+4j c = complex(3,4)11.\n \t \r12."字符串" % (值1,值2 ... ) %d %f %s13.list : 可获取可修改有序 tuple/str:可获取,不可修改,有序 set:无序,自动去重 dict:键值对存储的数据,表面上有序,本质上无序14.空元祖 整型 字符串 元组15.可哈希不可修改的类型 Number str tuple16.lst[-1] lst[len(lst) - 1]17.int:-5~正无穷 float: 非负数 bool:值相同 complex:只有虚数例外,剩下都不一样 str:值相同即可 tuple:空元组即可 其他容器都不相同; |
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容!
原文链接：https://blog.csdn.net/weixin_46818279/article/details/120816641
