day3-python基础内容二

最新推荐文章于 2024-06-15 12:18:05 发布

是萧文呀！

最新推荐文章于 2024-06-15 12:18:05 发布

阅读量641

点赞数 1

文章标签： markdown python

本文链接：https://blog.csdn.net/CNTw20211107/article/details/121661591

版权

文章目录

前言
一、定义变量和给变量赋值的原理
- - - - 1.1 定义变量和给变量赋值的原理：
      - 1.2 python与java中定义变量和给变量赋值的区别：
二、运算符
三、分支结构
总结：

前言

python学习第3天，学习内容主要包括：定义变量和给变量赋值的原理、运算符（包括：数学运算符、比较运算符、逻辑运算符、赋值运算符）、运算符优先级、分支结构（if语句）。

一、定义变量和给变量赋值的原理

回顾：变量是数据的载体，变量是保存数据的一块内存储空间，空间中放着变量的值，变量的值可被读取和修改。
定义变量（创建变量）：将数据保存在变量中，变量用来保存数据。
语法：变量名 = 数据
说明：①变量名：程序员自己定义命名。
要求：遵循标识符要求、不是关键字。
规范：a.变量名要见名知义。
b. python中变量名所有的字母都小写，多个单词之间用下划线隔开。
c.python中变量名不使用系统的函数名、类名、模块名。

1.1 定义变量和给变量赋值的原理：

1）python定义变量的时候，需要先在计算机运行内存中申请一段内存空间，内存空间申请多大看数据需要多大，然后将数据保存到申请的内存中最后再和变量进行关联；
2）重新给变量赋值的时候，又会重新在计算机运行内存中申请新的内存，新的内存的大小由新的数据的大小决定，然后再将新数据对应的内存空间和变量重新进行关联。重新赋值后的变量地址与赋值前的变量地址不一样。

1.2 python与java中定义变量和给变量赋值的区别：

1）python中给变量赋值是根据数据的大小来申请内存空间的大小，因此不会出现数据溢出或者浪费内存空间的情况。python中变量赋值在申请内存空间过程中涉及到计算，因此python中变量保存数据的效率相对java来说要低一些。
2）java中给变量赋值是根据变量的类型先确定内存空间的大小，一旦变量类型确定了其内存空间就确定了大小，简单来说就是先有空间再将数据保存到这个内存空间中。java中变量的内存空间不随数据的大小而随意改变，因此存在着内存空间浪费和数据溢出的不良结果。

小结与补充：
①变量就是保存数据的一段内存空间，保存的数据的值可修改和读取。
②python中变量的内存由数据大小决定，java中变量的内存由变量类型决定。
③计算机运行内存中申请内存的最小单位为字节bytes。
计算机基础：位bit<1字节bytes = 8位<1kb=1024bytes<1mb = 1024kb<1Gb = 1024mb<1T = 1024Gb。

二、运算符

1.数学运算符

数学运算符：加 + 、减 - 、乘 * 、除 / 、取余 % 、整除 // 、幂 **

1.1 加减乘除（+ - * /）

python中的加减乘除的功能和数学中的加减乘除功能一样。

print(2 + 5)
print((-6) + 9)
print(2 - 5)
print(7 - 2)
print(2 * 5)
print(9 * 9)
print(100 / 2)
print(5 / 2)
print(9.8 / 2)

执行结果如下：

小结：
①加减乘中如果运算对象中有浮点数，结果就是浮点数；如果都是整数，结果都是整数。
②除法运算中运算的结果一定是浮点数。

1.2 取余 %

取余又叫取模，取余相当于求取数学中一个数的商的余数：

x % y — 求x除以y的余数

print(100 % 2)
print(5 % 2)
print(99 % 5)

执行结果如下：

0
1
4

应用一：判断一个数是否能被另外一个数整除，就看两个数的余数是否为0。如果余数为0，则能被整除；否则，就不能被整除。
应用二：取整数的低位数——对10或者是10的幂次方取余。

# 获取一个数的低位数
num = 12345
print(num % 10)             # 5
print(num % 100)            # 45
print(num % 1000)           # 345

# 判断一个数能否被另一个数整除
num1 = 29
num2 = 3
print(num1 % num2 == 0)		# False

1.3 整除 //

整除简单来说就是求取一个数的商，并且是向小取整。

