总复习（一）

总复习（一）
目录
0524总复习

计算机之编程

什么是编程语言

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

什么是编程

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

为什么要编程

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

计算机组成原理

计算机五大组成

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
$$
7200(r/min) / 60 = 120(r/s)
1/120(r/s) = 0.0083s = 8.3ms
8.3 / 2 = 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 = 18
age = int('18')
```
1. 方法: + - * / % // **
2. 多个值or一个值:一个值
3. 有序or无序:压根没有有序无序这一说
4. 可变or不可变:不可变
- 可变:值变id不变，值变id也变
浮点型
1. 作用:定义薪资/价格
2. 定义方式:
```
salary = 3.2

salary = float('3.2')
```
1. 方法:+ - * / % // **
2. 多个值or一个值:一个值
3. 有序or无序:压根没有有序无序这一说
4. 可变or不可变:不可变
字符串类型内置方法
1. 作用:姓名/
2. 定义方式:
```
name = 'nick'
name = "nick"
name = '''
nick
nick
'''
name = """
nick
nick
"""
name = "'nick'"
name = '"nick"'
```
1. 方法
  1. 优先掌握
    
    索引取值
    
    切片
    
    长度
    
    切分split
    
    除两边空白strip
    
    成员运算in&emsp；not in
    
    for循环
  2. 需要掌握
    
    lstrip/rstrip
    
    rsplit
    
    upper/lower
    
    startstwith/endswith
    
    join
    
    replace
    
    isdigit
  3. 了解
    
    find/rfind/index/rindex/count
    
    center/ljust/rjust/zfill
    
    expantabs
    
    capitalize/swapcase/title
    
    is系列
2. 多个值or一个值:一个值
3. 有序or无序:有序
4. 可变or不可变:不可变
列表类型内置方法
1. 作用:多个女朋友/
2. 定义方式:[]内用逗号隔开多个任意数据类型的元素
```
friends_list = ['longzeluola'，'canglaoshi'，'qiaobenai'，'nick']
lis = list('abcd')
```
1. 方法:
  1. 优先掌握
    
    索引取值(即可取又可改)
    
    切片
    
    长度
    
    append
    
    成员运算
    
    for循环
  2. 需要掌握
    
    count
    
    remove
    
    reverse
    
    pop
    
    insert
    
    sort
    
    index
    
    del
    
    extend
    
    clear
2. 多个值or一个值:多个值
3. 有序or无序:有序
4. 可变or不可变:可变
元祖类型内置方法
1. 作用:类似于列表，可以取不可以存
2. 定义方式:
```
friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick')
tup = tuple('abcd')
```
1. 方法
  1. 优先掌握
    
    索引取值(无法更改)
    
    切片
    
    长度
    
    成员运算
    
    for循环
    
    count
    
    index
2. 多个值or一个值:多个值
3. 有序or无序:有序
4. 可变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)
```
1. 方法
  1. 优先掌握
    
    按键取值
    
    长度
    
    keys/values/items
    
    for循环
    
    成员运算
  2. 需要掌握
    
    pop
    
    fromkeys
    
    setdefault
    
    get
    
    update
    
    del
2. 多个值or一个值:多个值
3. 有序or无序:无序
4. 可变or不可变:可变
集合类型内置方法
1. 作用:存多个值，为了集合之间做运算
2. 定义方式:
```
s = set()

s = {1，2，3，4，5，1}
```
1. 方法:
  1. 优先掌握
    
    去重
    
    并集 |
    
    交集 &
    
    差集 -
    
    对称差集 ^
    
    父集 >&emsp；>=
    
    子集 <&emsp；<=
    
    ==
  2. 需要掌握
    
    add
    
    difference_update
    
    isdisjoint
    
    remove # 值不存在会报错
    
    discard # 不会报错
2. 多个值or一个值:多个值
3. 有序or无序:无序
4. 可变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:'<Python从入门到放弃>'
}

