变量、运算符和字符串

1.变量

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

1.声明变量(定义变量) - 假的声明

• 语法：
  变量名 = 值

• 说明：
  变量名 - 要求：标识符，不能是关键字

• 规范：
  a.遵守PEP8命名规范(名字的所有字母都小写，如果由多个单词组成，单词之间用_隔开)
  b.见名知义(看到名字就知道变量中存的是什么数据)

• = ：赋值符号，将=右边的值赋给左边的变量

• 值 ：可以是任何有结果的表达式。 例如：190， 变量, 10+20, 调用函数表达式
  示例：

age = 18
name = '小明'
number = 2910
#使用变量的时候，就是在使用变量中保存的值
print(age)# 18 
#变量必须先声明(赋值)再使用
print(age1) # NameError: name 'age1' is not defined

• a.同时声明多个变量，并且赋一样的值。（同时给多个变量赋值）

num1 = num2 = num3 = 10
print(num1, num2, num3)

• b.同时声明多个变量，并且赋不通的值。 （注意：变量的个数和值的个数要保持一致）

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

num4 = 100
num4 = 200
print(num4)  # 给同一个变量赋值，后赋的值会覆盖先赋的值
num4 = 'abc'
num4 = [1, 2, 3]
num4 = {'a': 100}
print(num4)  # 同一个变量可以存储不同类型的值

2.声明变量和给变量赋值的本质

• 结论：python所有的变量，存的都是数据在内存中的地址。内存地址的大小一样
  用一个变量给另外一个变量赋值，实质是将变量中的地址赋给另外一个变量.
  使用变量的时候，是使用的变量中地址对应的值

C中声明变量：

int num = 10
num = 100

python中声明变量：

num = 10
num = 'asdfhaskhfjkh'
num = 5732987593745973298457893
print(num)

3.变量的三要素：值、地址和类型

• 值：变量中存的地址对应的值。
• 地址：变量中存储的地址 (id)。
• 类型：变量中存的地址对应的值的类型。
  示例：

name1 = '小明'
name2 = name1
print(name1)  # 使用变量拿到变量中地址对应的值
print(id(name1), id(name2))  # id(变量) - 获取变量中存储的地址
print(type(name1))#获取变量中存储地址的值的类型

---

2.运算符

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

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

• a. +: 加法运算，-:减法运算，*:乘法运算，/:除法运算， %:取余（求余数）, //:整除， **：幂运算。
• b. +,-,*,/和数学中的+，-，x,÷ 对应的功能一模一样
  示例:

print(10+20)
print(10-20)
print(10*20)
print(10/20)

打印结果为：

a. % ： 取余

应用1：获取一个整数的最低的一位或者几位的值 num%(10^n)
print(10 % 3)
应用2：判断一个是是否能够被另外一个数整除 num1 % num2
print(10 % 2)
获取一个数的个数:
num = 36523
print(num % 10) # 3
print(num % 100) # 23

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

