总复习

计算机之编程

什么是编程语言

编程语言是人与计算机交流的介质

什么是编程

编程就是使用编程语言编写一个个文件

为什么要编程

为了奴隶计算机，解放劳动力，帮人类完成一个个具体的任务

计算机组成原理

计算机五大组成

CPU

控制器

控制硬件

运算器

进行逻辑运算+算术运算

内存

临时存储数据的硬件

• 优点(相比较于外存):速度快

• 缺点(相比较于外存):临时存储/断电即消失

外存

永久存储数据的硬件

• 优点(相比较于内存):永久存储

• 缺点(相比较于内存):速度慢

输入设备

输入信息的硬件，如键盘/鼠标/u盘

输出设备

输出信息的硬件，如显示器/打印机/u盘

I/O设备

即可输入信息，又可以输出信息的硬件，称为I/O设备

32位和64位

32位

一次性能读取32个二进制位的操作系统

64位

一次性能读取64个二进制位的操作系统

多核CPU

可以同时完成多件事的CPU，如4核CPU则一个大的CPU集成了4个小的CPU

硬盘工作原理

机械硬盘工作原理

• 机械手臂:寻找数据

• 磁道:存储数据

• 扇区:划分磁道

• 平均寻道时间:由于工业水平的限制，为5ms

• 平均延迟时间:以7200r/min的硬盘为例，为4.15ms

 

• 平均寻找数据时间:5+4.15=9.15ms

固态硬盘工作原理

• 基于算法和电存储的外存

计算机操作系统

文件是什么?

操作系统提供的一个虚拟的单位

应用程序是什么?

应用程序其实就是一堆文件，用来完成具体的某个任务

操作系统能干什么?

接受应用程序/人的外部指令，然后控制硬件

计算机三大组成?

应用程序

应用程序其实就是一堆文件，用来完成具体的某个任务，与人/操作系统交互

操作系统

接受应用程序/人的外部指令，然后控制硬件，与人/应用程序/硬件交互

硬件

最终的目的是用来存储数据，与操作系统交互

应用程序的启动和操作系统的启动?

应用程序的启动

1. 双击qq(发送指令给操作系统)

2. 操作系统接收指令，将指令转化成0和1发送给CPU

3. CPU接收指令，发送给内存

4. 内存从硬盘中取出qq的程序，执行，打开qq

操作系统的启动

1. 按下开机键(启动一个临时操作系统)

2. 临时操作系统唤醒真正的操作系统

编程语言分类

机器语言

• 优点(汇编语言):执行效率高

• 缺点(汇编语言):开发效率低

汇编语言

• 优点(机器语言):开发效率高

• 缺点(机器语言):执行效率低

高级语言

解释型语言

类似于同声传译，写一句翻译一句

• 优点(编译型语言):开发效率高

• 缺点(编译型语言):执行效率低

编译型语言

类似于谷歌翻译，写完所有的代码，一次性编译后得到结果，并且结果可以保存，无法得到及时的报错反馈

• 优点(解释型语言):执行效率高

• 缺点(解释型语言):开发效率低

执行Python程序的两种方式

交互式

在终端内输入python3，然后输入python代码

命令行式

在终端内输入python3 文本文件路径

执行Python程序的两种IDE

Pycharm

Jupyter

变量

什么是变量?

变量一般用来用来描述世间万物变化的状态

变量的组成?

变量名 = 变量值

• ==变量名是用来接收变量值的==

变量名的定义规范

1. 变量名具有某种意义

2. 由数字/字母/下划线组成，且不能由数字开头，(也不能由下划线开头)

3. 不能用Python关键字

['and'， 'as'， 'assert'， 'break'， 'class'， 'continue'， 'def'， 'del'， 'elif'， 'else'， 'except'， 'exec'， 'finally'， 'for'， 'from'， 'global'， 'if'， 'import'， 'in'， 'is'， 'lambda'， 'not'， 'or'， 'pass'， 'print'， 'raise'， 'return'， 'try'， 'while'， 'with'， 'yield']

定义变量的两种方式

• 驼峰体:NameOfNick

• 下划线:name_of_nick(推荐)

常量

常量是约定俗成的一种规范，常量名的定义方式为全大写.实际上可以被修改.

注释

单行注释

#注释的语句，#后面的字符不执行语法，即只为普通字符，一般用来解释某一段代码

多行注释

三单引号/三双引号

引用计数

变量值的引用次数

x = 257  # 257的引用计数为1 y = x   # 257的引用计数为2 del x # 257的引用计数为1

垃圾回收机制

当变量值的引用计数为0的时候，该变量值会被Python自动回收它的内存占用

