1.什么是变量和变量的声明

变量是用来申请空间保存数据的

• 1）声明变量的语法 ：声明完变量后，使用变量就是在使用变量里面存储的值

变量名 = 值

• 2）说明
  变量名：变量名是由程序员自己命名的；
  变量名的命名要求：和标识符的命名要求相同，且不能是系统关键字
  变量名的命名规范：
  - 1.见名知意；满足PEP8命名规范（所有的字母都小写，多个单词用下划线隔开）；
  - 2.不能使用系统提供的函数名、类名、库名等来给变量命名;
  - 3.=: 赋值符号，将右边的数据赋给左边的变量（动词）;
  - 4.值:任何有结果的表达式；例如：数据、已经申明过的变量、运算表达式等。

• 3）变量的值

b1 = 89
b2 = 0x1101
b3 = '你好！'
b4 = True
b5 = b1
b6 = 10 + 2 + b1

2.变量的使用

使用变量就是使用变量中的值；变量中的值可以修改

age = 50
age = 18
# 修改之后原有的age的值会被覆盖
age = '你好！'
# 同一个变量可以被赋予不同类型的值，新赋予的值会覆盖旧的值

3.同时声明多个变量

• 1）同时声明多个变量赋相同的值
  变量名1 = 变量名2 = 变量名3 = …… = 值

• 2）同时声明多个变量赋不同的值
  变量名1， 变量名2， 变量名3， …… = 值1， 值2， 值3， ……

c1 = c2 = c3 = 10
print(c1, c2, c3)

x, y = 10, 20
print(x, y)

4.python声明变量的原理

java/c语言声明变量：赋值前先向内存申请空间，不同的数据类型对应的空间不同，一旦申请之后空间就确定了。

类型名 变量名 = 值；
int a = 10；# int一般是两个字节的空间
a = 100; #重新赋值时，也只能是int类型的数据

而python语言在声明变量时逻辑是相反的，即先开辟空间存储数据，存储的数据需要多大的内存就开辟多少内存空间，然后再将变量和数据对应的内存空间关联在一起（实际上关联的是变量和数据存储的内存空间的地址）;
在对变量重新赋值时，则是开辟一个新的空间储存数据，再与之前的变量关联同时销毁之前的数据空间。

python变量的三要素（类型、值、地址）

a = 10

• 值 - 给变量赋值的数据（10）- 使用变量
• 类型 - 给变量赋值的数据的类型（int）- type（变量）
• 地址 - 给变量赋值的数据在内存中的地址，也是变量中真正存储（关联）的东西（eg：0xff）- id（变量）

a = 10
print(a, type(a), id(a))
# 当对a重新赋值时，地址会发生变化
a = 100
print(a, type(a), id(a))
# 在java/c语言中，把一个值赋予两个变量时，复制的是容器中（地址中）的数据，即两个变量值相同但是地址不同
# 而在python中，用一个变量给另一个变量赋值时，是将原来的变量中数据的地址赋给另一个变量；赋值完成后，数据还是只有一个，即两个变量的值相同且地址也相同
b = a
print(a, type(a), id(a))
print(b, type(b), id(b))

                                            立ち入り禁止

python支持的运算符：数学运算符、比较运算符、逻辑运算赋、赋值运算符、位运算符

1.数学运算符：+、-、、/、%、//、*

• 1）+、-、*、/ 和小学数学中的加（+）、减（-）、乘（x）、除（÷）的功能一模一样

• 2）% - 求余数（取余/取模）

print(5 % 2)  # 5÷2 余数是1
print(10 % 4)  # 10÷4 余数是2

应用1：判断整数的奇偶性 - 判断这个数对2取余的结果是否是0
应用2：是否整除 - 判断余数是否为0
应用3：取低位数，例如，获取一个整数的个位数 - 数字%10

num = 123
print(num % 10)  # 3
print(num % 100)  # 23

• 3）// - 整除（商只取整数部分）

注意：负数整除除不尽的时候向下取整！！！

eg: -5 // 2 == -3

print(5 // 2)  # 2
a = 3.9 // 3  # 1.0
print(type(a))

应用：取高位

• 4）** - 幂运算；x ** y -- 求x的y次方

print(2 ** 3)
print(16 ** (1/2))  # 开平方

2.比较运算符：>、 <、 ==、 !=、 >=、 <=

注意：所有的比较运算的运算结果都是布尔值，即True和False

• 1）>、 <、 >=、 <= 和数学中的 >、 <、 ≥、 ≤是一样的

print(10 > 20)  # False
print(30 >= 20)   # True

• 2） == - 判断两个值是否相等， != 判断两个值是否不相等

print(10 == 10)  # True
print(10 != 10)  # False

• 3）python中可以像数学一样用比较运算符连写的方式来表示范围（c/java/js等不可以）

age = 20
print(18 < age < 28)

3.逻辑运算符：and（逻辑与运算）、or（逻辑或运算）、not（逻辑非运算）

逻辑运算符的运算对象和结果一般都是布尔值

• 1）and

运算规则：两个都是True，结果才是True;只要有一个是False，结果就是False
True and True -> True
True and False -> False
False and False -> False
使用场景：需要多个条件同时满足的时候，就用and；相当于生活中的并且

gpa = 4.5
score = 90
# 获取奖学金的条件:绩点不低于4并且操评分高于95
print('是否能够获取奖学金：', gpa >= 4 and score > 95)
# 练习：判断一个数是否能够同时被3和7整除
num = 35
print('这个数是否能同时被3和7整除:', num % 3 == 0 and num % 7 == 0)

• 2)逻辑或运算or

