9.21总结

9.21总结

作业回顾

1. 以下4组变量名(每组5个，以逗号分隔)完全符合Python变量命名规则的有(D)

A. ABC, abc, _abc, a_b_c, abc`_ `B. num123_, 123num, _123num, num_123, _num_123
C. print, id, int, if, else` `D. main, test, true1, false0, hello
# B选项错误：数字不能打头

2. 键盘输入一个三位数 获取各个位上的数字和

num = int(input('数字：'))
gw = num % 10
sw = num // 10 % 10
bw = num // 100 % 10
# bw 这里之所以要 %10，是因为考虑到通用情况，即小数等。不加 %，只能得到整数的百位数字。

3. 键盘输入一个五位数 获取各个位上数字立方和的平方根

(gw**3 + sw**3 + bw**3 + qw ** 3) **(1/2)
# 此处注意，平方和立方，都用 ** 来表示，平方为 **2 ，立方为 **3 ， 平方根则是 **1/2

2.5运算符

分为一元运算符、二元运算符、三元运算符【Python中没有 其他语言条件语句?表达式1:表达式2】

一元运算符是由一个数据参与运算，比如正负号 +78 -10 ~19[按位取反]

2.5.1算术运算符

加法 +
减法 -
乘法 *
除法	
	/  结果是浮点类型的  除不尽 商会有小数
	// 结果是整型的  对商进行向下取整 
		<=商且最接近于商的整数 称为向下取整
取余数 
	%  A除以B除不尽 会余下数据 这个余下的数据就是余数
	11除以3得3余2  这个2就是余数
	11 % 3 = 2
求幂数 
	**  比如x**y,求x的y次方 
	y如果是正整数N  对x求幂数次方
	y是1/N 小数格式  对x进行开方
	
	x = 2
	y = 3
	x ** y = 2的3次方 = 8
	
	x = 27
	y = 1/3
	x ** y = 27的三分之一次方 
	开方的时候结果是浮点型的  8**(1/2)

算术运算符的优先级别：

** > 符号 > *、/、//、% > 加减

提高表达式的优先级使用小括号()包含

2.5.2赋值运算符

简单赋值运算符

变量名 = 数据值
	将等号右边的表达式计算结果 赋值给左边的变量名
	
	比如 a = 17
	a = 19 % 4
	b = 18
	a = b // 4

复合赋值运算符

结合其他运算符在内的赋值格式，比如
变量名 += 表达式
-=
*=
/=
//=
%=
**=

先计算表达式的结果  在对变量名根据结果进行相应的算术运算，最后把计算结果赋值给变量名

比如 a = 17
a -= 18 % 4

1. 18 % 4 = 2
2. a - 2 = 17 - 2 = 15
3. a = 15

赋值表达式(海象运算符)

把某个赋值表达式的结果再赋值给另外一个变量，这种格式称为赋值表达式

比如在其他语言中 支持 y = (x = 17 % 3)

解读：先计算x的结果，再把x的值赋值给y

但是这个写法在Python中不支持，Python变更成 y = (x := 17 % 3)

这里其实也是同时定义了两个变量，只不过不同于a, b=11, 22的是这个赋值表达式在定义变量的时候，某个变量的值参与另外一个变量定义的运算

y = (x := 17 % 5)  # 海象运算符可输出两个变量值
print(x,y)

# 线性关系 y = 2x + 5
x =int(input('请输入x的值：'))
y = 2 * x + 5

# 使用赋值表达式 写成一条语句：
y = 2 * (x := int(input('请输入x的值：'))) +5
print(y)

2.5.3 比较运算符

又称为关系运算符，对比两个表达式结果的关系的，运算符有：

>  判断前者是否大于后者
>= 判断前者是否大于或者等于后者
<  判断前者是否小于后者
<= 判断前者是否小于或者等于后者
== 判断两者是否相等
!= 判断两者是否不相等

算术运算符的优先级别高于比较运算符**

