Python语法--程序逻辑篇_python逻辑

此篇只要整理了Python中的运算符，程序的组织结构，函数和模块这些内容；上一篇的部分内容可能需要看完这篇才能看懂；

运算符

算术运算符

处理四则运算的符号，在数字的处理中应用的最多

算术运算符的优先级

• 先乘除后加减
• 同级运算符从左到右进行计算
• 可以使用小括号()调整计算的优先级

算术运算符优先级由高到低

• 第一级：**
• 第二级：*，/，%，//
• 第三级：+，-

注意事项：
除数不能为0

赋值运算符

主要用于为变量进行赋值，直接把赋值运算符右边的值赋给左边的变量

比较运算符

也称关系运算符，用于对变量或者表达式的结果进行大小，真假等比较，如果比较结果为真，则值为True,比较结果为假，值为False

逻辑运算符

逻辑运算符是对真和假两种布尔值进行运算，运算的结果仍然是一个布尔值

使用逻辑运算符进行逻辑运算的结果：

tips：
与是都为True才为True，或是都为False才为False，非取反

按位运算符

位运算是把数字看做二进制数来进行计算的，所以需要先将要执行运算的数据转换为二进制，然后才能进行运算

位与运算(&)

两个操作的数据的二进制表示，只有对应数位都是1时，结果数位才是1，否则为0

位或运算(|)

两个操作数据的二进制表示，只有对应数位都是0时，结果数位才是0，否则为1

位异或运算(^)

两个操作数据的二进制表示，对应数位相同(同时为0或者同时为1)，结果为0，否则为1

位取反运算(~)

两个操作数据的二进制表示，对应数位1修改为0，0修改为1

左移位运算(<<)

将一个二进制数向左移动指定的位数，左边(高位端)溢出的位被丢弃，右边(低位端)的空位用0补充

左移位运算相当于乘以2的N次幂

右移位运算(>>)

将一个二进制数向右移动指定的位数，右边(低位数)溢出的位被丢弃，左边(高位端)的空位端，如果最高位是0(正数)左侧空位填0，如果最高位是1(负数)，左侧空位填1

右移位运算相当于除以2的N次幂

成员运算符

# 举例:
a = 1
b = 2
lst = [1, 2, 3, 4, 5]


if a in lst:
    print("变量a在给定的列表lst中")
else:
    print("变量a不在在给定的列表lst中")
    
if b not in lst: # 注意:这里返回的是False
    print("变量b不在给定的列表lst中")
else:
    print("变量b在给定的列表lst中")

"""
变量a在给定的列表lst中
变量b在给定的列表lst中
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'
运行
运行

身份运算符

# 举例:
a = 10
b = 20

if a is b:
    print("a和b引用自同一对象")
else:
    print("a和b引用自不同对象")

if a is not b: # 注意:这里的结果为True
    print("a和b引用自不同对象")
else:
    print("a和b引用自同一对象")
"""
a和b引用自不同对象
a和b引用自不同对象
"""

# 改变b的值
a = 10
b = 10

if a is b:
    print("a和b引用自同一对象")
else:
    print("a和b引用自不同对象")

if a is not b: # 注意:这里的结果为False
    print("a和b引用自不同对象")
else:
    print("a和b引用自同一对象")

"""
a和b引用自同一对象
a和b引用自同一对象
"""
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
'
运行
运行

注意:

is与==的区别在于is用于判断两个变量引用的对象是否为同一个(同一个内存空间),==用于判断引用变量的值是否相等.

运算符的优先级

程序的组织结构

• 顺序结构：按程序语句的自然顺序，从上到下，依次执行每条语句的程序
  

• 选择结构：按照条件执行不同的代码段
  

• 循环结构：在一定的条件下反复执行某段程序的流程结构
  

顺序结构

顺序结构是程序中最基本的语句，赋值语句，输入/输出语句，模块导入语句等都是顺序结构语句

# 元组分解赋值
(name1, age1) = ('张三', 20)
print(name1, age1)
# 张三 20

# 列表分解赋值
[name2, age2] = ["李四", 21]
print(name2, age2)
# 李四 21

# 字符串分解赋值
a, b, c, d = "room"
print(a)
print(b)
print(c)
print(d)
"""
r
o
o
m
"""

# 区别于下面的代码
e = f = g = h = 'room'
print(e)
print(f)
print(g)
print(h)
"""
room
room
room
room
"""

# *号匹配赋值
i, *j = "r"
print(i)
print(j)
"""
r
['o', 'o', 'm']
"""
l, *m = "r"
print(l)
print(m)
"""
r
[]
"""

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
'
运行
运行

选择结构

if语句

语法格式：

if 表达式：
	语句块
"""
汉语关联词：
	如果...就...
