本章大纲

布尔类型

布尔表达式

布尔操作符

布尔类型

布尔类型：只有2中结果：真 假

boolData = True  # True/False在布尔表达式中是必须大写
'''
使用场景：
    浏览器中的选项，比如：选A，显示A内容；选B，显示B内容
    搜索输入框内容是否可见，可操作
'''
# 搜索输入框内容是否可见,示例：
from selenium import webdriver
# 根据驱动的实际路径填写
executable_path = r"E:\selenium\cheomedriver.exe"
# 初始化，运行Chrome driver
driver = webdriver.Chrome(executable_path)
# 打开网址
driver.get('https://www.baidu.com')
# 定位搜索框
el = driver.find_element_by_id('kw')
# 判断搜索框是否可见，并打印结果：True
print(el.is_displayed())  # is_displayed()判断搜索框可见

布尔表达式

布尔表达式

​ 1、关系运算符：

​ 数值比较

​ 字符串比较

​ in 和 not in

​ 2、关系运算符的结果是bool

# 关系运算符：>  <  ==  >=   <=  !=
# = 赋值， == 关系等于
# 关系运算符：数值比较
print(3 >= 1)
print(3 != 1)
# is 是不是同一个对象--python解释器中操作下面数据
>>> a = 100
>>> b = 100
>>> a == b
True
>>> a is b
True

>>> a = 256
>>> b = 256
>>> a == b
True
>>> a is b
True
>>> id(a)
4305291616
>>> id(b)
4305291616

>>> a = 257
>>> b = 257
>>> a is b
False
>>> id(a)
4373499792
>>> id(b)
4375680208
"""
a is b
结果True，原因：a和b的对象在256内,所以a = 100 的时候已经创建了一个100，当b = 100时解释器会自动识别内存地址中的100，a和b共用一个对象（内存地址），不再生产新的内存地址，节省内存空间
a和b的对象大于256，b就会创建新的内存地址
这是python本身的存储机制
"""

# 关系运算符：字符串比较--比较的是a b的ASCII值的大小
print('abc' > 'bc')  print('abc' > 'bc')  # 比较abc中的a与bc中的b的ASCII值的大小，a=97，b=98，所以为False，如果abc与bc中一个值相等就比第二个值，依此类推
注：ASCII：A=65 B=66 C=67，a=97 b=98 c=99

# 关系运算符：in 和 not in
# 1- in 在字符串：前者是后者的一个元素；前者是后者的连续一段
str1 = 'abcdefg'
print('acd' in str1)  # 必须连续一段
print('abc' in str1)
print('a' in str1)
# 2- in 数据存储使用--前者是后者的一个元素
alist = [10, 20, 40, 20]
print(20 in alist)
print(alist[0:3] in alist)  # 前者不能是后者的连续一段元素，只能是一个元素，所以切片不行

在线工具：https://tool.oschina.net/commons?type=4

ASCII对照表

ASCII值	控制字符	ASCII值	控制字符	ASCII值	控制字符	ASCII值	控制字符
0	NUT	32	(space)	64	@	96	、
1	SOH	33	!	65	A	97	a
2	STX	34	"	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	,	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	0	80	P	112	p
17	DCI	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	/	124	|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	`
31	US	63	?	95	_	127	DEL

布尔操作符

条件组合

逻辑条件

且（and）：

​ 要求工作3年且统招本科，同时满足两同个条件才为真

逻辑 且 - and
    条件1 and 条件2
        1- 全真为真，一假为假
        2- 如果条件1为真，条件2一定会运行
        3- 如果条件1为假，条件2一定不会运行

或 or

要求本科或有python自动化经验，满足1个条件就为真

逻辑 或 - or
    条件1 or 条件2
        1- 一真为真，全假为假
        2- 如果条件1为真，条件2一定不会运行
        3- 如果条件1为假，条件2一定会运行

不/非 not

逻辑 不/非 - not
    将真变为假，将假变为真

混合运算
优先级---适当的打上括号--方便理解逻辑--维护代码比较好理解
代码加注释
算数运算符（+ - * /.....） > 关系运算符（> < ==.....） > 逻辑运算符（逻辑运算符优先级：not > and > or）

练习-代码(python解释器执行)

>>> 2 > 1 and 3 > 2 
True
>>> 2 > 1 and 3 > 4
False
>>> 3 > 4 and 2 > 1
False
>>> 2 > 1 or 3 > 2
True
>>> 2 > 1 or 3 > 4
True
>>> (2 > 1 or 3 > 4) and 5 > 4
True
>>> not 3 > 2
False
>>> not 1 > 2 or 4 > 3
True
>>> not (1 > 2 or 4 > 3)
False
>>> 1 > 2 or not 4 > 3
False
>>> 1 > 2 and not 4 > 3
False

面试官：

​ 描述下：python的赋值，深拷贝和浅拷贝的区别？

# 不可变对象，赋值、深拷贝和浅拷贝可种方法都行
# 可变对象，根据情况使用 深拷贝或浅拷贝
"""
项目场景：
一个接口api_A,获取到数据- sData---[[],100]有区别
需要：
    1- 接口a 调用数据源 sData
    2- 接口b 调用数据源 sData
期望效果：接口a使用完数据源，不会改变数据
总结：
    1- 如果数据源只有一层列表，深拷贝/浅拷贝都可
    2- 如果数据源多层列表，使用深拷贝
    3- 赋值--指向同一个对象-相互没有关联
使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。
"""
# 方案1 --赋值--指向同一个对象，会改变数据
alist = [10, 30, [100, 200]]
blist = alist
# 接口a操作
blist.append(30)
print('blist-->:', blist, 'id-->:', id(blist))
print('alist-->:', alist, 'id-->:', id(alist))

# 方案2 --浅拷贝：只是增加了一个指针指向已存在的内存地址--拷贝父对象，不会拷贝对象的内部的子对象。
import copy
alist = [10, 30, [100, 200]]
blist = copy.copy(alist)  #对象拷贝，浅拷贝
# 接口a操作
blist.append(50)  #修改对象blist
blist[2].append(50)  #修改对象blist中的['100', '200']数组对象
print('blist-->:', blist, 'id-->:', id(blist))
print('alist-->:', alist, 'id-->:', id(alist))

# 方案3 --深拷贝：是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存
# copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
import copy
alist = [10, 30, [100, 200]]  #原始对象
blist = copy.deepcopy(alist)  #对象拷贝，深拷贝
# 接口a操作
blist[2].append('3')   #修改对象blist中的['100', '200']数组对象
print('blist-->:', blist, 'id-->:', id(blist))
print('alist-->:', alist, 'id-->:', id(alist))

参考文档：https://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html