【Python基础】Python全栈体系（一）_python全栈知识体系

Python 基础

第一章 计算机基础结构

一、硬件

• 1944年，美籍匈牙利数学家冯·诺依曼提出计算机基本结构。
• 五大组成部分：运算器、控制器、存储器、输入设备、输出设备。
  • 运算器：按照程序中的指令，对数据进行加工处理。
  • 控制器：根据程序需求，指挥计算机的各个部件协调工作。
• 通常将运算器和控制器集成在中央处理器（CPU）中。
  • 存储器：保存各类程序的数据信息。
    • 内存RAM – 容量小，速度快，临时存储数据
    • 硬盘HDD – 容量大，速度慢，永久存储数据
  • 输入设备：外界向计算机传送信息的装置。
    • 例如：鼠标、键盘、扫描仪…
  • 输出设备：计算机向外界传送信息的装置。
    • 例如：显示器、音响、打印机…
      

二、软件

1. 操作系统：

• 管理和控制计算机软件与硬件资源的程序。
• 隔离不同硬件的差异，使软件开发简单化。
• Windows，Linux，Unix。

2. 应用软件：为了某种特定的用途而被开发的软件。

3. 软件：程序 + 文档。

• 程序是一组计算机能识别和执行的指令集合。
• 文档是为了便于了解程序所需的说明性资料。

三、小结

• 计算机基础架构：硬件（冯·诺依曼架构）+ 软件（系统 + 应用）

第二章 Python 简介

一、Python 定义

• 是一个免费、开源、跨平台、动态、面向对象的编程语言。
• 免费：使用者不需要支付任何费用，没有版权问题
• 开源：将程序的源代码免费提供给开发者进行修改传播
• 跨平台：一次开发到处部署 Linux、Windows、Unix（Mac OS）

二、Python程序的执行方式

1. 交互式

• 在命令行输入指令，回车即可得到结果。
  • 打开终端
  • 进入交互式：python3
  • 编写代码：print(“hello world”)
  • 离开交互式：exit()

2. 文件式

• 将指令编写到.py文件，可以重复运行程序。
  • 编写文件。
  • 打开终端
  • 进入程序所在目录：cd 目录
  • 执行程序： python3 文件名

三、Linux常用命令

• pwd：查看当前工作目录的路径
• ls：查看指定目录的内容或文件信息
• cd：改变工作目录（进入到某个目录）
• touch ：创建文件

四、执行过程

• 计算机只能识别机器码(1010)，不能识别源代码(python)。
• 由源代码转变成机器码的过程分成两类：编译和解释。
• 编译：在程序运行之前，通过编译器将源代码变成机器码，例如：C语言。
  • 优点：运行速度快
  • 缺点：开发效率低，不能跨平台。
• 解释：在程序运行之时，通过解释器对程序逐行翻译，然后执行。例如：Javascript
  • 优点：开发效率高，可以跨平台；
  • 缺点：运行速度慢。
• python是解释型语言，但为了提高运行速度，使用了一种编译的方法。编译之后得到pyc文件，存储了字节码（特定于Python的表现形式，不是机器码）。
• 源代码 – 编译 --> 字节码 – 解释 --> 机器码
• |————1次———|

五、解释器类型

• CPython（C语言开发)
• Jython (java开发)
• IronPython (.net开发)

第三章 数据基本运算

一、基础知识

1. pycharm常用快捷键

"""
    汇率转换器
"""
# 1. 获取数据：美元
usd = float(input("请输入美元："))
# 2. 逻辑计算：美元*6.405
cny = usd * 6.405
# 3. 显示结果：xx美元=xx人民币
print(str(usd) + "美元=" + str(cny) + "人民币")
1
2
3
4
5
6
7
8
9

1. 移动到本行开头：home键
2. 移动到本行末尾：end键盘
3. 注释代码：ctrl + /
4. 复制行：ctrl +d
5. 选择列：鼠标左键 + alt
6. 移动行：shift + alt + 上下箭头
7. 智能提示：ctrl + space
8. 代码格式化：ctrl+alt+l

