python创建一个全零图片 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 
9 #123 
注：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__()代表类的构造函数
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'] 
3
4 #"_"指定分隔符；1为从左边往右边找，找到第一个就停止继续查找
5 #v = a.split("_",1) #输出：['pathon', 'pycharm_day11'] 
6
7 #"_"指定分隔符；1为从右边往左边找，找到第一个就停止继续查找
8 #v = a.rsplit("_",1) #输出：['pathon_pycharm', 'day11'] 
9 v = a.rsplit("_",2) #输出：['pathon', 'pycharm', 'day11'] 
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\[e-mail]\t18502337951\t\n张三\tzhangsan\[e-mail]\t18502337951\t\n张三\tzhangsan\[e-mail]\t18502337951\t\n张三\tzhangsan\[e-mail]\t18502337951\t\n"v2 = str_user_inform.expandtabs(20)
print(v2)
输出结果
用户名 密码 邮箱 电话 备注
张三 zhangsan [e-mail] 18502337951张三 zhangsan [e-mail] 18502337951张三 zhangsan [e-mail] 18502337951张三 zhangsan [e-mail] 1850233795130、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 inv_index:6 print(i,v[i])7 #第二种
8 v = input("请输入你的理想，少年：")9 for i inrange(0,len(v))10 print(i,v[i])
3、关于字符串的误区
# 字符串一旦创建，不可修改
# 一旦修改或者拼接，都会造成重新生成字符串
1 name = "zhangsan"
2 age = "18"
3
4 info = name +age5 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 inli: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 ina: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)
View Code
六、字典：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)
View Code
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)
View Code
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)
View Code
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)
View Code
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 k122 223 k324 k425
26 """
27
28 #for item in info.keys():
29 #print(item)
30 """输出结果：将key值循环打印31 k132 233 k334 k435
36 """
37 #for item in info.values():
38 #print(item)
39 """输出结果：将value值循环打印40 1841 True42 [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 1849 2 True50 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 1858 2 True59 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)
View Code
七、布尔值：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
View Code