day3-变量，运算符，位运算总结

变量

1.什么是变量

变量是在程序开辟空间存储数据用的>

2}说明：变量名 - 程序员自己命名；
（要求）是标识符，不能是关键字
（规范）遵守PEP8命名规范变量名中所有的字母都小写
如果变量名由多个单词组成，单词之间用下划线
隔开。
见名知义 :

看见变量名大概知道变量中存储的是什么数据= 赋值符号，将右边的值赋给左边的变量
值 任何有结果的表达式，可以是具体的数据，也可以是赋值过的变量，也可以是运算表达式>

python中同一个变量可以存储不同的类型

num = 200
print(num)
num = 'abc'
print(num)        # 变量必须先声明/赋值再使用
a = b = c = 100    # 同时声明多个变量，赋相同的值
print(a, b, c)

name, age, gender = '小明', 18, '女'  # 同时声明多个变量赋不同的值
print(name, age, gender)  # 注意变量的个数要和值的个数一致

声明变量和给变量赋值的原理

现在内存中开辟空间存储数据（内存空间大小由数据的大小动态分配） 然后再将保存数据的内存空间的地址赋给变量
用一个变量给另一个变量赋值的时候，实质是将变量中的地址赋给新的变量

num3 = 100
print(type(num3))
print(id(num3))          # 获取变量中数据在内存中的地址

运算符

逻辑运算符; and(逻辑于运算), or(逻辑或运算), not(逻辑非运算)

所有的逻辑运算符的运算对象是布尔，结果也是布尔>

1）and
a.运算规则：两个都为True结果才是True，只要有一个False结果就是False （生活逻辑相当于并且）

True and True 结果是True
True and False 结果是False
False and True 结果是False
False and False 结果是False>

b.什么时候用：

当希望多个条件同时满足的时候，就用and将多个条件连接。

2. or
   a.运算规则：两个都为False结果才为False，只要有一个是True结果就是True （生活逻辑相当于或者）

True or True 结果是True
True or False 结果是True
False or True 结果是True
False or False 结果是False

b.什么时候用：

当希望多个条件只要有一个满足的时候，就用or将多个条件连接。

3)not逻辑非运算：
a.运算规则：True变False，False变True

not True False
not False True

b.什么时候使用：

对某个条件进行否定

4）短路操作

逻辑与运算的短路操作：当and前面的表达式的值是False的时候，程序不会再去执行and后面的表达式
逻辑或运算的短路操作：当and前面的表达式的值是True的时候，程序不会再去执行and后面的表达式

用一个变量保持学生的绩点，一个变量保存学生的操评分；写一个条件来判断学生是否能拿奖学金
奖学金条件：绩点不低于3.5， 操评分至少90分

grade = 4
score = 92
# 条件1： grade >= 3.5 条件2： score >= 90
print('是否能拿奖学金:', grade >= 3.5 and score >= 90)

grade = 4
score = 72
# 条件2： grade >= 3.5 条件2： score >= 90
print('是否能拿奖学金:', grade >= 3.5 or score >= 80)

练习1：
1）判断一个数是否能够被2或者5整除

num = int(input('输入一个数字：'))
print('能否被2或者5整除：', num % 2 == 0 or num % 5 == 0 )

2）判断一个数是否能同时被2或者5整除

num1 = int(input('输入一个数字：'))
print('能否被2或者5整除：', num1 % 2 == 0 and num1 % 5 == 0 )

3）判断一个数是否是3或者7的倍数，并且这个数的末尾不是3

num2 = int(input('输入一个数字：'))
print('能否被3或者7整除：', (num2 % 3 == 0 or num2 % 7 == 0) and num2 % 10 != 3 )

赋值运算符：=, +=, -=, *=, /=, %=, //=, **=

不管什么样的赋值运算符，最终的操作都是给变量赋值；所以赋值符号的左边必须是变量

1） = ：将右边的值赋给左边的变量
2）复合的赋值运算符：先将赋值符号左边变量中的值取出来，然后进行指定的运算，最后将运算结果再重新赋值给左边的变量
注意：复合的赋值运算符的左边必须是已经赋值过的变量

位运算:

