1 Day01
2 Exercise01
3 print("你好，世界！")
4 Exercise02
5 汇率转换器
6 # 获取数据 -- 美元
7 str_usd = input("请输入美元：")
8 int_usd = float(str_usd)
9 # 逻辑计算 -- 美元 × 7.1393
10 result = int_usd * 7.1393
11 # 显示结果 -- 人民币
12 print("结果是："+str(result))
13
14 # 1. 程序是改出来
15 # 2. 程序不是自上而下编写的，但是自上而下运行的。
16 # 3. 英语不好用词典
17 Exercise03
18 (1)指定范围内，列出素数
19 # 方法一
20 # def get_prime(begin,end):
21 # '''
22 # 指定范围内，列出素数
23 # :param begin: 范围起点
24 # :param end: 范围终点
25 # :return:素数列表
26 # '''
27 # list_result = []
28 # #生成范围内的整数
29 # for number in range(begin,end):
30 # # 判断素数
31 # for item in range(2,number):
32 # if number % item == 0:
33 # continue
34 # else:
35 # list_result.append(number)
36 # return list_result
37 # print(get_prime(5,10))
38
39 # 方法二 艺术讲究的是代码质量
40 # 第一步，判断一个数是不是素数
41 def is_prime(number):
42 '''
43 判断指定的数字是否为素数
44 :param number: 指定的整数
45 :return:True表示是素数，False表示不是素数
46 '''
47 for item in range(2, number):
48 if number % item == 0:
49 return False
50 return True
51
52 def get_prime(begin,end):
53 '''
54 获取范围内的素数
55 :param begin: 开始值（包含）
56 :param end: 结束值（不包含）
57 :return: 所有素数的列表
58 '''
59 return [number for number in range(begin,end) if is_prime(number)]
60 print(get_prime(5,30))
61
62 # 先写类型，在写逻辑
63 # 结构清晰，凸显艺术性
64 # 函数的定义：
65 # 1，用于封装一个特定的功能，表示一个功能或者行为
66 # 2，函数是可与重复执行的语句块，可以重复调用
67 # 作用：提高代码的可重复性和维护性（代码层次结构更清晰）
68
69 Day02
70 Review
71 复习
72 python执行方式
73 交互式 文件式
74 python执行过程
75 源代码 -"编译"-> 字节码 -解释-> 机器码
76 print("..") 01
77 """
78
79 Demo01
80 """
81 函数
82 """
83 #10:15 上课
84
85 # 字面意思：输入
86 # 作用：在终端中输入信息，按下回车后，信息进入程序(左边)。
87 # = 叫做 赋值 符号
88 msg = input("输吧：")
89 # 字面意思：打印/显示
90 # 作用：将程序中的信息，输出到终端。
91 print(msg)
92 Demo02
93 """
94 变量
95 练习:
96 exercise01.py
97 exercise02.py
98
99 程序运行在哪里？ 内存
100 程序在处理什么？ 数据
101 作用：程序存储数据
102 语法：名称 = 对象
103 本质：内存示意图
104 """
105
106 a = "赵敏"
107 b = "张无忌"
108 a = "敏儿"
109 # a与b的运算，实际操作的是变量ab所指向的数据。
110 # 运算结果产生新的对象
111 c = a + b
112 print(c)
113
114 #11:25
115 # 其他语法
116 num01 = name02 = 500
117 num03 , name04 = 800,1000
118 Demo03
119 """
120 数据类型
121 """
122
123 # 1. 整形 int
124 # 十进制：0123456789 10
125 a = 500
126 # 二进制(逢二进一):0 1 10
127 b = 0b10
128 # 八进制(逢八进一)：0 1 2 3 4 5 6 7 10 11 12
129 c = 0o10
130 # 十六进制：0 1 2 3 --> 9 a(10) --> f(15)
131 d = 0x10
132 print(d)
133
134 # type 函数 可以查看变量所指向的对象类型
135 print(type(a))
136
137 # 2. 浮点型
138 e = 1.23
139 # 以科学计数法表达
140 print(0.00000000000000000000005)# 5e-23
141 print(type(e))
142
143
144 # 3. 字符串 str
145 name = "张无忌"
146 f = "100"# 只是字符串不是整数100
147 print("name")# 打印name,而不是变量.
148
149 Demo04
150 """
151 数据类型转换
152 int float str
153
154 运算符
155
156 练习:exercise03.py
157 exercise04.py
158 exercise05.py
159 exercise06.py
160 exercise07.py
161
162 """
163 # 1. 类型转换
164 str01 = "100"
165 # str --> int
166 # 注意：如果字符串存储的数据,不像整形,转换失败.
167 int01 = int(str01)
168 re = int01 + 1
169 # int --> str
170 print("结果是：" + str(re))
171
172 # 2. 运算符
173 # (1)算数运算符+ - * / // % **
174 num01 = 5
175 num02 = 2
176 print(num01 / num02) # 2.5 除法：取最终结果
177 print(num01 // num02) # 2 除法：取整数商
178 print(num01 % num02) # 6 除法：取余数
179 print(56 % 10) # 获取个位
180
181 print(2 ** 6)
182 # (2) 增强运算符+= -= *= /= //= %= **=
183 num03 = num01 + 5 # 不会改变num01
184 num01 = num01 + 5 # 变量num01 加5后创建新对象，又赋值给自身.
185 print(num01) # 10
186
187 num01 += 5 # 相当于 num01 = num01 + 5
188 Demo05
189 """
190 数据类型
191 复数
192 bool
193 运算符
194 比较
195 逻辑
196 练习：exercise08.py
197 """
198 # 1.复数 = 实部 + 虚部
199 a = 10 + 3j
200 print(type(a))
201
202 # 2. bool 命题：带有判断性质的陈述句。
203 # 例如：我是一个男人. 结果：对True 错Flase
204 num01 = 10
205 num02 = 3
206 b = 10 < 3
207 print(b) # F
208
209 # 3. 比较运算符 > < >= <= 相同 == 不同!=
210 print(10.5 > 5) # 如果不能参与比较运算，会报错。
211
212 # 4. 逻辑运算符 and or not
213 # 判断bool的关系
214 # and 表示并且的关系（都得满足）, 现象：一假俱假
215 print(True and True) # True
216 print(True and False) # False
217 print(False and True) # False
218 print(False and False) # False
219 # or 表示或者的关系（满足一个就行）, 现象：一真俱真
220 print(True or True) # True
221 print(True or False) # True
222 print(False or True) # True
223 print(False or False) # False
224 # 非 （取反）
225 b = True
226 c = not b
227 print(c) # False
228 """
229 字符串字面值
230 练习:exercise06
231 """
232
233 # 1. 各种引号
234 str01 = "悟空"
235 str02 = '悟空'
236
237 # 可见即所得
238 str03 = """
239 悟
240 空
241 """
242 print(str03)
243 str04 = '''悟空'''
244
245 str05 = '我叫"孙悟空"'
246 str05 = "我叫'孙悟空'"
247
248 print(str05)
249
250 # 2.转义符：改变原始字符含义的特殊符号
251 # \" \' \\ \n 换行 \t
252 str06 = "我叫\'孙\n悟\t空\""
253 print(str06)
254
255 url = "C:\\nltk_data\corpora\\biocreative_ppi"
256 # 原始字符串（没有 转义符）
257 url = r"C:\nltk_dat\a\corpora\biocre\ative_ppi"
258 print(url)
259
260 # 3. 格式化
261 name = "悟空"
262 age = 3000
263 score = 99.99
264 print("%s的年龄是%d成绩是%.1f。"%(name,age,score))
265
266 Demo06
267 """
268 del 语句
269 空值对象None
270 """
271 a = 500
272 b = 800
273 c = a
274 d = b
275
276 Exercise01
277 """
278 画出下列代码内存图
279 """
280
281 class_name = 1908
282 stu_name = "小智"
283 class_name = stu_name
284 stu_name = "小霞"
285 print(class_name)# ?
286 Exercise02
287 """
288 画出下列代码内存图
289 """
290
291 # 变量交换
292 name01 = "苏大强"
293 name02 = "苏明玉"
294 temp = name01
295 name01 = name02
296 name02 = temp
297 print(name01) # ?
298 print(name02) # ?
299 Exercise03
300 """
301 练习1：在终端中获取一个变量
302 再获取另外一个变量
303 然后编写程序，交换两个变量的数据.
304 最后打印两个变量
305 """
306 variable01 = input("请输入第一个变量：")
307 variable02 = input("请输入第二个变量：")
308 # temp = variable01
309 # variable01 = variable02
310 # variable02 = temp
311 variable01,variable02 = variable02,variable01
312 print("变量1是：" + variable01)
313 print("变量2是：" + variable02)
314
315 Exercise04
316 """
317 练习2：在终端中获取一个商品单价。5
318 再获取一个购买的数量.3
319 最后获取支付的金额。20
320 计算应该找回多少钱。5 20 - 5 × 3
321 """
322 # 备注：float() int() 存在输入错误的风险
323 # 15:25 上课
324 str_price = input("请输入一个商品单价：")
325 float_price = float(str_price)
326
327 str_count = input("请输入一个购买的数量：")
328 int_count = int(str_count)
329
330 money = float(input("请输入支付的金额："))
331
332 result = money - float_price * int_count
333
334 print("结果是："+str(result))
335 Exercise05
336 """
337 古代的秤，一斤是十六量.
338 在终端中获取两，然后计算是几斤零几量
339 显示格式：几斤零几量
340 """
341 liang_weight = int(input("请输入两："))
342 jin = liang_weight // 16
343 liang = liang_weight % 16
344 print(str(jin) + "斤零" + str(liang) + "量")
345
346 Exercise06
347 """
348 练习:
349 公式：
350 距离 = 加速度 * 时间的平方 * 0.5 + 初速度 × 时间
351 已知(在终端中录入)：距离、时间、初速度
352 计算：加速度
353
354 (距离 - 初速度 × 时间) * 2/ 时间的平方 = 加速度
355 """
356 distance = float(input("请输入距离："))
357 initial_velocity = float(input("请输入初速度："))
358 time = float(input("请输入时间："))
359 accelerated_speed = (distance - initial_velocity * time) * 2 / time ** 2
360 print("加速度是：" + str(accelerated_speed))# round(accelerated_speed,2)
361
362 Exercise07
363 """
364 在终端中获取一个四位整数:1234
365 计算每位相加和 1+2+3+4
366 """
367 #16:50 上课
368 number = 1234
369 # # 方式1：
370 # # 个位
371 # unit01 = number % 10
372 # # 十位 1234 // 10 --> 123 % 10 --> 3
373 # unit02 = number // 10 % 10
374 # # 百位 1234 // 100 --> 12 % 10 --> 2
375 # unit03 = number // 100 % 10
376 # # 千位 1234 // 1000 --> 1
377 # unit04 = number // 1000
378 # result = unit01 + unit02 + unit03 + unit04
379 # print("结果是：" + str(result))
380
381 # 方式2：
382 result = number % 10
383 result += number // 10 % 10
384 result += number // 100 % 10
385 result += number // 1000
386 print("结果是：" + str(result))
387 Exercise08
388 # 练习：在终端获取年份(year),判断是否是闰年(True 是，Flase 不是)
389 # 条件：年份能被4整数，但是不能被100整除
390 # 年份能被400整除
391
392 year = int(input("请输入年份："))
393 result = year % 4 == 0 and year % 100 != 0 or year % 400 == 0
394 print("是否为闰年："+str(result))
395 day02 作业
396 1. 三合一
397 2. 当天练习独立完成
398 3. 画出下列代码内存图
399 name01 = "张翠山"
400 name03 = name02 = "张三丰"
401 name03 = "张无忌"
402 del name02
403
404 number01 = 500
405 number02 = number01
406 number01 = 800
407 print(number02)
408 4. 温度转换器：
409 摄氏度 = （华氏度 - 32） 除以 1.8
410 开氏度 = 摄氏度 + 273.15
411 (1)在终端中录入华氏度，计算摄氏度
412 (2)在终端中录入摄氏度，计算开氏度
413 5. (扩展)在控制台中录入一个秒，计算是几小时零几分钟零几秒钟.
414 6. 阅读：
415 程序员的数学第二/三章
416
417 Homework01
418 # 画图
419 name01 = "张翠山"
420 name03 = name02 = "张三丰"
421 name03 = "张无忌"
422 del name02
423
424 number01 = 500
425 number02 = number01
426 number01 = 800
427 print(number02)
428 Homework02
429 """
430 温度转换器：
431 摄氏度 = （华氏度 - 32） 除以 1.8
432 开氏度 = 摄氏度 + 273.15
433 (1)在终端中录入华氏度，计算摄氏度
434 (2)在终端中录入摄氏度，计算开氏度
435 """
436 # (1)在终端中录入华氏度，计算摄氏度
437 fahrenheit_degree = float(input("请输入华氏度"))
438 centigrade_degree = (fahrenheit_degree - 32) / 1.8
439 print("摄氏度是：" + str(centigrade_degree))
440
441 # (2)在终端中录入摄氏度，计算开氏度
442 centigrade_degree = float(input("请输入摄氏度"))
443 kelvin_degree = centigrade_degree + 273.15
444 print("开氏度是：" + str(kelvin_degree))
445 Homework03
446 """
447 (扩展)在控制台中录入一个秒，计算是几小时零几分钟零几秒钟.
448 """
449 # 10:40
450 total_second = int(input("请输入总秒数："))
451 second = total_second % 60
452 hour = total_second // 60 // 60
453 minute = total_second // 60 % 60
454 # 在字符串中插入变量：
455 # “...x...” “..."+变量+"...”
456 print(str(hour) + "小时零" + str(minute) + "分钟零" + str(second) + "秒钟")
457 Day03
458 图
459 Review
460 复习
461 数据的基本运算
462 变量：
463 名称 = 对象
464 名称1 = 名称2 = 对象
465 名称1,名称2 = 对象1,对象2
466 变量交换：
467 名称1,名称2 = 名称2,名称1
468
469 核心数据类型
470 整数int 小数float 字符串str 布尔bool
471 空值对象None
472 类型转换int() float() str() bool()
473 del 删除变量
474 运算符
475 算数运算 + - × / // % **
476 增强运算 += .... a = a + 10
477 比较运算 > < >= <= == !=
478 逻辑运算and(并且 都得满足) or(或者 满足一个) not
479 短路逻辑
480 """
481 year = 2019
482
483 # True and ？ --> 后面的命题决定最终结论
484 # False and ？ --> 后面的命题不影响最终结论
485 # 短路逻辑：前面的命题如果可以确定最终结论，后面命题不再执行。
486 # 启发：如果有多个命题，尽量将算法复杂的放置在最后。
487 b01 = year < 0 and print("看见我了吗？")
488
489 # True or ? --> 后面的命题不影响最终结论
490 # False or ? --> 后面的命题决定最终结论
491 b02 = year < 0 or print("看见我了吗？")
492
493
494
495 Demo01
496 """
497 行
498 """
499
500 # 3个物理行 3个逻辑行
501 a = 10
502 b = 20
503 c = a + b
504
505 # 1个物理行 3个逻辑行
506 a = 10;b = 20;c = a + b
507
508 # 3个物理行 1个逻辑行
509 d = 1 + 2 \
510 + 3 + \
511 4 + 5
512
513 e = 1 + (2 +
514 3 +
515 4) + 5
516 Demo02
517 """
518 选择语句
519 练习：exercise01.py
520 exercise02.py
521 exercise03.py
522 exercise04.py
523 exercise05.py
524 exercise06.py
525
526 if 条件:
527 满足条件执行的代码
528 else:
529 不满足条件执行的代码
530
531 """
532
533 # tab 选中的代码向右移动
534 # shift+tab 选中的代码向左移动
535 sex = input("请输入性别：")
536 # 如果是男的
537 # if sex == "男":
538 # print("您好,先生！")
539 # else:
540 # # 否则
541 # print("您好,女士！")
542
543 if sex == "男":
544 print("您好,先生！")
545 # 否则 如果
546 elif sex == "女":
547 print("您好,女士！")
548 else: # 否则
549 print("性别未知")
550
551 # 调试:让程序在指定的行中断,然后逐语句执行。
552 # 步骤:
553 # 1. 加断点（在可能出错的代码）
554 # 2. 调试
555 # 3. 逐语句执行
556 # 重点：
557 # 1. 审查程序执行流程
558 # 2. 检查变量取值
559 Demo03
560 """
561 真值表达式
562 条件表达式
563 练习：exercise07.py
564 """
565 # 1. 真值表达式
566 # if 10 != 0:
567 # if bool(10):
568 if 10:
569 print("满足条件")
570 # 作用：
571 msg = input("请输入：")
572 # if msg != "":
573 if msg:
574 print("输入的不是空字符串")
575 # 2. 条件表达式
576 # if input("请输入性别：") == "男":
577 # sex = 1
578 # else:
579 # sex = 0
580 sex = 1 if input("请输入性别：") == "男" else 0
581 Demo04
582 """
583 while 循环
584
585 while 条件:
586 循环体
587
588 练习:exercise08
589 """
590
591 # 死循环：循环条件永远满足
592 while True:
593 str_usd = input("请输入美元：")
594 int_usd = float(str_usd)
595 result = int_usd * 7.1393
596 print("结果是：" + str(result))
597
598 if input("输入e键退出") == "e":
599 break # 退出循环体
600 Demo05
601 """
602 循环计数
603 三要素：
604 初始值 循环条件 增减变量
605 起点 终点 跨度
606 练习:exercise09.py
607 exercise10.py
608 exercise11.py
609
610 """
611
612 # 需求：跑5圈
613 count = 0
614 while count < 5: # 0 1 2 3 4
615 print("跑圈")
616 count += 1 # count = count + 1
617 Demo06
618 """
619 while 条件:
620 循环体
621 else:
622 条件不满足，才执行的代码.
623 """
624
625 # 需求：3次
626
627 import random # 产生随机数的工具
628
629 # 产生随机数
630 random_number = random.randint(1, 100)
631 print(random_number)
632
633 count = 0
634 while count < 3:
635 count += 1
636 input_number = int(input("请输入数字："))
637 if input_number > random_number:
638 print("大了")
639 elif input_number < random_number:
640 print("小了")
641 else:
642 print("猜对了，总共猜了" + str(count) + "次")
643 break
644 else:# 只有猜错次数超过3次，才会执行else语句。(猜对了，不执行)
645 print("失败啦")
646 # 价值：判断循环结束，是因为不满足条件，还是循环体中的break,
647 Exercise01
648 # 练习：在day02/exercise04.py基础上，增加新功能。
649 # 如果钱不够提示"金额不足"
650 # 否则提示"应找回：xx元"
651
652 str_price = input("请输入一个商品单价：")
653 float_price = float(str_price)
654 str_count = input("请输入一个购买的数量：")
655 int_count = int(str_count)
656 money = float(input("请输入支付的金额："))
657 result = money - float_price * int_count
658
659 if result < 0:
660 print("金额不足")
661 else:
662 print("应找回："+str(result)+"元")
663 Exercise02
664 # 练习:在终端中获取一个季度(春夏秋冬)
665 # 显示相应的月份
666 # 春天：1月2月3月
667 # 夏天：4月5月6月
668 # 秋天：7月8月9月
669 # 冬天：10月11月12月
670
671 season = input("请输入季度：")
672 # if season == "春":
673 # print("1月2月3月")
674 # if season == "夏":
675 # print("4月5月6月")
676 # if season == "秋":
677 # print("7月8月9月")
678 # if season == "冬":
679 # print("10月11月12月")
680
681 if season == "春":
682 print("1月2月3月")
683 elif season == "夏":
684 print("4月5月6月")
685 elif season == "秋":
686 print("7月8月9月")
687 elif season == "冬":
688 print("10月11月12月")
689 Exercise03
690 # 练习:在终端中录入一个数字：
691 # 再终录入一个运算符：
692 # 最后终录入另外一个数字：
693 # 根据运算符计算数字
694 # 要求：运算符+-*/,如果输入其他符号，提示：运算符输入有误。
695
696 number_one = float(input("请输入第一个数字："))
697 operator = input("请输入运算符：")
698 number_two = float(input("请输入第二个数字："))
699 if operator == "+":
700 print(number_one + number_two)
701 elif operator == "-":
702 print(number_one - number_two)
703 elif operator == "*":
704 print(number_one * number_two)
705 elif operator == "/":
706 print(number_one / number_two)
707 else:
708 print("运算符输入有误")
709 Exercise04
710 """
711 练习:在终端中录入4个同学的体重
712 打印最重的数字。
713 思路：假设第一个就是最大值
714 如果第二个大于假设的，那么替换假设的。
715 如果第三个大于假设的，那么替换假设的。
716 如果第四个大于假设的，那么替换假设的。
717 最终，假设的就是最大的。
718 """
719 number01 = float(input("请输入第1个体重："))
720 number02 = float(input("请输入第2个体重："))
721 number03 = float(input("请输入第3个体重："))
722 number04 = float(input("请输入第4个体重："))
723
724 max_value = number01
725 if number02 > max_value:
726 max_value = number02
727 if number03 > max_value:
728 max_value = number03
729 if number04 > max_value:
730 max_value = number04
731
732 print(max_value)
733 Exercise05
734 # 练习：在终端中录入一个分数，显示等级.
735 # 不及格 及格 良好 优秀 输入有误(范围不在0--100之间)
736
737 score = float(input("请输入成绩："))
738 # if score >= 90 and score <= 100:
739 # print("优秀")
740 # elif score >= 80 and score < 90:
741 # print("良好")
742 # elif score >= 60 and score < 80:
743 # print("及格")
744 # elif score >= 0 and score < 60:
745 # print("不及格")
746 # else:
747 # print("输入有误")
748
749 # if 90 <= score <= 100:
750 # print("优秀")
751 # elif 80 <= score < 90:
752 # print("良好")
753 # elif 60 <= score < 80:
754 # print("及格")
755 # elif 0 <= score < 60:
756 # print("不及格")
757 # else:
758 # print("输入有误")
759
760 # score == 85
761
762 if score > 100 or score <0:
763 print("输入有误")
764 elif 90 <= score:
765 print("优秀")
766 elif 80 <= score:
767 print("良好")
768 elif 60 <= score:
769 print("及格")
770 else:
771 print("不及格")
772 Exercise06
773 # 练习：在终端中获取一个月份，年份，打印相应的天数.
774 # 1 3 5 7 8 10 12 --> 31天
775 # 2 --> 28(平年) 29(闰年)
776 # 4 6 9 11 --> 30天
777
778 year = int(input("请输入年份："))
779 month = int(input("请输入月份："))
780 if month < 1 or month > 12:
781 print("月份有误")
782 elif month == 2:
783 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
784 print("29天")
785 else:
786 print("28天")
787 elif month == 4 or month == 6 or month == 9 or month == 11:
788 print("30天")
789 else: # 1 3 5 7 8 10 12
790 print("31天")
791 Exercise07
792 练习1：在终端中录入一个整数，如果是奇数为变量state赋值"是奇数",
793 # 否则赋值"是偶数"。
794
795 # number = int(input("请输入整数："))
796 # if number % 2 == 1:
797 # state = "是奇数"
798 # else:
799 # state = "是偶数"
800
801 # number = int(input("请输入整数："))
802 # if number % 2:
803 # state = "是奇数"
804 # else:
805 # state = "是偶数"
806
807 state = "是奇数" if int(input("请输入整数：")) % 2 else "是偶数"
808 print(state)
809 # 练习2：在终端中录入一个年份，如果是闰年为变量day赋值29,
810 # 否则赋值28。
811 # year = int(input("请输入年份："))
812 # if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
813 # day = 29
814 # else:
815 # day = 28
816 # 不建议，太绕了。
817 # year = int(input("请输入年份："))
818 # if not year % 4 and year % 100 or not year % 400:
819 # day = 29
820 # else:
821 # day = 28
822 year = int(input("请输入年份："))
823 day = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
824 Exercise08
825 # 练习：改造exercise02,实现重复录入季度打印月份功能
826 # 如果输入q键，则程序停止。
827
828 while True:
829 season = input("请输入季度：")
830 if season == "春":
831 print("1月2月3月")
832 elif season == "夏":
833 print("4月5月6月")
834 elif season == "秋":
835 print("7月8月9月")
836 elif season == "冬":
837 print("10月11月12月")
838
839 if input("输入q键退出：") == "q":
840 break
841 Exercise09
842 # 练习1:在终端中显示0 1 2 3
843 count = 0
844 while count <= 3:
845 print(count)
846 count += 1
847 # 练习2:在终端中显示2 3 4 5 6
848 count = 2
849 while count <= 6:
850 print(count)
851 count += 1
852 # 练习3:在终端中显示1 3 5 7
853 count = 1
854 while count <= 7:
855 print(count)
856 count += 2
857 # 练习4:在终端中显示8 7 6 5 4
858 count = 8
859 while count >= 4: #
860 print(count)
861 count += -1
862 # 练习5:在终端中显示-1 -2 -3 -4 -5
863 count = -1
864 while count >= -5: #
865 print(count)
866 count += -1
867 # 16:55 上课
868 Exercise10
869 """
870 练习：
871 一张纸的厚度是0.01毫米
872 请计算，对折多少次超过珠穆朗玛峰(8844.43米).
873 """
874
875 # thickness = 0.01 / 1000
876 thickness = 1e-5
877 count = 0
878 while thickness < 8844.43:
879 # 对折
880 thickness *= 2
881 count += 1
882
883 print(count)
884 Exercise11
885 # 练习：猜数字1.0
886 # 程序产生1个1--100之间的随机数
887 # 在终端中重复猜测，直到猜对了为止
888 # 提示："大了" "小了" "猜对了，总共猜了?次"
889 import random # 产生随机数的工具
890
891 # 产生随机数
892 random_number = random.randint(1, 100)
893 count = 0
894 while True:
895 count += 1
896 input_number = int(input("请输入数字："))
897 if input_number > random_number:
898 print("大了")
899 elif input_number < random_number:
900 print("小了")
901 else:
902 print("猜对了，总共猜了" + str(count) + "次")
903 break
904 day03 作业
905 1. 三合一
906 2. 当天练习独立完成.
907 3. 在终端中获取月份，显示季度。
908 4. 在终端中获取年龄，显示
909 婴儿(0-1)、儿童(2-13)、青少年(14-20)、成年人(21-65)、老年人(66--150)、仙人(上不封顶)
910 5. 根据身高体重，参照BMI,返回身体状态。
911 BMI：用体重(千克)除以身高(米)的平方。
912 体重过低：小于18.5(不包含)
913 正常：18.5 -- 24(不包含)
914 超重：24 -- 28(不包含)
915 I度肥胖：28 -- 30(不包含)
916 II度肥胖：30 -- 40(不包含)
917 III度肥胖：大于40
918 要求：循环不断执行，如果身高是空字符串则退出。
919 6. 阅读：
920 python入门到实践 从一 – 五章
921 Homework01
922 """
923 在终端中获取月份，显示季度。
924 """
925 month = int(input("请输入月份："))
926 if month < 1 or month > 12:
927 print("月份输入有误")
928 elif month >= 10:
929 print("冬天")
930 elif month >= 7:
931 print("秋天")
932 elif month >= 4:
933 print("夏天")
934 else:
935 print("春天")
936 Homework02
937 """
938 在终端中获取年龄，显示
939 婴儿(0-1)、儿童(2-13)、青少年(14-20)、成年人(21-65)、老年人(66--150)、仙人(上不封顶)
940 """
941
942 age = int(input("请输入年龄："))
943 if age < 0:
944 print("输入有误")
945 elif age <= 1:
946 print("婴儿")
947 elif age <= 13:
948 print("儿童")
949 elif age <= 20:
950 print("青少年")
951 elif age <= 65:
952 print("成年人")
953 elif age <= 150:
954 print("老年人")
955 else:
956 print("仙人")
957 Homework03
958 """
959 根据身高体重，参照BMI,返回身体状态。
960 BMI：用体重(千克)除以身高(米)的平方。
961 体重过低：小于18.5(不包含)
962 正常：18.5 -- 24(不包含)
963 超重：24 -- 28(不包含)
964 I度肥胖：28 -- 30(不包含)
965 II度肥胖：30 -- 40(不包含)
966 III度肥胖：大于40
967 要求：循环不断执行，如果身高是空字符串则退出。
968 """
969 while True:
970 height = input("请输入身高(米)：")
971 # 短路思想
972 if height == "":
973 break
974 height = float(height)
975 weight = float(input("请输入体重(千克)"))
976 bmi = weight / height ** 2
977 if bmi < 18.5:
978 print("体重过低")
979 elif bmi < 24:
980 print("正常")
981 elif bmi < 28:
982 print("超重")
983 elif bmi < 24:
984 print("正常")
985 elif bmi < 30:
986 print("I度肥胖")
987 elif bmi < 40:
988 print("II度肥胖")
989 else:
990 print("III度肥胖")
991 Day04
992 Review
993 """
994 复习
995 语句
996 选择语句：让一条或多条语句有选择性的执行。
997 if bool条件:
998 满足条件执行的代码
999 elif 条件2:
1000 满足条件2执行的代码
1001 else:
1002 都不满足执行的代码
1003
1004 循环语句:让一条或多条语句重复执行。
1005 while 条件:
1006 满足条件执行的代码
1007 else:
1008 不满足循环条件执行的代码
1009
1010 while 不超过三次:
1011 猜数字
1012 if 猜对了:
1013 离开
1014 else:
1015 失败
1016 总结
1017 1. for + range
1018 2. 容器 --> 字符串 --> 编码、格式化字符串(占位符)
1019 --> 通用操作(索引/切片)
1020 --> 列表list(内存图、存储变量、可变)
1021 Demo01
1022 """
1023 for
1024
1025 for 变量名 in 可迭代对象：
1026 变量 存储的是可迭代对象中的元素
1027 """
1028
1029 for item in "我叫张无忌！":
1030 print(item)
1031
1032 Demo02
1033 """
1034 for + range
1035 练习:exercise02.py
1036 exercise03.py
1037 """
1038 # 预定次数
1039
1040 # range --> 1 2 3 4
1041 for element in range(1,5):
1042 print(element)
1043
1044 # range --> 0 1 2
1045 for element in range(3):
1046 print("跑圈")
1047
1048 # range --> 8 10 12 14
1049 for element in range(8,15,2):
1050 print(element)
1051
1052
1053 Demo03
1054 """
1055 continue
1056 练习：exercise04.py
1057 """
1058
1059 # 需求：累加1--100之间，能被5整除的数字.
1060 # sum_value = 0
1061 # for item in range(1, 101):
1062 # 思想：满足条件累加
1063 # if item % 5 == 0:
1064 # sum_value += item
1065 # print(sum_value)
1066 sum_value = 0
1067 for item in range(1, 101):
1068 # 思想：不满足条件跳过
1069 if item % 2 != 0:
1070 continue # 跳过本次循环
1071 sum_value += item
1072 print(sum_value)
1073 Demo04
1074 """
1075 字符串
1076 练习:exercise05
1077 """
1078 # 1. 不可变
1079 # 原因：如果在原有内存上修改数据，可能破坏其他对象的内存。
1080 name = "孙悟空"
1081 name = "悟空"
1082 print(name)# "齐天大圣"
1083
1084 # 2. 编码:让字符 转换为 数字
1085 # 字 --> 数
1086 number = ord("a")
1087 print(number)#97
1088 # 数 --> 字
1089 char = chr(97)
1090 print(char)# a
1091 Demo05
1092 """
1093 字符串通用操作
1094 练习：exercise07
1095 """
1096
1097 #1. 数学运算
1098 str01 = "八戒"
1099 str01 += "悟空"
1100 print(str01)# 八戒悟空
1101
1102 # 重复生成容器元素
1103 str01 *= 3
1104 print(str01)# 八戒悟空八戒悟空八戒悟空
1105
1106 # 2.成员运算 元素 in 容器 --> bool
1107 print("八戒" in str01)# true
1108
1109 # 3. 索引:定位单个元素
1110 str02 = "我是齐天大圣孙悟空。"
1111 print(str02[0])# 第一个字符
1112 print(str02[-1])# 最后一个字符
1113 # 正数第四个
1114 print(str02[3])
1115 # 倒数第三个
1116 print(str02[-3])
1117 # print(str02[50])# 索引不能超出界限 "索引越界"
1118 # print(str02[-30])
1119 # 4. 切片:定位多个元素 容器名[起点:终点:间隔]
1120 print(str02[2:6:1])# 齐天大圣
1121 print(str02[0:2])# 我是"""
1122 列表
1123 与字符串最大的区别：存储字符与存储变量、可变与不可变
1124 练习：exercise08.py
1125 """
1126
1127 # 1. 创建
1128 list01 = ["悟空",50,1.5,True]
1129 list02 = list("齐天大圣")# "齐天大圣" --> ["齐","天","大","圣"]
1130 print(list02)
1131 # 空列表
1132 list03 = []
1133 list04 = list()
1134
1135 # 2. 查询(索引/切片/循环)
1136 print(list01[-1])
1137 # 通过切片访问元素，会创建新列表
1138 print(list01[1:3])
1139 for item in list01:
1140 print(item)
1141
1142 # 3. 增加
1143 # 追加
1144 list01.append("唐僧")
1145 # 插入
1146 list01.insert(1,"八戒")
1147
1148 print(list01)
1149 # 4.修改
1150 list01[0] = "孙悟空"
1151 # 通过切片修改元素，不会创建新列表
1152 # list01[2:5] = [1,2,3]
1153 # list01[2:5] = [1]
1154 # list01[2:5] = [1,23,4,234,245,43,5,53,6]
1155 # list01[2:5] = 100 # 不是可迭代对象，不能通过切片修改.
1156 print(list01)
1157
1158 # 5.删除 del 变量
1159 # del
1160 del list01[0]
1161 del list01[1:3]
1162 # 根据元素
1163 list01.remove("唐僧")
1164 print(list01)
1165 print(str02[:2])# 我是
1166 print(str02[-4:-1])# 孙悟空
1167 print(str02[-4:])# 孙悟空
1168 print(str02[:])#我是齐天大圣孙悟空。
1169 print(str02[-2:-5:-1])#空悟孙
1170 print(str02[::-1])#。空悟孙圣大天齐是我
1171 print(str02[1:1])# 空的
1172 print(str02[3:1])# 空的
1173 print(str02[3:1:-1])# 天齐
1174 print(str02[-2:3:-1])# 空悟孙圣大
1175 print(str02[::2])# 我齐大孙空
1176 # 练习: “我是明教教主张无忌”
1177 # 打印第一个字符
1178 # 打印最后一个字符
1179 # 打印最后一个字符
1180 # 打印中间的字符
1181 # 打印前三个字符
1182 # 打印后三个字符
1183 # 打印 我教张
1184 # 忌张教明我
1185 # ...
1186 Demo06
1187 """
1188 列表
1189 与字符串最大的区别：存储字符与存储变量、可变与不可变
1190 练习：exercise08.py
1191 """
1192
1193 # 1. 创建
1194 list01 = ["悟空",50,1.5,True]
1195 list02 = list("齐天大圣")# "齐天大圣" --> ["齐","天","大","圣"]
1196 print(list02)
1197 # 空列表
1198 list03 = []
1199 list04 = list()
1200
1201 # 2. 查询(索引/切片/循环)
1202 print(list01[-1])
1203 # 通过切片访问元素，会创建新列表
1204 print(list01[1:3])
1205 for item in list01:
1206 print(item)
1207
1208 # 3. 增加
1209 # 追加
1210 list01.append("唐僧")
1211 # 插入
1212 list01.insert(1,"八戒")
1213
1214 print(list01)
1215 # 4.修改
1216 list01[0] = "孙悟空"
1217 # 通过切片修改元素，不会创建新列表
1218 # list01[2:5] = [1,2,3]
1219 # list01[2:5] = [1]
1220 # list01[2:5] = [1,23,4,234,245,43,5,53,6]
1221 # list01[2:5] = 100 # 不是可迭代对象，不能通过切片修改.
1222 print(list01)
1223
1224 # 5.删除 del 变量
1225 # del
1226 del list01[0]
1227 del list01[1:3]
1228 # 根据元素
1229 list01.remove("唐僧")
1230 print(list01)
1231 Exercise01
1232 # 练习：
1233 # 在终端中获取一个四位整数，计算每位相加和.
1234 # “1234” --> “1” --> 1
1235 # --> “2” --> 2
1236
1237 str_number = input("请输入整数：")
1238 result = 0
1239 for item in str_number:
1240 result += int(item)
1241 print(result)
1242
1243 # 三板斧：调试、 内存图、..
1244 # 10:15 上课
1245 Exercise02
1246 # 练习1:累加在终端中显示0 1 2 3
1247 sum_value = 0
1248 for item in range(4):
1249 sum_value += item
1250 print(sum_value)
1251 # 练习2:累加在终端中显示2 3 4 5 6
1252 sum_value = 0
1253 for item in range(2, 7):
1254 sum_value += item
1255 print(sum_value)
1256 # 练习3:累加在终端中显示1 3 5 7
1257 sum_value = 0
1258 for item in range(1, 8, 2):
1259 sum_value += item
1260 print(sum_value)
1261 # 练习4:累加在终端中显示8 7 6 5 4
1262 sum_value = 0
1263 for item in range(8, 3, -1):
1264 sum_value += item
1265 print(sum_value)
1266 # 练习5:累加在终端中显示-1 -2 -3 -4 -5
1267 sum_value = 0
1268 for item in range(-1, -6, -1):
1269 sum_value += item
1270 print(sum_value)
1271 Exercise03
1272 # 练习:随机加法考试题
1273 # 随机产生两个数字(1-10之间) 5 2
1274 # 在终端中获取两个数字相加的结果 “请输入5+2=?”
1275 # 如果回答正确加10分，错误减5分。
1276 # 总共3道题，最后显示得分。
1277 # 11:15
1278
1279 import random
1280
1281 score = 0
1282 for item in range(3):#0 1 2
1283 random_number01 = random.randint(1,10)
1284 random_number02 = random.randint(1,10)
1285 input_number = int(input("请输入"+str(random_number01)+"+"+str(random_number02)+"=?"))
1286 if input_number == random_number01 + random_number02:
1287 score += 10
1288 else:
1289 score -= 5
1290
1291 print("得分是："+str(score))
1292 Exercise04
1293 # 练习：累加10--50之间，个位不是2、5、9的整数
1294 sum_value = 0
1295 for item in range(10, 51):
1296 unit01 = item % 10
1297 if unit01 == 2 or unit01 == 5 or unit01 == 9:
1298 continue
1299 sum_value += item
1300 print(sum_value)
1301
1302 # 总结：
1303 # 循环语句
1304 # for：预定次数 for item in range(次数)
1305 # 经典案例：3道考试题
1306 # while：不知道次数，但知道循环条件。while 条件：
1307 # 经典案例：纸张对折到8848m。
1308 # 循环的价值：累加4位整数 -变成-> 累加n位整数
1309 Exercise05
1310 # 练习1：在终端中获取一个字符串，循环打印每个字符的编码.
1311 str_input = input("请输入字符串：")
1312 for item in str_input:
1313 print(ord(item))
1314
1315 # 练习2：在终端中反复录入一个编码值，然后打印字符串。
1316 # 如果录入空字符串，则退出程序。
1317 while True:
1318 str_input = input("请输入：")
1319 if str_input == "":
1320 break
1321
1322 code_value = int(str_input)
1323 print(chr(code_value))
1324 Exercise06
1325 # 练习:在终端中输出下列内容，将?换成变量.
1326 # ?斤零?两
1327 jin, liang = 10, 5
1328 print("%d斤零%d两" % (jin, liang))
1329
1330 # ?+?=?
1331 number01, number02 = 20, 10.5
1332 print("%.1f+%.1f=%.1f" % (number01, number02, number01 + number02))
1333
1334 # 我的名字是?,成绩是?。
1335 name, score = "悟空", 100
1336 print("我的名字是%s,成绩是%d。" % (name, score))
1337
1338 # 15:30 上课
1339 Exercise07
1340 # 练习: “我是明教教主张无忌”
1341 # 16:50 上课
1342 str01 = "我是明教教主张无忌"
1343 # 打印第一个字符
1344 print(str01[0])
1345 # 打印最后一个字符
1346 print(str01[-1])# 通过反向索引
1347 print(str01[len(str01)-1])# 通过正向索引
1348 # 打印中间的字符
1349 print(str01[len(str01) // 2])
1350 # 打印前三个字符
1351 print(str01[:3])# 通过反向索引
1352 # 打印后三个字符
1353 print(str01[-3:])# 通过反向索引
1354 # 打印 我教张
1355 print(str01[::3])# 通过反向索引
1356 # 忌张教明我
1357 print(str01[::-2])# 通过反向索引
1358 # ...
1359 print(str01[2:20])# 通过反向索引
1360 Exercise08
1361 """
1362 练习：
1363 1. 创建列表，存储八大行星.
1364 2. 打印距离太阳最近的行星(第一个元素).
1365 3. 打印距离太阳最远的行星(最后一个元素).
1366 4. 打印金星到天王星之间的行星.
1367 5. 正向打印所有行星(一行一个)
1368 6. 反向打印所有行星(一行一个)
1369 """
1370
1371 list_planets = ["水星", "金星", "地球", "火星", "木星", "土星", "天王星", "海王星"]
1372 print(list_planets[0])
1373 print(list_planets[-1])
1374 print(list_planets[2:-2])
1375 for item in list_planets:
1376 print(item)
1377 # 反向
1378 # 通过切片实现
1379 for item in list_planets[::-1]:
1380 print(item)
1381 # 通过索引实现
1382 for i in range(len(list_planets) - 1, -1, -1):
1383 print(list_planets[i])
1384 day04作业
1385 1. 三合一
1386 2. 当天练习独立完成
1387 3. 在终端中获取一个整数，
1388 作为边长，打印矩形。
1389 例如:边长3
1390 ***
1391 * *
1392 ***
1393 例如:边长5
1394 *****
1395 * *
1396 * *
1397 * *
1398 *****
1399 4. 判断一个字符串是否是回文
1400 回文:上海自来水来自海上
1401 思路:正向 == 反向
1402
1403 5. (扩展)
1404 一个小球从100米高度落下
1405 每次弹回原高度一半
1406 请计算：
1407 (1)总共弹起来多少次(最小弹起高度是0.01m)?
1408 (2)整个过程总共走了多少米?
1409 Homework01
1410 """
1411 3. 在终端中获取一个整数，
1412 作为边长，打印矩形。
1413 例如:边长3
1414 ***
1415 * *
1416 ***
1417 例如:边长5
1418 *****
1419 * *
1420 * *
1421 * *
1422 *****
1423 """
1424
1425 number = int(input("请输入整数："))
1426 print("*" * number)
1427 for item in range(number - 2):
1428 print("*" + " " * (number - 2) + "*")
1429 print("*" * number)
1430 Homework02
1431 """
1432 4. 判断一个字符串是否是回文
1433 回文:上海自来水来自海上
1434 思路:正向 == 反向
1435 """
1436 str01 = "上海自来水来自海上"
1437 if str01 == str01[::-1]:
1438 print("是回文")
1439 else:
1440 print("不是回文")
1441 Homework03
1442 """
1443 一个小球从100米高度落下
1444 每次弹回原高度一半
1445 请计算：
1446 (1)总共弹起来多少次(最小弹起高度是0.01m)?
1447 (2)整个过程总共走了多少米?
1448 """
1449 height = 100
1450 count = 0
1451 distance = height
1452 # 当前高度
1453 # while height > 0.01:
1454 # 弹起来的高度
1455 while height / 2 > 0.01:
1456 count += 1
1457 # 弹起来
1458 height /= 2
1459 # print("第%d次弹起高度是%f米." % (count, height))
1460 distance += height * 2 # 累加起/落距离
1461
1462 print("总共弹起来%d次。" % count)
1463 print("总共经过%.2f米" % distance)
1464 # 10:15 上课
1465
1466 Day05
1467 Review
1468 """
1469 复习
1470 语句
1471 选择
1472 if 条件:
1473 满足条件执行的代码
1474 else:
1475 不满足条件执行的代码
1476
1477 循环
1478 while 条件:
1479 循环体
1480 else:
1481 不满足条件执行的代码
1482
1483 for 变量 in 可迭代对象：
1484 循环体
1485 可迭代对象：容器(str/list....),
1486
1487 range:整数生成器
1488 range(起点,终点,间隔)
1489 -- 不包含终点
1490 -- 起点默认0
1491 -- 间隔默认1
1492 -- 通过for获取整数
1493
1494 for + range:预定次数
1495 while:已知条件
1496
1497 跳转
1498 在循环内部使用
1499 break : 中断循环
1500 continue：跳过一次
1501
1502 容器
1503 字符串str:存储字符编码,不可变序列.
1504 列表list:存储变量,可变序列.
1505 """
1506
1507
1508 Demo01
1509 """
1510 list 内存图
1511 练习:exercise01.py
1512 exercise02.py
1513 exercise03.py
1514 """
1515 list01 = ["唐僧", "悟空", "八戒"]
1516 list01.append("沙僧")
1517 # 将list01存储的列表地址赋值给list02(两个变量指向同一个列表对象)
1518 list02 = list01
1519 list01[0] = "唐三藏"
1520 print(list02[0]) # "唐三藏"
1521
1522 list01 = [800, 1000]
1523 list01.append(900)
1524 # 将list01指向的列表拷贝一份(创建了新列表),再赋值给list02(两个变量指向不同的列表对象)
1525 list02 = list01[:]
1526 # 所以修改其中一个列表对象，不影响另外一个列表对象.
1527 list01[0] = 500
1528 print(list02[0]) # 800
1529
1530 list01 = [300]
1531 list02 = list01
1532 # 修改的是变量list01的指向（列表对象没有变化）
1533 list01 = 500
1534 print(list02[0]) # 300
1535
1536 list01 = [300, 400, 500]
1537 # 将list01指向的列表倒叙拷贝一份(创建新列表)
1538 list02 = list01[::-1]
1539 # 遍历列表["四百","五百","六百"],将所有元素插入到list01指向的列表中。
1540 list01[1:2] = ["四百", "五百", "六百"]
1541 print(list01)
1542 print(list02)
1543
1544 list01 = [1, 2]
1545 # 向列表追加一个元素(列表)
1546 list01.append([3, 4])
1547 # list02 = list01[:]
1548 # 浅拷贝
1549 list02 = list01.copy()
1550 # 修改列表第三个元素（列表）的第一个元素
1551 list01[2][0] = "三"
1552 print(list02[2][0])
1553
1554 list01 = [100, [200, 300]]
1555 # 将list01存储的列表地址赋值给变量list02
1556 list02 = list01
1557 # 将list01存储的列表浅拷贝一份(创建新列表)
1558 list03 = list01[:]
1559 # 同上
1560 # list03 = list01.copy()
1561 # 深拷贝
1562 import copy
1563
1564 list04 = copy.deepcopy(list01)
1565 # 优点：深拷贝后的数据，与之前的数据互不影响。
1566 # 缺点：由于拷贝整个依赖的数据，所以特别占用内存。
1567
1568
1569 list01 = [500, 600, 700]
1570 list02 = [500, 600, 700]
1571 # 比较的是list01指向的对象与list02指向的对象
1572 print(list01 == list02)# true
1573 # is 比较的是变量list01存储的地址与变量list02存储的地址
1574 print(list01 is list02)# false
1575 # is 的本质比较地址 id(变量) 返回变量指向的对象地址
1576 print(id(list01) == id(list02)) # false
1577 Demo02
1578 """
1579 list --> str
1580 练习:exercise04.py
1581 """
1582
1583 # 需求: 根据某些逻辑，拼接字符串.
1584 # 0123456789
1585 # str_result = ""
1586 # for item in range(10):
1587 # # 两个字符串拼接，会产生新的字符串对象，
1588 # str_result = str_result + str(item)
1589 # print(str_result)
1590
1591 list_result = []
1592 for item in range(10):
1593 # 将新字符串追加到列表中，不会产生新对象
1594 list_result.append(str(item))
1595 str_result = "".join(list_result)
1596 print(str_result)
1597 Demo03
1598 """
1599 str --> list
1600 练习：exercise05.py
1601 """
1602
1603 # 使用一个字符串记录多个数据
1604 # 使用分割符隔离多个数据
1605 str01 = "孙悟空-猪八戒-qtx"
1606 list_result = str01.split("-")
1607 print(list_result)
1608 Demo04
1609 """
1610 列表推导式
1611 练习:exercise06.py
1612 """
1613 # 需求1：将list01中的每个元素增加1以后，存入list02中。
1614 list01 = [4, 54, 5, 65, 76, 89, 4]
1615 # list02 = []
1616 # for item in list01:
1617 # list02.append(item + 1)
1618 list02 = [item + 1 for item in list01]
1619 print(list02)
1620
1621 # 需求2：将list01中的所有偶数，存入list03中。
1622 # list03 = []
1623 # for item in list01:
1624 # if item % 2 == 0:
1625 # list03.append(item)
1626 list03 = [item for item in list01 if item % 2 == 0]
1627 print(list03)
1628 Demo05
1629 """
1630 元组tuple
1631 练习:exercise07.py
1632 练习:exercise08.py
1633 """
1634 # 1. 创建
1635 tuple01 = (1, 2, 3, 4)
1636 tuple02 = ()
1637 # list 预留空间 --> tuple 按需分配
1638 tuple03 = tuple(["a", "b", "c"])
1639 list03 = list(tuple03)
1640
1641 # tuple04 = ("a") # 类型是str
1642 tuple04 = ("a",) # 如果元组中只有一个元素，那么必须加上逗号.
1643 print(type(tuple04))
1644
1645 tuple05 = 1, 2, 3
1646
1647 # 可以直接从序列给多个变量赋值
1648 name01, name02 = ("张无忌", "孙悟空")
1649
1650 # 2. 查询(索引/切片/循环)
1651 print(tuple03[-1])
1652 print(tuple03[::-1]) # 元组切片的结果还是元祖
1653 for item in tuple03:
1654 print(item)
1655
1656 for i in range(len(tuple03) - 1, -1, -1):
1657 print(tuple03[i])
1658 Exercise01
1659 """
1660 练习1：在终端中循环录入学生的成绩,
1661 如果录入空字符串,则停止。
1662 打印最高分、最低分、平均分。
1663 """
1664 list_score = []
1665 while True:
1666 str_score = input("请输入学生成绩：")
1667 if str_score == "":
1668 break
1669
1670 list_score.append(float(str_score))
1671
1672 print(max(list_score))
1673 print(min(list_score))
1674 print(sum(list_score) / len(list_score))
1675 Exercise02
1676 """
1677 练习2：在终端中循环录入你喜欢的人名：
1678 如果录入空字符串,则停止。
1679 将所有人倒序打印在终端中（一人一行）
1680 要求：如果名称重复提示"已经存在"，不再存储。
1681 """
1682 list_name = []
1683 while True:
1684 name = input("请输入您喜欢的人名：")
1685 if name == "":
1686 break
1687 if name in list_name:
1688 print("已经存在")
1689 else:
1690 list_name.append(name)
1691 # 通过切片访问列表元素(浅拷贝列表)
1692 # for item in list_name[::-1]:
1693 # print(item)
1694 # 通过索引访问列表元素
1695 for i in range(len(list_name) - 1, -1, -1):
1696 print(list_name[i])
1697 Exercise03
1698 # 练习3：将列表[4,5,6,4,8,9]中所有偶数删除
1699
1700 list01 = [4, 5, 6, 4, 8, 9]
1701 # for item in list01:
1702 # if item % 2 == 0:
1703 # # 删除的是变量item，而不是列表中的元素
1704 # del item
1705
1706 # for i in range(len(list01)):
1707 # if list01[i] % 2 == 0:
1708 # # 删除列表中的元素
1709 # 删除元素时，后一个元素向前赋值，总会错过。
1710 # del list01[i]
1711 #
1712
1713 # 方案1
1714 # for i in range(len(list01)-1,-1,-1):
1715 # if list01[i] % 2 == 0:
1716 # del list01[i]
1717 #
1718
1719 # 方案2
1720 # for item in list01[::-1]:
1721 # if item % 2 == 0:
1722 # list01.remove(item)
1723 # 15:30 上课
1724 for i in range(len(list01)-1,-1,-1):
1725 if list01[i] % 2 == 0:
1726 list01.remove(list01[i])
1727
1728 print(list01)
1729 Exercise04
1730 练习:在终端中循环录入字符串，如果录入空字符，则停止录入.
1731 # 最后打印录入的内容（一个字符串）
1732
1733 list_result = []
1734 while True:
1735 str_input = input("请输入内容：")
1736 if str_input == "":
1737 break
1738 list_result.append(str_input)
1739
1740 str_result = "".join(list_result)
1741 print(str_result)
1742 Exercise05
1743 # 练习:将英文语句，进行单词反转(结果还是str).
1744 # "How are you" --> you are How
1745
1746 str_message = "How are you"
1747 list_temp = str_message.split(" ")
1748 str_result = " ".join(list_temp[::-1])
1749 print(str_result)
1750
1751
1752 Exercise06
1753 # 练习1:使用列表推导式生成1--50之间能被3 或者 5 整除的数字.
1754 # result01 = []
1755 # for item in range(1,51):
1756 # if item % 3 == 0 or item % 5 == 0:
1757 # result01.append(item)
1758
1759 result01 = [item for item in range(1,51) if item % 3 == 0 or item % 5 == 0]
1760
1761 # 练习2:使用列表推导式生成5 -- 20 之间数字的平方.
1762 result02 = [item ** 2 for item in range(5,21)]
1763 print(result01)
1764 print(result02)
1765
1766 # 16:50
1767 Exercise07
1768 """
1769 使用容器思想，改造根据月份计算天的功能。
1770 """
1771
1772 year = int(input("请输入年份："))
1773 month = int(input("请输入月份："))
1774 if month < 1 or month > 12:
1775 print("月份有误")
1776 elif month == 2:
1777 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
1778 print("29天")
1779 else:
1780 print("28天")
1781 # elif month == 4 or month == 6 or month == 9 or month == 11:
1782 elif month in (4,6,9,11):
1783 print("30天")
1784 else: # 1 3 5 7 8 10 12
1785 print("31天")
1786
1787 # 思路：将每月的天数，统一存入元组.
1788 # days_of_month = (31,?,31,30,31,30,31,31,30,31,30,31)
1789 # days_of_month[2]
1790 Exercise08
1791 # 练习: 在终端中录入年月日，计算这是这一年的第几天.
1792 # 2019 年 3 月 5 日
1793 # 31 + 28 + 5
1794
1795 year = int(input("请输入年份："))
1796 month = int(input("请输入月份：")) # 3
1797 day = int(input("请输入天：")) # 5
1798
1799 if month <1 or month > 12:
1800 print("月份有误")
1801 else:
1802 # 计算2月的天数
1803 day_of_month02 = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
1804 # 存储每月的天数
1805 days_of_month = (31, day_of_month02, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
1806
1807 # total_day = 0
1808 # for i in range(month - 1):
1809 # total_day+= days_of_month[i]
1810
1811 total_day = sum(days_of_month[:month - 1])
1812
1813 total_day += day
1814
1815 print(total_day)
1816 day05 作业：
1817 1. 三合一
1818 2. 当天练习独立完成
1819 3. 画出下列代码内存图
1820 name01 = "孙悟空"
1821 names = ["八戒"]
1822 tuple01 = ("唐僧",name,names)
1823 name = "齐天大圣"
1824 names[0] = "天蓬元帅"
1825 print(tuple01)
1826
1827 4. 将1970年到2050年之间所有闰年，存入列表.
1828
1829 5. 将元组(4,5,15,6,7,8)中最大的数字找出来。(不使用max)
1830 思想:假设第一个元素就是最大的
1831 依次与后面的元素进行比较，如果大于假设的，则替换。
1832
1833 6. 彩票：双色球
1834 红色：6个 1--33之间的整数 不能重复
1835 蓝色：1个 1--16之间的整数
1836 1) 随机产生一注彩票(列表(前六个是红色，最后一个蓝色))
1837 2) 在终端中录入一支彩票
1838 要求：满足彩票的规则.
1839 Homework01
1840 """
1841 画图
1842 name01 = "孙悟空"
1843 names = ["八戒"]
1844 tuple01 = ("唐僧",name,names)
1845 name = "齐天大圣"
1846 names[0] = "天蓬元帅"
1847 print(tuple01)
1848 """
1849 name = "孙悟空"
1850 names = ["八戒"]
1851 tuple01 = ("唐僧", name, names)
1852 name = "齐天大圣"
1853 names[0] = "天蓬元帅"
1854 print(tuple01)
1855 Homework02
1856 """
1857 将1970年到2050年之间所有闰年，存入列表.
1858 """
1859 # list_year = []
1860 # for item in range(1970,2051):
1861 # if item % 4 ==0 and item % 100 != 0 or item % 400 == 0:
1862 # list_year.append(item)
1863
1864 list_year = [item for item in range(1970, 2051) if item % 4 == 0 and item % 100 != 0 or item % 400 == 0]
1865 print(list_year)
1866 Homework03
1867 """
1868 将元组(4,5,15,6,7,8)中最大的数字找出来。(不使用max)
1869 思想:假设第一个元素就是最大的
1870 依次与后面的元素进行比较，如果大于假设的，则替换。
1871 """
1872 tuple01 = (4, 5, 15, 6, 7, 8)
1873 max_value = tuple01[0]
1874 # 与后面元素（ tuple01[i] ）进行比较
1875 for i in range(1, len(tuple01)):
1876 if max_value < tuple01[i]:
1877 max_value = tuple01[i]
1878 print(max_value)
1879 Homework04
1880 """
1881 6. 彩票：双色球
1882 红色：6个 1--33之间的整数 不能重复
1883 蓝色：1个 1--16之间的整数
1884 1) 随机产生一注彩票(列表(前六个是红色，最后一个蓝色))
1885 2) 在终端中录入一支彩票
1886 要求：满足彩票的规则.
1887 """
1888 import random
1889 # 10:20 上课
1890 # 1) 随机产生一注彩票(列表(前六个是红色，最后一个蓝色))
1891 list_ticket = []
1892 while len(list_ticket) < 6:
1893 number = random.randint(1, 33)
1894 if number not in list_ticket:
1895 list_ticket.append(number)
1896
1897 list_ticket.append(random.randint(1, 16))
1898 print(list_ticket)
1899
1900 # 2) 在终端中录入一支彩票
1901 list_ticket = []
1902 while len(list_ticket) < 6:
1903 number = int(input("请输入第%d个红球号码：" % (len(list_ticket) + 1)))
1904 if number in list_ticket:
1905 print("号码已经存在")
1906 elif number < 1 or number > 33:
1907 print("号码不在范围内")
1908 else:
1909 list_ticket.append(number)
1910
1911 while len(list_ticket) < 7:
1912 number = int(input("请输入蓝球号码："))
1913 if number < 1 or number > 16:
1914 print("号码不在范围内")
1915 else:
1916 list_ticket.append(number)
1917 print(list_ticket)
1918 Day06
1919 Review
1920 """
1921 复习
1922 容器
1923 str：存储字符编码值，不可变序列.
1924 list：存储变量，可变序列. 【预留空间】
1925 tuple：存储变量，不可变序列. 【按需加载】
1926 ...
1927 创建
1928 str01 = ""
1929 str02 = str(其他类型对象)
1930
1931 list01 = []
1932 list02 = list(可迭代对象)
1933
1934 tuple01 = ()
1935 tuple02 = tuple(可迭代对象)
1936
1937 查询(索引/切片/循环)
1938 print(str01[-1])
1939 print(list01[-3:])
1940 for itme in tuple02:
1941 print(itme)
1942 for i in range(len(tuple02)-1,-1,-1):
1943 print(tuple02[i])
1944
1945 修改
1946 str01 += "a"
1947 tuple01 += ("a",) # 容器拼接后产生新对象
1948 list01 += ["a"] # 在原有列表基础上增加新元素
1949 list01[0] = 数据
1950 list01[1:3] = 可迭代对象
1951
1952 删除
1953 list01.remove(元素)
1954 del list01[索引]
1955 del list01[切片]
1956
1957 通用操作
1958 + * == ！= in
1959 """
1960 tuple01 = ("e",)
1961 # print(id(tuple01))
1962 tuple01 += ("a",)
1963 # print(id(tuple01))
1964 print(tuple01)
1965
1966
1967 list01 = ["e"]
1968 print(id(list01))
1969 # list01.append("a")
1970 list01 += ["a"]
1971 print(id(list01))
1972
1973 print(list01)
1974
1975 Demo01
1976 """
1977 字典
1978 练习：exercise01.py
1979 exercise02.py
1980 exercise03.py
1981 """
1982 # 11:20上课
1983
1984 # 1. 创建
1985 dict01 = {101:"悟空"}
1986 dict02 = {}
1987
1988 dict03 = dict([("a","b"),("c","d")])
1989 print(dict03)
1990
1991 #2. 查询(键/循环)
1992 print(dict03["a"])
1993
1994 # 获取所有key
1995 for key in dict03:
1996 print(key)
1997 print(dict03[key])
1998
1999 for element in dict03.items():
2000 print(element)# 元组
2001
2002 # 获取所有记录(键值对)
2003 for k,v in dict03.items():
2004 print(k)
2005 print(v)
2006
2007 # 获取所有值
2008 for v in dict03.values():
2009 print(v)
2010
2011 # 注意：如果查找不存在的key,会报错
2012 if "q" in dict03:
2013 print(dict03["q"])
2014
2015 # 3.增加 dict03[键] = 值
2016 dict03["bj"] = "八戒"
2017 dict03["ds"] = "大圣"
2018
2019 # 4. 修改
2020 dict03["ds"] = "齐天大圣"
2021
2022 # 5. 删除
2023 del dict03["bj"]
2024
2025 print(dict03)
2026
2027
2028 Demo02
2029 """
2030 字典推导式
2031 练习：exercise04.py
2032 """
2033 # 需求：range(10) key:0--9 value: 键的平方
2034 # dict01 = {}
2035 # for item in range(10):
2036 # dict01[item] = item ** 2
2037
2038 dict01 = {item: item ** 2 for item in range(10)}
2039 print(dict01)
2040
2041 # 需求：range(10) key:0--9 value: 键的平方
2042 # 2 < key < 8
2043 dict01 = {item: item ** 2 for item in range(10) if 2 <item<8}
2044 print(dict01)
2045 Demo03
2046 """
2047 集合
2048 价值：去重复(容器转换)
2049 """
2050
2051 # 1. 创建
2052 set01 = {"悟空", "八戒", "唐僧"}
2053 print(type(set01))
2054 # set02 = {} # 创建的是字典，不是集合.
2055 set02 = set([23, 78, 5, 78, 67, 78, 78])
2056 set03 = set({"a": "A", "b": "B"})
2057
2058 # 2. 查询(循环)
2059 for item in set01:
2060 print(item)
2061
2062 # 3. 添加
2063 set01.add("白龙马")
2064
2065 # 3. 修改(由于无法定位元素，所以改不了)
2066 # 4. 删除
2067 # set01.remove("悟空2")# 如果不存在则错误
2068 set01.discard("悟空2")# 即使不存在也不会错误
2069 print(set01)
2070
2071 # 数学运算
2072 set01 = {1, 2, 3}
2073 set02 = {2, 3, 4}
2074 # 交集 (重合)
2075 print(set01 & set02) # {2, 3}
2076 # 并集
2077 print(set01 | set02) # {1, 2, 3, 4}
2078 # 对称补集
2079 print(set01 ^ set02) # {1, 4}
2080 print(set01 - set02) # {1}
2081 print(set02 - set01) # {4}
2082 # 子集(set03) 超集(set01)
2083 set03 = {2, 3}
2084 print(set03 < set01) # true
2085
2086 Demo04
2087 """
2088 for for
2089 练习：exercise06.py
2090 """
2091
2092 # 外层循环控制行
2093 for r in range(3):# 0 1 2
2094 #内层循环控制列
2095 for c in range(5):#01234 01234 01234
2096 print("*",end = " ")
2097 print()
2098 Exercise01
2099 """
2100 练习1: 在终端中循环录入商品信息(名称、价格),
2101 如果名称是空字符串，则停止。
2102 -- 将所有商品的名称与价格打印出来(一个商品一行)
2103 -- 如果录入了"游戏机",则单独打印其价格.
2104 """
2105 dict_commodity_info = {}
2106 while True:
2107 name = input("请输入商品名称：")
2108 if name == "":
2109 break
2110 price = float(input("请输入价格："))
2111 dict_commodity_info[name] = price
2112 for k, v in dict_commodity_info.items():
2113 print("%s商品的价格是%f" % (k, v))
2114 if "游戏机" in dict_commodity_info:
2115 print(dict_commodity_info["游戏机"])
2116 Exercise02
2117 """
2118 练习2: 在终端中循环录入人的信息(名字、年龄、性别、体重...),
2119 如果名称是空字符串，则停止。
2120 -- 将所有人的信息打印出来(一个人一行)
2121 -- 如果录入了"张无忌",则单独打印其信息(名字、年龄、性别、体重...).
2122 数据结构：
2123 {
2124 "张无忌":[26,"男",50],
2125 "赵敏":[24,"女",40]
2126 }
2127 """
2128
2129 dict_person_info = {}
2130 while True:
2131 name = input("请输入人的名称：")
2132 if name == "":
2133 break
2134 age = int(input("请输入年龄："))
2135 sex = input("请输入性别：")
2136 weight = float(input("请输入体重："))
2137 dict_person_info[name] = [age, sex, weight]
2138
2139 for k_name, v_info in dict_person_info.items():
2140 print("%s的年龄是%d,性别是%s,体重是%f" % (k_name, v_info[0], v_info[1], v_info[2]))
2141
2142 if "张无忌" in dict_person_info:
2143 list_info = dict_person_info["张无忌"]
2144 print("张无忌的年龄是%d,性别是%s,体重是%f" % (list_info[0], list_info[1], list_info[2]))
2145 Exercise03
2146 """
2147 练习2: 在终端中循环录入人的信息(名字、年龄、性别、体重...),
2148 如果名称是空字符串，则停止。
2149 -- 将所有人的信息打印出来(一个人一行)
2150 -- 打印最后一个人的信息(名字、年龄、性别、体重...).
2151 数据结构：
2152 [
2153 {"name":"张无忌","age":26,"sex":"男","weight":50},
2154 {"name":"赵敏","age":24,"sex":"女","weight":40},
2155 ]
2156
2157 总结：存储多个数据，使用什么数据结构？
2158 根据需求，结合优缺点，综合考虑(两害相权取其轻)
2159
2160 列表
2161 优点：获取数据更为灵活(索引/切片)
2162 缺点：遍历元素获取数据，速度慢.
2163
2164 字典：
2165 优点：根据key获取值，速度快.
2166 缺点：获取数据不灵活(键)
2167 因为散列更占内存
2168 """
2169
2170 list_person_info = []
2171 while True:
2172 name = input("请输入人的名称：")
2173 if name == "":
2174 break
2175 age = int(input("请输入年龄："))
2176 sex = input("请输入性别：")
2177 weight = float(input("请输入体重："))
2178 dict_info = {"name": name, "age": age, "sex": sex, "weight": weight}
2179 list_person_info.append(dict_info)
2180
2181 for dict_item in list_person_info:
2182 print("%s的年龄是%d,性别是%s,体重是%f" % (dict_item["name"], dict_item["age"], dict_item["sex"], dict_item["weight"]))
2183
2184 dict_person = list_person_info[-1]
2185 print("%s的年龄是%d,性别是%s,体重是%f" % (dict_person["name"], dict_person["age"], dict_person["sex"], dict_person["weight"]))
2186 Exercise04
2187 # 练习1:["无忌","张翠山","张三丰"]-->{"无忌":2,"张翠山":3,"张三丰":3}
2188 # key: 列表元素, value: key的长度
2189 list_names = ["无忌", "张翠山", "张三丰"]
2190 dict_names = {item: len(item) for item in list_names}
2191 print(dict_names)
2192
2193 # 练习2:姓名列表： ["无忌","赵敏","周芷若"]
2194 # 房间号：[101,102,103]
2195 # 将两个列表合并为字典,key:姓名列表元素,值:房间列表元素.
2196
2197 list_names = ["无忌", "赵敏", "周芷若"]
2198 list_rooms = [101, 101, 103]
2199 dict_info = {list_names[i]: list_rooms[i] for i in range(len(list_names))}
2200 print(dict_info)
2201
2202 # 需求：根据房间号查找人
2203 # 根据值找键
2204
2205 # 方法1:遍历字典所有记录，判断值.
2206 # 方法2:反转key 与 value
2207 # dict_info = {v:k for k,v in dict_info.items() }
2208 # print(dict_info)
2209
2210 # 注意：反转后，因为键不能相同，所以可能导致丢失数据。
2211 list_info = [(v,k) for k,v in dict_info.items()]
2212 print(list_info)
2213 # 15:37
2214
2215 Exercise05
2216 """
2217 经理："曹操","刘备","孙权"
2218 技术员："曹操","刘备","张飞","关羽"
2219
2220 计算：
2221 1. 是经理也是技术员的都有谁？
2222 2. 是经理也不是技术员的都有谁？
2223 3. 不是经理也是技术员的都有谁？
2224 4. 张飞是不是经理？
2225 5. 身兼一职的都有谁？
2226 6. 公司总共有几个人?
2227 """
2228 # 字典 + 集合
2229 dict_person = {
2230 "经理": {"曹操", "刘备", "孙权"},
2231 "技术员": {"曹操", "刘备", "张飞", "关羽"}
2232 }
2233 # 1.是经理也是技术员的都有谁？ 交集
2234 print(dict_person["经理"] & dict_person["技术员"])
2235 # 16:50 上课
2236 # 2.是经理也不是技术员的都有谁？ 补集
2237 print(dict_person["经理"] - dict_person["技术员"])
2238
2239 # 3.不是经理也是技术员的都有谁？ 补集
2240 print(dict_person["技术员"] - dict_person["经理"])
2241
2242 # 4.张飞是不是经理？
2243 print("张飞" in dict_person["经理"])
2244
2245 # 5.身兼一职的都有谁？
2246 print(dict_person["经理"] ^ dict_person["技术员"])
2247
2248 # 6.公司总共有几个人? 并集
2249 print(len(dict_person["经理"] | dict_person["技术员"]))
2250
2251 Exercise06
2252 """
2253 打印图形：
2254 * * * *
2255 # # # #
2256 * * * *
2257 # # # #
2258 * * * *
2259 """
2260 for r in range(5):
2261 for c in range(4):
2262 if r % 2 == 0:
2263 print("*", end=" ")
2264 else:
2265 print("#", end=" ")
2266 print() # 换行
2267 Exercise07
2268 list01 = [
2269 [1, 2, 3, 4],
2270 [4, 5, 6, 7],
2271 [8, 8, 10, 11],
2272 ]
2273
2274 # 打印二维列表第二行(一个数据一行)练习1：
2275 # list01[1][0] list01[1][1] list01[1][2] list01[1][3]
2276 for c in range(len(list01[1])): # 0 1 2 3
2277 print(list01[1][c])
2278
2279 # 练习2：打印二维列表第三列(一个数据一行)
2280 # list01[0][2]
2281 # list01[1][2]
2282 # list01[2][2]
2283 for r in range(len(list01)): # 0 1 2
2284 print(list01[r][2])
2285
2286
2287 # 练习3：打印二维列表(行列)
2288 # # list01[0][0] list01[0][1] list01[0][2] list01[0][3]
2289 # for c in range(4):#0123
2290 # print(list01[0][c],end = " ")
2291
2292 # # list01[1][0] list01[1][1] list01[1][2] list01[1][3]
2293 # for c in range(4):#0123
2294 # print(list01[1][c],end = " ")
2295 for r in range(len(list01)): # 0 1 2
2296 for c in range(len(list01[r])): # 0123
2297 print(list01[r][c], end="\t")
2298 print()
2299 Exercise08
2300 # 练习:矩阵转置
2301 # 将list01中的每列，存储到list02中的每行(列表)。
2302 list01 = [
2303 [1, 2, 3, 4],
2304 [4, 5, 6, 7],
2305 [8, 8, 10, 11],
2306 ]
2307
2308 list02 = []
2309
2310
2311 #list01[0][0]
2312 #list01[1][0]
2313 #list01[2][0]
2314
2315 for c in range(4):
2316 line = []
2317 for r in range(3):
2318 line.append(list01[r][c])
2319 list02.append(line)
2320
2321 print(list02)
2322 day06 作业
2323 1. 三合一
2324 2. 当天练习独立完成
2325 3. 定义数据结构，存储以下数据。
2326 (1) 多个人的多个爱好
2327 qtx:编码,看书,跑步
2328 悟空:刷抖音,飞翔
2329 八戒:美食,美女,睡觉
2330 (2) 多个城市的多个景区与美食
2331 "北京":
2332 "景区":"故宫","天安门","长城"
2333 "美食":"烤鸭","豆汁"
2334 "四川":
2335 "景区":"九寨沟","峨眉山"
2336 "美食":"火锅","老妈兔头"
2337 -- 打印北京美食(一行一个)
2338 -- 打印所有城市(一行一个)
2339 -- 打印所有城市的景区(一行一个)
2340
2341
2342 4. (扩展)对列表进行升序排序[3,8,6,5,2]
2343 思想:取元素(不要最后一个)
2344 作比较(与后面元素进行比较)
2345 如果发现后面元素更小，则与取出的元素进行交换.
2346
2347 5. 看书:
2348 程序员的数学第5章—排列组合
2349 Homework01
2350 """
2351 3. 定义数据结构，存储以下数据。
2352 (1) 多个人的多个爱好
2353 qtx:编码,看书,跑步
2354 悟空:刷抖音,飞翔
2355 八戒:美食,美女,睡觉
2356 (2) 多个城市的多个景区与美食
2357 "北京":
2358 "景区":"故宫","天安门","长城"
2359 "美食":"烤鸭","豆汁"
2360 "四川":
2361 "景区":"九寨沟","峨眉山"
2362 "美食":"火锅","老妈兔头"
2363 -- 打印北京美食(一行一个)
2364 -- 打印所有城市(一行一个)
2365 -- 打印所有城市的景区(一行一个)
2366
2367 """
2368
2369 # (1) 多个人的多个爱好
2370 dict_hobbys = {
2371 "qtx": ["编码", "看书", "跑步"],
2372 "悟空": ["刷抖音", "飞翔"],
2373 "八戒": ["美食", "美女", "睡觉"]
2374 }
2375 (2)多个城市的多个景区与美食
2376 dict_info = {
2377 "北京":
2378 {
2379 "景区": ["故宫", "天安门", "长城"],
2380 "美食": ["烤鸭", "豆汁"]
2381 },
2382 "四川":
2383 {
2384 "景区": ["九寨沟", "峨眉山"],
2385 "美食": ["火锅", "老妈兔头"]
2386 }
2387 }
2388 # -- 打印所有城市(一行一个)
2389 for key in dict_info:
2390 print(key)
2391
2392 # -- 打印北京美食(一行一个)
2393 for item in dict_info["北京"]["美食"]:
2394 print(item)
2395
2396 # -- 打印所有城市的景区(一行一个)
2397 for city in dict_info:
2398 for item in dict_info[city]["景区"]:
2399 print(item)
2400 Homework02
2401 """
2402 4. (扩展)对列表进行升序排序[3,8,6,5,2]
2403 思想:取元素(不要最后一个)
2404 作比较(与后面元素进行比较)
2405 如果发现后面元素更小，则与取出的元素进行交换.
2406 价值:列表中所有元素俩俩比较
2407 """
2408 list01 = [3, 8, 6, 5, 2]
2409
2410 # 取元素： 第一个
2411 # 作比较： 从第二个 ... 最后一个
2412 # for c in range(1,len(list01)):
2413 # list01[0] list01[c]
2414 # 取元素： 第二个
2415 # 作比较： 从第三个 ... 最后一个
2416 # for c in range(2,len(list01)):
2417 # list01[1] list01[c]
2418 # 取元素： 第三个
2419 # 作比较： 从第四个 ... 最后一个
2420 # for c in range(3,len(list01)):
2421 # list01[2] list01[c]
2422
2423 # 结论：
2424 # 取元素
2425 # for r in range(len(list01)-1):
2426 # 作比较
2427 # for c in range(r+1, len(list01)):
2428 # list01[r] list01[c]
2429
2430 for r in range(len(list01) - 1):
2431 for c in range(r + 1, len(list01)):
2432 if list01[r] > list01[c]:
2433 list01[r], list01[c] = list01[c], list01[r]
2434
2435 print(list01)
2436 # 10:10 上课