print(5//2)   #结果为 2
print(3.9 // 3)  # 结果为1.0
num = 289
print(num//100)  # 取num的百位上的值

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

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

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

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

• a.值1 > 值2 ： 值1是否大于值2

print(100 > 10) # True
print(10 > 100) # False
print(10 > 10) # False

• b.值1 < 值2： 值1是否小于值2

print(100 < 10) # False

• c.值1==值2： 值1是否等于值2

print(10 == 100) # False
print(10 == 10) # True
num = 10
print(num == 10) # True

• d.值1!=值2: 值1是否不等于值2

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

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将多个条件连接在一起
  示例：

grade = 90 # 成绩
score = 98 # 分数
要求成绩大于90并且表现分大于95，才能获得奖学金：
print('是否获取奖学金:', grade > 90 and score > 95)

• 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将多个条件连接在一起

grade = 90 # 成绩
score = 98 # 分数
例子：要求成绩大于90或者表现分大于95，就能获得奖学金
print(grade > 90 or score > 95)

• c.not(逻辑非运算)
  not 值：如果值是True,结果就是False;如果值是False，结果就是True

not True -> False
not False -> True
not用来对某个条件进行否定

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

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

所有赋值符的左边必须是变量; 组合的赋值运算符的左边的变量必须已经赋值；
所有赋值运算符最终的会进行赋值操作

• a. = - 直接将右边的结果赋给左边的变量
  num = 100

• b. +=， -=， *=， /=， %=， //=， **=
  变量 += 值 --> 相当于 变量 = 变量 + 值

num1 = 1
num1 += 10 # num1 = num1+10 = 1+10
print(num1)

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

num1 = 2 # num1 = num12 = 11*2
print(num1)

5.运算符的优先级

数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符
优先级高的先算。如果有括号，先算括号里面的

• 数学运算符中: ** > *, /, %, // > +, -

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

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

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

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)
print(3 & -2)

print(5 & 1, 111 & 1, 123 & 1) # 1 1 1
print(100 & 1, 12 & 1, 67238 & 1) # 0 0 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(补)

-3 | 20
111101(补) | 010100 = 111101(补)'''
print(3 | 20)#结果为23
print(-3 | 20)#结果为-3

• c.按位取反
  ~ 数字 - 将每一位取反(0变成1，1变成0)

~1 = 0
~0 = 1
~2：
010 -> 101(补) = 100(反) = 111
print(~2)

• d.按位异或
  数字1 ^ 数字2 - 每一位如果相同就为0，不同为1
  1 ^ 1 - 0
  1 ^ 0 - 1
  0 ^ 1 - 1
  0 ^ 0 - 0
  列如：

11 ^ 2
01011 ^ 00010 = 01001(补)
print(11 ^ 2) 结果为9

num = 10
print(num ^ 10) 结果为 0

• e.左移
  数字1 << n(位数) - 左移指定的位数就是在二进制的后面加指定个数个0
  相当于：数字1 * (2**n)
  列如：

'''10 << 1
01010 << 1 = 010100 = 20
01010 << 2 = 0101000 = 2^5 + 2^3 = 32 + 8 = 40

-10 << 1
11010 -> 10110(补码) << 1 = 101100(补)= 101011(反)=110100 = -20
'''
print(10 << 1)#结果为：20
print(10 << 2)#结果为：40
print(-10 << 1)#结果为：-20

• f.右移

数字1 >> n(位数) 将数字的二进制位向右移动指定的位数(将低位删除指定的位数)
相当于: 数字1 // (2**n)

'''010100 >> 2 = 0101 = 5
0101 >> 1 = 010 = 2
010 >> 1 = 01 = 1
01 >> 1 = 0 = 0'''
print(-20 >> 2)#结果为-5

3.字符串

1.什么是字符串（str）

字符串是python中一种常用的有序但是不可变的容器类的数据类型，可以同时存储多个字符。属于序列

• 字面量：使用单引号或者双引号将任意字符括起来，就是字符串常量
  'hjh是否就是23as+-'， "是89===——238jsNM是"

• 字符：指的就是字符串中的每一个单元。注意，python中只有字符的概念没有字符类型
  num = 10

2.字符串中的内容

• a.普通字符：包含数字字符、字母、普通符号：+，-（），%#@等、中文、韩文、日语等
  '123'， 'hsja', '*&sd23顺'

• b. 转义字符：通过反斜杠将一些字符转换成有特殊功能或者特殊意义的字符

\n - 换行
\t - 制表符
' - 表示一个单引号
" - 表示一个双引号
\ - 表示一个\

注意：一个转义字符代表一个字符

• c. 阻止转义: 在字符串的最前面加r/R,可以阻止转义字符转义

示例：

print('\tabc\n123')
print('abc'123')
print("ab"c'123")
print('abc\n123')
print(r'abc\n12\3')
print(r'\b')

打印结果为：