介绍字符串数据的比较，本质比较的是字符对应的十进制数据，比较规则是相同位置的字符进行比较，直到比较出结果

比如
s1 = 'hello'
s2 = 'head'
res = s1 > s2  这个结果是真还是假？？？

第一次比较是 h 对 h
第二次比较是 e 对 e
第三次比较是 l 对 a   成立
因此结果为真

m = 17
n = 14
print(m - 2 > n) # True
print(m - 2 >= n + 2) # False

#设定一个三位数 判断十位上的数据是否为偶数
num = 758
#1.获取十位上的数据
decade = num // 10 % 10
# 2.判断是否为偶数【偶数是2 的偶数 能被2 整除】 【整除，余数为0】
result = decade % 2 == 0
print（result）

练习

#录入一个四位数，判断前两位之和是否等于后两位之和
num = int(input('请输入一个四位整数：'))
num_1 = num // 1000 % 10
num_2 = num // 100 % 10
num_3 = num // 10 % 10
num_4 = num % 10

result = num_1 + num_2 == num_3 + num_4
print(result)

# 录入一个三位数，判断从个位上的数到百位上的数，是否是等差数列
num = int(input('请输入一个三位数：'))
ge = num % 10
shi = num // 10 % 10
bai = num // 100 % 10
print(ge - shi == shi - bai)

2.5.4 逻辑运算符

逻辑运算符的优先级别是低于比较运算符的

逻辑运算符是来关联表达式的逻辑关系的，逻辑关系是有三种的

1. 逻辑与(and)

   连接的逻辑关系是一个并且的关系，这两个表达式同时成立，结果才是成立的

True and True = True
True and False = False
False and False = False
False and True = False

总结and的运行机制：

and是具备有短路原则，左边表达式不成立，右边表达式不被执行

执行机制是左边表达式成立，结果取决于右边表达式；左边表达式不成立，结果就是左边表达式的值

例子：# 左边不成立，右边就不会执行，所以短路
res1 = 10 < 5 and (y := 7) > 3
print(res1, y)
# NameError: name 'y' is not defined
	           y没有被定义
    
res1 = 10 < 5 and (y := 7) > 3  # 不输出y的话会被执行
print(res1)    # False

2. 逻辑或（or)

   连接的逻辑关系是或者的关系，两个表达式中有一个成立，结果就是成立的

True or True = True
True or False = True
False or True = True
False or False = False

or 也是具备短路原则的，左边表达式成立，右边不执行

执行机制：左边表达式成立，结果就是左边表达式的；左边表达式不成立，解决取决于右边表达式的值

res2 = 10 > 5 or (z := 4) > 3
print(res2)
print(z)
# NameError: name 'z' is not defined

3. 逻辑非（not)

   对逻辑关系取反，逻辑关系结果为真，not之后设定为假；逻辑结果为假，not之后设定为真

not True = False
not False = True

优先级别的问题:

​ not > and > or

练习

# 录入一个三位数，判断从个位上的数到百位上的数是否是步长为2的等差数
num = int(input('请输入一个三位数：'))
n1 = num % 10
n2 = num // 10 % 10
n3 = num // 100 % 10
result = n1 - n2 == -2 or n2 - n3 == -2
print(result)

# 录入一个字符判断其是否为小写英文字母
ch = input('请输入字符：')
res = 'a' <= ch <= 'z'
print(res)

# 判断是否为英文字母
ch = input('请输入字符：')
res1 = ('a' <= ch <= 'z') or ('A' <= ch <= 'Z')
print(res1)

# 判断是否为汉字
ch = input('请输入字符：')
res2 = '\u4e00' <= ch <= '\u9fa5'
print(res2)  # 录入一个整数，判断其是否非同时是3和5的倍数

# 【是3或者5的倍数 但是不能同时是3和5的倍数】
c = int(input('录入一个整数：'))
res = (c % 3 == 0 or c % 5 == 0) and not (c % 3 == 0 and c % 5 == 0)
print(res)

