一、基本数据类型
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 efg mail" 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:默认清除左边的空格、 、 ;指定参数,去除左边指定参数、指定子字符串;从左边开始找,找到第一个就不在继续查找去除;
rstrip:默认清除右边的空格、 、 ;指定参数,去除右边指定参数、指定子字符串;从右边开始找,找到第一个就不在继续查找去除;
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 passwd mail" 2 3 # 参数:True保留换行符 4 v = a.splitlines(True) #输出:['username ', 'passwd ', '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 = "用户名 密码 邮箱 电话 备注 张三 zhangsan zhangsan@qq.com 18502337951 张三 zhangsan zhangsan@qq.com 18502337951 张三 zhangsan zhangsan@qq.com 18502337951 张三 zhangsan zhangsan@qq.com 18502337951 " 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)
(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)、元组中的一级元素不可被修改、删除、增加
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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值可以是任意数据类型
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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不能是列表、字典
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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、可以通过索引方式找到指定元素
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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]
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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循环
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
布尔值比较简单,就不在罗列
八、数据类型整理
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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