15_布尔值_运算符_条件表达式理解

15.布尔值

---

菜鸟教程python3运算符

官方文档-内置类型，布尔，运算符

---

Python2中没有布尔值，直接用 数字 0表示 False ,用 数字1 表示True。

Python3中，把 True和 False 定义成了关键字，但他们的本质还是 1和 0，甚至可以和数 字相加。

>>> a = True 
>>> b = 3 
>>> a+b 
4

比较运算符

所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。

在python中有八个比较操作。它们都具有相同的优先级（高于布尔运算的优先级）。比较可以任意链接；例如， x < y <= z 等于 x < y and y <= z 除了 y 只评估一次（但在这两种情况下 z 当 x < y 被发现是错误的）。

操作	意义
<	严格小于
<=	小于或等于
>	严格大于
>=	大于或等于
==	平等的
!=	不等
is	对象标识
is not	否定的对象标识

逻辑运算符

操作	结果	笔记
x or y	如果 x 是假的，那么 y ，否则 x	(1)
x and y	如果 x 是假的，那么 x ，否则 y	(2)
not x	如果 x 是假的，那么 True ，否则 False	(3)

if not x:
    表达式    # 当x为false 表达式才会执行

not,and,or

一些用法

a=int(input("请输入一个数字:"))
# 返回True
a>=18 or print("满18岁可以考驾照")
# 逻辑或 如果 a<18 为false 则执行  后面的语句（短路语法）
a<18 or print("未满18岁不能考驾照")

a=int(input("请输入一个数字:"))
#逻辑与 a>=18 则 执行 print
a>=18 and print("满18岁可以考驾照")
# a<18为 false 则直接 返回 flase  不再 计算 后面的表达式
a<18 and print("未满18岁不能考驾照")

同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。

is,is not

is 与 == 区别：

  is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。

  == 用于判断引用变量引用对象的值是否相等，默认调用对象的 __eq__()方法。

实验

a=1000
b=1000
a==b
返回True
a is b
返回 False

整数缓存问题

Python仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对 象。
需要注意的是，这仅仅是在命令行中执行，
而在Pycharm或者保存为文件执行，结果是不一样的 ，这是因为解释器做了一部分优化 (范围是 [ - 5 , 任意正整数]) 。

整数缓存如何理解。 看实验

In [6]: a=255

In [7]: b=255

In [8]: a is b
Out[8]: True

In [9]: a=257 # 范围外的  不会指向 同一个对象。 

In [10]: b=257

In [11]: a is b
Out[11]: False

·总结

1、is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；

2、== 比较的是两个对象的内容是否相等，值是否相等；

3、小整数对象[-5, 256]在全局解释器范围内被放入缓存供重复使用；

4、is 运算符比 == 效率高，在变量和None进行比较时，应该使用 is。

---

基本运算符

运算符	说明
and , or , not	与或非
is , is not	同一性判断是否为同一个对象
<，<=，>，>= ，!=， ==	比较值是否相当，可以连用，链式比较
| ，^，&	按位或， 按位异或， 按位与
<<, >>	移位
~	按位翻转 ， 按位取反
+, -, *, /,//, %,	加，减，乘，浮点除，整除，取余
**	幂运算

1. 比较运算符可以连用，并且含义和我们日常使用完全一致。

>>> a = 4 
>>> 3<a<10 #关系运算符可以连用
True 

2. 位操作

>>> a = 0b11001 
>>> b = 0b01000 
>>> c = a|b 
>>> bin(c) #bin()可以将数字转成二进制表示
'0b11001'
>>> bin(c&b) 
'0b1000' 
>>> bin(c^b) 
'0b10001'
>>> a = 3 
>>> a<<2 #左移1 位相当于乘以2.左移 2位，相当于乘以4
12
>>> a = 8 
>>> a>>1 #右移 1位相当于除以 2. 

# 需要 说一下的是  我们的  python 的 按位 取反的 运算符  得到的是 
# 比如 ~x = -(x+1)
# ~1 = -2
# -2 的二进制 形式 '0b0_1111_1110' 这个叫 反码
# 但是 Python 得到的 是 一个  带符号 的  数字 -2
# 但是 其实 我想要得到 的是 '0b0_1111_1110' 这个 也就是  254 这个 无符号 数字
# 意思就是 '0b0_1111_1110' 有符号数的 时候 这个 代表的是 -2
# 无符号数 那么就 代表  254

# ~2 = -3
# 如果 我们想要 拿到 一个 数字的  无符号 形式
# 可以 这样
~1 & 0xff # 输出 254  
f"{~1&0xff:0=#{11}_b}" # 输出 '0b1111_1110'  
~2 & 0xff # 输出 253
f"{~2&0xff:0=#{11}_b}" # 输出 '0b1111_1101'
# 只要 和 0xff 按位 与 就可以了 0xff 是 16进制 的 0b1111_1111
# 如果 需要长度 更长的 那么 就  增加  ff 即可. 
# 这里 现在是 8 bit  那么 我要 16bit 的 话
f"{~2&0xffff:0=#{11}_b}" # 输出的 是这个  '0b1111_1111_1111_1101' 

3. 加法操作

(1) 数字相加 3+2 ==> 5
(2) 字符串拼接 “3”+“2”==> “32” 
(3) 列表、元组等合并 [10,20,30]+[5,10,100] ==>[10,20,30,5,10,100] 

4. 乘法操作