# 核心代码
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
```
0531总复习

数据类型内置方法

整形类型内置方法

+ - * / // % **

浮点型类型内置方法

+ - * / // % **

字符串类型内置方法

优先掌握
1. 索引取值
2. 切片
3. 切割split
4. 长度
5. 成员运算
6. 去除空白strip
7. for循环取值
需要掌握
1. lstrip/rstrip
2. rsplit
3. upper/lower
4. startswith
5. endswith
6. isdigit
7. join
8. replace
了解
1. find/rfind/index/rindex/count
2. center/ljust/rjust/zfill
3. swapcase/capitalize/title
4. extendtaps
5. is系列
列表类型内置方法

优先掌握
1. 索引取值，索引更改值
2. 切片
3. 长度
4. 成员运算
5. append
6. del
7. for循环
需要掌握
1. insert
2. index
3. sort
4. remove
5. extend
6. count
7. pop
8. clear
9. copy
10. reverse
元组类型内置方法

优先掌握
1. 索引取值
2. 切片
3. 长度
4. 成员运算
5. count
6. index
7. for循环
字典类型内置方法

优先掌握
1. 按键取值
2. 长度
3. 成员运算
4. keys/vlaues/items
5. for循环
6. del
7. pop（随机删除，因为字典是无序的）
需要掌握
1. fromkeys
2. get
3. update
4. setdefault
集合类型内置方法

优先掌握
1. 去重
2. 长度
3. 成员运算
4. |
5. &
7. ^
8. > >=
9. < <=
10. = =
需要掌握
1. add
2. remove
3. difference_update
4. discard(不报错）
5. isdisjoint
数据类型总结

可变or不可变

可变不可变

列表，字典，集合字符串，整形，浮点型

有序or无需

有序无序

字符串，列表，元组字典，集合

存一个值or多个值

存一个值存多个值

整型，浮点型，字符串列表，集合，字典，元组

拷贝
```
l1= [1,1]
l2 = l1
```
- 当l2为l1的拷贝对象时，l1发生变化，l2也会随之发生变化
浅拷贝
```
l1 = [1,2,[1,2]]
import copy

l2 = copy.copy(l1)
```
- 当l2为l1的浅拷贝时，l1内部的不可变元素发生变化，l2不变；l1内部的可变元素发生变化，l2也会随着发生变化
深拷贝
```
l1 = [1,2,3,[2,3]]
import copy

l2 = copy.deepcopy(l1)
```
- 当l2为l1的深拷贝对象时，l1内部的元素发生变换，l2都不会发生变化
- 拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的
字符编码
- 用什么编码写的文件，就用什么编码打开，unicode--》gbk 编码encode；gbk ---》 unicode 解码 decode
Python3解释器编码

当python3解释器启动，并生成变量时，会以unicode的形式把变量读入内存，当我们使用print方法时，print会自动按照终端的字符编码编码unicode形式的变量

生成变量时以unicode丢入内存，终端时gbk，还是utf8，这终端都可以识别。
生成变量时以utf8丢入内存，终端为utf8，可以，但是终端为gbk，不可以了。错误

文件操作

打开文件的流程
1. 打开文件 open
2. 读写文件 read/write
3. 关闭文件 close
with管理上下文
```
with open(文件名，打开模式，编码格式) as f:
	f.操作命令
```
打卡文件的三种模式
1. r只读（默认）
2. w清空只写
3. a追加写入
- t 文本模式（默认）
- b 二进制模式
同时打开两个文件
```
with open(文件一),open(文件二),open(文件三)……
```
文件复制
```
with open('a.txt','r',encoding='utf8') as fr, 							open('a_swap.txt','w',encoding='utf8') as fw:
	data = fr.read()
	# 做一些处理之后
	fw.write(data)
	fw.flush()
	
import os

os.remove('a.txt')
os.rename('a_swap.txt','a.txt')
```
打开文件file后，file的方法
1. f.read() # read(n)意味着读几个字符
2. f.write()
3. f.readline()
4. f.readlines() （如果取出来时for循环的话，可以for i in f）
5. f.flush()
6. f.seek()
7. f.tell()
8. f.truncate()
函数

定义函数
```
def 函数名():
	代码块
```
- 定义阶段只检测语法，不执行代码
函数的三种形式
1. 无参函数
2. 有参函数
3. 空函数
调用函数
```
def f1():
	return 2
	
f1()
f = f1()
```
- 调用阶段才执行代码
函数的返回值
- 默认为None，如果遇到return则会终止函数，可以返回多个值（接收的时候为元组形式），并且值为任意数据类型
函数的参数

形参：接受实参，具有某种描述意义，但没有具体的值
1. 位置形参：最普通的参数，从左到右接收一一对应的实参
2. 默认形参：具有默认值，必须的写在位置形参的后面
实参：具有具体的值
1. 位置实参：从左到右传值给一一对应的形参
2. 关键字实参：指定参数传给形参，必须写在位置实参后面
可变长参数

*
1. *实参：把元组/列表打散成位置实参一个个传给形参，类似于解压缩
2. *形参：接收多余的位置实参，储存为元组的形式
```
import random
import time

with open('0531总复习.md','r',encodint='utf8') as fr:
    for i in range(50):
        fr.read(random.randint(1,300))
        time.sleep(30)
```
**
1. **实参：把字典打散成关键字实参一个个传给形参，
2. **形参：接收多余的关键字实参，存储为字典的形式，**kwargs
函数对象
```
def f1():
	pass

# 1.引用
f = f1

# 2.当作返回值
def f2():
	return f1
	
# 3. 当作参数传入
def f3(func):
	func()
f3(f1)

# 4. 作为容器元素

lis = [1,2,3,[2,3],f1,f2,f3]
```
函数嵌套
```
def f1():
	def f2():
		pass