2. 注释

• 给人看的，通常是对代码的描述信息。
  • 单行注释：以#号开头。
  • 多行注释：三引号开头，三引号结尾。

3. 函数

• 表示一个功能，函数定义者是提供功能的人，函数调用者是使用功能的人。
• 例如：
  • print(数据) 作用：将括号中的内容显示在控制台中
  • 变量 = input(“需要显示的内容”) 作用：将用户输入的内容赋值给变量
    
• 练习

"""
练习1: 在终端中显示古诗“登高”
效果：
           登高
        作者 : 杜甫
风急天高猿啸哀，渚清沙白鸟飞回。
无边落木萧萧下，不尽长江滚滚来。
万里悲秋常作客，百年多病独登台。
艰难苦恨繁霜鬓，潦倒新停浊酒杯。
"""
print("           登高")
print("        作者 : 杜甫")
print("风急天高猿啸哀，渚清沙白鸟飞回。")
print("无边落木萧萧下，不尽长江滚滚来。")
print("万里悲秋常作客，百年多病独登台。")
print("艰难苦恨繁霜鬓，潦倒新停浊酒杯。")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

"""
练习2：判断英文句子成分：I kiss you
效果：
请输入I kiss you的主语:I
请输入I kiss you的谓语:kiss
请输入I kiss you的宾语:you
您输入的主语是:I,谓语是:kiss,宾语是:you
"""
subject = input("请输入I kiss you的主语:")
predicate = input("请输入I kiss you的谓语:")
object = input("请输入I kiss you的宾语:")
print("您输入的主语是:" + subject + ",谓语是:" + predicate + ",宾语是:" + object)
1
2
3
4
5
6
7
8
9
10
11
12

二、数据

1. 变量

1. 定义：关联一个对象的标识符。
2. 命名：必须是字母或下划线开头，后跟字母、数字、下划线。
   不能使用关键字(蓝色)，否则发生语法错误：SyntaxError: invalid syntax。
3. 建议命名：字母小写，多个单词以下划线隔开。
   class_name
4. 赋值：创建一个变量或改变一个变量关联的数据。
5. 语法：变量名 = 数据
   变量名1 = 变量名2 = 数据
   变量名1, 变量名2, = 数据1, 数据2
   

• 练习

"""
    画出下列代码内存图,说出终端显示结果
"""
# 创建2变量 2数据
name_of_beijing, region = "北京", "市"
# 创建1个变量关联相加产生的新数据
name_of_beijing_region = name_of_beijing + region
region = "省" # 修改之前变量
print(name_of_beijing_region) # 不影响新变量 "北京市"
del name_of_beijing # 删除之前变量
print(name_of_beijing_region) # 不影响新变量 "北京市"
1
2
3
4
5
6
7
8
9
10
11

2. 删除语句（del 语句）

1. 语法:
   del 变量名1, 变量名2

name01 = "悟空"
name02 = name01
del name01, name02
1
2
3

2. 作用：
   用于删除变量,同时解除与对象的关联.如果可能则释放对象。
3. 自动化内存管理的引用计数：
   每个对象记录被变量绑定(引用)的数量,当为0时被销毁。

"""
    del 删除语句
    引用计数
        数据会记录着被变量所绑定的次数
        当次数为零时，数据被销毁
"""
name01 = "悟空"  # "悟空"引用计数为1
name02 = name01  # "悟空"引用计数为2
name03 = name02  # "悟空"引用计数为3
name04 = name02  # "悟空"引用计数为4

del name01  # "悟空"引用计数为3
del name02, name03  # "悟空"引用计数为1
name04 = "孙悟空"  # "悟空"引用计数为0
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 核心数据类型

1. 在python中变量没有类型，但关联的对象有类型。
2. 通过type函数可查看。

3.1 空值对象 None