小整数池

[-5，256]之间的整数会在Python解释器启动的时候，自动开辟一块内存存入这些整数.也就是说这些整数不会因为引用计数为0而被删除

与用户交互

input

input输入的都是字符串形式

格式化输出

占位符

%s接收任意数据类型的数据 %d接收数字类型的数据

name = 'nick' ​ 'nick name is %s'%name

format格式化

{}接收任意数据类型的数据

name = 'nick' ​ 'nick name is {}'.format(name)

f-string格式化

在字符串前面加上f或F，然后使用{}接收任意数据类型的数据

name = 'nick' ​ f'nick name is {name}'

基本运算符

算术运算符

+ - * / % // **

逻辑运算符

and or not

比较运算符

> >= < <= == !=

赋值运算符

= += -= *= /= //= **= %=

身份运算符

is is not

• id相同的值一定相同，值相同的id不一定相同

运算符优先级(略)

如果需要某个运算符优先运算，则加个括号，使用a and b is c == d的是傻逼

链式赋值

x = y = z = 10

交叉赋值

# 交叉赋值 x = 10 y = 20 ​ x， y = y， x print(x， y) # 使用临时变量 x = 10 y = 20 temp = x x = y y = temp print(x， y)

解压缩

hobby_list = ['read'，'run'，'sleep'，'fishing'，'piao'] # 如果取第2-3个爱好 _，hobby2，hobby3，*_ = hobby_list print(hobby2， hobby3)

流程控制

流程控制之if判断

if

if 条件:     代码块

if...else

if 条件:     代码块 else: 代码块

if...elif....elif...else

if 条件:     代码块 elif 条件: 代码块 elif 条件: 代码块 ...(可以写任意个elif) else: 代码块

流程控制之while循环

while

while 条件:     代码块

while + break

while 条件:     代码块  break # 结束本层循环，跳出循环

while + continue

while 条件:     代码块  if 条件: 代码块 cotinue # 不执行下面代码，然后继续循环，即跳出本次循环 代码块

while + else

while 条件:     代码块 else: print('如果我没有被break，我就会被打印出来')

流程控制之for循环

for

for i in range/str/list/tuple/dict/set(可迭代对象): print(i)

for + break

for i in range/str/list/tuple/dict/set(可迭代对象): print(i) break # 结束本层循环

for + continue

for i in range/str/list/tuple/dict/set(可迭代对象):	print(i)	if 条件:		continue  # 结束本次循环，即不执行下面代码，继续循环	代码块

for + else

for i in range/str/list/tuple/dict/set(可迭代对象):	print(i)else:	print('如果我没有被break，我就会被打印出来')

数据类型内置方法

数字类型内置方法

整型

1. 作用:定义年龄/身高/体重/id号

2. 定义方式:

age = 18age = int('18')

3. 方法: + - * / % // **

4. 多个值or一个值:一个值

5. 有序or无序:压根没有有序无序这一说

6. 可变or不可变:不可变

• 可变:值变id不变，值变id也变

浮点型

1. 作用:定义薪资/价格

2. 定义方式:

salary = 3.2salary = float('3.2')

3. 方法:+ - * / % // **

4. 多个值or一个值:一个值

5. 有序or无序:压根没有有序无序这一说

6. 可变or不可变:不可变

字符串类型内置方法

1. 作用:姓名/

2. 定义方式:

name = 'nick' name = "nick" name = ''' nick nick ''' name = """ nick nick """ name = "'nick'" name = '"nick"'

3. 方法s

   1. 优先掌握

      1. 索引取值

      2. 切片

      3. 长度

      4. 切分split

      5. 除两边空白strip

      6. 成员运算in&emsp；not i

      7. for循环

   2. 需要掌握

      1. lstrip/rstrip

      2. rsplit

      3. upper/lower

      4. startstwith/endswith

      5. join

      6. replace

      7. isdigit

   3. 了解

      1. find/rfind/index/rindex/count

      2. center/ljust/rjust/zfill

      3. expantabs

      4. capitalize/swapcase/title

      5. is系列

4. 多个值or一个值:一个值

5. 有序or无序:有序

6. 可变or不可变:不可变

列表类型内置方法

1. 作用:多个女朋友/

2. 定义方式:[]内用逗号隔开多个任意数据类型的元素

friends_list = ['longzeluola'，'canglaoshi'，'qiaobenai'，'nick'] lis = list('abcd')

3. 方法:

   1. 优先掌握

      1. 索引取值(即可取又可改)

      2. 切片

      3. 长度

      4. append

      5. 成员运算

      6. for循环

   2. 需要掌握

      1. count

      2. remove

      3. reverse

      4. pop

      5. insert

      6. sort

      7. index

      8. del

      9. extend

      10. clear

