九、赋值运算符及内存分析
运算符：
赋值运算符
算术运算符
关系运算符
逻辑运算符
位运算符
1、赋值运算符
name = 'admin'
# 将'admin'的值赋值给变量name（取出后面的值赋值给前面的）
name1 = name
print(id(name))
print(id(name1))
print(id(name), name)
print(id(name1), name1)
print(name == name1) # ==是一种关系判断
运行结果：
58021216
58021216
58021216 admin
58021216 admin
True
解释：
name = ‘admin’ ------>将 'admin’当作是一个字符串常量，内存里会特地有一块空间存放 ‘admin’，给这块空间起一个地址（eg：58021216）。此外，还有一个“容器”，它的名字为name，经过name = 'admin’这条语句，就会把’admin’的地址指向name这个“容器”（空间）。
name1 = name------>相当于把’admin’这个地址又给了name1一份儿。
声明了name = ‘admin’ 则可以多处复用，节省内存，避免了空间的浪费。
在上段程序中加上两句来分析
name1 = 'admin1'
# 问：打印的地址与原来的地址是否一样？
print(id(name1), name1)
print(id(name), name)
name1 = ‘admin1’------>再分配一块空间给 ‘admin1’存放地址。且此时name1就不再指向’admin’ 的地址了，而是指向 'admin1’的地址。
52271424
52271424
52271424 admin
52271424 admin
True
52273600 admin1
52271424 admin
拓展后的赋值符号+= -= *= /=…
num = 8
num += 5 # num=num+5此时的加号是数学符号，表示的就是相加的意思
print(num)
num -= 10
print('num=', num) # num=num-10
a = 'abc'
a += 'gg' # 此时等价于a=a+'gg' 此时的+是连接符 包含两个动作：1、连接字符串 2、把连接后的结果赋值给a
print(a)
# 针对字符串 没有-= *= /= 这一系列的运算
运行结果：
13
num= 3
abcgg
2、算术运算符+ - * /
拓展的算术运算符：** //
# 算术运算符
a = 8
b = 2
result = a*b
print('乘法运算：', result)
result = a/b
print('除法运算：', result)
b = 3
result = a**b
print('a**b=', result) # 相当于是幂的概念 a的b次幂
result = a//b
print('a//b=', result) # 相当于是整除的概念 运算结果中商取整数值
result = a % b
print('a%b=', result) # 取余
运行结果：
乘法运算： 16
除法运算： 4.0
a**b= 512
a//b= 2
a%b= 2
注释：
在这里有一点说明，一个字符串乘以一个数即为将该字符串重复多少次
eg：
print('*'*50)
print('\t 英雄联盟')
print('*'*50)
运行结果：
**************************************************
英雄联盟
**************************************************
3、关系运算符
注释：
所有比较运算符的结果只有两种，要么True，要么False。
如果说我们现在要登录一个app，我们需要输入用户名和密码，在我们输入完自己的用户名以及密码之后，就会把这些数据交到后台服务器上，后台服务器收到这些个信息，将其与数据库里面存的那些信息进行匹配验证（因为注册的东西都在数据库里）。一经比较就会产生结果，两种结果分别为True和False。在我们的开发过程中，这种比较是随处可见的。那么比较时会用到哪些运算符呢？
==、 != 、 >= 、 <= 、>、<、is、is not等
example 1：
n1 = int(input('请输入第一个数:'))
n2 = int(input('请输入第二个数:'))
# 在之前的笔记中提到过 input输出的都是字符串类型，现在要进行数值之间的比较，必须要把它转化为整型才可以比较。
resault = (n1 > n2) # 结果为True或False
print('n1 > n2:', resault)
resault = (n1 == n2)
print('n1 == n2:', resault)
# 若比较的是字符串，可以用==吗？
m1 = 'hello'
m2 = 'hello'
resault = (m1 == m2) #这里可以不要括号
print('m1 == m2:', resault)
运行结果：
请输入第一个数:10
请输入第二个数:8
n1 > n2: True
n1 == n2: False
m1 == m2: True
example 2：开发过程中的用户验证：
# 在用户验证时，也是要用到==这个运算符
# 假设输入用户名用username存储，数据库存的用户名用变量uname来存储
username = input('请输入用户名:')
uname = 'admin123'
resault = username == uname
#resault = username != uname # 如果两者不相等就会返回True相等就会返回False
print('用户验证的结果为：', resault)
运行结果：（假设输入的用户名为admin，而数据库中存储的是admin123）
请输入用户名:admin
用户验证的结果为： False
example 3：is的用法
is 用于用户对象的比较或者认为是地址的比较
age = 20
age1 = 20
print(age is age1)
运行结果：
True
# python提供了一个全局的函数叫id 可以打印他们的地址
age = 20
age1 = 20
print(id(age))
print(id(age1))
print(age is age1)
运行结果：
1611901152
1611901152
True
money = 3000000
salary = 1000000
print(id(money))
print(id(salary))
print(money is salary)
money = 3000000
salary = 3000000
print(id(money))
print(id(salary))
print(money is salary)
运行结果：
12073136
12074560
False
12073136
12073136
True
***注释：（重要！）在交互式下运行是一个结果，在源文件形式下运行又是另外一个结果，为什么呢？？？ ***
python交互式下运行的结果
>>> money=2000000
>>> id(money)
10629664
>>> salary=2000000
>>> id(salary)
10633040
>>> money is salary
False
注释：显而易见，money与salary的id不一致
>>> age=3
>>> id(age)
1611900880
>>> age1=3
>>> id(age1)
1611900880
>>>
*money和salary在数值相同时，输出的id结果不一致
而age与age1在数值相同时，输出的id结果却是一样的。*
在执行源文件（xxx.py文件）时，是那么多行代码一起交给python解释器，它在处理代码的时候是批量进行处理的。且程序自上而下自左向右进行执行，在这个过程中开辟的内存都是属于这一次的，是一个整体，这时候会有一个“大整数对象池”，意即一个代码块的大整数是同一个对象。
交互式的特点是所见即所得，写完一句就执行一句的结果。在交互式模式下，程序是一行一行去执行的。而且，对于“小整数”（-5—256以内的数都被认为是小整数，这些整数对象是提前建立好的，不会被垃圾回收）来说，存在“小整数对象池”（是为了避免为整数频繁申请和销毁内存空间），它的内存可以被复用。
但是对于大整数来讲，python没有专门的一个空间去存它。（终端即交互式，每每执行一次，大整数都会重新创建）只要交互式中来一个大整数，就会开辟一块空间去存储它，当再次声明一个大整数时，就会再给你分配一块空间去存储它。本质上，在这个时候，用is比较的这两个分配空间的大小。如果比较的是地址，地址不一样，自然返回的是false。*
***此处验证一下所谓的大整数与小整数***
>>> money=256
>>> id(money)
1611904928
>>> salary=256
>>> id(salary)
1611904928
>>> money is salary
True
>>> money=257
>>> id(money)
10632992
>>> salary=257
>>> id(salary)
10633008
>>> money is salary
False
4、逻辑运算符（and、or 、not三种）
and 表示逻辑与
or 表示逻辑或
not 表示逻辑非
逻辑运算符的结果也是只有两种，要么True，要么False。
逻辑运算符是两个条件同时比较，所以可以理解为逻辑运算符是在关系运算符的基础上多了一层。
（1）and 表示逻辑与，两边同时为真，结果即为真 即：True and True----->True ,其他情况下都为False
'''
True and True----->True
True and False----->False
False and True----->False
False and False----->False
eg:8>10 and 6<8 是False and True----->False的情况
验证用户名和密码时
'admin'=='admin123' and '123456'=='123456' ----->False
False and True----->False
'''
n1 = 8
n2 = 5
n3 = 3
resault = n1 >= (n2+n3) and n1 > n2
print(resault)
'''
步骤：
1、n1 >= (n2+n3) -------------- 8 >= 8 True
2、n1 > n2 -------------- 8 > 5 True
3、True and True -------------- 判定为True
'''
n2 = n2+n3 # n2=8
resault = n1 >= n2 and n1 == n3
print(resault)
n4 = (n1+n3-n2) # now n4=8+3-8=3
resault = n4 < n1 and (n4+n3) > n2
运行结果：
True
True
False
（2）or 表示逻辑或，只要有一边为真True，结果即为真True。
只要有一边为真True，结果即为真True
True or True----->True
True or False----->True
False or True----->True
False or False----->False
# 判断是否存在用户，手机号 或者 账户名 都可以进行用户的登录操作
username = '' # 表示不填写用户名 只填写email
email = '[email protected]'
resault = username == 'admin123' or email == '[email protected]'
# False or True----->True
print('测试逻辑或打印结果:', resault)
a = 2
b = 5
c = 7
resault = (a+b) != c or c > a
print('测试逻辑或打印结果:', resault)
运行结果：
测试逻辑或打印结果: True
测试逻辑或打印结果: True
（3）not 逻辑非，即取反
flag = False
resault = not flag # not就是取反
print('测试逻辑非打印结果:', resault)
运行结果：
测试逻辑非打印结果: True
5、位运算符
在介绍位运算符之前，首先介绍一下进制转换的相关知识。
# 二进制的表示（十进制转换为二进制）
a = 3
print(bin(a)) # 意思是输出它的二进制转换结果，结果为0b 11
# 0b表示二进制
a = 13
print(bin(a)) # 0b1101
# 二进制转换十进制
a = 0b1101
print(int(a))
a = 0b10111
print(int(a))
运行结果：
0b11
0b1101
13
23
十进制负数转换二进制
# 十进制负数如何转换为二进制呢?这就涉及到符号位了
b = -8
print(bin(b)) # -0b1000，这是python的运行结果，因为python认为0b就代表二进制，但实际计算不是这样的
# 先求这个负数的相反数的二进制表示结果，再取反加一
# eg：-5的二进制表示
'''
5用二进制表示为 0b0101
取反（反码）为 1010
再加一为 1011
字节byte 八个二进制位构成一个字节
* 1byte 是八个二进制位 所以往往表示数的时候会用八个二进制位来表示
则5就表示为0000 0101
1kb=1024byte
1Mb =1024kb
1G =1024M
1Tb =1024G
'''
运行结果：
-0b1000
八进制转换十进制与二进制
# 0o 代表的是八进制 里面的数字小于8即可
'''
0o6430------->转换为十进制0*8^0+3*8^1+4*8^2+6*8^3=0+24+4*64+6*512= 3352
'''
c = 0o6430
print(int(c))
# 八进制转换二进制？如何转换
# 把八进制中的每一个数字都转换为二进制数并组合起来
'''
6 4 3 0
110 100 011 000
组合为 110100011000
eg：0o721-----> 0b 111 010 001
'''
# 验证所得的二进制数是否正确
d =0b110100011000
print(int(d))
运行结果：
3352
3352
十六进制转换十进制与二进制
# 0x 代表十六进制,其数值表示是0-9，a-f
e = 0x9 # 9*16^0=9*1=9 转换为十进制结果为9
print(int(e))
e = 0x911 # 9*16^2+1*16^1+1*16^0=9*256+1*16+1=2321
# 转换为十进制结果为2321
print(int(e))
f = 0x9ab16
'''
16 8 4 2 1
| | | | |
1111 1000 0010 0010 0001
9 a b 1 6
| | | | |
1001 1010 1011 0001 0110
十六进制转换为二进制也是 将十六进制中的每一位都用二进制表示以后组合即可
'''
print(bin(f))
print(int(f))
运行结果：
9
2321
0b10011010101100010110
633622
接下来着重开始介绍位运算符，位运算符本质上是位移。
位运算符号包括：
&(与)、|(或)、~(非)、^(异或)、<<(左移)、 >>(右移)
print(3 & 2)
'''
与运算类似于and
1为true 0为False
0000 0011
& 0000 0010
-------------
0000 0010
故3&2运行结果为2
|类似or
也是1为true 0为False
0000 0011
| 0000 0010
-------------
0000 0011
故3|2运行结果为3
'''
print(3 | 2)
print(5 | 3)
print(~5) # 取反
'''
5表示为：
0000 0101
取反：
1111 1010
-6(相反数的反码加一)
0000 0110
1111 1001 反码
+1
---------
1111 1010 补码
'''
'''
反过来验证：
-6：
1111 1010
先减一
1111 1001
再取反
0000 0110 ------------>6
'''
# 异或^ 不同为1，相同为0
print(3 ^ 5)
'''
步骤：
1、左侧的数字转成二进制
2、右侧的数字转成二进制
3、对齐，上下进行比较（不同为1，相同为0）
4、将计算的结果转成十进制
3 0000 0011
5 0000 0101
------------------
0000 0110--------------->6
'''
# 左移<< 右移>>
print(2 << 1) # 4
print(2 >> 1) # 1
'''
2的二进制
0000 0010
左移：0|000 0010|0
|
补零
变成： 0000 0100-------》4
右移：0000 001|0
在左侧补符号位，符号位为0就补零 符号位为1就补1
变成： 0|000 0001---------》1
规律：
m<<n:结果为 m*2的n次方
m>>n:结果为 m//2的n次方(m整除2的n次方)
'''
print(36 >> 4)
'''
2^4=16
36//16=2
'''
print(16 << 2)
print(16 >> 2)
运行结果：
3
7
-6
6
4
1
2
64
4
附：三目运算符
# 三目运算符
# 格式： 表达式 ？ 真 ： 假
# resault = (8>10)? '真': '假'
# print(resault)
# 这样会报错resault = (8>10)? '真': '假'
# ^
# SyntaxError: invalid syntax
'''
三目运算符的正确格式
结果 if 表达式 else 结果
步骤：
判断表达式是True还是False
如果是True则将if前面的内容进行运算，并将结果赋值给resault
如果是False则将else后面的内容进行运算，并将结果赋值给resault
'''
a = 6
b = 5
resault = (a+b) if a<b else (b-a)
print(resault)
'''
运算符的优先级别排序：
**
~
+ -（符号运算符）
* / // %
+ - 加减
<< >>
&
^
|
== != > >= < <=
is is not
not
and
or
'''
运行结果：-1