一.变量

变量就是在程序中用来保存数据的容器

1. 声明变量(定义变量) —— 假的声明
   语法：
   变量名 = 值
   说明：
   变量名 —— 要求：标识符，不能是关键字
   规范：a.遵守PEP8命名规范(名字的所有字母都小写，如果由多个单词组成，单词之间用_隔开)
   b.见名知义(看到名字就知道变量中存的是什么数据)
   student_name
   = —— 赋值符号，将=右边的值赋给左边的变量
   值 —— 可以是任何有结果的表达式，例如：190，变量，10+20，调用函数表达式
   在使用变量的时候，就是在使用变量中保存的值。

a1= 998
a2 = a1 - 10
print(a2) #988
#变量必须先声明(赋值)再使用
#print(a3) #NameError: name 'a3' is not defined
#同时声明多个变量，并且赋一样的值。(同时给多个变量赋值)
num1 = num2 = num3 = 88
print(num1,num2,num3) #88 88 88
#同时声明多个变量，并且赋不同的值。(注意：变量的个数和值的个数需保持一致)
x,y,z = 10,20,30
print(x,y,z) #10 20 30
#给同一个变量赋值，后赋的值会覆盖先赋的值
num4 = 100
num4 = 200
print(num4) #200
#同一个变量可以存储不同类型的值
num4 = [1,2,3]
print(num4) #[1,2,3]

2. 声明变量和给变量赋值的本质
   结论：python中所有的变量，存的都是数据在内存中的地址。内存地址的大小一样。 用一个变量给另外一个变量赋值，实质是将变量中的地址赋给另外一个变量。使用变量的时候，是使用的变量中地址对应的值。
   C中声明变量：
   int num = 10
   num = 100
   python中声明变量：
   num = 10
   num = 'ddf_samsara'
3. 变量的三要素：值、地址和类型
   值：变量中存的地址对应的值
   地址：变量中存储的地址(id)
   类型：变量中存的地址对应的值的类型

name1 = '小明'
name2 = name1
print(name1) #使用变量拿到变量中地址对应的值 #小明
print(id(name1),id(name2)) #id(变量)——获取变量中存储的地址 #6520608 6520608
print(type(name1))#<class 'str'>

二 .运算符

python中的运算符：数学运算符，比较运算符，逻辑运算符，赋值运算符，位运算符。

1. 数学运算符：+，-，*，/, %, //, **
   +: 加法运算，-:减法运算，*:乘法运算，/:除法运算， %:取余（求余数）, //:整除， **:幂运算
   +,-,*,/和数学中的+，-，x,÷ 对应的功能一模一样
   a.%——取余
   应用1：获取一个整数的最低的一位或者几位的值 num%(10^n)
   应用2：判断一个数是否能够被另外一个数整除 num1 % num2

print(10 % 3) #1
print(10 % 2) #0
num = 362352
print(num % 10) #获取一个数的个位数#2
print(num % 100)#获取一个数的个位数和十位数#52

b.// —— 除法运算，求商，获取商的整数部分

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

