python变量基础练习题 python 变量运算

1.变量

1.1 定义变量

• 语法：
  变量名 = 数据
• 对于重复使用，并且经常需要修改的数据，可以定义为变量，来提高编程效率。
  定义变量的语法为: 变量名 = 变量值。(这里的 = 作用是赋值。)
  定义变量后可以使用变量名来访问变量值。
• 说明：所谓变量名，可以理解为箱子，当需要使用变量值，就把对应的箱子拿来。
  变量即是可以变化的量，可以随时进行修改。
  程序就是用来处理数据的，而变量就是用来存储数据的
• 说明：
  变量名 - 程序员自己命名
  要求：1）标识符 2）不能是关键字
  规范：1)见名知义 2)满足PEP8的命名规范(所有的字母都小写，多个单词之间用下划线隔开)
  3)不使用系统提供的类型名、函数名和模块名
  = - 赋值符号，固定写法
  数据 - 任何有结果的表达式，包括：独立数据、运算表达式(除了赋值运算)、函数调用表达式
• 1）.变量名

age = 18
teacher_name = '张三'
int_num = 20
# print = 100     # 错误写法
# print('abc')

• 2）. 独立数据

x = 19
x1 = 12.4
x2 = 0b11011
x3 = '你好'
x4 = True

• 3）.运算表达式

y1 = 10 + 20

定义一个变量，保存学生的分数：90

stu_score = 90

1.2 使用变量

• 变量中保存的数据能做什么，变量就能做什么
• 使用变量的时候其实是在使用变量中保存的数据

# print('hello world!')
print(age)
print('age', age)    # age 18

# 变量中保存的数据能做什么，变量就能做什么
print(10 + 20)       # 30
print(age + 20)      # 38

# 变量中保存的数据能做什么，变量就能做什么
print('abc'[0])
str1 = 'hello word!'
print(str1[0])

1.3修改变量中的数据(重新给变量赋值)

# 变量 = 新值
print(age)
# 重新给变量age赋值为20
age = 20
print(age)    # 20
# python中同一个变量可以保存不同类型的值
age = '你好！'
print(age)   # 你好！

1.4 同时定义多个变量/同时给多个变量赋值

1. 同时给不同的变量赋不同的值: 变量名1,变量名2,变量名3,…= 数据1,数据2,数据3,…

a, b, c = 10, 20, 30 
print(a, c, b)

# python交换两个变量的值： 变量1, 变量2 = 变量2, 变量1
x = 100
y = 200
x, y = y, x    # x, y = 200, 100
print(x, y)

# 练习：假设已经存在三个变量x1, x2, x3 要求用一句代码完成功能：x1 = x3, x2=x1, x3=x2
# x1=1, x2=2, x3=3 -> x1=3, x2=1, x3=2
x1, x2, x3 = 1, 2, 3
x1, x2, x3 = x3, x1, x2
print(x1, x2, x3)

1. 同时给不同的变量赋相同的值：变量1 = 变量2 = 变量3 = … = 数据

a1 = a2 = a3 = 100
print(a1, a2, a3)

# a1, a2, a3 = 1, 2, 3
# a1 = a2 = a3 = 10
# a1 = 1, a2 = 2 (错误)
# a1 = 1; a2 = 2
# 注意：没有赋值过的变量不能使用
# print(stu_age)     #  NameError: name 'stu_age' is not defined
# stu_age = 10

2.变量赋值原理

2.1 定义变量和给变量赋值的原理:

变量 = 数据

• 1)先在堆中申请内存(申请多大看被被赋值的数据需要多大内存)
• 2)将数据保存在内存区域中
• 3)让变量和保存数据的内存进行关联（让变量保存数据对应的内存地址）

2.2 id函数

id(变量) - 获取变量中关联的数据在内存中的地址

num = 10
print(id(num))

num = 20
print(id(num))

a=10过程如下：

• 注意：我们并不是为标记a建立了一个值，而是先建立一个值以后，再用一个标记去指向它

a = 10；b = a ; a = 20过程如下：

先是b也指向了a指向的地方，然后a指向了新的20，b所指还是10.

3.数学运算符

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

数学运算符: +(加)，-(减)，*(乘)，/(除)，%(取余、取模)，//(整除)，**(幂运算)

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

print(5+2)
print(5-2)
print(5*2)
print(5/2)

1. % - 求余数

# 数字1 % 数字2  -> 求数字1除以数字2的余数
print(5 % 2)

应用1： 取整数的个位数或者低几位数
练习: 获取变量 num 的个位数

num = 8679
print(num % 10)    # 9

print(num % 100)    # 79

应用2：判断一个数是否能够被另外一个数整除
练习：判断num的是否是偶数

num = 2898
print(num % 2)

