kaikethreeday

python基础知识第2节（9.15）

大概内容：

• 同时定义多个变量

• python定义变量的底层逻辑

• 运算符：数学运算符，比较运算符，逻辑运算符，赋值运算符

• 分支

了解计算机内存单位： bit(位)，1byte(字节)=8位，1Kb=1024字节，1Mb=1024kb,1G=1024Mb,1T=1024G,…

1、变量

1.同时定义多个变量

1.同时定义多个变量

1）同时定义多个变量赋相同的值：变量名1 = 变量名2 = 变量名3 = …=数据

x = y = 0
print(x, y)

2)同时定义多个变量赋不同的值：

变量名1， 变量名2， 变量名3，… = 数据1， 数据2， 数据3，…
注意：变量的个数和数据的个数必须一致

name, age, gender = '小明', 10, '男'
print(name, age, gender)

2.变量重新赋值

2.变量重新赋值

重新给变量赋值以后，使用变量使用时变量中最新的值

score = 100
print(score)
score = 90
print(score)
score = '满分'
print(score)

3. Python定义变量和重新给变量赋值的原理

• Python在定义变量的时候会申请内存保存数据，内存申请多大看被保存的数据需要多大。
• 重新给变量赋值的时候，会申请新的内存，新的内存的大小由新的数据大小决定，然后变量会和新的内存关联，原来的内存会自动销毁。
• id（变量） - 获取变量对应的内存地址

# 9999**9999
num = 100
print(id(num))

num = 200
print(id(num))

2、数字运算符

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

1.+ 、- 、*、 / 和数学中的+、-、×、÷的功能一模一样

注意：除法运算的运算结果是浮点数

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

2. % - 取余（取模）

x % y - 求x除以y的余数
被除数 ÷ 除数 = 商 … 余数
被除数 = 除数 × 商 +余数

print(10 % 3)
print(15 % 3)
print(9 % 2)

应用一：判断两个数是否存在整除关系 – 判断两个数的余数是否为0

print(10 % 2)

应用二：取整数的低位数

一个整数对10取余，能够获取这个数的个位数
一个整数对100取余，能够获取这个数的后两位数
一个整数对1000取余，能够获取这个数的后三位数

num = 2346
print(2346 % 10)  # 6
print(num % 100)  # 46

3.// - 整除（商向小取整）