num = 288
print(num//100) #取num的百位上的值 #2

注意:整除的时候，如果商是负的小数(小数点后的值大于0)，最后的结果是整数部分减一。

print(-5//2)    #-3
print(-4.2//2) #-3.0

c.**——幂运算
x**y——求x的y次方

print(2**10) #2的10次方#1024
print(9**0.5) #9的开方#3.0
print(8**(1/3)) #8开3次方#2.0

2. 比较运算符：>, <, ==, !=, >=, <=
   所有的比较运算符的运算结果都是布尔值

#值1>值2：值1是否大于值2
print(100>10,10>10) #True False
#值1<值2：值1是否小于值2
print(100<10) #False
#值1==值2：值1是否等于值2
print(10==10)#True
num = 10
print(num == 10) #True
#值1！=值2：值1是否不等于值2
print(10!=100) #True

注意：支持像数学中的方式去使用>,<,>=,<=去表示范围

num = 10
print(num > 0 and num < 10)
print(0 < num < 10)

3. 逻辑运算符：and,or,not
   逻辑运算符的运算对象是布尔值，运算符结果也是布尔值
   a. and(逻辑与运算):
   值1 and 值2：如果值1和值2的都为True,结果才是True；只要有一个False结果就是False。
   True and True ->True
   True and False ->False
   False and True ->False
   False and False ->False

#逻辑与运算相当于生活中的'并且'；当需要多个条件同时满足，就是用and将多个条件连接在一起
#例子：要求成绩大于90分并且表现分大于95，才能获得奖学金
grade =99 #成绩
score = 80 #分数
print('是否获得奖学金',grade>90 and score>95)#是否获得奖学金 False

and短路操作：如果and前面的条件为False，and后面的条件语句不会执行。
b.or(逻辑或运算)
值1 or 值2：如果值1和值2中有一个是True，结果就是True。两个是False，即结果才是False
True or True ->True
True or False ->True
False or True ->True
False or False ->False

#逻辑或运算相当于生活中的'或者'；当需要多个条件中至少有一个条件满足，就是用or将多个条件连接在一起
#例子：要求成绩大于90分或者表现分大于95，才能获得奖学金
grade =99 #成绩
score = 80 #分数
print('是否获得奖学金',grade>90 or score>95)#是否获得奖学金 True

or短路操作：如果or前面的条件为True，or后面的条件语句不会执行。
c.not(逻辑非运算)
not 值：如果值是True，结果是就是False；如果值是False,结果就是True
not True ->False
not False ->True

#是否能够进入网吧的条件：年龄不小于18
age=18
print('是否能进入网吧',not age<18)#是否能进入网吧 True
print('是否能进入网吧',age >=18)#是否能进入网吧 True

4. 赋值运算符：=,+=,-=,*=,/=,%=,//=,**=
   所有赋值符的左边必须是变量; 组合的赋值运算符的左边的变量必须已经赋值；
   所有赋值运算符最终的会进行赋值操作

#a. = ——直接将右边的结果赋给左边的变量
num = 100
#b. +=,-=,*=,/=,%=,//=,**=

---

变量 += 值 -->相当于 变量 = 变量 + 值
变量 -= 值 -->相当于 变量 = 变量 - 值
变量 *= 值 -->相当于 变量 = 变量 * 值
...

---

num1 = 1
num1 +=10 # num1=num1+10=1+10
print(num1) #11
num1 *=2 #num1=num1*2=11*2
print(num1) #22
num1 %=2 #num1=num1%2=22%2
print(num1) #0

num2=88
num2 //=22 #num2//2=88//22
print(num2) #4
num2 **=3 #num2**3=4**3
print(num2) #64

5. 运算符的优先级
   数学运算符>比较运算符>逻辑运算符>赋值运算符
   优先级高的先算。如果有括号，先算括号里面的。
   数学运算符中：** > *,/,%,// > +,-

num = 10 +20 > 25 and True < 2
#num = 30 > 25 and True < 2
#num = True and True
#num = True
print(num) #True

num = 10 + (20 > 25 and True < 2)
#num = 10 + (False and True < 2)
#num = 10 + False
#num = 10
print(num) #10

num = 10 + 2 * 3 ** 2
print(num) #28

6. 位运算
   位运算是针对二进制中的每一位进行的相关操作
   a. 数字1 & 数字2 -> 二进制的每一位进行与运算，运算的时候如果都为1结果就是1，否则就是0。
   1 & 1 - 1
   1 & 0 - 0
   0 & 1 - 0
   0 & 0 - 0
   与的特点：一位上的数如果和1与，就会保留这一位上的数。如果和0与，就会将这一位置0。
   11010 & 00111 = 00010
   与运算的应用：判断一个数的奇偶性(最优解答)
   将数字和1与，如果结果是0，说明这个数是偶数；如果结果是1，说明这个数是奇数
   3(原/补) = 0011
   2(原/补) = 0010
   3 & 2 = 0011 & 0010 = 0010(补)
   -2 = 1010(原) = 1101(反) = 1110(补)
   3 & -2 = 0011 & 1110 = 0010(补)

print(3 & 2) #2
print(3 & -2) #2
print(5 & 1,7787 & 1,56681 & 1)#1 1 1 #数字和1与，如果结果是1，说明这个数是偶数
print(8 & 1,3776 & 1)#0 0  #数字和1与，如果结果是0，说明这个数是偶数

b.数字1 | 数字2 - 如果有一位是1结果就是1，两个都为0结果才是0
1 | 1 - 1
1 | 0 - 1
0 | 1 - 1
0 | 0 - 0
1101 | 1010 - 1111
3 | 20
000011(补)| 010100(补)= 010111(补/原) = 23
print(3 | 20) #23
-3 | 20
111101(补)|010100(补)=111101(补)=111100(反)=100011(原)=-3
print(-3 | 20) #-3
c.按位取反
~ 数字 - 将每一位取反(0变成1,1变成0)
~ 1 = 0
~ 0 = 1
~ 2 = 010->101(补)=100(反)=111(原)=-3
print(~2) #-3
d.按位异或
数字1^数字2——每一位如果相同就位0，不同为1
1^1 - 0
1^0 - 1
0^1 - 1
0^0 - 0
11^2
01011^00010=01001(补/原)=9
print(11^2) #9

#判断数是否相同
num = 10
print(num ^ 10)#0 #为0表示相同

e.左移
数字1<<n(位数)——左移指定的位数就是在二进制的后面加指定个数个0
相当于：数字1 * (2**n)
10<<1
01010(补)<<1=010100(补)
01010<<2=0101000
-10<<1
11010->10110(补)<<1=101100(补)=101011(反)=110100(原)=-20

print(10 << 1)#20
print(10 << 2)#40
print(-10 << 2)#-40

f.右移
数字1 >> n(位数) 将数字的二进制位向右移动指定的位数(将低位删除指定的位数)
相当于: 数字1 // (2**n)
20
010100 >> 2 = 0101 = 5
0101 >> 1 = 010 = 2
010 >> 1 = 01 = 1
01 >> 1 = 0 = 0