Python语法--程序逻辑篇

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

运算符

算术运算符

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

运算符	说明	示例	结果
+	加	1 + 1	2
-	减	1 - 1	0
*	乘	2 * 3	6
/	除	10 / 2	5
//	取整	10 // 3	3
%	取余	10 % 3	1
**	幂运算	2 ** 4	16

算术运算符的优先级

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

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

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

注意事项：
除数不能为0

赋值运算符

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

运算符	说明	示例	展开形式
=	简单的赋值运算	x = y	x = y
+=	加等于	x += y	x = x + y
-=	减等于	x -= y	x = x - y
*=	乘等于	x *= y	x = x * y
/=	除等于	x /= y	x = x / y
%=	取余等于	x %= y	x = x % y
**=	幂等于	x ** = y	x = x ** y
//=	整除等于	x //= y	x = x // y

比较运算符

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

运算符	作用	举例	结果
>	大于	98 > 90	True
<	小于	98 < 90	Fales
==	等于	98 == 90	False
!=	不等于	98 != 90	True
>=	大于等于	98 >= 90	True
<=	小于等于	98 <= 90	True

逻辑运算符

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

运算符	含义	用法	结合方向
and	与	表达式1 and 表达式2	从左到右
or	或	表达式1 or 表达式2	从左到右
not	非	not 表达式	从右到左

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

表达式1	表达式2	表达式1 and 表达式2	表达式1 or 表达式2	not 表达式1
True	True	True	True	False
True	False	False	True	False
False	False	False	False	True
False	True	False	True	True

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次幂

成员运算符

运算符	描述
in	如果在指定的序列中找到值,返回True,否则返回False
not in	如果在指定的序列中没有找到值,返回True,否则返回False

# 举例:
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中
"""

身份运算符

运算符	描述
is	用于判断两个标识符是否引自同一个对象
is not	用于判断两个标识符是否引自不同对象

# 举例:
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引用自同一对象
"""

注意:

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

运算符的优先级

运算符	说明
**	幂
~，+，-	取反，正号，负号
*，/，%，//	算术运算符程，除，取余，取整
+，-	算术运算符加，减
<<，>>	位运算符中的左移和右移
&	位运算符中的与
^	位运算符中的异或
|	位运算符中的或
<，<=，>，>=，!=，==	比较运算符
is,is not	身份运算符
in,not in	成员运算符
not,and,or	逻辑运算符

程序的组织结构

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

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

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

顺序结构

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

赋值类型	细化分类	示例	注意
增强赋值运算	增强赋值运算	i += 1	相当于i = i + 1
序列分解赋值	元组分解赋值	name,age = ‘张三’,20
	列表分解赋值	[name,age] = [‘张三’,20]
	字符串分解赋值	a,b,c,d = ‘room’
扩展序列解包	*号匹配赋值	a,*b = ‘room’

# 元组分解赋值
(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
[]
"""

选择结构

if语句

语法格式：

if 表达式：
	语句块
"""
汉语关联词：
	如果...就...
执行顺序：
	如果表达式的值为True,就执行语句块
	如果表达式的值为False，就跳过语句块不执行，继续执行后面的语句
"""

if…else…语句

语法格式：

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

and和or运算：

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

if…elif…else语句

语法格式：

if 表达式1：
	语句块1
elif 表达式2：
	语句块2
....
elif 表达式n:
	语句块n
else:
	语句块n+1

if语句的嵌套

语法格式：

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

if 表达式1:
	if 表达式2：
		语句块1
	else：
		语句块2
else：
	if 表达式3：
		语句块3
	else：
		语句块4

循环结构

遍历循环for

语法格式：

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

遍历循环的扩展模式

语法结构：

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

无限循环while

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

语法结构：

while 表达式：
	语句块

"""
当表达式的值为True时，执行语句块
当表达式的值为False时，跳过语句块而执行语句块之后的代码
"""

无限循环while的扩展结构

语法结构：

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

"""
else语句只有在循环正常结束后才执行
通常与break和continue语句一起使用
"""

嵌套循环

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

语法格式：

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

for 循环变量1 in 遍历对象1：
	for 循环变量2 in 遍历对象2：
		语句块2

程序跳转语句

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

语法格式：

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

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


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

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

空语句pass

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

语法结构：

if 表达式：
	pass

while 表达式：
	pass

for 循环变量 in 遍历对象：
	pass

函数

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

函数的定义

语法格式：

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

函数的调用

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

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

# 调用函数
函数名()

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

函数的文档注释：

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

tips：IDEA中快速添加注释

效果如下：

函数的参数使用

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

参数的作用：

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

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

变量进阶

变量的引用

• 变量和数据都是保存在内存中的
• 在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. 在函数调用时，如果有多个缺省参数，需要指定参数名，这样解释器才能知道参数的对应关系

多值参数

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

语法格式：

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}
"""

多值参数类型：

• 参数名前增加一个 * 可以接收元祖，一般使用*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}

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

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