1. 表示不存在的特殊对象。
2. 作用：占位和解除与对象的关联。

3.2 整型 int

1. 表示整数，包含正数、负数、0。
   如： -5, 100, 0
2. 字面值：
   十进制：5
   二进制：0b开头，后跟1或者1
   八进制：0o开头，后跟0~7
   十六进制：0x开头，后跟0_9,AF,a~f

3.3 浮点型 float

1. 表示小数，包含正数、负数，0.0)。
2. 字面值：
   • 小数：1.0 2.5
   • 科学计数法：e/E (正负号) 指数
   • 1.23e-2 (等同于0.0123)
   • 1.23456e5(等同于123456.0)

3.4 字符串 str

• 是用来记录文本信息(文字信息)。
• 字面值：双引号

3.5 复数 complex

• 由实部和虚部组成的数字。
• 虚部是以j或J结尾。
• 字面值： 1j 1+1j 1-1j

3.6 布尔 bool

• 用来表示真和假的类型
• True 表示真(条件满足或成立)，本质是1
• False 表示假(条件不满足或不成立)，本质是0

"""
    在python中变量没有类型，但关联的对象有类型。
    类型转换：
        结果 = 目标类型（待转数据）
        适用性：
            获取数据时，如果需要做数学运算，必须转换为数值类型
            显示结果时，如果将数值类型按照某种格式展示需要转换为字符串类型
"""
# 1. 字符串str：存储文本
name = "悟空"
# 2. 整型int：存储整数
age = 26
# 3. 浮点型float：存储小数
score = 95.5

print("1" + "1")  # 字符拼接
print(1 + 1)  # 数学运算
# 在Python语言中，字符串与数值不能直接运算
# print("1" + 1)

# input函数的结果一定是字符串
age = int(input("请输入您的年龄："))
print("明年您" + str(age + 1) + "岁了")

# 字符串str <--> 整数int
result01 = int("8")
result02 = str(10)

# 字符串str <--> 小数float
result03 = float("95.5")
result04 = str(95.5)

# 整数int <--> 小数float
result05 = float(15)
print(result05) # 15.0

result06 = int(15.9)
print(result06) # 15 向下取整数

# 注意：将字符串转换为其他类型时
print(float("95.5"))

print(18)
# 以某种格式显示，则必须类型转换
print("我年龄是：" + str(18))

"""
11
2
请输入您的年龄：18
明年您19岁了
15.0
15
95.5
18
我年龄是：18
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

4. 运算

4.1 数据类型转换

1. 转换为整型: int(数据)
2. 转换为浮点型:float(数据)
3. 转换为字符串:str(数据)
4. 转换为布尔:bool(数据)
   结果为False：bool(0) bool(0.0) bool(None)
5. 混合类型自动升级：
   1 + 2.14 返回的结果是 3.14
   1 + 3.0 返回结果是: 4.0

"""
    核心数据类型
        变量没有类型，关联的对象才有类型.

"""

name = "lzmly"

# 1. None 空
# -- 占位：只希望有一个变量，但指向的对象还不能确定.
skill = None
# ...
skill = "乾坤大挪移"

# -- 解除与对象的绑定关系
name = None

# 2. 整形(整数)  int
# 字面值
# -- 十进制：0 1 2 3 ...9 10
number01 = -1
number01 = 1
number01 = 0

# -- 二进制：0 1 10  11  100  101 ..
number02 = 0b10
print(number02)

# -- 八进制：0 1 2 3 ... 7  10
number03 = 0o10
print(number03)

# -- 十六进制：0 --9  a(10) -- f(15)  10   11
number04 = 0x11
print(number04)

# 3. 浮点型(小数) float
# 字面值
number05 = 1.0
# 科学计数法
number06 = 5e3
print(number06)

number07 = 0.00000000000000000005
number07 = 500000000000000000000.0
print(number07)

# 4. 字符串(文字)  str
name = "lzmly"
str_number = "1000"
# 数学运算
result = 1000 + 1
# 文字拼接
result = "1000" + "1"
print(result)

# 5. 数据类型转换
# input函数的返回值永远都是字符串类型
str_number = input("请输入一个数字：")

# str --> int
# print(type(变量)) --> 获取变量所关联的对象类型
# re = int(str_number)

# str --> float
re = float(str_number)
print(type(re))

# 注意：int()转换时，数据必须像整数
# 注意：float()转换时，数据必须像小数

# 其他类型 --> str
re = str(100.6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

• 练习

"""
    练习：
        在终端中输入商品单价、购买的数量和支付金额。
        计算应该找回多少钱。
    效果：
    请输入商品单价：5
    请输入购买数量：3
    请输入支付金额：20
    应找回：5.0