(1) 数字相乘 3*2 ==> 6 
(2) 字符串复制 “sxt”*3 ==> ”sxtsxtsxt”
(3) 列表、元组等复制 [10,20,30]*3 ==> [10,20,30,10,20,30,10,20,30]

5. 成员判断

In [341]: a=[1,2,3]

In [342]: b={"a":1,"b":2}

In [343]: c=(1,23,4)

In [344]: d="onepis"

In [345]: e={1,2,3}

In [346]: 1 in a # a 列表中是否包含 1
Out[346]: True

In [347]: 1 in b # b 字典中 是否 包含 1
Out[347]: False

In [348]: "a" in b # b 字典中 是否包含 a 这里 字典 判断的是键。 
# 还没 写到 字典。 所以 后面 会讲 字典的
Out[348]: True

In [349]: 1 in c # c 元组 中是否 包含 1
Out[349]: True

In [350]: 1 in e # e 集合中是否包含 1
Out[350]: True

In [351]: "o" in d # 字符串 d 是否包含 o
Out[351]: True

---

dir vars locals 判断 一个变量是否被定义

# 方法 1 vars
In [354]: "a" in vars() # 判断变量 a 是否定义
# 前面我们 定义了 a,b,c,d,e
Out[354]: True
# f 我们没有定义
In [355]: "f" in vars()
Out[355]: False

# -----------------------------------
# 这里只需要理解  if判断就行  至于  re正则  可以百度看下简介，后面我们会学习这个模块的。
import re
In [380]: def extract_str():
     ...:     match_obj=re.search(r"^[o]\w+","onepis")
     ...:     if match_obj:
     ...:         result=match_obj.group()
     ...:     if "result" in vars():
     ...:         return result
     ...:


In [381]: extract_str()
Out[381]: 'onepis'


# -------------------------------------------

# 方法 2 locals

In [356]: "a" in locals()
Out[356]: True

In [357]: "f" in locals()
Out[357]: False

# -------------------------------

In [374]: def extract_str():
     ...:     match_obj=re.search(r"^[o]\w+","onepis")
     ...:     if match_obj:
     ...:         result=match_obj.group()
     ...:     if "result" in locals():
     ...:         return result
     ...:

In [375]: extract_str()
Out[375]: 'onepis'

# ------------------------

# 方法 3 dir
In [358]: "a" in dir()
Out[358]: True

In [359]: "f" in dir()
Out[359]: False
In [378]: def extract_str():
     ...:     match_obj=re.search(r"^[o]\w+","onepis")
     ...:     if match_obj:
     ...:         result=match_obj.group()
     ...:     if "result" in dir():
     ...:         return result
     ...:



In [379]: extract_str()
Out[379]: 'onepis'


# ----------------------------

# 方法 4
# 在模块级， locals() 和 globals() 是同一本字典。
In [361]: "b" in globals() # 在函数中的 局部变量 是不在 globals 中的
Out[361]: True

In [362]: "f" in globals()
Out[362]: False
# -------------------

In [369]: def extract_str():
     ...:     match_obj=re.search(r"^[o]\w+","onepis")
     ...:     if match_obj:
     ...:         result=match_obj.group()
     ...:     if "result" in globals():
     ...:         return result
     ...:
In [370]: extract_str() # 没有返回 result 说明 result 不在 globals 中
In [371]: "result" in globals()
Out[371]: False

总结 ：

• 在不确定该用 globals 还是 locals 的时候 应该使用 dir 或者 vars
• 一般来说全局中 使用 globals ，函数中有局部作用域的时候 使用 locals

重新封装了一下这个 extract_str 函数

import re
def extract_str(pat,str_,func=re.search):
    '''
    不支持 func 为 re.sub
    '''
    match_obj = func(pat,str_)
    if match_obj:
        result = match_obj if isinstance(match_obj, list) else match_obj.group()
    if 'result' in vars():
        return result
        
pat=r".{3}[p]is.{2}"
str_="onepisYama this is the thipisYahh"
extract_str(pat,str_,re.findall)

---

复合赋值运算符

复合赋值可以让程序更加精炼，提高效率。

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。	在这个示例中，赋值表达式可以避免调用 len() 两次: 其实海象操作符就是为了实现 在 表达式中 进行赋值的，这是我的个人观点。 1. 比如 各种 推导式中临时再 创建一个变量。 2. 或者 条件判断中 临时 创建一个变量。

海象操作符 `:=`

>>> count=5
>>> if count>3:
...     print(count)
...
5
>>> if count:=5>3:
...     print(count)
...
True
>>> if (count:=5)>3:
...     print(count)
...
5

注：与C 和JAVA不一样，Python不支持自增(++)和自减(–)

运算符优先级问题

如下优先级，从高到低。

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，求余数和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
== !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用 小括号组织。

1. 乘除优先加减
2. 位运算和算术运算 > 比较运算符 > 赋值运算符 > 逻辑运算符

(5+10*x)/5-13*(y-1)*(a+b)/x+9*(5/x+(12+x)/y)

条件表达式详解

判断False和True

在选择和循环结构中，条件表达式的值为 False的情况如下：

---

• False、0、0.0、空值 None、空序列对象（空列表、空元祖、空集合、空字典、空字 符串）、空range 对象、空迭代对象。
• 其他情况，均为True。

这么看来，Python所有的合法表达式都可以看做条件表达式，甚至 包括函数调用的表达式。