2 # -*- coding:utf-8 -*-
3
4 # python中有如下数据类型：数字、字符串、列表、字典、元组、布尔值
5 #
6 # 一、整型数字（int）
7 # 1、应注意：
8 # a.在python2中分为整型和长整型（long），是根据数字大小区分
9 # b.在pycharm中输入相关类型名如int，然后按住ctrl键点击鼠标左键就可看到该类型的所有方法
10 # 2、方法：
11 # a. - int(sub)
12 # 可用来转换数据类型，例如可将字符串中的数字转为整型数字：
13 # s = '123'
14 # i = int(s)
15 # >>> i = 123
16 # num = '0010'
17 # v = int(num,base = 2)----(base =2 则表示将num以2进制转换为10进制)
18 # >>> v = 2
19 # v = int(num,base = 10)----(base =10 则表示将num以10进制转换为10进制)
20 # >>> v = 10
21 # b. - sub.bit_length()
22 # 可用来计算数字用二进制（注：不计算前面的补0位数）表示所需的位数
23 # age = 3 (3的二进制为 11 )
24 # age.bit_length()
25 # >>> 2
26 # age = 5 (5的二进制为 101)
27 # age.bit_length()
28 # >>> 3
29 # 二、字符串（str）
30 # 1、字符串一般以引号引起来，引号内的内容即为字符串；
31 # 2、字符串中的字符不可修改；
32 # 3、方法：
33 # a. str.capitalize()
34 # 用于将字符串首字母转换为大写。
35 # name = "liming"
36 # name.capitalize()
37 # >>>"Liming"
38 # b. 1>sr.casefold()
39 # 2>sr.lower()
40 # 上述两个方法用于将字符串中的大写字母转换为小写，但casefold()功能更大，可将很多未知的对应关系进行大小写转换
41 # 而lower()只能简单的平时遇到的英文等。
42 # name = "liMinG "
43 # name.casefold()
44 # >>> "liming"
45 # name.lower()
46 # >>> "liming"
47 # c. 1>str.center(width[,fillchar])
48 # 用于将字符串指定为指定宽度，并将str居中，两边用fillchar字符填充，fillchar为可选项，若没有则以空格填充。
49 # name = "Hello"
50 # name.center(15,"*")
51 # >>>"*****Hello*****"
52 # 2>str.ljust(width[,fillchar])
53 # 用于将字符串指定为指定宽度，并将str居左，右边用fillchar字符填充，fillchar为可选项，若没有则以空格填充。
54 # name = "Hello"
55 # name.ljust(15,"*")
56 # >>>"Hello**********"
57 # 3>str.rjust(width[,fillchar])
58 # 用于将字符串指定为指定宽度，并将str居右，左边用fillchar字符填充，fillchar为可选项，若没有则以空格填充。
59 # name = "Hello"
60 # name.rjust(15, "*")
61 # >> > "**********Hello"
62 # 4>str.zfill(width)
63 # 用于将字符串指定为指定宽度，并以0填充在str前面形成长度为width的字符串。
64 # name = "Hello"
65 # name.zfill(15)
66 # >> > "0000000000Hello"
67 # d. str.count(sub[,start[,end]])
68 # 用于统计字符串str中的sub出现的次数，返回一个int。其中start用于指定开始位置，end用于指定结束位置，二者均为可选项，
69 # 若没有指定则默认统计整个字符串。(start=< [指定的位置] <end)
70 # name = "hello world"
71 # name.count("o")
72 # >>> 2
73 # name.count("o",5,11)
74 # >>> 1
75 # e. 1>str.startswith(sub[,start[,end]])
76 # 2>str.endswith(sub[,start[,end]])
77 # 上诉两个方法分别用于判断字符串str是否以子序列sub作为开始或者结束，返回一个布尔值。其中start用于指定开始位置，
78 # end用于指定结束位置，二者均为可选项， 若没有指定则默认统计整个字符串。(start=< [指定的位置] <end)
79 # name = "Hello"
80 # name.startswith("H")
81 # name.expandtabs()
82 # >>>True
83 # name.endswith("lo")
84 # >>>True
85 # f. str.expandtabs([tabsize = int])
86 # 用于（断句）将字符串中"\t"转换为指定宽度的tab键分割，默认一个tab = 8个空格。
87 # name = "Hel\tlo"
88 # name.expandtabs(2)
89 # >>>"Hel lo"
90 # g. str.find(sub[,start[,end]])
91 # 用于查找字符串str中的子序列sub在字符串的位置，从开始往后找，返回一个位置int，如果没找到，返回 -1 。
92 # 其中start用于指定开始位置，end用于指定结束位置，二者均为可选项，若没有指定则默认统计整个字符串。(start=< [指定的位置] <end)
93 # name = "Hello"
94 # name.find("e")
95 # >>> 1
96 # name.find("l")
97 # >>> 2
98 # name.find("l",3,4)
99 # >>> 3
100 # h. str.format()
101 # 用于格式化字符串（传值），用于传递大括号{}内的内容，有多种方式：
102 # ①按照变量名传递
103 # st = "I am {name},age {age}"
104 # info = st.format(name = "Liming",age = 18)
105 # print(info)
106 # >>> "I am Liming,age 18"
107 #
108 # ②按照索引（从0开始）传递
109 # st = "I am {0},age {1}"
110 # info = st.format("Liming",18)
111 # print(info)
112 # >>> "I am Liming,age 18"
113 # i. str.format_map()
114 # 用于格式化字符串（传值），用于传递大括号{}内的内容，是以字典的形式进行传递：
115 # st = "I am {name},age {age}"
116 # info = st.format_map({"name":"Liming","age":18})
117 # print(info)
118 # >> > "I am Liming,age 18"
119 # j. str.inainum()
120 # 判断字符串至少有一个字符，且是否只由数字或字母或二者组合组成，若为判断成立则输出True，反之则双输出False
121 # st = "abc123a"
122 # st.isalnum()
123 # >>> True
124 # k. str.isalpha()
125 # 判断字符串至少有一个字符，且是否只由字母或者汉字或者二者组合组成（中英文），若为判断成立则输出True，反之则双输出False
126 # st = "abc123a"
127 # st.isalpha()
128 # >>> False
129 # st = "abcd"
130 # st.isalpha()
131 # >>> True
132 # st = "你好"
133 # st.isalpha()
134 # >> > True
135 # l. 1> str.isdigit()
136 # 判断字符串是否只由十进制数字组成，若为判断成立则输出True，反之则双输出False
137 # >>满足①True：Unicode数字、byte数字（单字节）、全角数字（双字节）、罗马数字
138 # >> ②False:汉字数字
139 # >> ③Error：无
140 # st = "1234"
141 # st.isdigit()
142 # >>> True
143 # st = "四"
144 # st.isdigit()
145 # >>> False
146 # 2> str.isdecimal()
147 # 判断字符串是否只由数字组成，若为判断成立则输出True，反之则双输出False
148 # >> 满足①True：Unicode数字、全角数字（双字节）
149 # >> ②False: 汉字数字、罗马数字
150 # >> ③Error：byte数字（单字节）
151 # st = "1234"
152 # st.isdigit()
153 # >> > True
154 # st = "IV"
155 # st.isdigit()
156 # >> > False
157 # 3> str.isnumeric()
158 # 判断字符串是否只由数字组成，若为判断成立则输出True，反之则双输出False
159 # >> 满足①True：Unicode数字、全角数字（双字节）、罗马数字、汉字数字
160 # >> ②False: 无
161 # >> ③Error：byte数字（单字节）
162 # st = "1234"
163 # st.isnumeric()
164 # >>> True
165 # st = "四"
166 # st.isnumeric()
167 # >>> True
168 # m. str.isidentifier()
169 # 用于检测字符串是否满足变形名的标识符，是则返回True，反之返回False
170 # st = "abc11"
171 # st.isidentifier()
172 # >>> True
173 # st = "123aaa"
174 # st.isidentifier()
175 # >>> False
176 # st = "_123aa"
177 # st.isidentifier()
178 # >>> True
179 # n. str.isprintable()
180 # 用于检测字符串中是否有不可显示（print）的字符(\t \n等），如有返回False，反之True
181 # st = "qqw\t3112"
182 # st.isprintable()
183 # >>> False
184 # o. str.isspace()
185 # 用于检测字符串是否全部由空格字符串组成（不是空字符串），是则返回True，反之False
186 # st = ""
187 # st.isspace()
188 # >>> False
189 # st = " "
190 # st.isspace()
191 # >>> True
192 # p. str.istitle()
193 # 用于检测字符串是否为标题（即为字符串中每个单词是否首字母大写），是则返回True，反之False
194 # （可用str.title()将字符串转换为标题格式）
195 # st = "Abc is B"
196 # st.istitle()
197 # >>> False
198 # st = "Abc Is B"
199 # st.istitle()
200 # >>> True
201 # q. sub.join(str)
202 # 以sub字符串作为拼接符，将str字符串中的每一个元素进行拼接
203 # sub = "_"
204 #
205 # str = "ABCDEFG"
206 # str_sub = sub.join(str)
207 # >>> "A_B_C_D_E_F_G"
208 # r. 1>str.islower()
209 # 检测字符串是否均为小写，是则返回True，反之False
210 # st = "AcccSd"
211 # st.islower()
212 # >>> False
213 # 2>str.lower()
214 # 用于将字符串中的每个字母转换为小写。
215 # st = "AcccSd"
216 # st.lower()
217 # >>> "accsd"
218 # s. 1>str.isupper()
219 # 检测字符串是否均为大写，是则返回True，反之False
220 # st = "AcccSd"
221 # st.isupper()
222 # >>> False
223 # st = "ADDFA"
224 # st.isupper()
225 # >>> True
226 # 2>str.upper()
227 # 用于将字符串中的每个字母转换为大写。
228 # st = "AcccSd"
229 # st.upper()
230 # >>> "ACCCSD"
231 # t. 1>str.strip([char])
232 # ①char为可选项，若不指定，则去清除字符串中首尾不显示的内容：空格，\t，\n等，对于字符串中间的空白内容无效。
233 # st = " A BCDD "
234 # st.strip()
235 # >>> "A BCDD"
236 # st = " \tAV DC\n "
237 # st.strip()
238 # >>> "AV DC"
239 # ②若指定char，则会比对char中的字符与str中的字符，从两边进行清除char和str相同的字符（优先最多匹配）。
240 # st = "ABCDBA"
241 # st.strip("AB")
242 # >> > "CD"
243 # 2>str.lstrip()
244 # ①用去清除字符串中左边不显示的内容：空格，\t，\n等；
245 # st = " A BCDD "
246 # st.lstrip()
247 # >>> "A BCDD "
248 # ②同上②
249 # 3 > str.rstrip()
250 # ①用去清除字符串中右边不显示的内容：空格，\t，\n等；
251 # st = " A BCDD "
252 # st.rstrip()
253 # >>> " A BCDD"
254 # ②同上②
255 # u. 1>str.maketrans(str1,str2)
256 # 用于制造替换的对应关系
257 # o = "abecimoku"
258 # a = "aeiou"
259 # b = "12345"
260 # c = str.maketrans(a,b)
261 # (c返回的是一个字典，a、b对应的asccii值)、
262 # 2>str.translate(str.maketrans(str1,str2))
263 # 结合上述的str.maketrans(str1,str2)生成的对应关系，而对新的字符串按此规则进行替换
264 # d = c.translate(c)
265 # >>> "1b2c3m4k5"
266 # v. 1>str.partition(char) str.rpartition()
267 # 用于以指定的char作为分隔符并且包含char进行分割，分割为三部分（char必须指定）
268 # a = "abdcbf"
269 # b = a.partiton("b")
270 # >>> ["a","b","dcbf"]
271 # c = a.rpartition("b")
272 # >>> ["abdc","b","f"]
273 # 2>str.spilt(char[,maxnum = -1]) str.rspilt(char[,maxnum = -1])
274 # 用于以指定的char作为分隔符并且分割出不包含char进行分割；maxnum为可选项，默认为-1，则表示全部分割
275 # 0表示不分割，1表示分割为两份，2为三份，以此类推
276 # a = "abdcbf"
277 # b = a.split("b")
278 # >>> ["a","dc","f"]
279 # b = a.split("b",0)
280 # >>> ["abdcbf"]
281 # b = a.split("b",1)
282 # >>> ["a","dcbf"]
283 # c = a.rsplit("b",1)
284 # >>> ["abdc","f"]
285 # 3>str.splitlines([False])
286 # 以"\n"作为分隔符进行分割，有True，False可选，默认为False；True则分割的字符串包含"\n"，False则不包含。
287 # a = "abcd\nacfd\nadsa"
288 # b = a.splitlines()
289 # >>> ["abcd","acfd","adsa"]
290 # b = a.splitlines(True)
291 # >>> ["abcd\n","acfd\n","adsa"]
292 # w. str.swapcase()
293 # 将字符串中的大写字符转换为小写，小写转换为大写。
294 # a = "aBcdE"
295 # b = a.swapcase()
296 # >>> "AbCDe"
297 # x. str.replace(old,new[,count])
298 # 将字符串中的old字符或者子序列替换为new，指定count则替换不超过count此；默认不指定则表示全部替换。
299 # a = "helloworld"
300 # old = "l"
301 # new = "L"
302 # b = a.replace(old,new)
303 # >>> "heLLoworLd"
304 # 三、列表（list）
305 # 0、列表中的元素均有索引对应，所以说列表是有序的；
306 # 1、列表是以中括号[]引起来，并且以“,”分隔；列表中的元素可以是数字（int）、字符串（str）、列表（list）、布尔值（bool）等；
307 # 即所有的对象均可以放入列表；
308 # 2、同样可以用索引和切片进行取值或者修改；
309 # a = [1,2,3,4]
310 # a[1] = 222
311 # print(a)
312 # >>> [1,222,3,4]
313 # 3、列表内容是可以被修改（删除、增加、插入等）；
314 # 4、可以用in来判断某一元素是否存在列表中；
315 # 5、字符串同样可以转换为列表（可以理解为在字符串中使用for循环将对象添加至列表）。反之若要将列表转换为字符串的话，①需要自己
316 # 写for循环来迭代处理（针对列表中既有数字又有字符串）；②若列表中只有字符串元素，则可以用join方法进行转换拼接；
317 # a = "abcdefg"
318 # b = list(a)
319 # >>> ['a','b','c','d','e','f','g']
320 # c = ['1',1,'a']
321 # d = ""
322 # for i in c:
323 # d += str(i)
324 # print(d)
325 # >>> "11a"
326 # e = ['a','b','1']
327 # d = ''.join(e)
328 # >>> "ab1"
329 # 6、list的相关方法：
330 # a. list.append(sub)
331 # 用于向列表末尾追加（增添）整个的元素sub，sub可以是任意对象（因为列表是可修改的，所以该方法直接使用，不需要重新赋值）。
332 # a = ['a','c']
333 # a.append('b')
334 # print(a)
335 # >>> ['a','c','b']
336 # b. list.clear()
337 # 用于清空列表（删除列表中所有元素，返回的是空列表）（因为列表是可修改的，所以该方法直接使用，不需要重新赋值。）。
338 # a = ['a','c']
339 # a.clear()
340 # print(a)
341 # >>> []
342 # c. list.copy()
343 # 用于复制（拷贝【浅拷贝】）列表，返回一个元素相同的新列表，需要有变量来接收。
344 # a = ['a','c']
345 # b = a.copy()
346 # print(b)
347 # >>> ['a','c']
348 # d. list.count(sub)
349 # 用于计算列表中的某一元素sub出现的次数，返回一个int，需要有变量来接收。
350 # c = [1,2,3,1,1]
351 # d = c.count(1)
352 # print(d)
353 # >>> 3
354 # e. list.extend(iterable)
355 # 用于扩展原列表，向列表中追加（增添）一个可迭代对象iterable对象的每一个元素。这个可迭代对象可以是列表或者字符串
356 # 等的任意可迭代对象（因为列表是可修改的，所以该方法直接使用，不需要重新赋值），与append()方法不同的是，它是将可迭代
357 # 对象的每个元素迭代添加到原列表中，而appen()是将传入的对象（无论是否为可迭代对象）作为整体添加到原列表中。
358 # a = ['a','c']
359 # a.extend(['b','d'])
360 # print(a)
361 # >>> ['a','c','b','d']
362 # a = ['a','c']
363 # a.extend("def")
364 # print(a)
365 # >>> ['a','c','d','e','f']
366 # a = ['a','c']
367 # a.append(['b', 'd'])
368 # print(a)
369 # >>> ['a','c',['b', 'd']]
370 # f. list.index(sub[,start[,end]])
371 # 用于查找列表中某一元素sub的索引值（左边优先，即为从左往右查找，找到即返回索引值），同样可以指定查找的起始和结束位置
372 # ，返回int，需用变量接收；弱若传入的sub不在查找的列表中则报错。
373 # a = [1,2,3,2,1]
374 # b = a.index(1)
375 # print(b)
376 # >>> 0
377 # a = [1, 2, 3, 2, 1]
378 # b = a.index(2,2,4)
379 # print(b)
380 # >>> 3
381 # g. list.insert(index,sub)
382 # 用于向列表中插入元素，index指定插入位置的索引，sub为插入的元素。
383 # a = [1,2,4,5]
384 # a.index(0,6)
385 # print(a)
386 # >>> [6,1,2,4,5]
387 # h. list.pop([index])
388 # 用于删除指定索引的元素，若不指定index，则默认删除最后一个元素，并获取删除的值。
389 # a = [1,2,4,5]
390 # b = a.pop()
391 # print(a)
392 # >>> [1,2,4]
393 # print(b)
394 # >>> 5
395 # c = a.pop(1)
396 # print(c)
397 # >>> [1,4,5]
398 # i. list.remove(sub)
399 # 用于删除指定元素（左边优先）。
400 # a = [1,2,4,5]
401 # a.remove(4)
402 # print(a)
403 # >>> [1,2,5]
404 # j. del list
405 # 注意del是一个语句，不是列表的方法，所以不必加（）；若del后加的是列表名，则表示删除整个列表；若del后加的是
406 # 列表切片或者索引则删除指定切片或者索引内容。
407 # a = [1,2,3,4]
408 # del a
409 # print(a)
410 # >>> []
411 # b = ['a','b','c']
412 # del b[1]
413 # print(b)
414 # >>> ['a','c']
415 # k. list.reverse()
416 # 用于反转列表。
417 # a = [1,2,3,4]
418 # a.reverse()
419 # print(a)
420 # >>> [4,3,2,1]
421 # l. list,sort([reverse = False])
422 # 用于对列表元素排序，可选项reverse默认为False表示不反转排序（即从小到大排序），反之若reverse = True，则从大到小。
423 # a = [2,5,3,1,4]
424 # a.sort()
425 # print(a)
426 # >>> [1,2,3,4,5]
427 # a.sort(reverse = True)
428 # print(a)
429 # >>> [5,4,3,2,1]
430 # 四、元组（tuple）
431 # 0、元组也是有序的；
432 # 1、元组是用()括起来的对象，元组中内容可以是str，int，list，tuple，bool等；
433 # a = (1,'avc',[1,2,3],True,(1,3,4))
434 # 2、元组一旦被创建，其中的整体（一级）元素不可被修改（但是若元组中有一个列表元素，则可以对该元素修改），不能被增加或者删除；
435 # a = (1,'avc',[1,2,3],True,(1,3,4))
436 # a[2][0] = 111
437 # print(a)
438 # >>> (1,'avc',[111,2,3],True,(1,3,4))
439 # a = (1,'avc',[1,2,3],True,(1,3,4))
440 # a[0] = 111
441 # 则会直接报错！！！~
442 # 3、一般写元组的时候，推荐在最后加“,”；
443 # 4、元组同样可以通过索引和切片访问（取值）元素；
444 # 5、元组同样可以用For循环；
445 # 6、字符串、列表同样可以用tuple()方法转换为元组；元组可以转换为列表；
446 # 7、元组的基本方法：
447 # a. tuple.count(sub)
448 # 用于获取指定元素在元组中出现的次数，返回一个int对象
449 # tu = (1,2,3,2,1)
450 # co = tu.count(1)
451 # print(co)
452 # >>> 2
453 # b. tuple.index(sub)
454 # 用于获取元组中元素的索引（若元组中有多个相同的元素，则同样遵从左边优先规则），返回一个int对象
455 # tu = ('a','b','a',)
456 # co = tu.index('a')
457 # print(co)
458 # >>> 0
459 #五、字典
460 # 1、字典是用{}括起来的对象（键值对）；
461 # di = {'a':'1','b':'2'}
462 # 其中 'a':'1' 为字典中的一个键值对， 'a'为字典的Key，'1'为字典的value
463 # 2、元组中的value内容可以是str，int，list，tuple，bool，dict等；list、dict不能作为字典的key；
464 # 3、字典是无序的；
465 # 4、字典可以通过key获取相应value；
466 # di = {'a':'1','b':'2'}
467 # dia = di['a']
468 # print(dia)
469 # >>> '1'
470 # 5、字典同样支持del删除指定的键值对；
471 # di = {'a':'1','b':'2'}
472 # del di['a']
473 # print(di)
474 # >>> ['b':'2']
475 # 6、字典可以进行for循环，默认根据key进行循环；
476 # di = {'a':'1','b':'2'}
477 # for i in di:
478 # print(i)
479 # >>> 'a'
480 # 'b'
481 # 也可以的用字典的内置方法dict.keys()来获取字典的key值：
482 # di = {'a': '1', 'b': '2'}
483 # for k in di.keys():
484 # print(i)
485 # >>> 'a'
486 # 'b'
487 # 若想要获取字典的value值，可以用内置方法dict.values()：
488 # di = {'a': '1', 'b': '2'}
489 # for v in di.values():
490 # print(i)
491 # >>> '1'
492 # '2'
493 # 若想同时获取key和value则可以用内置方法dict.items()：
494 # di = {'a': '1', 'b': '2'}
495 # for k,v in di.items():
496 # print(k,v)
497 # >>> 'a' '1'
498 # 'b' '2'
499 # 7、字典的基本方法：
500 # a. dict.clear()
501 # 用于清空字典
502 # di = {'a': '1', 'b': '2'}
503 # di.clear()
504 # print(di)
505 # >>> {}
506 # b. dict.copy()
507 # 用于复制（浅拷贝）字典
508 # di = {'a': '1', 'b': '2'}
509 # d = di.copy()
510 # print(d)
511 # >> > {'a': '1', 'b': '2'
512 # c. dict.fromkeys(iterable[,value])
513 # 该方法为静态方法（暂不懂），根据一个可迭代对象创建一个字典，并指定统一的值（若不传入，则为None）
514 # 第一个参数作为key，第二个参数作为value值
515 # di = dict.fromkeys(['a','b''c'])
516 # print(di)
517 # >>> {'a':None,'b':None,'c':None}
518 # di = dict.fromkeys(['a','b''c'],'abc')
519 # print(di)
520 # >>> {'a':'abc','b':'abc','c':'abc'}
521 # d. dict.get(key[,value])
522 # 用于根据key获取值，若key不存在，可以指定默认值，若不指定则返回None
523 # di = {'a': '1', 'b': '2'}
524 # v = di.get('a')
525 # print(v)
526 # >>> '1'
527 # 若取的值不存在有如下情况：
528 # di = {'a': '1', 'b': '2'}
529 # v = di.get('aa','abcd')
530 # print(v)
531 # >>> 'abcd'
532 # 而通过索引key来取值，若key不存在，则报错。
533 # e. dict.pop(key[,value])
534 # 用于移除并获取到指定指定的key对应的值，若key不存在，则返回指定的value值
535 # di = {'a': '1', 'b': '2'}
536 # v = di.pop('a')
537 # print(di,v)
538 # >>> {'b':'2'} '1'
539 # 若指定的key不存在，则传入的value值可起到作用而不报错
540 # di = {'a': '1', 'b': '2'}
541 # v = di.pop('c','3')
542 # print(di, v)
543 # >> > {'a':'1','b': '2'} '3'
544 # f. dict.popitem()
545 # 用于随机删除并获取键值对
546 # di = {'a': '1', 'b': '2'}
547 # v = di.popitem()
548 # print(di,v)
549 # >>> {'a':'1'} ('b',2)
550 # g. dict.setdefault(key,value)
551 # 用于设置值，若key已存在在当前字典中，则设置无效并返回当前key的值；若key不存在，则设置将指定的key，value添加到字典中
552 # di = {'a': '1', 'b': '2'}
553 # v = di.setdefault('a','111')
554 # print(di,v)
555 # >>> {'a':'1','b':'2'} '1'
556 # v1 = di.setdefault('c','3')
557 # print(di,v1)
558 # >>> {'a':'1','b':'2','c':'3'} '3'
559 # h. dict.update({key:value})
560 # 用于更新字典，key存在则更新指定的值，若不存在则直接添加到字典中
561 # ①可以直接传入字典形式
562 # di = {'a':'1','b':'2'}
563 # di.update({'a':'111','c':'3'})
564 # print(di)
565 # >>> {'a':'111','b':'2','c':'3'}
566 # ②可以指定key和value的形式进行传入
567 # di = {'a':'1','b':'2'}
568 # di.update(a = '111',c = '3')
569 # print(di)
570 # >>> {'a':'111','b':'2','c':'3'}
571 # 六、布尔值（bool）
572 # 在内存中bool值是以0 1存储的，0为False，1为True
573 # 还有None '' () [] {}这些均为False
574 # bool(对象)可用于将对象转换为bool值
575 # 七、enumerate(iterable[,startint])方法
576 # 该方法可用作获取列表、元组或者字典等元素的值与其对应的位置（或者索引），默认从0开始，也可以指定
577 # li = ['a','b','c','d','e']
578 # for i,v in enumerate(li,1):
579 # print(i,v)