# 简化，找其公倍数
res = (c % 3 == 0 or c % 5 == 0) and not (c % 15 == 0)
print(res)

2.5.5成员运算符

成员运算符是用来判定 数据是否是某个容器型数据中的元素

数据 in 容器型数据
	把数据作为一个整体 判断是否在容器中
数据 not in 容器型数据
	把数据作为一个整体 判断是否不在容器中

目前接触到的是字符串，之后还会接触到列表、元组、字典、集合、range等等

5.6 身份运算符

判定两个数据的地址在内存是否是一致的

数据1 is 数据2
	判断两个数据在内存中的地址是否是一致的
数据1 is not 数据2
	判断两个数据在内存中的地址是否是不一致的

启动程序，维护程序运行的数据存储于内存中，当程序结束，数据在内存中被释放了

内存也是分为不同的区域的，不同的区域存储的数据是不一样的，数据的生命周期也是不一样的，区域有：

1. 栈区

2. 堆区

3. 常量池

   常量池中存储的是数值类型以及字符串类型的数据

   特点：获取数据时检查数据是否在常量池中存在，如果存在的话直接根据地址获取数据，如果不存在，先分配空间添加数据，再把数据的地址赋值给变量

   生命周期：当程序结束的时候才会释放

4. 静态池

   存储全局变量【直接在py文件中定义的变量称为全局变量】

   生命周期：当程序结束的时候才会释放

5. 方法区

2.5.7 位运算符

这个运算符的运算机制是对二进制数据进行计算的，因为直接是针对于二进制数据计算，计算效率是非常高的

&  按位与
	  相同位置的数据，只要有一个是0，该位置的结果为0
|  按位或
	  相同位置的数据，只有有一个是1，该位置的结果为1
^  按位异或
	  相同位置的数据一样，该位置位0，否则为1  【相同为0 不同为1】
	  一个数与相同的数异或两次结果是其本身  【交换两个变量的值】
	  
	  交换两个变量的值  a = 10  b = 20 ====> a = 20 b = 10
	  [使用至少3种方法交换两个变量的值]  ***** 
	  -- 方式1：大众的方式 借助第三方变量
          c = a
          a = b
          b = c
      -- 方式2：采用异或 【不用第三方变量】
      	  a = a ^ b  # 10 ^ 20
      	  b = a ^ b  # 10^20 ^ 20  ====> 10
      	  a = a ^ b  # 10^20^10   ====> 20
      -- 方式3：采用距离问题  【不采用第三方变量】
      	  a = a + b  # 10 + 20
      	  b = a - b  # 10 + 20 - 20 ====> 10
      	  a = a - b  # 10 + 20 - 10 ====> 20
      -- 方式4：Python独有的方法
      	 a, b = b, a  ====> a, b = 20, 10
	  
~  按位取反
	   该位置上的数据0变1, 1变0
>> 按位右移
	   将二进制数据向右移动N位，左边空出
	   如果是正数 左边补0
	   如果是负数 左边补1
	   规律：
	   	  数值//(2**N)
<< 按位左移
		将二进制数据向左移动N位，右边空出补0
		规律：
			数值*2**N

运算符都是针对于位【二进制数据中一个0或者一个1称为一位】的

在计算机发展过程中，根据数据计算的发展的一个历程，二进制形态出现过三种：原码/反码/补码。 现在的计算机中存储处理二进制数据的形态是补码

对于正数来说，三码合一，格式是一样的， 原码样子就是将十进制数据按照规则转化为二进制的格式

负数的原码： 在正数的基础上将最高位置为1，则表示这个数据为负数。【二进制的最高位为符号位：0表示正数 1表示负数】，之前接触过进制转换，数据大小不一样，获取的二进制数据中位的个数不一样，怎么确定哪个是最高位？？？ 【计算机中数据存储时开辟的最小单元是字节，1个字节是8位，位数一确定 最高位就确定了】，比如常规的数据开启的字节数是4个字节 0000 0000 0000 0000 0000 0000 0000 0001

