Python全栈之运算符详解

目录
  • 1. 算数_比较_赋值_成员
    • 1.1 算数运算符
    • 1.2 比较运算符
    • 1.3 赋值运算符
    • 1.4 成员运算符
  • 2. 身份运算符
    • 小提示:
  • 3. 逻辑运算符
    • 3.1 位运算符
    • 3.2 小总结
  • 4. 代码块_单项_双项分支
    • 4.1 代码块
    • 4.2 流程控制
    • 4.3 单项分支
    • 4.4 双项分支
  • 5. 小作业
  • 总结

1. 算数_比较_赋值_成员

1.1 算数运算符

算数运算符: + - * / // % **

# +
var1 = 7
var2 = 90
res = var1 + var2
print(res)
# -
var1 = 7
var2 = 90
res = var1 - var2
print(res)
# *
var1 = 7
var2 = 10
res = var1 * var2
print(res)
# / 结果永远为小数
var1 = 10
var2 = 5
res = var1 / var2
print(res , type(res))
# // 地板除
"""被除数  除数 = 商"""
"""注意点:如果被除数或者除数是小数,那么得到正常结果之后,数值后面带上.0变成小数"""
var1 = 10.0
var2 = 3.0
# var2 = 3.0
res = var1 // var2
print(res)

# %  取余
var1 = 7
var2 = 4
res = var1 % var2
res = -7 % 4  # -3 + 4 = 1
res = 7 % -4  # 3 + (-4) = -1
res = -7 % -4 # -3 (被除数和除数都是负的,正常结果加负号)
res = 81 % 7   # 4
res = 81 % -7  # -3
res = -81 % 7  # 3
res = -81 % -7 # -4
print(res)
# ** 幂运算
res = 2 ** 3
print(res)

1.2 比较运算符

比较运算符: > < >= <= == !=

"""比较运算符的结果要么是True , 要么是False 只有两个值"""
res = 10 > 5
res = 10 >= 10
# ==这个符号是在做比较,比较==两边的数值是否一样
res = 5 == 9
res = 5 != 9
print(res)

1.3 赋值运算符

赋值运算符: = += -= *= /= //= %= **=

# = 赋值运算符 将右侧的值赋值给左侧变量
a = 5 <= 3
print(a)

var1 = 10
var2 = 5
# +=
"""var1 = var1 + var2"""
# var1 += var2
# print(var1)
# -=
"""var1 = var1 - var2"""
# var1 -= var2
# print(var1)
# %=
"""var1 = var1 % var2"""
var1 %= var2
print(var1)

1.4 成员运算符

成员运算符: in not in (针对于容器型数据)

"""字符串判断时,必须是连续的片段"""
strvar = "今天天气要下雨,赶紧回家收衣服"
res = "今" in strvar
res = "天气" in strvar
res = "赶回" in strvar
print(res)
# 针对于列表,元组,集合
container = ["赵沈阳","赵万里","赵世超"]
container = ("赵沈阳","赵万里","赵世超")
container = {"赵沈阳","赵万里","赵世超"}
# res = "赵沈阳" in container
# res = "赵万里" not in container
res = "赵世超1223232" not in container
print(res)
# 针对于字典 (判断的是字典的键,不是值)
container = {"zsy":"赵沈阳","zwl":"赵万里","zsc":"赵世超"}
res = "赵沈阳" in container # False
res = "zsy" in container
print(res)

2. 身份运算符

身份运算符 is 和 is not (检测两个数据在内存当中是否是同一个值)

# 整型 -5~正无穷
var1 = 100
var2 = 100
print(var1 is var2)
# 浮点型 非负数
var1 = -9.1
var2 = -9.1
print(var1 is var2)
# bool 相同即可
var1 = True
var2 = True
print(var1 is var2)
# complex 在实数+虚数不相同 (只有虚数的情况下例外)
var1 = 6-8j
var2 = 6-8j
var1 = -10j
var2 = -10j
print(var1 is var2)
# 容器: 相同字符串 , 空元组相同即可  剩下的所有容器都不相同
container1 = ()
container2 = ()
print(container1 is not container2)
container1 = "你"
container2 = "你"
print(container1 is not container2)
container1 = [1,23,3]
container2 = [1,23,3]
print(container1 is not container2)

