处理四则运算的符号,在数字的处理中应用的最多
运算符 | 说明 | 示例 | 结果 |
---|---|---|---|
+ | 加 | 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 表达式:
语句块
"""
汉语关联词:
如果...就...
执行顺序:
如果表达式的值为True,就执行语句块
如果表达式的值为False,就跳过语句块不执行,继续执行后面的语句
"""
语法格式:
if 表达式:
语句块1
else:
语句块2
"""
汉语关联词:
如果...否则...
执行顺序:
如果表达式的值为True,就执行语句块1,否则执行语句块2
"""
and和or运算:
语法格式:
if 表达式1:
语句块1
elif 表达式2:
语句块2
....
elif 表达式n:
语句块n
else:
语句块n+1
语法格式:
# 第二层if语句看做一个语句块
if 表达式1:
if 表达式2:
语句块1
else:
语句块2
if 表达式1:
if 表达式2:
语句块1
else:
语句块2
else:
if 表达式3:
语句块3
else:
语句块4
语法格式:
for 循环变量 in 循环对象:
语句块
"""
变量对象:
1.字符串
2.文件
3.组合数据类型
4.range()函数等
tips:range()函数产生一个[n,m)的整数序列,包含n,不包含m
"""
语法结构:
for 循环变量 in 遍历对象:
语句块1
else:
语句块2
"""
else语句只有在循环正常结束后才执行
通常与break和continue语句一起使用
"""
通过一个条件来控制是否要继续反复执行循环体中的语句
语法结构:
while 表达式:
语句块
"""
当表达式的值为True时,执行语句块
当表达式的值为False时,跳过语句块而执行语句块之后的代码
"""
语法结构:
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
不做任何事情,只起到占位符的作用,使语法结构完整,不报错。一般可用在if,for,while,函数定义,类定义中
语法结构:
if 表达式:
pass
while 表达式:
pass
for 循环变量 in 遍历对象:
pass
语法格式:
def 函数名():
函数封装的代码
....
"""
相关说明:
1.def是英文define(定义)的缩写
2.函数名称应该能够表达函数封装代码的功能,方便后续调用,即见名知意
3.函数名称的命名应该符合标识符的命名规则
- 不能以字母,下划线和数字组成
- 不能以数字开头
- 不能与关键字重名等
"""
调用函数很简单的,通过**函数名()**即完成对函数的调用
def 函数名():
函数封装的代码
....
# 调用函数
函数名()
"""
注意:
1.定义好函数之后,表示这个函数封装了一段代码,如果不主动调用函数,函数是不会主动执行的
2.函数的调用必须在函数定义的下面
"""
函数的文档注释:
参数的作用:
增加函数的通用性,针对相同的数据处理逻辑,能够适应更多的数据
1. 在函数内部,把参数当做变量使用,进行需要的数据处理
2. 在函数调用时,按照函数定义的参数顺序,把希望在函数内部处理的数据,通过参数传递
形参和实参:
注意:
return表示返回,后续的代码是不会被执行的
模块是Python程序架构中的一个核心概念
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中
注意:
如果变量已经被定义了,当个一个变量赋值的时候,本质上是修改了数据的引用,变量不再指向之前的数据地址,变量改为对新值的地址引用
不可变类型:
内存中的数据不允许被修改
可变类型:
内存中的数据可以被修改
注意:
字典的key只能使用不可变类型的数据,value可以是任意类型的数据
哈希(hash)小笔记:
哈希是一种算法,其作用就是提取数据的特征码(指纹)
Python中有个内置的hash(o)函数,接收一个不可变类型的数据作为参数,返回一个整数
在python中,设置字典的键值对时,会首先对key进行hash,以决定如何在内存中保存字典的数据,以便后续对字典的操作(增删改查)
局部变量的生命周期:
全局变量是在函数外部定义的变量(没有定义的某一个函数内),所有函数内部内部都可以使用这个变量
变量的加载顺序:
全局变量的命名建议:
全局变量名称钱应该增加g_或者gl_的前缀
面试题:
问:+=会影响列表的引用吗?
答:在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.如果一个参数的值不能确定,则不应该设置默认值,具体的数值在调用函数时,由外界传递
"""
缺省参数注意事项:
有时可能需要一个函数能够处理的参数个数是不确定的,这个时候,就可以使用多值参数
语法格式:
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。我们就可以使用拆包,简化参数传递。
语法格式:
在元组变量前,增加一个*
在字典变量前,增加两个*
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分补充了身份运算符和成员运算符这一部分内容.