运算规则：两个都是False，结果才是False，只要有一个是True，结果就是True
True or True -> True
True or False -> True
False or False -> False
使用场景：需要多个条件中有一个条件满足就行，就使用or；它相当于生活中的或者or

• 3）not非运算(单目运算符)

运算规则：True变False， False变True
not True -> False
not False -> True
使用场景：对某一个条件进行否定

num = 14
# 一个数不能同时被3和7整除的条件
print('不能同时被3和7整除：', not (num % 3 == 0 and num % 7 == 0))

• 4)短路操作

and的短路操作：条件1 and 条件2 -> and前面的条件如果结果是False，那么后面的条件语句不会执行，结果直接是False
or的短路操作：条件1 or 条件2 -> or前面那个条件结果如果是True，那么后面的条件语句不会被执行，结果直接是True

def func1():
    print('函数被执行了')
    return True

False and func1()  # and的短路操作
True or func1()  # or的短路操作

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

所有的赋值运算符的左边必须是变量；组合的赋值运算符的左边除了要求是变量，这个变量还必须是已经声明过的

• 1）变量 = 值 -> 将右边的值赋给左边的变量

a = 10
b = 10 * 2
c = a
d = a + b

• 2)组合的赋值运算符
  变量 += 值 -> 变量 = 变量 + 值

bb = 100
bb += 10
print(bb)

bb -= 20
print(bb)

bb *= 4/2  # 除法运算的结果都是浮点类型的数据
print(bb)

bb %= 2  # bb = bb%2 ; bb = 180%2; bb=0

5.运算符优先级（运算顺秀）

运算符优先级：
数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符（最低）
数学运算符的优先级和数学一样：** > *, /, //, % > +, -
如果有括号，先算括号里面的

                                            立ち入り禁止

所有的位运算都是针对数字的补码进行操作的；特点是快速（运算效率高）

位运算：&（与）， |（或）， ~(取反)， ^(异或)， <<(左移)， >>(右移)

注意：位运算时，符号位也参与运算

• 1.&

运算规则：补码每一位分别进行运算，当参与运算的补码的相同位都是1，结果就是1；如果有一个0结果就是0
1110（补码） & 0111（补码） = 0110
应用：高效判断数字的奇偶性 - 让数字和1进行按位与运算，判断结果是0（偶数）还是1（奇数）

a = 3 & 2
print(a)
"""
3的补码：00000011
2的补码：00000010
00000011 & 00000010 = 00000010 == 2
"""

b = -7 & 3
print(b)

"""
-7 的补码：100000111（原） -> 11111001（补码）
3 的补码                      00000011
-7 & 3 = 00000001（补码）== 1
"""

print(7 & 1, 111 & 1, 82 & 1)

• 2.|按位或运算

运算规则：参与运算的数的补码对应每一位上的数都是0，结果就是0，只要有1结果就是1
1110 | 0111 -> 1111

print(3 | 2)
print(-7 | 3)  # 11111001 | 00000011
"""
-7: 11111001
3: 00000011
11111011(补) -> 11111010(反) -> 10000101 == -5
"""

• 3.~取反（单目）

运算规则：将每一位上的0变成1，1变成0
~ 1101 -> 0010

print(~-7)
"""
11111001(补码) -> 00000110 == 6
"""

• 4.^异或

运算规则：参与运算的数的补码对应每一位上的数相同结果是0，不同结果就是1
11011 ^ 10010 -> 01001

• 5.<<

数字<< N -> 指定的数字的补码整体向左移动N位;计算：数字*2 **N
00100110 << 1 -> 01001100

print(2 << 1)  #  2 * 2 ** 1 = 4
print(-3 << 2) #  -3 * 2 ** 2 = -12
# 力扣 这个网站有许多算法题可以参考

• 6.>>

数字>> N -> 计算：数字//2**N

print(4 >> 1)  # 2
print(9 >> 2)  # 2
print(-8 >> 2)  # -2
print(-9 >> 1)  # -5
print(-9 // 2)  # -5 注：负数整除的时候会往小的方向取整