小提示:

# var1和var2地址id是一样的
var1 = 10j
var2 = 10j
# var1和var2地址id是不一样的
var1 = -10j
var2 = -10j

3. 逻辑运算符

逻辑运算符: and or not

# and 逻辑与
"""全真则真,一假则假"""
res = True and True    # True
res = True and False   # False
res = False and True   # False
res = False and False  # False
print(res)
# or  逻辑或
"""一真则真,全假则假"""
res = True or True    # True
res = False or True   # True
res = True or False   # True
res = False or False  # False
print(res)
# not 逻辑非
res = not True
res = not False
print(res)
# 逻辑短路
"""
无论后面的表达式是True 还是False 都已经无法改变最后的结果,那么直接短路,后面的代码不执行;
(1) True or print("程序执行了 ~ 1111")
(2) False and print("程序执行了 ~ 2222")
True or print("程序执行了 ~ 1111")
True or True => True
True or False => True
False and print("程序执行了 ~ 2222")
False and True  => False
False and False => False
"""
"""
计算规律:
	先脑补计算当前表达式的布尔值是True还是False
	如果出现了 True or 表达式  或者 False and 表达式的情况,直接返回前者,后面代码不执行
	如果没有出现短路效果,直接返回后者
"""
res = 5 and 6 # 6
"""
True and True =>True
True and False => False
"""
res = 5 or 6  # 5
res = 0 and 999
res = 0 or "abc"
print(res)
# 逻辑运算符的优先级
""" 优先级从高到低: () > not > and > or   """
res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 # 5 and 7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
"""
not (False or False) => True
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
res = True or False and True or True and True
res = True or False or True
res = True or True => True
"""
print(res)

3.1 位运算符

位运算符: & | ^ << >> ~

var1 = 19
var2 = 15
# & 按位与
res = var1 & var2
"""
000 ... 10011
000 ... 01111
000 ... 00011 => 3
"""
print(res)
# | 按位或
res = var1 | var2
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""
print(res)
# ^ 按位异或
"""两个值不相同=>True 反之返回False"""
res = var1 ^ var2
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""
print(res)
# << 左移 (相当于乘法)
"""5乘以2的n次幂"""
res = 5 << 1 # 10
res = 5 << 2 # 20
res = 5 << 3 # 40
print(res)
"""
000 ... 101  => 5
000 .. 1010  => 10
000 ..10100  => 20
000 .101000  => 40
"""
# >> 右移 (相当于除法)
"""5地板除2的n次幂"""
res = 5 >> 1 # 2
res = 5 >> 2 # 1
res = 5 >> 3 # 0
"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""
print(res)

# ~ 按位非 (针对于补码进行操作,按位取反,包含每一位)
""" -(n+1) """
# res = ~22
res = ~19
print(res)
"""
原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011
补码:   000 ... 10011
按位非: 111 ... 01100
给你补码->原码
补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 => -20
"""
res = ~-19
print(res)
"""
原码:100 ... 10011
反码:111 ... 01100
补码:111 ... 01101
补码:   111 ... 01101
按位非: 000 ... 10010
给你补码->原码 (因为是整数 ,原反补相同)
000 ... 10010 => 18
"""

3.2 小总结

总结:
	个别运算符:
		运算符优先级最高的: **
		运算符优先级最低的: =
		()可以提升优先级
	一元运算符 > 二元运算符 (优先级)
		一元运算符 : 同一时间,操作一个值 ~ -
		二元运算符 : 同一时间,操作一个值 + - * / ....
	同一种类运算符:
		算数运算符 : 乘除 > 加减
		逻辑运算符 : () > not > and > or
		位运算符   : ( << >> ) > & > ^ > |
	整体排序:
		算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
		赋值运算符用来做收尾
"""
res = 5+5 << 6 // 3 is 40 and False
"""
res = 10 << 2 is 40 and False
res = 40 is 40 and False
res = True and False
res = False
"""
print(res)
# 用括号提升下优先级
res = (5+5) << (6//3) is 40 and False

4. 代码块_单项_双项分支

4.1 代码块

代码块:以冒号作为开始,用缩进来划分相同的作用域,这个整体是代码块

"""作用域: 作用的范围"""
if 10 == 11:
	print(1)
	print(2)
	print(3)
print(4)

# 缩进:要么全都使用\t tab  要么全都是使用4个空格(也可以两个空格,标准的是四个),来表达相同的作用域,不能混再一起;
"""
if 10 == 10:
	print(1)
    print(2)