1. // - 求商取商的整数部分(向下取整/向小取整)

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

应用：取定长数字的最高位

num = 367
print(num // 100)    # 3
print(num // 10)     # 36

1. **
   M ** N - 计算M的N次方

print(3 ** 2)   # 9
print(2 ** 3)   # 8
print(9 ** 0.5)   # 3.0
n = 1/3
print(8 ** n)   # 2.0

练习：12 + 3 * 4 // 5 - 6 ** 2

# 12 + 12 // 5 - 36
# 12 + 2 - 36
# -22
print(12 + 3 * 4 // 5 - 6 ** 2)

4.比较运算符

比较运算符(关系运算符)：>, <, ==, >=, <=, !=,<>
注意：1.所有比较运算的结果都是布尔值

2.数字数据不能和字符串数据进行比较

3.如果是两个字符串进行比较，会将每个字符都转换成对应的编码，然后逐一进行对比，直到其中一个比完

4.数字和字符串做==运算结果是false,除了 == 以外的逻辑运算时，会直接报错

print(10 > 5)    # True
print(10 < 5)    # False
print(10 <= 5)   # False
print(10 <= 10)  # True
print(10 == 10)  # True
print(10 != 5)   # True
print(10 != 10)  # False

a = 3 > 4
print(a)

b = 5 % 2
print(b)

python中支持比较运算符的连写来表示范围

x = 10
print(0 <= x <= 100)    # True

5.逻辑运算符

python中的逻辑运算符：and(逻辑与)、or(逻辑或)、not(逻辑非) 优先级：not > and >or

5.1 and

1. 运算规则：
   a. 操作对象都是布尔值：两个都是True结果才是True,只要有一个是False结果就是False

"""
True and True  -> True
True and False -> False
False and True -> False
False and False -> False
"""

1. 应用场景：希望两个或者多个条件同时满足才做什么事情，就使用逻辑与运算。相当于生活中的并且
   练习1：写出学生是否能拿奖学金的条件，拿奖学金的要求：绩点超过4，操评分高于85，这个两个条件同时满足

grade = 4.5
score = 80
# result = grade > 4 and score > 85
# print(result)
print('是否能拿奖学金：', grade > 4 and score > 85)

5.2 or

• 1)运算规则
  a.操作对象都是布尔值: 两个都是False结果才是False,只要有一个是True结果就是True

"""
True or True  -> True
True or False -> True
False or True -> True
False or False -> False
"""

• 2)应用场景：希望两个或者多个条件只要有一个满足就可以就使用逻辑或运算。相当于生活中的或者
  练习2：写出学生是否能拿奖学金的条件，拿奖学金的要求：绩点超过4或者操评分高于90

grade = 4.5
score = 80

练习3：写出判断指定的年是否是闰年的条件: 1）能被4整除但是不能被100整除 2）直接能被400整除

year = 2012
d1 = year % 4 == 0    # 能被4整除的条件
d2 = year % 100 != 0  # 不能被100整除的条件
d3 = year % 400 == 0  # 能被400整除的条件
print('是否是闰年：', (d1 and d2) or d3)
print('是否是闰年：', year % 4 == 0 and year % 100 != 0 or year % 400 == 0)

5.3 not

1. 运算规则：True 变 False , False 变 True

"""
not True  -> False
not False -> True
"""

1. 应用场景：不满足某个条件就做什么，就用not。

age = 18
print('是否成年：', age >= 18)
print('是否成年：', not age < 18)

练习：写出num是否不能同时被3和7整除

num = int(input('请输入一个数：'))
print('是否满足条件：', not (num % 3 == 0 and num % 7 == 0))

5.4 操作对象不是布尔的时候

逻辑运算符语法上可以操作任何数据

• 1）数据1 and 数据2 -> 如果数据1的布尔值是True,结果是数据2;
  如果数据1的布尔值是False, 结果就是数据1
• 2）数据1 or 数据2 -> 如果数据1的布尔值是True,结果是数据1；
  如果数据1的布尔值是False,结果是数据2
  补充: 数据的布尔值怎么确定 - 所有为零为空的值都是False,其他数据的布尔都是True

print(1 and 'abc')      # 'abc'
print('abc' and 'hello')    # 'hello'
print(0 and 'abc')      # 0
print(False and 100)    # False
print('' and 'abc')   # ''

print(1 or 'abc')    # 1
print(7 or 8)        # 7
print(0 or 'abc')    # 'abc'

print(not 1)     # False
print(not 0)     # True

5.5 短路操作

and 的短路操作：
表达式1 and 表达式2 -> 如果表达式1的结果是False, 表达式2不会执行

or 的短路操作：
表达式1 or 表达式2 -> 如果表达式1的结果是True, 表达式2不会执行

• 逻辑与运算的规则:只有所有的运算数都是True,结果才是True;只要有一个运算数是False,结果就是False-
• 逻辑或运算的规则:只有所有的运算数都是False,结果才是False;只要有一个运算数是True,结果就是True
• 逻辑运算的取值使用：逻辑运算的结果，不一定是布尔值
• 逻辑与运算只要遇到False,就停止了。
• 逻辑与运算做取值时，取第一个为False的值;如果所有的运算数都是True,取最后一个值
• 逻辑或运算只要遇到True,就停止了。
• 逻辑或运算做取值时，取第一个为True的值;如果所有的运算数都是False,取最后一个值

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

False or func1()

6.赋值运算符

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

• 1）所有的赋值运算都是用来给变量赋值的
• 2）所有的赋值运算符的左边都必须是变量，复合赋值运算符左边的变量必须是已经赋值过的变量
• 3）所有赋值运算符的右边都可以是任意有结果的表达式

1. =

a = 10
age = 18
a = 100

2. +=、-=、*=、/=、%=、//=、**=
   变量 += 数据 -> 变量 = 变量 + 数据

a += 20    # a = a + 20 -> a = 100 + 20 -> a = 120
print(a)   # 120

a /= 4     # a = a / 4 -> a = 120 / 4
print(a)   # 30.0

a **= 2
print(a)   # 900

6.2 运算符的优先级

数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符(最低)
** > *,/,%,// > +, -
有括号先算括号里面的

a = 10 + 30 > 35
a = 30 * 2 > 50 * 2
print(a)

7.位运算符

1. 位运算的特点：效率高、内存消耗少
2. 位运算运算符： &(按位与)、|(按位或)、^(异或)、~(按位取反)、>>(右移)、<<(左移)
   所有的位运算都是直接操作数据在内存中存储的补码

说明:

与(&),按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

或（|），按位或运算符：只要对应的两个二进位有一个为1时，结果位就为1

异或（^）,按位异或运算符：当两对应的二进位相异时，结果为1,即不同为1，相同为0

取反（~），按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1

左位移（<<）,运算数的各二进位全部左移若干位，由<<右边的数字指定了移动的位数，高位丢弃，低位补0

右位移（>>）,把‘>>’左边的运算数的各二进制位全部右移若干位，>>右边的数字指定了移动的位数

print(5 & 9)
"""
5: 00000101
9: 00001001
5 & 9 = 00000001(补) = 1

-5：10000101(原) - 11111011(补)
-9：10001001(原) - 11110111(补)
-5 & -9  = 11110011(补) - 11110010(反) - 10001101(原) - -13
"""
print(-5 & -9)    # -13

应用：判断数字的奇偶性
“”"
让被判断的数字和 1 进行按位与运算，结果如果是0说明是偶数否则是奇数
“”"

print(-35 & 1)

1. &(按位与)
   数字1 & 数字2 - 两个都是1结果就是1，否则结果0
   01101101(补) & 10101100(补) -> 00101100(补)
   特点：某一位上的数和1与可以对这一位上的数进行保存，和0与会对这一位进行置0操作

• 2）|(按位或)
  数字1 | 数字2 - 只要有一个是1结果就是1，两个都是0结果才是0
  练习：7 | -16
• 3）^(异或)
  数字1 ^ 数字2 - 不同为1，相同为0

print(18 ^ 9)   # 27
print(27 ^ 9)   # 18

1. ~ - 0变1，1变0
   ~ 数字

，<<
数字1 >> 数字2 - 数字1 // 2**数字2
数字1 << 数字2 - 数字 * 2**数字2
应用：高效率、快速的乘2或者2的次方数

print(6 << 1)   # 6 * 2**1
print(5 << 2)   # 5 * 2**2
print(6 >> 1)   # 6 // 2**1
print(7 >> 1)   # 7 // 2**1
print(-7 >> 1)  # -7 // 2**1

age = 18
age *= 2
age = age << 1
或)
 数字1 | 数字2  - 只要有一个是1结果就是1，两个都是0结果才是0
 练习：7 | -16

- 3）^(异或)
 数字1 ^ 数字2 - 不同为1，相同为0
```python
print(18 ^ 9)   # 27
print(27 ^ 9)   # 18

1. ~ - 0变1，1变0
   ~ 数字

，<<
数字1 >> 数字2 - 数字1 // 2**数字2
数字1 << 数字2 - 数字 * 2**数字2
应用：高效率、快速的乘2或者2的次方数

print(6 << 1)   # 6 * 2**1
print(5 << 2)   # 5 * 2**2
print(6 >> 1)   # 6 // 2**1
print(7 >> 1)   # 7 // 2**1
print(-7 >> 1)  # -7 // 2**1

age = 18
age *= 2
age = age << 1