变量

1.什么是变量

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

1）声明变量的语法 - 声明完变量后，使用变量就是在使用变量里面存储的值0
变量名 = 值w

2）说明
变量名 - 程序员自己命名的；
要求：是标识符：不能是关键字
规范：见名知义；满足PEP8命名规范（变量名所有字母都小写，多个单词用_隔开）；
不能用系统提供的类名、函数名、库名等来给变量命名

= - 赋值符号，将右边的数据赋给左边的变量（动词）
值 - 任何有结果的表达式都可以；例如：数据、已经声明过的变量、运算表达式.....

age = 50
print('我的年龄是:', age)
if age < 18:
    print('未成年')
else:
    print('成年')

变量的值

b1 = 89
b2 = 0b1101
b3 = "hello"
b4 = True
b5 = age
b6 = 10 + 2

2.变量的使用

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

age = 18
print(age)
age = "hello"
print(age)

3.同时声明多个变量

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

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

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

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

4.python声明变量的原理

先开辟空间存储数据(存储的数据需要多大的内存就开辟多少内存空间)，
然后再将变量和这个数据对应的内存空间关联在一起

变量三要素：
a = 10
值 - 给变量赋值的数据（10） - 使用变量
类型 - 给变量赋值的数据的类型（int） - type(变量)
地址 - 给变量赋值的数据在内存中的地址，
也是变量中真正存储的东西 - id(变量)

a = 10
print(a, type(a), id(a))
a = 100
print(a, type(a), id(a))
a = 'abc'
print(a, type(a), id(a))

在python中用一个变量给另一个变量赋值的时候，是将原来的变量中数据地址赋给另一个变量；赋值完成后，数据还是只有一个

b = a
print(id(a), id(b))

运算符

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

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

====================数学运算符====================

1）+、-、、/和数学中的加(+)、减(-)、乘()、除(/)的功能一模一样

print(1+1)
print(20-10)
print(20*10)
print(5/2)

2)% - 求余数(取余/取模)

print(5 % 2)
print(10 % 4)

应用1：判断整数的奇偶性 - 判断这个数对2取余的结果是否为0

print(10 % 2)
print(11 % 2)

应用2：是否整除 - 判断余数是否为0

应用3：取低位数，例如：获取一个整数个位数 - 数字%10

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

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

负数整除除不尽的时候向下取整 , -5//2 == -3

print(5//2)  # 2
print(3.9//3)  # 1.0

应用：取高位

num = 123
print(num//100)  # 1

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

print(2**3)  # 8

开平方

print(16**(1/2))  # 4
print(8**(1/3))  # 2

====================比较运算符=====================

2.比较运算符；>、<、==、！=、>=、<=

注意：所有比较运算符的运算结果都是布尔值

1）>、<、>=、<=和数学中的大于、小于、大于等于、小于等于是一样的

print(1 > 2)  # False
print(1 < 2)  # True
print(3 >= 3)  # 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 True -> False
False and False -> False

使用场景：需要多个条件同时满足的时候，就用and；
相当于生活中的并且
gpa = 4.5
score = 98
获取奖学金的条件:绩点不低于4且操行分高于95

print('是否能够获取奖学金：', gpa >= 4 and score > 95)

练习：判断一个数是否能够同时被3和7整除3

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 True  ->  True
False or False  ->  False

使用场景：需要多个条件中有一个条件满足就行，就是用or；
相当于生活中的or

gpa = 4.5
score = 90
获得奖学金的条件：绩点不低于4或者操行分高于95

print('是否获得奖学金：', gpa >= 4 or score > 95)

3） not

运算规则：True变False，False变True

not True  ->  False
not False  ->  True

使用场景：对某一个条件进行否定

一个数不能同时被3和7整除的条件

num = 21
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
True and func1()
# func1()
True or func1()

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

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

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

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

2）组合的赋值运算符

变量 += 值 ->变量 = 变量 + 值

变量 -= 值 ->变量 = 变量 - 值

aa = 100
aa += 10   # aa = aa + 10; aa = 100 + 10; aa = 110
print(aa)

aa *= 4/2  # aa *= 2.0; aa = aa * 2.0; aa = 110 * 2.0; aa = 220.0
print(aa)

aa %= 2
print(aa)

aa = 2
aa **= 64
print(aa)

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的补码：10000111(原)-> 11111000(反)-> 11111001(补)
                               3的补码：00000011
-7 & 3 = 00000001(补) == 1

print(7 & 1, 97 & 1, 99 & 1)
print(8 & 1, 6 & 1, 648 & 1)

2）|

运算规则：每一位是的数如果都是0结果就是0，只要有1就是1
1110 | 0111 -> 1111

print(3 | 2)
print(-7 | 3)

-7：11111001(补)
3：00000011(补)
-7 | 3 = 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

print(2 << 1)  # 2*2**1==4
print(3 << 2)  # 3*2**2==12
print(-4 << 1)  # -4*2**1==-8

6）>>

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

print(4 >> 1)  # 2
print(9 >> 2)  # 2
print(-8 >> 2)  # -2
print(-9 >> 1)  # -5
print(-9 // 2)  # -5