"""
# 其他语言的写法 (了解)
"""
if(10 == 10){
	print(1)
					print(2)
																								print(3)
}
"""

4.2 流程控制

"""
流程: 代码执行的过程
控制: 对代码执行过程中的把控
三大结构:
(1)顺序结构: 默认代码从上到下,依次执行
(2)分支结构: 单项分支 双向分支 多项分支 巢状分支
(3)循环结构: while / for
"""

4.3 单项分支

"""
if 条件表达式:
	code1
	code2
当条件表达式成立,返回True,执行对应的代码块
"""
zhiye = "程序员"
if zhiye == "程序员":
	print("拿高薪")
	print("钱多,话少,死的早")
	print("发量日渐稀少")

4.4 双项分支

"""
if 条件表达式:
	code1  ..
else:
	code2 ...
如果条件表达式成立,返回True ,执行if这个区间的代码块
如果条件表达式不成立,返回False,执行else这个区间的代码块
if   分支的代码块也叫做真区间
else 分支的代码块也叫做假区间
"""

zhiye = "强盗"
zhiye = "律师"
if zhiye == "强盗":
	print("打他")
	print("骂他")
	print("喂他辣椒水")
else:
	print("给你一朵红花")

# input 等待用户输入字符串 (注意:结果一定是字符串)
"""
name = input("你好~ 你妈贵姓~")
print(name , type(name))
"""
# ### 模拟网站登录
# 如果admin = wangwen  密码:password = 111 显示登录成功,否则显示登录失败
# admin = "wangwen"
# password = "111"
admin = input("请输入您的账号:")
password =  input("请输入您的密码:")
if admin == "wangwen" and password == "111":
	print("登录成功")
else:
	print("登录失败")

5. 小作业

1.99//4  ,  99%4 ,  -99 %4  ,  -99 %-4值是多少
2.成员和身份运算符如何使用
3.逻辑运算符优先级?逻辑短路在什么情况下发生?
4.优先级最高和最低的运算符是?
5.左移右移后的值如何计算?按位非的公式?
6.~(-25) ~25 推到一下过程
7.res = 17>15 or 78<11 or 7 and 8 and not True is True  res=?
8.计算表达式的值
    1).6 or 2 > 1
    2).3 or 2 > 1
    3).0 or 5 > 4
    4).5 < 4 or 3
    5).2 > 1 or 6
    6).3 and 2 > 1
    7).0 and 3 > 1
    8).2 > 1 and 3
    9).3 > 1 and 0
    10).3 > 1 and 2 or 2 < 3 and 3 and 4 or 3 > 2
    11)not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6
9.提示用户输入 "如何在dnf中变得更强?". 如果输入的是充钱,打印"马化腾爱你" ,反之输出,"你想一想,不充钱怎么可能变得更强"

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • 解析python高级异常和运算符重载

    目录 一.高级异常 二.环境管理器 2.1.对象的属性管理函数 三.运算符重载 3.1.算术运算符的重载 四.反向算术运算符的重载 五.复合赋值算术运算符的重载 六.比较运算符的重载 七.位运算符重载 八.反向位运算符重载 九.复合赋值位运算符重载 十.一元运算符的重载 十一.in / not in 运算符的重载 十二.索引和切片运算符的重载 十三.slice 构造函数 一.高级异常 回顾异常相关的语句: try-except:用来捕获异常的通知 try-finally:用来做一定要做的事 re

  • Python开发技巧之海象运算符的三种运用方式

    目录 1. 第一个用法:if/else 2. 第二个用法:while 3. 第三个用法:推导式 Python 版本发展非常快,如今最新的版本已经是 Pyhton 3.9,即便如此,有很多人甚至还停留在 3.6 或者 3.7,连 3.8 还没用上. 很多 Python 3.8 的特性还没来得及了解,就已经成为旧知识了,比如今天要说的海象运算符. 海象运算符是在 PEP 572 被提出的,直到 3.8 版本合入发布. 它的英文原名叫 Assignment Expressions,翻译过来也就是 赋值

  • python接口,继承,重载运算符详解

    目录 1. 序列__getitem__ 2. __setitem__ 3. 抽象基类 4. 不要直接子类化内置类型 5. 继承顺序 6. 重载运算符 总结 1. 序列__getitem__ 如果没有 __iter__ 和 __contains__ 方法, Python 会调用 __getitem__ 方法, 设法让 迭代 和 in 运算符可用 class Foo: def __getitem__(self, pos): return range(0, 30, 10)[pos] f = Foo()

  • 解决Python运算符重载的问题

    python进行有理数运算时,希望用运算符(+ - * /)描述计算过程. 只是用来写出更加自然的计算表达式.为此,python为所有算数运算符规定了特殊方法名.其中所有特殊的名字都以两个下划线开始,并以两个下划线结束,即: 当在Python中输入"a+b"时,程序发现使用了"+"运算符,因此就会调用"__add__"方法. 此时,若对自定义类中进行运算符的重载,则可以实现对类的打印.有理数运算等等. 其中,一个问题应当注意,如以下代码 clas

  • python基础之基本运算符

    目录 Python基本运算符 算数运算符 比较运算符 逻辑运算符 赋值运算符 总结 Python基本运算符 算数运算符 # + - * / % ** // 算数运算符 # 定义如下运算符 a=7 b=3 print(a+b) print(a-b) print(a*b) print(a/b) print(a%b) print(a//b) # 地板除,相除取整,也可进行复合运算 比较运算符 # == != < > >= <= 比较运算符 a,b=10,5 print(a==b) pri

  • Python中的三目(元)运算符详解

    目录 Python 三元运算符 一.示例 1:使用三元运算符找出两个数字中的最大值. 二.示例 2:根据条件的返回值,Python 执行打印语句之一 三.示例 3:使用嵌套的三元运算符,找到三个数字中的最大值 总结 Python 三元运算符 Python 三元运算符用于根据条件选择两个值之一.它是 if-else 语句的一个缩影,它将两个值之一分配给一个变量. Python 三元运算符的语法是: [statement_1] if [expression] else [statement_2] 如

  • python not运算符的实例用法

    说明 1.not逻辑非,可以对符号右侧的值进行非运算. 2.对于布尔值,非运算会对其进行取反操作,True变False,False变True. 对于非布尔值,非运算会先将其转换为布尔值,然后再取反. 空性值为False,其他为True. 实例 a = True # 如果表达式不赋值.不会对变量a有任何影响, # 只是创建了一个新对象存储了结果, # 同数据类型转换所讲的 not a # 对变量a赋值之后,表达是结果才影响变量a. a = not a print(f"a = {a}")

  • Python学习之运算符号

    目录 1.算数运算符: 2.赋值运算符: 3.比较运算符 4.逻辑运算符 5. 成员运算符 总结 大至分为以下5类运算符号 算数运算符 赋值运算符 比较运算符 逻辑运算符 成员运算符 算数运算符 和 赋值运算符 运算是得到真实的结果 比较运算符 逻辑运算符 和 成员运算符 运算得到的 是布尔值 真True 或 假False 1.算数运算符: +          加          -          减          *          乘          /          除

  • Python全栈之运算符详解

    目录 1. 算数_比较_赋值_成员 1.1 算数运算符 1.2 比较运算符 1.3 赋值运算符 1.4 成员运算符 2. 身份运算符 小提示: 3. 逻辑运算符 3.1 位运算符 3.2 小总结 4. 代码块_单项_双项分支 4.1 代码块 4.2 流程控制 4.3 单项分支 4.4 双项分支 5. 小作业 总结 1. 算数_比较_赋值_成员 1.1 算数运算符 算数运算符: + - * / // % ** # + var1 = 7 var2 = 90 res = var1 + var2 pri

  • Python全栈之线程详解

    目录 1. 线程的概念 1.1 Manager_进程通信 1.2 线程的概念 2. 线程的基本使用 3. 自定义线程_守护线程 3.1 自定义线程 3.2 守护线程 4. 线程安全问题 4.1 线程安全问题 4.2 Semaphore_信号量 5. 死锁_互斥锁_递归锁 6. 线程事件 总结 1. 线程的概念 1.1 Manager_进程通信 # ### Manager ( list 列表 , dict 字典 ) 进程之间共享数据 from multiprocessing import Proc

  • Python全栈之队列详解

    目录 1. lock互斥锁 2. 事件_红绿灯效果 2.1 信号量_semaphore 2.2 事件_红绿灯效果 3. queue进程队列 4. 生产者消费者模型 5. joinablequeue队列使用 6. 总结 1. lock互斥锁 知识点: lock.acquire()# 上锁 lock.release()# 解锁 #同一时间允许一个进程上一把锁 就是Lock 加锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,即串行的修改,没错,速度是慢了,但牺牲速度却保证了数据

  • Python实现栈的方法详解【基于数组和单链表两种方法】

    本文实例讲述了Python实现栈的方法.分享给大家供大家参考,具体如下: 前言 使用Python 实现栈. 两种实现方式: 基于数组 - 数组同时基于链表实现 基于单链表 - 单链表的节点时一个实例化的node 对象 完整代码可见GitHub: https://github.com/GYT0313/Python-DataStructure/tree/master/5-stack 目录结构: 注:一个完整的代码并不是使用一个py文件,而使用了多个文件通过继承方式实现. 1. 超类接口代码 arra

  • Python生成随机数的方法详解(最全)

    目录 使用 random 模块 使用 NumPy 库 使用 secrets 模块 使用 random.org 网站 使用 random.choices()方法 python生成随机数都有哪些办法呢 使用 random 模块:random模块是python内置的模块,使用方法如random.randint()生成一个随机整数. 使用 NumPy 库:NumPy 是一个强大的数值计算库,它提供了生成随机数的功能,例如numpy.random.randint()生成一个随机整数. 使用 secrets

  • Python深度学习线性代数示例详解

    目录 标量 向量 长度.维度和形状 矩阵 张量 张量算法的基本性质 降维 点积 矩阵-矩阵乘法 范数 标量 标量由普通小写字母表示(例如,x.y和z).我们用 R \mathbb{R} R表示所有(连续)实数标量的空间. 标量由只有一个元素的张量表示.下面代码,我们实例化了两个标量,并使用它们执行一些熟悉的算数运算,即加法.乘法.除法和指数. import torch x = torch.tensor([3.0]) y = torch.tensor([2.0]) x + y, x * y, x

  • PHP读书笔记_运算符详解

    什么是运算符 什么是运算符?运算符是告诉PHP做相关运算的标识符号.例如,你需要计算123乘以456等于多少,这时候就需要一个符号,告诉服务器,你需要做乘法运算. PHP中的运算符有哪些?PHP运算符一般分为算术运算符.赋值运算符.比较运算符.三元运算符.逻辑运算符.字符串连接运算符.错误控制运算符. PHP中的算术运算符 算术运算符主要是用于进行算术运算的,例如:加法运算.减法运算.乘法运算.除法运算.在PHP中的常用的算术运算符对应下表: PHP中的赋值运算符 PHP的赋值运算符有两种,分别

  • Python 迭代器与生成器实例详解

    Python 迭代器与生成器实例详解 一.如何实现可迭代对象和迭代器对象 1.由可迭代对象得到迭代器对象 例如l就是可迭代对象,iter(l)是迭代器对象 In [1]: l = [1,2,3,4] In [2]: l.__iter__ Out[2]: <method-wrapper '__iter__' of list object at 0x000000000426C7C8> In [3]: t = iter(l) In [4]: t.next() Out[4]: 1 In [5]: t.

  • 基于Python代码编辑器的选用(详解)

    Python开发环境配置好了,但发现自带的代码编辑器貌似用着有点不大习惯啊,所以咱们就找一个"好用的"代码编辑器吧,网上搜了一下资料,Python常用的编辑器有如下一些: 1. Sublime Text 2. Vim 3. PyScripter 4. PyCharm 5. Eclipse with PyDev 6. Emacs 7. Komodo Edit 8. Wing 9. The Eric Python IDE 10. Interactive Editor for Python

随机推荐