num3 = 10
print(num3 // 3)        # 3 正数向小取整
num4 = -10
print(num4 // 3)        # -4 负数向小取整

应用：去掉一个数的低位数。一般和取模 % 结合使用。

# 去掉一个数的个位数
num5 = 34567
print(num5 // 10)       # 3456 去掉34567这个数的个位数

# 取一个数的低位数
num6 = 234567
print(num6 % 10)        	# 7 取这个数的个位上的数
print(num6 // 10 % 10)      # 6 取这个数的十位上的数
print(num6 // 100 % 10)     # 5 取这个数的百位上的数

1.4 幂 (**)运算

幂运算相当于数学中的乘方
x ** y — 求取一个数 x 的 y 次方

print(3 ** 3)     			# 27
print(2 ** 5)       		# 32
print(81 ** 0.5)        	# 9.0  开2次方根号
print(64 ** (1 / 6))        # 2.0  开6次方根号

2. 比较运算符

比较运算符：大于 > 、小于 < 、大于等于 >= 、小于等于 <= 、不等于 != 、等于 ==

1)所有比较运算符的运算结果都是布尔值True和False.

2)python可以直接通过比较运算符来表示范围.

# 所有比较运算符的运算结果都是布尔值True和False
print(10 > 20)      # False
print(2 < 5)        # True
print(8 >= 8)       # True
print(9 <= 8)       # False
print(10 != 11)     # True
print(123 == 321)   # False

# python可以直接通过比较运算符来表示范围
i = 20
print(18 <= i <= 21)         # True
a = 1234
print(1234 > a > 123)        # False

3. 逻辑运算符

python中逻辑运算符：逻辑与 and 、逻辑或 or 、逻辑非 not

3.1 逻辑与运算：and

应用场景：用于需要多个条件同时成立的时候，相当于生活中的 “并且”。
运算规则：条件1 and 条件2 ——两个条件都是True,结果才是True;只要有一个是False，结果就是False。(全真为真)
True and True ——> True
False and True ——> False
True and False ——> False
False and False ——> False

i = 123
j = 12.3
print(i != 124 and j == 12.3)       # True
print(i > 124 and j == 12.3)        # False
print(i <= 125 and j == 123)        # False
print(i >= 125 and j != 12.3)       # False

3.2 逻辑或运算：or

应用场景：应用与需要多个条件只要一个条件满足就可以的情况，相当于生活中的或者。
运算规则：条件1 or 条件2 ——两个条件只要有一个是True结果就是True，两个条件都是False时结果才是False。（全假为假）
True and True ——> True
False and True ——> True
True and False ——> True
False and False ——> False

# 快乐大抽奖中奖规则：抽中一个数的个位数是7并且十位数加上个位数为9，或者十位数能被3整除且个位数不能被2整除的数中奖.判断一个数是否中奖。
num = 237
#条件1： num % 10 ==7 and (num % 10 + num // 10 % 10)
#条件2： (num // 10 % 10) / 3 == 0 and (num % 10) / 2 != 0
a = bool(num % 10 ==7 and (num % 10 + num // 10 % 10))
b = bool((num // 10 % 10) / 3 == 0 and (num % 10) / 2 != 0)

print("是否中奖：", a or b)		# True

3.3 逻辑非运算：not

应用场景：对一个条件进行否定。当一个条件正向写的时候情况很多很复杂，反向写却很简单的时候，条件就反向写再加not
运算规则：not 条件
not True ——> False
not False ——> True

# 练习：写出num不能同时被3和7整除的条件
num = 23
# 方法一：正向写
# 情况1：能被3整除同时不能被7整除         —— num % 3 == 0 and num % 7 != 0
# 情况2：不能被7整除同时能被3整除          —— num % 7 == 0 and num % 3 != 0
# 情况3：既不能被3整除同时又不能被7整除        —— num % 3 != 0 and num % 7 != 0
print((num % 3 == 0 and num % 7 != 0) and (num % 7 == 0 and num % 3 != 0) and (num % 3 != 0 and num % 7 != 0))

# 方法二：反向写
# 反向思考：能同时被3和7整除 —— num % 3 == 0 and num % 7 == 0 / num % 21 ==0
print(not num % 21 == 0)

4. 赋值运算符

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

所有赋值运算符的功能都是将数据直接或者间接存储到一个变量中，不会产生任何结果。

变量赋值运算符数据

重要的结论：赋值运算没有结果/赋值运算表达式是没有结果的。

4.1 基本赋值运算符：=

变量 = 数据

num = 20
num = 35
print(num)		# 35

4.2 复合的赋值运算符：+=、 -=、 /=、*=、%=、 //=、 **=

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a

c = 10
c += 3
print(c)         	# 13
c -= 1
print(c)         	# 12
c *= 3           
print(c)			# 36
c /= 2           
print(c)			# 18.0
c %= 5          
print(c)			# 3.0
c //= 3             
print(c)			# 1.0
c **= 2             
print(c)			# 1.0

小结：复合赋值运算符赋值时前面的变量必须是已经赋值过的变量。

5. 运算符的优先级

运算符的优先级（从高到低）：数学运算符 > 比较运算符 > 赋值运算符 > 逻辑运算符（最低）
数学运算符中运算优先级（从高到低）：幂 > *、/、%、// > +、-
有括号()先算括号中的。

三、分支结构

1.流程控制 — 程序执行顺序（程序执行方式）

1).顺序结构（默认） —— 代码从上往下依次执行，每条语句执行一次
2).分支结构(if) —— 根据条件选择执行或者不执行相关操作
3).循环结构(for\while) —— 让代码重复执行
python的分支结构只有 if 结构

2. if 语句

2.1 if 单分支结构

满足条件执行某个操作，如果不满足这个操作就不执行。
语法：

if 条件语句：
    代码段

说明：
① if —— 关键字，固定写法
②条件语句 —— 任何有结果的表达式，比如：具体的数据、保存数据的变量、运算表达式（赋值运算除外）—
③ ：—— 冒号，固定写法，英文输入
④ 代码段 —— 此处的代码段从结构上和if保持一个缩进的一条或者多条语句；从逻辑上讲该代码段就是满足条件时才执行的代码
执行过程：先判断条件语句是否为True，如果是就执行代码段，然后再执行后面的其他代码；如果是False，不执行代码段直接执行其它代码。
注意：如果条件语句的结果不是布尔，就先转换成布尔再看。（其他数据转换布尔的时候除了零值和空值，都是True）。

# 练习1：如果num是偶数，就打印偶数
num = 24
if num % 2 == 0:
    print("偶数：", num)

# 练习2：根据年龄值打印“成年了！”
age = 23
if age > 18:
    print("成年了！")

# 练习3：判断指定的年是否是闰年，如果是闰年就打印“闰年”
# 闰年分为世纪闰年和普通闰年两种
# 世纪闰年  ——  能被400整除
# 普通闰年  ——  能被4整除但是不能被100整除
year = 2000
if (year % 400 == 0) or (year % 4 == 0 and year % 100 != 0):
    print("闰年：", year)

2.2 if 双分支结构

满足条件执行某个操作，这个条件不满足的时候就执行另一个操作。
if — else （相当于生活中的：如果xxx就xxx,否则就xxx）
语法：

if 条件语句：
    代码段1（满足条件执行的代码）
else：
    代码段2（不满足条件时执行的代码）

示例：

# 练习1：如果num是偶数，就打印偶数或者奇数
num = 23
if num % 2 == 0:
    print("偶数：", num)
else:
    print("奇数：", num)
# 练习2：根据年龄值打印“成年”或者“未成年”
age = 23
if age >= 18:
    print("成年")
else:
    print("未成年")
# 练习3：判断指定的年是否是闰年，如果是闰年就打印“闰年”或者“平年”
year = 2022
if (year % 400 ==0) or (year % 4 == 0 and year % 100 != 0):
    print("闰年：", year)
else:
    print("平年：", year)

2.3 if 多分支结构

根据不同的条件做不一样的事情。
if 多分支结构使用if—elif—else结构
语法：

if 条件1：
    代码段1
elif 条件2：
    代码段2
elif 条件3：
    代码段3
...
else:
	代码段n

示例：

# 练习5：根据年龄值打印“儿童”、“少年”、“青年”、“壮年”、“中年”、“老年”
# 儿童——12岁以下
# 少年——12—18岁
# 青年——18—28岁
# 壮年——28—40岁
# 中年——40—60岁
# 老年——60岁以上
age = 18
if age <= 12:
    print("儿童")
elif age <= 18:
    print("少年")
elif age <= 28:
    print("青年")
elif age <= 40:
    print("壮年")
elif age <= 60:
    print("中年")
else:
    print("老年")