4. 多个值or一个值:多个值

5. 有序or无序:有序

6. 可变or不可变:可变

元祖类型内置方法

1. 作用:类似于列表，可以取不可以存

2. 定义方式:

friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick') tup = tuple('abcd')

3. 方法

   1. 优先掌握

      1. 索引取值(无法更改)

      2. 切片

      3. 长度

      4. 成员运算

      5. for循环

      6. count

      7. index

4. 多个值or一个值:多个值

5. 有序or无序:有序

6. 可变or不可变:无可变不可变这一说

字典类型内置方法

1. 作用:值太多列表存容易，取麻烦时使用字典

2. 定义方式:

nick_info_dict = {
   'name':'nick'， 'height':180， 'weight':140， 'hobby_list':['read'，'run'，'music'，'fishing'，'programming'，'coding'，'debugging'] } for k，v in nick_info_dict.items(): print(k，v)

3. 方法

   1. 优先掌握

      1. 按键取值

      2. 长度

      3. keys/values/items

      4. for循环

      5. 成员运算

   2. 需要掌握

      1. pop

      2. fromkeys

      3. setdefault

      4. get

      5. update

      6. del

4. 多个值or一个值:多个值

5. 有序or无序:无序

6. 可变or不可变:可变

集合类型内置方法

1. 作用:存多个值，为了集合之间做运算

2. 定义方式:

s = set() ​ s = {
     1，2，3，4，5，1}

3. 方法:

   1. 优先掌握

      1. 去重

      2. 并集 |

      3. 交集 &

      4. 差集 -

      5. 对称差集 ^

      6. 父集 >&emsp；>=

      7. 子集 <&emsp；<=

      8. ==

   2. 需要掌握

      1. add

      2. difference_update

      3. isdisjoint

      4. remove # 值不存在会报错

      5. discard # 不会报错

4. 多个值or一个值:多个值

5. 有序or无序:无序

6. 可变or不可变:可变

布尔类型

1. 作用:一般用于判断，除了0/None/空/False自带布尔值为False，其他的数据类型自带布尔值为True

数据类型总结

一个值	多个值
整型/浮点型/字符串	列表/元祖/字典/集合/

有序	无序
字符串/列表/元祖	字典/集合

可变	不可变
列表/字典/集合	整型/浮点型/字符串

拷贝

• ==拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的==

l1 = ['a'，'b'，'c'，['d'，'e'，'f']] l2 = l1 ​ l1.append('g') ​ print(l1) # ['a'，'b'，'c'，['d'，'e'，'f']，'g'] print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']，'g']

如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变

浅拷贝

import copy ​ ​ l1 = ['a'，'b'，'c'，['d'，'e'，'f']] l2 = copy.copy(l1) l1.append('g') print(l1) # ['a'，'b'，'c'，['d'，'e'，'f']，'g'] print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']] l1[3].append('g') print(l1) # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g'] print(l2) # ['a'，'b'，'c'，['d'，'e'，'f'，'g']]

如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变

深拷贝

import copy ​ ​ l1 = ['a'，'b'，'c'，['d'，'e'，'f']] l2 = copy.deepcopy(l1) l1.append('g') print(l1) # ['a'，'b'，'c'，['d'，'e'，'f']，'g'] print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']] l1[3].append('g') print(l1) # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g'] print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']]

如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化

 

 

age = 18  # 答案 count = 0  # 游戏次数控制 prize_dict = { 0:'布娃娃', 1:'变形金刚', 2:'奥特曼', 3:'
    
     ' } # 核心代码 while count < 3: inp_age = input('请输入你的年龄>>>').strip() # 与用户交互 # 判断用户是否骚扰 if not inp_age.isdigit(): print('傻逼,你的年龄输错了') continue inp_age_int = int(inp_age) # 核心逻辑,判断年龄 if inp_age_int == age: print('猜对了') print(prize_dict) # 打印奖品 # 获取两次奖品 for i in range(2): prize_choice = input('请输入你想要的奖品,如果不想要,则输入"n"退出!!!').strip() # 与用户交互获取奖品 # 判断是否需要奖品 if prize_choice != 'n': print(f'恭喜你获得奖品: {prize_dict[int(prize_choice)]}') else: break break elif inp_age_int < age: print('猜小了') else: print('猜大了') count += 1 # 成功玩一次游戏 if count != 3: continue again_choice = input('是否继续游戏,继续请输入"Y",否则任意键直接退出.').strip() # 交互是否再一次 # 判断是否继续 if again_choice == 'Y': count = 0