执行顺序：
	如果表达式的值为True,就执行语句块
	如果表达式的值为False，就跳过语句块不执行，继续执行后面的语句
"""
1
2
3
4
5
6
7
8
9

if…else…语句

语法格式：

if 表达式：
	语句块1
else：
	语句块2
"""
汉语关联词：
	如果...否则...
执行顺序：
	如果表达式的值为True,就执行语句块1，否则执行语句块2
"""
1
2
3
4
5
6
7
8
9
10

and和or运算：

• 使用and连接多个选择条件时，只有同时满足多个条件，才能执行if后面的语句块
• 使用or连接多个选择条件时，只要满足多个条件中的一个，就可以执行if后面的语句块

if…elif…else语句

语法格式：

if 表达式1：
	语句块1
elif 表达式2：
	语句块2
....
elif 表达式n:
	语句块n
else:
	语句块n+1
1
2
3
4
5
6
7
8
9

if语句的嵌套

语法格式：

# 第二层if语句看做一个语句块
if 表达式1:
	if 表达式2：
		语句块1
	else：
		语句块2

if 表达式1:
	if 表达式2：
		语句块1
	else：
		语句块2
else：
	if 表达式3：
		语句块3
	else：
		语句块4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

循环结构

遍历循环for

语法格式：

for 循环变量 in 循环对象：
	语句块
"""
变量对象：
	1.字符串
	2.文件
	3.组合数据类型
	4.range()函数等
tips：range()函数产生一个[n，m)的整数序列，包含n,不包含m
"""
1
2
3
4
5
6
7
8
9
10

遍历循环的扩展模式

语法结构：

for 循环变量 in 遍历对象：
	语句块1
else：
	语句块2
"""
else语句只有在循环正常结束后才执行
通常与break和continue语句一起使用
"""
1
2
3
4
5
6
7
8

无限循环while

通过一个条件来控制是否要继续反复执行循环体中的语句
1

语法结构：

while 表达式：
	语句块

"""
当表达式的值为True时，执行语句块
当表达式的值为False时，跳过语句块而执行语句块之后的代码
"""
1
2
3
4
5
6
7

无限循环while的扩展结构

语法结构：

while 表达式：
	语句块1
else:
	语句块2

"""
else语句只有在循环正常结束后才执行
通常与break和continue语句一起使用
"""
1
2
3
4
5
6
7
8
9

嵌套循环

在一个循环结构中嵌套另一个完整的循环结构

语法格式：

while 表达式1：
	while 表达式2
		语句块2

for 循环变量1 in 遍历对象1：
	for 循环变量2 in 遍历对象2：
		语句块2
1
2
3
4
5
6
7

程序跳转语句

只能在循环结构中使用，通常与if一起搭配使用
break直接跳出整个循环，continue是跳出本次循环继续下一次循环

语法格式：

# break
while 表达式1：
	语句块
	if 表达式2：
		break

for 循环变量 in 遍历对象:
	语句块
	if 表达式：
		break


# continue
while 表达式1：
	语句块
	if 表达式2：
		continue

for 循环变量 in 遍历对象:
	语句块
	if 表达式：
		continue
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

空语句pass

不做任何事情，只起到占位符的作用，使语法结构完整，不报错。一般可用在if，for，while，函数定义，类定义中

语法结构：

if 表达式：
	pass

while 表达式：
	pass

for 循环变量 in 遍历对象：
	pass
1
2
3
4
5
6
7
8

函数

• 函数就是把具有独立功能的代码块组织为一个小模块，在需要的时候调用
• 函数的使用包含两个步骤：
  1.定义函数：封装独立的功能
  2.调用函数：享受封装的成果
• 函数的作用：在开发过程中使用函数可以提高编写的效率以及代码的重用

函数的定义

语法格式：

def 函数名():
	函数封装的代码
	....
"""
相关说明：
	1.def是英文define(定义)的缩写
	2.函数名称应该能够表达函数封装代码的功能，方便后续调用，即见名知意
	3.函数名称的命名应该符合标识符的命名规则
		- 不能以字母，下划线和数字组成
		- 不能以数字开头
		- 不能与关键字重名等