```
名称空间与作用域
1. 内置名称空间
2. 全局名称空间
3. 局部名称空间
- 执行顺序：内置--》全局--》局部
- 查找顺序：从当前位置开始，如果当前为局部，则为局部--》全局--》内置
作用域: 全局的变量和局部的变量没有任何关系，即使两者中有同一名字的变量，同意名字的变量之间进行任何操作都不会影响对方
```
x = 10

def f1():
	x = 2
	print(x)  # 2
	
f1()

print(x)  # 10
```
可变的作用域事项（了解）
```
lis = [1]

def f1():
	lis[0] = 2

f1()

print(lis)  # [2]
```
闭包函数
```
def f1(x):
	def f2():
		print(x)
	return f2
	
f = f1(5)  # f-->f2,x=5
f()  # f()-->f2(),x=5  # 5
f()  # 5


f3 = f1(3)  # f-->f2,x=3
f3()  # f()-->f2(),x=3  # 3
f3()  # 3
```
- 把内部定义的变量放到内部的函数中，让两者一起返回出去
装饰器
```
def deco(func):
	def wrapper(*args,**kwargs):  # 赋值后的time_sleep
		res = func(*args,**kwargs)  # 真正的time_sleep
		
		return res
	return wrapper

@deco  # time_sleep（赋值后的） = deco(time_sleep（真正的）)
def time_sleep(name):
	print(name)
	return 123
```
无参装饰器
```
is_login_dict = {'username': None}


def login_deco(func):
    
    def wrapper(*args, **kwargs):  # 赋值后的time_sleep

        if not is_login_dict['username']:

            username = input('请输入你的用户名》》》').strip()

            if username != 'fanping':
                print('非法登录')

                return

            is_login_dict['username'] = username

            res = func(*args, **kwargs)  # 真正的time_sleep

            return res
        else:
            res = func(*args, **kwargs)  # 真正的time_sleep

            return res         

    return wrapper


@login_deco
def shopping():
    print('from shopping')


@login_deco
def withdraw():
    print('from withdraw')
```
有参装饰器
```
is_login_dict = {'username': None}

def auth(origin):
    
    def login_deco(func):

        def wrapper(*args, **kwargs):  # 赋值后的time_sleep

            if origin == 'file':

                if not is_login_dict['username']:

                    username = input('请输入你的用户名》》》').strip()

                    if username != 'fanping':
                        print('非法登录')

                        return

                    is_login_dict['username'] = username

                    res = func(*args, **kwargs)  # 真正的time_sleep

                    return res
                else:
                    res = func(*args, **kwargs)  # 真正的time_sleep

                    return res

            elif origin == 'mongodb':
                print('非法登录')
                
            else:
                print('dsb')


        return wrapper
    
    return login_deco


# f = origin('file')  # login_deco
# shopping = f(shopping)
# shopping()


@auth('file')
def shopping():
    print('from shopping')


@auth('mongodb')
def withdraw():
    print('from withdraw')
```
- 装饰器是为了给函数增加功能，但是不改变函数内部语法，不改变函数调用方式
相关阅读:
Android实现通过浏览器点击链接打开本地应用（APP）并拿到浏览器传递的数据（转）
保存图片文件到本地
 android ScrollView中嵌套GridView，ListView只显示一行的解决办法
 蒙版提示页（添加新功能后的一种提示）
C和指针第三章--数据
 *(ptr++) += 123
优先级队列-堆
 单链表相关（一）
字符间的距离-动态规划
 和最大的连续子数组
原文地址：https://www.cnblogs.com/1naonao/p/10932642.html

总复习（一）

0524总复习

计算机之编程

什么是编程语言

什么是编程

为什么要编程

计算机组成原理

计算机五大组成

CPU

控制器

运算器

内存

外存

输入设备

输出设备

I/O设备

32位和64位

32位

64位

多核CPU

硬盘工作原理

机械硬盘工作原理

固态硬盘工作原理

计算机操作系统

文件是什么?

应用程序是什么?

操作系统能干什么?

计算机三大组成?

应用程序

操作系统

硬件

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

应用程序的启动

操作系统的启动

编程语言分类

机器语言

汇编语言

高级语言

解释型语言

编译型语言

执行Python程序的两种方式

交互式

命令行式

执行Python程序的两种IDE

Pycharm

Jupyter

变量

什么是变量?

变量的组成?

变量名的定义规范

定义变量的两种方式

常量

注释

单行注释

多行注释

引用计数

垃圾回收机制

小整数池

与用户交互

input

格式化输出

占位符

format格式化

f-string格式化

基本运算符

算术运算符

逻辑运算符

比较运算符

赋值运算符

身份运算符

运算符优先级(略)

链式赋值

交叉赋值

解压缩

流程控制

流程控制之if判断

if

if...else

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

流程控制之while循环