print(5 / 2)
print(5 // 2)  # 2 2.5 3
print(1.8 // 2)  # 0 0.9 1(值为小数)
print(-5 // 2)  # -3   -2.5  -2

应用场景：去掉低位数

num = 2342
print(num // 10)  # 234
print(num // 100)
print(num // 1000)

#练习：获取任意一个正整数的十位数
# 234 -> 3; 1098 -> 9
num = 5678  # -> 7   78-->7
print(num % 100 // 10) #7
print(num // 10 % 10)
# a = 234
# print(a % 100 // 10)
# print(a // 10 % 10)
# b = 1098
# print(b % 100 // 10)
### 获取任意一个正整数的百位数
num = 5678
print(num //100 % 10) # 先整除去掉78，得到56，再取余   -->6
print(num % 1000 // 100) #先取余679 ，得到678，再整除去掉78  -->6

4.** – 幂运算

x ** y - 求 x 的 y 次方

print(8 ** 3)
print(1.3 ** 4)    # 计算机保存接近值 2.8561
print(9 ** 0.5)    # 开方的结果  3.0
print(8 ** (1/3))  # 开方的结果  2.0
print(2 ** (-1))   # 0.5

3、比较运算符

比较运算符： >、 <、 ==、 ！=、 >=、 <=

比较运算符： >、 <、 ==、 ！=、 >=、 <=
所有的比较运算符的运算结果都是布尔值

print(20 > 10)
print(20 < 10)
print(20 == 10)
print(20 != 10)
# print(20 = 10)   错误！
print(20 >= 10)
print(20 <= 10)

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

x = 0.5
print(0 <= x <= 1)

4、逻辑运算符

逻辑运算符： and（逻辑与） 、or(逻辑或) 、not（逻辑非）

1. and

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

# 练习：写出判断一个是否能同时被3和7整除的条件
# 判断数是否能被3整除 ： num % 3 == 0
# 判断数是否能被7整除 ： num % 7 == 0
num = 21
a = num % 3
b = num % 7
print('是否能同时被3和7整除：', a == 0 and b == 0)   # 结果True
print('是否能同时被3和7整除：', num % 21 == 0 )   # 结果True

# 练习：判断指定数是否能被3整除的偶数
# 能被3整数： num % 3 == 0
# 是偶数 ：num % 2 ==0
num = 9
a = num % 3
b = num % 2
print('是否能被3整除的偶数：', a == 0 and b == 0)
print('是否能被3整除的偶数：', num % 6 ==0)

2. or 逻辑或

   “”"
   1)应用场景：用于需要多个条件只要有一个条件满足就行的时候，相当于生活中的或者
   2）运算规则：条件1 or 条件2 - 两个条件中只要有一个条件是True ,结果就是True，两个都是False的时候结果才是False
   条件1 or 条件2 or 条件3 …
   “”"

# 练习1：判断指定数是否能被5或者7整除
num = 25
a = num % 5
b = num % 7
print('是否能被5或者7整除:', a == 0 or b == 0)
# 练习2：判断指定的年是否是闰年
# 普通闰年:能被4整除且不能被100整除的为闰年。year % 4 == 0 and year % 100 != 0
# 世纪闰年:能被400整除的是闰年:year % 400 == 0
year = 2004
a = year % 4
b = year % 100
c = year % 400
print('指定的年是否是闰年:', (a == 0 and b != 0) or (c == 0) )
print('指定的年是否是闰年:', (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0) )

3. not

“”"
1)应用场景：（对某一个条件进行否定）如果正向写条件情况很多很复杂，反向却很简单的时候，条件就反向写再加not
2)规则：not 条件（取反操作）
not True --> False
not False --> True
“”"

num = 90
print(not num > 10)
print(num <= 10)

# 练习：写出判断一个数不能同时被3和7整除的条件
# 条件正向写：
# 1.能被3整除但是不能被7整除：num % 3 ==0 and num % 7 ！= 0
# 2.能被7整除但是不能被3整除：num % 3 ！=0 and num % 7 == 0
# 3.既不能被3整除也不能被7整除：num % 3 ！=0 and num % 7 ！= 0

num = 70
print(not (num % 3 ==0 and num % 7 == 0))
# 条件反向写：
# 能同时被3和7整除的条件：num % 21 == 0
# 不能同时被3和7整除的条件：not num % 21 == 0
print(not num % 21 == 0)

5、逻辑运算符扩展

1. 短路操作

“”"
条件1 and 条件2
and 的短路：如果条件1是False,那么条件2对应的代码不会执行

条件1 or 条件2
or 的短路：如果条件1是True,那么条件2对应的代码不会执行

“”"

True and print('and 的条件2')  # and 的条件2
False and print('and 的条件2')
True or print('or 的条件2')
False or print('or 的条件2')   # or 的条件2

2.逻辑运算符的通用运算规则

1. and
   数据1 and 数据2

1. or
   数据1 or 数据2
   “”"

(记住！！！)重要结论：python 中任何类型的数据都可以转换成布尔（都有布尔值），其中零值和空值是False，其他都是True

0，0.0,空值None，空的字符串，是False，其他数据是True

print( True and 100)  # 100
print( False and 100)  # False

print( True or 100)  # True
print( False or 100)  # 100


print( 7 and 8) # 8
print( 7 or 8)  # 7
# (记住！！！)重要结论：python 中任何类型的数据都可以转换成布尔（都有布尔值），其中零值和空值是False，其他都是True
# 0，0.0,空值None，空的字符串，是False，其他数据是True
print(bool(0), bool(0.0), bool(''), bool(None))
print(bool(8), bool(-2), bool(' '), bool(0.34), bool('abc'), bool(-2.14))

print(not 7) # False
print(not 8) # False
print(not 0) # True

# name = input('请输入你的姓名：')
# if name:        # 有输入姓名转化为True。判断为True
#     pass
# else:
#     print('输入的姓名为空。')
#
# name = input('请输入你的姓名：')
# if not name:
#     print('输入的姓名为空。')

6、赋值运算符

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

1）赋值运算符的作用不是计算初一个结果，而是将数据保存到变量中。
2）所有赋值运算符的左边必须是变量

2. =

变量 = 数据

a = 10
a = 100

3.+=、-=、*=、/=、%=、//=、**=

变量 += 数据 - 将变量中保存的数据和+=后面的数据进行加法运算，将运算结果重新赋值给前面的变量
注意：复合的赋值运算符前面的变量必须是已经赋值过的变量
！！！强调：所有的赋值运算是没有结果

a += 10
print(a)  # 110

a -= 20
print(a)  # 90
a %= 4
print(a)  # 2
a **= 3
print(a)  # 8
# ！！！强调：所有的赋值运算是没有结果
# print( a+= 1)  #报错！

7、运算符的优先级

运算符的优先级：数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符（最低）

1. 运算符的优先级：数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符（最低）
2. 数学运算符中：幂运算 ** > *、/、整除 //、取余 % > +、-
3. 有括号先算括号里面的 - （）

result = 100 + 2 * 3 ** 2 > 20*2 - 3
print(result) #True。bool值

True–1，False–0
如果布尔数据参与了数字运算，那么False就是0，True就是1.

result = 100 + (10 > 20)
print(result)
result =100 + True #101

result =100 + False #100
print(result)