位运算操作是数字的补码的每一位; 位运算因为是直接操作计算机存储空间的每一位，所以执行效率要比一般的运算要高

5.位运算: &(按位与运算), |(按位或运算),^(按位异或), ~(按位取反), <<(左移), >>(右移)

1)按位与

1. 数字1 & 数字2 -> 两个数字补码上相同位置上的数，如果都是1结果就是1，如果有一个是0结果就是0

1 & 1 -> 1
1 & 0 -> 0
0 & 1 -> 0
0 & 0 -> 0
110 & 001 -> 000
011 & 11100111 -> 00000011

print(10 & 20)   # 0

10原码: 00001010
20原码: 00010100
10 & 20 -> 00000000 -> 0

print(2 & 3)

2: 00000010
3: 00000011
00000010 -> 2

print(-2 & -3)

-2: (原)10000010 -> (反)11111101 -> (补)11111110
-3: (原)10000011 -> (反)11111100 -> (补)11111101
(补)11111100 -> 11111011(反) -> 10000100(原) -> -4

2)按位或运算

1.数字1 | 数字2 -> 两个数字补码上相同位置上的值如果都是0结果才是0，只要有一个1结果就是1

1 | 1 -> 1
1 | 0 -> 1
0 | 1 -> 1
0 | 0 -> 0
110 | 001 -> 111

print(10 | 20)

10原码: 00001010
20原码: 00010100
00011110 -> 16 + 8 + 4 + 2 -> 30

print(2 | 3)

2: 00000010
3: 00000011
00000011

print(-2 | -3)

-2: (原)10000010 -> (反)11111101 -> (补)11111110
-3: (原)10000011 -> (反)11111100 -> (补)11111101
11111111(补) -> 11111110(反) -> 10000001(原) -> -1

3)按位取反

数字 -> 将数字补码上每一位的值由0变成1，1变成0

1 -> 0
~0 -> 1
~1101 -> 0010

print(~10)

10原码: 00001010
11110101(补) -> 11110100(反) -> 10001011(原) -> -11

print(~-3)

-3: (原)10000011 -> (反)11111100 -> (补)11111101
00000010 -> 2

4)按位异或

数字1 ^ 数字2 -> 两个数补码上相同位置上的值，如果相同结果是0，不同结果是1

1 ^ 1 -> 0
1 ^ 0 -> 1
0 ^ 1 -> 1
0 ^ 0 -> 0
110 ^ 101 -> 011

print(10 ^ 20)

10原码: 00001010
20原码: 00010100
00011110 -> 16+8+4+2 -> 30

print(-2 ^ -3)

-2: (原)10000010 -> (反)11111101 -> (补)11111110
-3: (原)10000011 -> (反)11111100 -> (补)11111101
00000011 -> 3

特点: 一个数异或同一个数两次，结果就是这个数本身

print(-2 ^ -3 ^ -3)

5) 左移和右移

数字 << N -> 让数字的补码整体左移N位，低位用0补充 -> 数字 * (2N)
数字 >> N -> 让数字的补码整体右移N位，正数高位补0，负数高位补1 -> 数字 // (2N)

print(10 << 1)
print(10 >> 1)

10原码: 00001010
00010100 -> 20
00000101 -> 5

print(-3 << 1)
print(-3 >> 1)

-3: (原)10000011 -> (反)11111100 -> (补)11111101
11111010(补) -> 11111001(反) -> 10000110(原) -> -6
11111110(补) -> 11111101(反) -> 10000010 -> -2

print(-3 << 6)

-3: (原)10000011 -> (反)11111100 -> (补)11111101
1010000000 -> 100111111 -> 111000000 -> 2^7 + 2^6 = -192

print(9 >> 1)
print(4 >> 1)
print(2 >> 1)
print(1 >> 1)
print(-5 >> 1, -5 // 2)

#应用:

1.乘2的次方或者整除2的次方的操作 （<<, >>）

2. 数字 & 1 == 0 -> 偶数; 数字 & 1 == 1 -> 奇数

print(3 & 1, 113 & 1, 15 & 1, -11 & 1, -5 & 1)
print(2 & 1, 100 & 1, 12 & 1, -12 & 1, -6 & 1)