python学习之基本数据类型
一、基本数据类型
1、整形-int
2、字符串-str
3、布尔值-bool
4、列表-list
5、元组-tuple
6、字典-dict
二、整形数据类型——int
在python3中，整数类型的值不论有多大，都是属于int。
在python2中，整数类型的值在一定的范围内数据类型为int；超出了这个范围的数据类型为long长整形。
其实在java的数据类型中也是有int、long、short类型的划分，但是具体的划分标准没有深入的了解，等对python有了一定的了解后再回顾进行编辑。
1 a = 123 2 print(a)
1、int方法罗列
（1）、int.bit_length()：计算出该整形数以二进制表示出来需要使用多少位二进制——至少使用多少位二进制来进行表示
1 a = 123 2 # a_binary表示整型数a的二进制 3 # a_length 表示整型数a以二进制显示需要多少位二进制 4 a_binary = bin(a) 5 a_length = a.bit_length() 6 print(a, a_binary ,a_length) 7 # 运行结果为：123 0b1111011 7；其中a_binary的值0b111101中的0b表示以二进制表示
2、str：字符串类型转换为int：整型
1 a = "123" 2 # 将字符串123转化为整型123 3 b = int(a) 4 # 从打印结果可以a：123为str类型 5 # b： 123为int类型 6 print(a,type(a)) 7 print(b,type(b)) 8 # 打印结果为：123 <class 'str'> 9 # 123 <class 'int'>
注：type（）：可以输出值的数据类型；
3、字符串str转换为int（2）
1 a = "100111" 2 # 如果直接书写为int（a）表示为默认以10进制的方式进行转换 3 a_10 = int(a) 4 # base=2以二进制的方式进行转换 5 a_2 = int(a,base=2) 6 # base=16以16进制的方式进行转换 7 a_16 = int(a,base=16) 8 print(a_10,a_2,a_16)
三、字符串str
在str字符串的方法中如果参数=none表示该参数可有可无，不是必须要写入的参数
1、capitalize ：将字符串的首字符大写，其余字符小写；
用法：a.capitalize()
1 name = "tENgjiAng" 2 # 将字符串的第一个字符大写，其余小写 3 a = name.capitalize() 4 print(a) 5 #输出结果如下：Tengjiang
2、casefold/lower：将字符串全部转换为小写
用法：b.casefold() b.lower()
1 name = "tENgjiAng" 2 b = name.casefold() 3 # b = name.lower() 4 print(b) 5 #输出结果：tengjiang
name = "tENgjiAng" # 将字符串的第一个字符大写，其余小写 b = name.lower() print(b) # 输出结果：tengjiang
注：casefole与lower方法比较：
从代码执行的结果可以看出两方法结果是一致的，说明两者的功能是一样的；
区别：casefold方法更全面，很多未知的大小写对应关系都可以进行转换；
lower方法只能对通俗的英文大小写进行转换；
3、center：将字符串居中，指定参数可以指定长度内居中并将空白处用指定的字符填充
用法：a_center = a.center(20,"*")将字符串a在长度20的范围内居中，并用“*”号将空白处填充
1 # 字符串a 2 a = "it's ends" 3 # 在长度为20的字符串里面居中a字符串并用*号填充空白 4 a_center = a.center(20,"*") 5 # a_center_len统计a_center的长度是否为20； 6 a_center_len = a_center.__len__() 7 print(a_center,a_center_len) 8 # 输出结果：*****it's ends****** 20
注：从输出结果中可以看出当剩余的空白为偶数：两边填充的字符一样；
当剩余的空白为奇数时，左边填充少于到右边填充数
4、count：计算子字符串在字符串中出现的次数
使用方法：a.count("b"，5,6)计算字符b在字符串a中从第5到第6个字符中出现的次数
1 a = "chongbqing" 2 a_count = a.count("b",5,5) 3 a_count1 = a.count("b",5,6) 4 # 输入串结果分别为：0 1 5 print(a_count,a_count1) 6 # 从结果中可以看出5、6是值的是字符串a的脚标
5、encode、decode
该方法还未学习到，暂时先搁置在这儿
6、endswith：判断是否字符串是否以子字符串结束，返回布尔值
使用方法：a.endswith("b")，也是可以写入其他参数的：开始位置，结束位置
a = "chongqing" a_endswith1 = a.endswith("g") a_endswith2 = a.endswith("ing") a_endswith3 = a.endswith("q") print(a_endswith1,a_endswith2,a_endswith3) # 输出结果为：True True False
7、startwith：判断字符串是否以子字符串、字符开始，返回布尔值
使用方法：a.startwith("b"),
代码同endswith，在此就不在贴码了
8、find：从首字符往后查找，找到第一个后，获取位置，不在继续查找；输出结果返回index，结果为-1表示在指定的位置没有找到
使用方法：a.find("substr",start,end)
1 a = "chongqing" 2 b = a.find("ing",4) 3 b = a.find("ing",4,8) 4 print(b) 5 # 输出结果为：6 6 # 从结果可以看出参数缺省end参数,表示查找到字符串末尾；
9、format：格式化，将一个字符串的占位符替换为指定的值
1 a = "I am {name},{age},from {address}" 2 print(a) 3 v = a.format(name="tengjiang",age=19,address="chongqing") 4 # 运行v1的时候报错了，提示keyerror：'address',说明format方法的占位符必须全部要一一对应 5 # v1 = a.format(name="tengjiang",age=19) 6 print(v) 7 # 输出结果：I am {name},{age},from {address} 8 # I am tengjiang,19,from chongqing
10、format_map：该方法没有搞懂，待搞懂了在回顾补充
11、index：与find功能一致，唯一的区别在于index找不到要报错，而find方法找不到返回的值为-1
1 a = "chongqing" 2 # 我没有搞懂为什么b = a.index("ng",5,8)会报错；b1 = a.index("ng",5)我采用这种格式就能找到 3 # b = a.index("ng",5,8) 4 b1 = a.index("ng",5) 5 b2 = a.index("ng") 6 b3 = a.index("ng",4) 7 # b4也是错误的，为什么呢，没搞懂，在builtins.py中index的格式也是start与end参数的 8 # 原因排查：a、我格式是书写正确了的； 9 # 原因排查：b、我的脚标是8是没有超出字符串a的脚标的最大长度的，因为在java中当数组的脚标超出了字符串脚标的最大长度时，是会报错的 10 # 原因排查：c、在网上查询后，还是没有找到原因 11 # 原因排查：d、将参数end=8换成a._len_()结果执行成功了 12 # 原因排查：e、计算字符串a的长度确认是否等于8：b6 =a.__len__():输出结果为9，那说明字符串a的脚标最大为8是没有问题的啊 13 #b4= a.index("ng",5,8) 14 b6 =a.__len__() 15 b5 = a.index("ng",4,a.__len
1 a = "123" 2 v = a.isalnum() 3 print(v) #输出结果为：True 4 a = "sbd c" 5 v = a.isalnum() 6 print(v) #False
__()) 16 print(b6) 17 print(b1,b2,b3,b5) 18 # 输出的结果为：9 字符串a的长度 19 # 输出的结果为：7 3 7 7
注：# b = a.index("ng",5,8)语句报错，还未解决!
####后期咨询验证，了解到a.index("ng",5,8)表示的范围为5<=index<8,是没有包含脚标8的；
12、isalnum：用来判断字符串是否全部为数字或者字母，返回布尔值；；如果有其他字符或者空格（返回false）
1 a = "sbd" 2 v = a.isalnum() 3 print(v) #返回：True 4 5 # a = " teng " 6 # # print(a.isalnum()) #返回：False
13、isalpha：用来判断字符串是否由字母组成；返回布尔值
1 a = "adb" 2 v = a.isalpha() 3 print(v) #返回True 4 # a = " adb" 5 # v = a.isalpha() 6 # print(v) #返回False
14、isdecimal：判断字符串是否为十进制的数字；
isdigit：判断字符串是否为十进制的数字，还可以判断特殊的数字编号如：②
isnumeric：判断是否为十进制的数字，可以判断特殊的数字编号：②，还可以判断中文的数字如：二、十
1 ######isdecimal####### 2 # a = "123" 3 # v1 = a.isdecimal() #返回True 4 # a = "②" 5 # v1 = a.isdecimal() #返回False 6 a = "二" 7 v1 = a.isdecimal() #返回False 8 print(v1) 9 ########isdigit####### 10 a = "123" 11 v1 = a.isdigit() #返回True 12 # a = "②" 13 # v1 = a.isdigit() #返回True 14 # a = "二" 15 # v1 = a.isdigit() #返回False 16 print(v1) 17 ########isnumeric######### 18 19 # a = "123" 20 # v1 = a.isnumeric() #返回True 21 # a = "②" 22 # v1 = a.isnumeric() #返回True 23 a = "二" 24 v1 = a.isnumeric() #返回True 25 print(v1)
15、isidentifier 判断是否为标识符
标识符：
在python里，标识符有字母、数字、下划线组成。
在python中，所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头。
python中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头（_foo）的代表不能直接访问的类属性，需通 过类提供的接口进行访问，不能用"from xxx import *"而导入；
以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里 特殊方法专用的标识，如__init__（）代表类的构造函数
备注：该标识符摘自：https://www.cnblogs.com/liuzhenhua0122/p/6682159.html
1 a = "sum" 2 v = a.isidentifier() 3 print(v) #输出True
16、islower：判断是否是小写
isupper：判断是否为大写
# a = "sum" # v = a.islower() # print(v) #输出True a = "sum" v = a.isupper() print(v) # 输出False
17、isprintable：判断打印时是否有不显示的字符
a = "abc\tefg\nmail" print(a.isprintable()) # 输出False print(a) #输出 abc efg #输出 mail
18、isspace判断是否为空格
1 # a = " " 2 # print(a.isspace()) # 输出True 3 # a = "abc " 4 # print(a.isspace()) # 输出False 5 a = "a sbc" 6 print(a.isspace()) # 输出False
19、istitle判断是否为标题
标题首字符全部大写
1 # a = "This Is An Apple" 2 # print(a.istitle()) #输出True 3 a = "This Is An apple" 4 print(a.istitle()) # 输出False
20、join将字符串中的每个元素按照按照指定的分隔符进行拼接******
1 a = "别问我花儿是为谁红" 2 # a_join =" ".join(a) 3 # print(a_join) #输出：别 问 我 花 儿 是 为 谁 红 4 a_join1 = "_".join(a) 5 print(a_join1) #输出：别_问_我_花_儿_是_为_谁_红
21、ljust：对字符串左边使用指定字符填充
rjust：对字符串右边使用指定字符串填充
zfill：指定0进行填充
center：
1 a = "python" 2 # v = a.center(20,"*") #输出：*******python******* 3 # v = a.ljust(20,"*") #输出：python************** 4 # v = a.rjust(20,"*") #输出：**************python 5 v = a.zfill(20) #输出：00000000000000python 6 # 指定0进行填充，该方法不常用，因为center、ljust、rjust已经能够满足所有的填充要求 7 print(v)
22、lower：转换为小写
upper：转换为大写
#我们平时输入网址时输入大写和小写都是可以进行访问的，因为提交时就已经转换为小写了！
#在登录时，账号输入大小写也是可以进行登录，也是因为提交时进行转换了的，这种很少见！
23、strip：默认清除所有的空格；指定参数，去除指定参数、指定子字符串；
lstrip：默认清除左边的空格、\t、\n；指定参数，去除左边指定参数、指定子字符串；从左边开始找，找到第一个就不在继续查找去除；
rstrip：默认清除右边的空格、\n、\t；指定参数，去除右边指定参数、指定子字符串；从右边开始找，找到第一个就不在继续查找去除；
1 a1 = "pythonpy" 2 # print(a1.strip("py")) #输出结果为：thon 3 # print(a1.lstrip("py")) #ss输出结果为：thonpy 4 print(a1.rstrip("py")) #输出结果为：python
24、maketrans：创建对应关系，然后使用traslate进行替换
1 a = "pathon" 2 v = str.maketrans("a","y") 3 new_v = a.translate(v) 4 print(new_v) #输出：python
25、partition：按照指定字符进行分割：从左边往右边找到第一个指定字符然后分割；
rpartition：按照指定字符进行分割：从右边往左边找到第一个指定字符然后分割；
#两者都保留了指定分割符
1 a = "pathon_pycharm_day11" 2 # v = a.partition("_") #输出：('pathon', '_', 'pycharm_day11') 3 v = a.rpartition("_") #输出：('pathon_pycharm', '_', 'day11') 4 print(v)
26、split：按照指定分隔符分割，分割符去掉
rsplit：按照指定分隔符分割，分隔符去掉
ps：partiton与split功能的结合就是正则表达式的应用
1 a = "pathon_pycharm_day11" 2 # v = a.split("_") #输出：['pathon', 'pycharm', 'day11'] <class 'list'> 3 4 # "_"指定分隔符；1为从左边往右边找，找到第一个就停止继续查找 5 # v = a.split("_",1) #输出：['pathon', 'pycharm_day11'] <class 'list'> 6 7 # "_"指定分隔符；1为从右边往左边找，找到第一个就停止继续查找 8 # v = a.rsplit("_",1) #输出：['pathon_pycharm', 'day11'] <class 'list'> 9 v = a.rsplit("_",2) #输出：['pathon', 'pycharm', 'day11'] <class 'list'> 10 print(v,type(v))
splitlines：按照换行符进行分割
1 a = "username\npasswd\nmail" 2 3 # 参数：True保留换行符 4 v = a.splitlines(True) #输出：['username\n', 'passwd\n', 'mail'] 5 6 #参数：False不保留换行符 7 # v = a.splitlines(False) #输出：['username', 'passwd', 'mail'] 8 print(v,a)
27、startswith：判断字符串是否以子字符串开头
endswith：判断字符串是否以子字符串结束
1 a = "python_pycharm" 2 # v = a.endswith("rm") #输出：True 3 v = a.startswith("py") #输出：True 4 print(v)
28、swapcase 大小写转换：大写转换为小写；小写转换为大写
a = "Python" v = a.swapcase() #输出：pYTHON print(v)
29、expandtabs：分隔、断句，特殊适合用于断句
str_user_inform = "用户名\t密码\t邮箱\t电话\t备注\n张三\tzhangsan\tzhangsan@qq.com\t18502337951\t\n张三\tzhangsan\tzhangsan@qq.com\t18502337951\t\n张三\tzhangsan\tzhangsan@qq.com\t18502337951\t\n张三\tzhangsan\tzhangsan@qq.com\t18502337951\t\n" v2 = str_user_inform.expandtabs(20) print(v2)
输出结果
用户名 密码 邮箱 电话 备注 张三 zhangsan zhangsan@qq.com 18502337951 张三 zhangsan zhangsan@qq.com 18502337951 张三 zhangsan zhangsan@qq.com 18502337951 张三 zhangsan zhangsan@qq.com 18502337951
30、replace：替换原子字符串
name = "zhangsanlisiliwuzhaoli"
v = name.replace("li","si")
print(v)
name1 = "zhangsanlisiliwuzhaoli"
###第三个参数为替换多少次
v1 = name1.replace("li","si",2)
print(v1)
##输出结果：
zhangsansisisiwuzhaosi
zhangsansisisiwuzhaoli
*************************************************************
***************************************************
字符串Str方法小结
*************************************************************
*************************************************************
1、字符串方法中最常用的的方法
（1）、join #指定字符连接
（2）、split #指定分割符进行分割
（3）、find
（4）、strip
（5）、upper
（6）、lower
（7）、replace
2、字符串使用扩展
（1）、for循环
# for 变量名 in 字符串: # 变量名 # break # continue # index = 0 # while index < len(test): # v = test[index] # print(v) # # index += 1 # print('=======') # for zjw in test: # print(zjw) # test = "妹子有种冲我来" # for item in test: # print(item) # break # for item in test: # continue # print(item)
（2）、通过索引获取字符串中的字符
1 # v = test[3] 2 # print(v)
（3）、切片
1 # v = test[0:-1] 2 # print(v)
（4）、len，获取字符串长度
# Python3： len获取当前字符串中由几个字符组成 # v = len(test) # print(v) #在Python2：len获取当前字符串中有几个字节
（5）、range创建连续或者不连续的数字
1 #range创建连续的数字 2 v=range(100) #等价于range(0,100) 3 print(v) 4 #在python3里面，不会立即创建，这是一个优化内存机制，只有在for循环的#时候才会打印 5 #在python2里面，会立即创建，占用大量内存 6 v=range(0,100,5) #按照步长打印 7 v=range(len(input()))
（6）、index,将索引与对应的值打印出来
1 # 第一种 2 v = input("请输入你的理想，少年：") 3 v_length = v.__len__() 4 v_index = range(v_length) 5 for i in v_index: 6 print(i,v[i]) 7 # 第二种 8 v = input("请输入你的理想，少年：") 9 for i in range(0,len(v)) 10 print(i,v[i])
3、关于字符串的误区
# 字符串一旦创建，不可修改
# 一旦修改或者拼接，都会造成重新生成字符串
1 name = "zhangsan" 2 age = "18" 3 4 info = name + age 5 print(info)
四、列表、list
1、list：列表特点，li = [1,3,4,5,6,"list"]
（1）、中括号括起来
（2）、分割每个元素，逗号分割
（3）、列表中的元素可以是数字、字符串、列表、布尔值等，所有的数据类型都可以
（4）、列表是可以嵌套的，被嵌套的list算作一个元素
（5）、集合，内部可以放置任何类型的数据
（6）、可以通过索引取值，可以一层一层往下找；切片的结果也是列表；
（7）、可以进行迭代，循环：for in、while循环
备注：a、对于字符串转换为列表：list(),内部使用的for循环；
b、数字是不能进行循环的；
c、列表转换为字符：列表中都是字符串可以通过join方法直接连接；列表中数字字符串，需要自己写for循环
1 s ="" 2 for i in li: 3 s = s+str(i) 4 pritn(s)
（8）、列表的元素是可以进行修改的，也可以进行切片进行修改，
（9）、列表是有序的，存放元素的时候，每个元素后面保存有下一个元素的位置，类似于c语言中的链表
（10）、可以进行删除：del li[1]、切片方式删除：del li[1:3]
2、list方法
（1）、append：在原来的列表基础上追加元素
1 a = [11,22,33,444] 2 v = a.append(555) 3 print(v,a) #输出：None [11, 22, 33, 444, 555]
（2）、clear：清空列表
1 a = [11,22,33,444] 2 a.clear() 3 print(a)
（3）、copy：复制拷贝：浅拷贝
1 a = [11,22,33,444] 2 v = a.copy() 3 print(a,v)
准备：赋值操作、浅拷贝、深拷贝
a、赋值：其实就是对象的引用（别名）
b、浅拷贝：拷贝父对象，不会拷贝对象的内部的子对象
c、深拷贝：copy模块的deepcopy方法，完全拷贝了父对象及其子对象
（4）、count计算元素出现的次数
1 a = [11,22,33,444,22,444] 2 v = a.count(44) 3 print(v) # 输出：0
（5）、extend：扩展原来的列表
备注：append与extend的区别：
1 a = [11,22,33,444,22,444] 2 # 当append的是list时，直接将追加的列表当做一个元素放入list中 3 # a.append([55,"python","pycharm"]) #输出：[11, 22, 33, 444, 22, 444, [55, 'python', 'pycharm']] 4 5 # 当append一个字符串时，直接将字符串作为一个元素放入list中 6 a.append("zhangsan") #输出：[11, 22, 33, 444, 22, 444, 'zhangsan'] 7 print(a) 8 9 b = [11,22,33,444,22,444] 10 11 # 当extend的是list时，将列表中的每个元素作为元素放入list中 12 # b.extend([55,"python","pycharm"]) #输出：[11, 22, 33, 444, 22, 444, 55, 'python', 'pycharm'] 13 14 #当extend的是字符串时，将字符串中的每个字符放入list中 15 b.extend("zhangsan") # 输出：[11, 22, 33, 444, 22, 444, 'z', 'h', 'a', 'n', 'g', 's', 'a', 'n'] 16 print(b)
（6）、index查找指定的值的索引，从左往右找，找到第一个后就不在继续查找
1 b = [11,22,33,444,22,444] 2 print(b.index(22)) #输出：1
（7）、insert：指定索引位置插入元素
1 b = [11,22,33,444,22,444] 2 b.insert(2,555) 3 print(b) #输出：[11, 22, 555, 33, 444, 22, 444]
（8）、pop 默认删除最后一个元素，并获取删除的值；加入参数，删除指定索引的值
1 b = [11,22,33,444,22,444] 2 # v = b.pop() #删除指定的值 输出：[11,22,33,444,22] 3 v = b.pop(1) # 将index索引值为1的元素删除 输出：[11, 33, 444, 22, 444] 4 print(b)
（9）、remove：删除列表中的指定值，从左到右
1 b = [11,22,33,444,22,444] 2 # v = b.remove(11) #输出：[22, 33, 444, 22, 444]，删除指定的值 3 v = b.remove(22) #输出：[11, 33, 444, 22, 444]，从左到右，删除找到的第一个值，不在继续查找 4 print(v,b)
（10）、reverse：将当前列表进行翻转
1 b = [11,22,33,444,22,444] 2 b.reverse() #输出：[444, 22, 444, 33, 22, 11] 3 print(b)
（11）、sort：默认参数进行从小到大排序；sort（True）从大到小
1 b = [11,22,33,444,22,444] 2 # b.sort() #输出：[11, 22, 22, 33, 444, 444] 3 b.sort(reverse=False)#输出：[11, 22, 22, 33, 444, 444] 4 # b.sort(reverse=True) #输出：[444, 444, 33, 22, 22, 11] 5 print(b)
五、元组：tuple
元组不可以被增加、删除、修改
1、tuple方法
（1）、count 统计元素出现在元组中的次数
a = (11,22,33,44,11,33,) print(a.count(11)) #输出：2
（2）、index获取指定元素在元组中的出现的次数
1 a = (11,22,33,44,11,33,) 2 print(a.index(33) #查找到第一个后不再继续查找；输出：2
2、tuple扩展
（1）、书写格式：一般在最后一个元素中加入“，”，便于区分
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
（2）、索引：可以通过索引进行查找元素
（3）、可以进行切片
v = tu[0:2]
print(v)
（4）、可以被for循环，可以进行迭代
a = (11,22,33,44,11,33,) for item in a: print(item)
（5）、转换：元组、列表、字符串之间的转换
1 s = "asdfasdf0" 2 li = ["asdf","asdfasdf"] 3 tu = ("asdf","asdf") 4 # 字符串转换为元组：将每个字符作为一个元素转换为元组 5 # v = tuple(s) # 输出：('a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0') 6 # print(v) 7 8 # v = tuple(li) #输出：('asdf', 'asdfasdf') 9 # print(v) 10 11 # v = list(tu) #输出：['asdf', 'asdf'] 12 # print(v) 13 14 # v = "_".join(tu) #输出：asdf_asdf 15 # v = "".join(tu) #输出：asdfasdf 16 # print(v)
（6）、扩展与追加
1 li = ["asdf","asdfasdf"] 2 # li.extend((11,22,33,)) # ['asdf', 'asdfasdf', 11, 22, 33] 3 li.append((11.22,33)) # ['asdf', 'asdfasdf', (11.22, 33)] 4 print(li)
（7）、元组中的一级元素不可被修改、删除、增加
1 tu = (111,"alex",(11,22),[(33,44)],True,33,44,) 2 # # 元组，有序。 3 # v = tu[3][0][0] # 输出：33 4 # print(v) 5 v=tu[3] 6 print(v) #输出[(33, 44)] 7 tu[3][0] = 567 #输出(111, 'alex', (11, 22), [567], True, 33, 44) 8 print(tu)
六、字典：dict
1、书写格式：
键值对；逗号分；使用{}进行括起；键与值用‘“：”进行对应
1 info = { 2 "k1":"v1", 3 "k2":"v2" 4 } 5 print(info) #输出：{'k1': 'v1', 'k2': 'v2'}
2、字典中的value值可以是任意数据类型
1 info = { 2 "k1": 18, 3 "k2": True, 4 "k3": [ 5 11, 6 [], 7 (), 8 22, 9 33, 10 { 11 'kk1': 'vv1', 12 'kk2': 'vv2', 13 'kk3': (11,22), 14 } 15 ], 16 "k4": (11,22,33,44) 17 } 18 print(info)
3、字典中的key不能是列表、字典
1 info ={ 2 3 "k1": 'asdf', 4 True: "123", 5 # [11,22]: 123, #输出：unhashable type: 'list' 6 # (11,22): 123, 输出：unhashable type: 'dict' 7 {'k1':'v1'}: 123 8 9 } 10 print(info)
4、字典是无序的
打印同一字典，字典里的元素顺序是变化的
5、可以通过索引方式找到指定元素
1 info = { 2 "k1": 18, 3 2: True, 4 "k3": [ 5 11, 6 [], 7 (), 8 22, 9 33, 10 { 11 'kk1': 'vv1', 12 'kk2': 'vv2', 13 'kk3': (11,22), 14 } 15 ], 16 "k4": (11,22,33,44) 17 } 18 # v = info['k1'] #输出：18，将key值为"k1"的value找到 19 # print(v) 20 # v = info[2] #输出：True,同上 21 # print(v) 22 v = info['k3'][5]['kk3'][0] #输出：11； 23 print(v)
6、字典支持删除：del info[key]
1 info = { 2 "k1": 18, 3 2: True, 4 "k3": [ 5 11, 6 [], 7 (), 8 22, 9 33, 10 { 11 'kk1': 'vv1', 12 'kk2': 'vv2', 13 'kk3': (11,22), 14 } 15 ], 16 "k4": (11,22,33,44) 17 } 18 # del info['k1'] 19 20 del info['k3'][5]['kk1'] 21 print(info)
7、for循环
1 info = { 2 "k1": 18, 3 2: True, 4 "k3": [ 5 11, 6 [], 7 (), 8 22, 9 33, 10 { 11 'kk1': 'vv1', 12 'kk2': 'vv2', 13 'kk3': (11,22), 14 } 15 ], 16 "k4": (11,22,33,44) 17 } 18 # for item in info: 19 # print(item) 20 """输出结果：将key值循环打印 21 k1 22 2 23 k3 24 k4 25 26 """ 27 28 # for item in info.keys(): 29 # print(item) 30 """输出结果：将key值循环打印 31 k1 32 2 33 k3 34 k4 35 36 """ 37 # for item in info.values(): 38 # print(item) 39 """输出结果：将value值循环打印 40 18 41 True 42 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}] 43 (11, 22, 33, 44) 44 """ 45 # for item in info.keys(): 46 # print(item,info[item]) 47 """输出结果：将key：value值成对打印出 48 k1 18 49 2 True 50 k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}] 51 k4 (11, 22, 33, 44) 52 """ 53 54 # for k,v in info.items(): 55 # print(k,v) 56 """输出结果：将key：value值成对打印出 57 k1 18 58 2 True 59 k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}] 60 k4 (11, 22, 33, 44) 61 """ 62 # True 1 False 0 63 # info ={ 64 # "k1": 'asdf', 65 # True: "123", 66 # # [11,22]: 123 67 # (11,22): 123, 68 # # {'k1':' v1'}: 123 69 # 70 # } 71 # print(info)
七、布尔值：bool
布尔值比较简单，就不在罗列
八、数据类型整理
1 # 一、数字 2 # int(..) 3 # 二、字符串 4 # replace/find/join/strip/startswith/split/upper/lower/format 5 # tempalte = "i am {name}, age : {age}" 6 # # v = tempalte.format(name='alex',age=19) 7 # v = tempalte.format(**{"name": 'alex','age': 19}) 8 # print(v) 9 # 三、列表 10 # append、extend、insert 11 # 索引、切片、循环 12 # 四、元组 13 # 忽略 14 # 索引、切片、循环 以及元素不能被修改 15 # 五、字典 16 # get/update/keys/values/items 17 # for,索引 18 19 # dic = { 20 # "k1": 'v1' 21 # } 22 23 # v = "k1" in dic 24 # print(v) 25 26 # v = "v1" in dic.values() 27 # print(v) 28 # 六、布尔值 29 # 0 1 30 # bool(...) 31 # None "" () [] {} 0 ==> False