"""
# 1. 获取数据
commodity_price = float(input("请输入商品单价："))
purchase_quantity = int(input("请输入购买数量："))
payment_amount = float(input("请输入支付金额："))
# 2. 逻辑计算
result = payment_amount - commodity_price * purchase_quantity
# 3. 显示结果
print("应找回：" + str(result))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.2 运算符

4.2.1 算术运算符

+	加法
-	减法
*	乘法
/	除法：结果为浮点数
//	地板除：除的结果去掉小数部分
%	求余
**	幂运算
优先级从高到低： ()
          		 **
                 *  / % //
                 +  -
1
2
3
4
5
6
7
8
9
10
11

"""
    算术运算符
        + - * 幂**
        // 整数商
        /  小数商
        %  余数
"""
data01 = 5
data02 = 2
data03 = data01 + data02
data04 = data01 ** data02  # 5 * 5
print(data04)  # 25
print(data01 // data02)  # 2
print(data01 / data02)  # 2.5
print(data01 % data02)  # 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 练习

"""
练习1：在终端中输入一个疫情确诊人数再录入一个治愈人数，打印治愈比例
格式：治愈比例为xx%
效果：
请输入确诊人数：500
请输入治愈人数：495
治愈比例为99.0%
"""
# 获取数据
number_of_confirmed = int(input("请输入确诊人数："))
number_of_cure = int(input("请输入治愈人数："))
# 逻辑计算
cure_ratio = number_of_cure/number_of_confirmed * 100
# 显示结果
print("治愈比例为：" + str(cure_ratio) + "%")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

"""
练习2：古代的秤，一斤十六两。在终端中获取两，计算几斤零几两。
效果：
请输入总两数：100
结果为：6斤4两
"""
total_liang = int(input("请输入总两数："))
jin = total_liang // 16
liang = total_liang % 16
print("结果为：" + str(jin) + "斤" + str(liang) + "两")
print("结果为：%s斤%s两" % (jin, liang))
1
2
3
4
5
6
7
8
9
10
11

"""
练习3：
匀变速直线运动的速度与位移公式：
位移 = 初速度 × 时间 + 加速度 * 时间的平方 / 2
已知(在终端中录入)：位移、时间、初速度
计算：加速度
效果：
请输入距离：100
请输入初速度：6
请输入时间：10
加速度是：0.8
"""
s = int(input("请输入距离："))
v0 = int(input('请输入初速度：'))
t = int(input('请输入时间：'))
a = (s - v0 * t) * 2 / t ** 2
print("加速度是：" + str(a))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.2.2 增强运算符

y += x		等同于 y = y + x
y -= x		等同于 y = y - x
y *= x		等同于 y = y * x
y /= x		等同于 y = y / x
y //= x		等同于 y = y // x
y %= x		等同于 y = y % x
y **= x		等同于 y = y ** x
1
2
3
4
5
6
7

"""
    增强运算符
        在算术运算符基础上，增加了对自身赋值的功能
        += -= *= **= /= //= %=
