python lnum_Python基础-----数据类型

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=< [指定的位置]

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=< [指定的位置]

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=< [指定的位置]

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)