"""
1
2
3
4
5
6
7
8
9
10
11
12

函数的调用

调用函数很简单的，通过**函数名()**即完成对函数的调用
1

def 函数名():
	函数封装的代码
	....

# 调用函数
函数名()

"""
注意：
	1.定义好函数之后，表示这个函数封装了一段代码，如果不主动调用函数，函数是不会主动执行的
	2.函数的调用必须在函数定义的下面
"""
1
2
3
4
5
6
7
8
9
10
11
12

函数的文档注释：

• 在开发中，如果希望给函数添加注释，应该在定义的函数下发，使用多行注释添加多函数的说明性文字
• 在函数调用位置，可以查看函数的说明文字
• 在函数调用位置使用快捷键Ctrl + Q 可以查看函数的说明信息
• 因为函数体相对独立，函数定义的上方，应该和其他代码（包括注释）相隔两行

tips：IDEA中快速添加注释

效果如下：

函数的参数使用

• 在函数名的后面小括号内部填写参数
• 多个参数之间使用**,**分隔

参数的作用：

增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据

1. 在函数内部，把参数当做变量使用，进行需要的数据处理
2. 在函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递
1
2

形参和实参：

• 形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用
• 实参：调佣函数时，小括号中的参数，是用来把数据传递到函数内部用的

函数的返回值

• 在程序开发中，有时候希望有一个函数执行结束后，告诉调用者一个结果，方便调用者针对具体的结果做后续的处理
• 返回值是函数完成工作后，最后个调用者的一个结果
• 在函数中使用return关键字可以返回结果
• 在调用一方，可以用变量来接收函数的返回结果

注意：
return表示返回，后续的代码是不会被执行的

模块

模块是Python程序架构中的一个核心概念

• 模块就好比一个工具包，要想使用这个工具包的工具，就需要导入import这个模块
• 每个以扩展名.py结尾的Python源代码文件就是一个模块
• 在模块中定义的全局变量，函数都是模块能够提供给外界直接使用的工具
• 在Python中模块名也是一个标识符

Linux中的Shebang符号(#!)

• #! 这个符号叫做Shebang或者Sha-bang
• Shebang通常在Unix系统脚本中的第一行开头使用
• 指明执行这个脚本文件的解释程序

Shebang的使用步骤：

# 1.使用which查询python3解释器所在路径
which python3

# 2.修改要运行的主python文件，在第一行增加以下内容(后面的路径为上一条名称查询的python3解释器所在路径)
#! /usr/bin/python3

# 3.修改主python文件的文件权限，增加执行权限(test_main.py为主python文件名)
chmod +x test_main.py

# 4.在需要时执行程序即可
./test_main.py
1
2
3
4
5
6
7
8
9
10
11

变量进阶

变量的引用

• 变量和数据都是保存在内存中的
• 在python中的函数的参数传递和返回值都是靠引用传递的

引用：

在python中

• 变量和数据是分开存储的
• 数据保存在内存中的一个位置
• 变量中保存着数据在内存中的地址
• 变量中记录着数据的地址就叫做引用
• 使用id()函数可以查看变量中保存数据所在的内存地址

注意：

如果变量已经被定义了，当个一个变量赋值的时候，本质上是修改了数据的引用，变量不再指向之前的数据地址，变量改为对新值的地址引用

可变和不可变类型

不可变类型：
内存中的数据不允许被修改

• 数字类型 int，bool，float，complex，long(2.x)
• 字符串 str
• 元祖 tuple

可变类型：
内存中的数据可以被修改

• 列表 list
• 字典 dict

注意：

字典的key只能使用不可变类型的数据，value可以是任意类型的数据

哈希(hash)小笔记：
哈希是一种算法，其作用就是提取数据的特征码(指纹)

• 相同的内容得到的相同的结果
• 不同的内容得到不同的结果

Python中有个内置的hash(o)函数，接收一个不可变类型的数据作为参数，返回一个整数

在python中，设置字典的键值对时，会首先对key进行hash，以决定如何在内存中保存字典的数据，以便后续对字典的操作(增删改查)

局部变量

• 局部变量是在函数内部定义的变量，只能在函数内部使用
• 函数执行结束后，函数内部的局部变量，会被系统回收
• 不同的函数，可以定义相同名字的局部变量，但是各用各的不会产生影响

局部变量的生命周期：

• 局部变量在函数执行时才会被创建
• 函数执行结束后局部变量被系统回收
• 局部变量在生命周期内，可以用来存储函数内部临时使用到的数据

全局变量

全局变量是在函数外部定义的变量(没有定义的某一个函数内)，所有函数内部内部都可以使用这个变量

变量的加载顺序：

1. 首先查找函数内部是否存在指定名称的局部变量，如果有，直接使用
2. 如果没有，查找函数外部是否存在指定名称的全局变量，如果有直接使用
3. 如果还没有，程序报错

全局变量的引用

• 在函数内部，可以通过全局变量的引用获取对应的数据
• 不允许直接修改全局变量的引用(也就是使用赋值语句修改全局变量的值，如果使用赋值语句相当于在函数内部定义了一个局部变量)
• 如果在函数中需要修改全局变量，需要使用global进行修饰(这样再使用赋值语句时，就不回创建局部变量了)
• 为了保证所有的函数都能够正确的使用到全局变量，应该将全局变量定义在其他函数的上方

全局变量的命名建议：

全局变量名称钱应该增加g_或者gl_的前缀

函数高级

返回值的处理

• 元祖可以包含多个数据，因此可以使用元祖让函数一次返回多个值
• 如果函数的返回值是元祖，小括号可以省略(return result1,result2)
• 如果函数返回值的类型时元组，同时希望单独的处理元组中的元素，可以使用多个变量，一次性接收函数的返回结果，但此时应该保证变量的格式和元组中的元素个数保持一致(temp1, temp2 = 函数名())

可变和不可变参数

• 无论传递的参数是可变还是不可变，只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用
• 如果传递的参数是可变类型，在函数内部使用方法修改了数据的内容，同样会影响到外部的数据

面试题：
问：+=会影响列表的引用吗？
答：在python中，列表变量调用+=本质上是执行列表变量的entend方法，不会修改变量的引用

缺省参数

• 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫缺省参数
• 调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值
• 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用

语法格式：

def 函数名(非缺省参数1, 缺省参数=默认值):
	代码

# 例如：对列表排序的算法
num_list = [6,4,2,5]
# 默认就是升序排序，因为这种引用需求跟多
num_list.sort()
print(num.list)
# [2, 4, 5, 6]

# 只有当需要降序排序时，才需要传递reverse参数
num_list.sort(reverse=True)
print(num_list)
# [6, 5, 4, 2]

"""
提示：
	1.缺省参数，需要使用最常见的值作为默认值
	2.如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