"""
# data01 = 5
# data01 + 5
# print(data01) # 5

data01 = 5
# data01 = data01 + 5
data01 += 5  # 累加
print(data01)  # 10
1
2
3
4
5
6
7
8
9
10
11
12
13

# 1. 算数运算+ - * / //  %  **
number01 = 5
number02 = 2
print(number01 / number02)  # 除到余数为零的商  2.5
print(number01 // number02)  # 除到整数商 2
print(number01 % number02)  # 获取余数 1
print(number01 ** number02)  # 幂运算 25

# 2. 增强运算+= -= *= /= //=  %=  **=
# number01 = number01 + 10
# 变量 与 其他数据运算后的结果，又赋值给了自身
number01 += 10

# 练习1：在终端中录入一个半径，输出圆形的面积(3.14 × 半径的平方)
#       输出的格式：圆形面积是：xxx

radius = input("请输入圆形半径:")
area = 3.14 * float(radius) ** 2
print("圆形面积是：" + str(area))

# 练习2：在终端中分别录入3个数据(分钟数、小时数、天数)
#       输出总秒数
minute = float(input("请输入分钟："))
hour = float(input("请输入小时："))
day = float(input("请输入天："))

result = minute * 60 + hour * 60 * 60 + day * 24 * 60 * 60

print("总秒数是：" + str(result))

# 练习3：在终端中首先获取一个变量，再获取一个变量，然后交换他们，最后输出两个变量。

variable01 = input("请输入第一个变量：")
variable02 = input("请输入第二个变量：")
# 变量交换思想：
# temp = variable01
# variable01= variable02
# variable02 = temp

# python交换变量
variable01, variable02 = variable02, variable01

print("第一个变量是：" + variable01)
print("第二个变量是：" + variable02)

"""
    在终端中获取总秒数，计算几小时零几分钟零几秒。
    输入：10000
    输出：2小时零46分钟零40秒
"""
total_second = int(input("请输入总秒数："))
second = total_second % 60
hour = total_second // 60 // 60
minute = total_second // 60 % 60
print(str(hour) + "小时零" + str(minute) + "分钟零" + str(second) + "秒")

"""
    在终端中获取一个四位整数，计算每位相加和。
    输入:1234
    输出:10
"""
number = int(input("请输入4位整数："))
# 个位 number % 10
result = number % 10
# 十位 number // 10% 10
result += number // 10% 10
# 百位 number // 100 % 10
result += number // 100 % 10
# 千位 number // 1000
result += number // 1000
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

3. 比较运算符

 <		小于
 <=		小于等于
 >		大于
 >=		大于等于
 ==		等于
 !=		不等于
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100
1
2
3
4
5
6
7
8

4. 逻辑运算符

与and
表示并且的关系，一假俱假。         
示例:
    True and True	# True
    True and False	# False
    False and True	# False
False and False	# False
或or
表示或者的关系，一真俱真     
  示例:
True or True		# True
True or False		# True
False or True		# True
False or False		# False 
非 not 
表示取反
例如：
not True   # 返回False
not False  # 返回True
短路运算
一但结果确定，后面的语句将不再执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

"""
    在终端中录入年份，判断是否为闰年。
    条件1：年份能被4整除，但是不能被100整除。
    条件2：能被400整除。
"""
year = int(input("请输入年份："))
result = year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(result)
1
2
3
4
5
6
7
8

"""
    逻辑运算符的短路逻辑
"""
# 启发：逻辑运算时，尽量将复杂的(耗时的)判断放在后面
# False and  ?
re = 1 > 1 and input("请输入：") =="a"
print(re)

# True or  ?
re = 2 > 1 or input("请输入：") =="a"
print(re)
1
2
3
4
5
6
7
8
9
10
11

5. 身份运算符

语法:
    x is y
    x is not y
作用：
	is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
   	is not 的作用与is相反
1
2
3
4
5
6

6. 优先级

• 高到低：
  • 算数运算符
  • 比较运算符
  • 快捷运算符
  • 身份运算符
  • 逻辑运算符