0000 0000 0000 0000 0000 0000 0000 1010 [10]

1000 0000 0000 0000 0000 0000 0000 1010 [-10]

负数的反码：在负数原码的基础上，除了符号位，0变1，1变0

​ -10的反码1111 1111 1111 1111 1111 1111 1111 0101

负数的补码： 在负数反码的基础上加1

​ -10的补码 1111 1111 1111 1111 1111 1111 1111 0110

print(5 & -7)
5的原码/反码/补码都一样 ： 0000 0101
-7d的补码：
	7的原码： 0000 0111
    -7的原码：1000 0111
    -7的反码：1111 1000
    -7的补码：1111 1001 
    
0000 0101
1111 1001
------------
0000 0001  ----- # 1         # 0000开头，属于原码，可进行取值


print(3 | -7)

3的补码原码反码都一样：0000 0101
-7的补码：           1111 1001
-----------------------------
1111 1101【补码】 想要二进制对应的十进制是谁，需要看二进制的东西
1111 1100【反码】
1000 0011【原码】----  -3     # 1000开头，属于原码，可进行取值

# 按为右移
print（16 >> 3） # 2
0001 0000  # 正数原码反码补码都一样
0000 0010  ---- 2  # 向右移完，求得数字

print(-16 >> 3)
1001 0000 原码
1110 1111 反码
1111 0000 补码
-------------------
1111 1110 【补码】 # 向右移完后的补码    # 移的过程注意，正数补0 ，负数补 1
1111 1101 【反码】
1000 0010 【原码】---- -2   # 1000开头，属于原码了

--------------------
print(4 >> 3)
0000 0100 【原码/反码/补码】
0000 0000 【补码】  # 右移3位后为0 ，因为后几位都移完了  # 4整除2的3次方，商为0

十进制转二进制格式就是原码

补充：布尔类型参数算术或者位运算时 True被当做1，False被当做0

2.6流程控制语句

2.6.1顺序结构语句

代码是从上向下逐行运行的

2.6.2 分支结构语句

分为三种格式的，这三种格式分别是

1. 单分支

   语法：

   if 条件表达式:
   	满足条件执行的代码块
   

   语境：如果达到了某个条件，就去做某件事

   :缩进代表Python中代码块的包含体，满足要求执行的代码要统一缩进体现出来包合的关系

   

2. 双分支

   语法：

   if 条件表达式:
   	满足条件执行的代码块
   else:
   	不满足条件执行的代码块
   

   语境: 如果满足某个条件做事情A，否则做事情B

   

3. 多分支

   语法：

   if 条件表达式1:
   	满足条件1执行的代码块
   elif 条件表达式2:
   	不满足条件1 但是满足条件2执行的代码块
   elif 条件表达式3:
   	满足条件3 但是不满足条件1和2执行的代码块
   ...
   else:
   	以上条件都不满足执行的代码块
   

   1. 语境: 如果满足条件1，就做事情A，否则如果满足条件2，就做事情B…

   

布尔类型参数算数或者位运算时True被当作1，False被当作0

print(1 + True)  # 2
print(1000 * False)  # 0

的代码块
else:
不满足条件执行的代码块

语境: 如果满足某个条件做事情A，否则做事情B

[外链图片转存中...(img-UBVpIBhr-1695550387669)]

3. 多分支

语法：

```python
if 条件表达式1:
	满足条件1执行的代码块
elif 条件表达式2:
	不满足条件1 但是满足条件2执行的代码块
elif 条件表达式3:
	满足条件3 但是不满足条件1和2执行的代码块
...
else:
	以上条件都不满足执行的代码块

1. 语境: 如果满足条件1，就做事情A，否则如果满足条件2，就做事情B…

[外链图片转存中…(img-jYVhAcfi-1695550387670)]

布尔类型参数算数或者位运算时True被当作1，False被当作0

print(1 + True)  # 2
print(1000 * False)  # 0