缺省参数注意事项：

1. 必须保证带有默认值的缺省参数在参数列表的末尾
2. 在函数调用时，如果有多个缺省参数，需要指定参数名，这样解释器才能知道参数的对应关系

多值参数

有时可能需要一个函数能够处理的参数个数是不确定的，这个时候，就可以使用多值参数

语法格式：

def 函数名(确定参数,*args,**kargs):
	代码

def demo(num, *args, **kwargs):
    print(num)
    print(args)
    print(kwargs)


# 调用函数
demo(1, 2, 3, 4, 5, name="张三", age=20)

""""
1
(2, 3, 4, 5)
{'name': '张三', 'age': 20}
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

多值参数类型：

• 参数名前增加一个 * 可以接收元祖，一般使用*args
• 参数名前增加两个 * 可以接收字典，一般使用**kwargs

元祖和字典的拆包：

在调用有多值参数的函数时，想要将一个元组变量当做一个整体直接传给args，或者想要将一个字典变量当做一个整体传给kwargs。我们就可以使用拆包，简化参数传递。

语法格式：

在元组变量前，增加一个*
在字典变量前，增加两个*


def demo(*args, **kwargs):
    print(args)
    print(kwargs)


num = [1,2,3]
zhangsan = {"name": "张三", "age": 18}

# 这样调用只会将num, zhangsan都传给*args
# demo(num, zhangsan)
# ([1, 2, 3], {'name': '张三', 'age': 18})
# {}

demo(*num, **zhangsan)
# (1, 2, 3)
# {'name': '张三', 'age': 18}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

至此，Python逻辑处理相关知识点语法整理完毕；下一篇整理Python面向对象的内容。

----------------------------分割线----------------------------
2022年3月10日23点22分补充了身份运算符和成员运算符这一部分内容.