2021.3.3总结

最新推荐文章于 2023-06-14 20:57:29 发布

z.354

最新推荐文章于 2023-06-14 20:57:29 发布

阅读量381

点赞数

本文链接：https://blog.csdn.net/zzdy11/article/details/114336901

版权

2021.3.3

总结：

01review

注释
语句
标识符
关键字
数据和数据类型
输出和输入
变量

02variable

内存大小的单位

位(bit)
- 1字节(byte) = 8位
- 1kb = 1024字节
- 1Mb = 1024kb
- 1G = 1024Mb
- 1T = 1024G
定义变量和重新给变量赋值的底层原理

定义变量的时候会先根据数据去申请内存，内存申请多大看数据需要多大。然后将数据保存对应的内存中，最后将内存空间和变量进行关联。
重新给变量赋值的时候，会重新根据新的数据申请新的内存，然后将新的数据存储到新的内存中，最后将新的内存空间和原来的变量进行关联，原来的内存会被自动释放。

id（变量） - 获取变量的地址
```
a = 100
print(id(a))  # 8791409169168

a = 200
print(id(a))  # 8791409172368
```

03mathOperator

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

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

+、-、*、/ 和数学中的+、-、×、÷的功能一模一样
% - 取余/取模，求余数

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

print(12 % 5)   # 2
print(15 % 6)   # 3

应用1：判断一个数是否能被另外一个数整除
```
print(15 % 3)   # 0
print(20 % 5)   # 0
```

应用2：取低位数

num = 15642

# 取num的个位数
print(num % 10)     # 2

# 取num的后两位数
print(num % 100)    # 42

// - 整除；求商，商保留整数部分（向小取整）

print(9 // 4)       # 2
print(6.5 //3)      # 2.0
print(-16 // 5)     # -4

应用：取高位(去掉低位)

num = 1345
# 取num的前三位数
print(num // 10)     # 134
# 取num的前两位数
print(num // 100)    # 13
# 取num的前一位数
print(num // 1000)   # 1

** - 幂运算

x ** y - 求x的y次方

# 4的平方
print(4 ** 2)       # 16
# 3的3次方
print(3 ** 3)       # 27
# 4的0.5次方 (根号4)
print(4 ** 0.5)     # 2.0
print(8 ** (1/3))   # 2.0
print(2 ** 10)      # 1024
print(1024 ** 0.1)  # 2.0

04compare

比较运算符：

==(等于)、 !=(不等于)、 >(大于)、 <(小于)、 >=(大于等于)、 <=(小于等于)

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

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

python支持两个比较运算符连写来表示数据范围
```
age = 24
print(18 <= age <= 30)   # True
```
不同类的数据不能进行比较大小
```
print('123' > 10)  # 不能比较
```

05logic

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

and

应用场景：用于表达多个条件同时满足的时候，相当于生活中的并且
运算符规则：两个都是True结果才是True,否则结果是False

True and True 结果：True
True and False 结果：False
False and True 结果：False
False and False 结果：False

练习1：某学校获得奖学金的条件：绩点不低于3.5并且操评分大于90分

grade = 3.0
score = 92
print('是否获得奖学金：', grade >= 3.5 and score > 90)
# 是否获得奖学金： False

grade = 3.8
score = 94
print('是否获得奖学金：', grade >= 3.5 and score > 90)
# 是否获得奖学金： True

练习2：写出一个整数是否能够同时被3和7整除的条件

num = 21
print('是否能够同时被3和7整除：',num % 3 == 0 and num % 7 ==0)
print('是否能够同时被3和7整除：',num % 21 == 0)
# 是否能够同时被3和7整除： True


num = 24
print('是否能够同时被3和7整除：',num % 3 == 0 and num % 7 ==0)
print('是否能够同时被3和7整除：',num % 21 == 0)
# 是否能够同时被3和7整除： False

应用场景：用于表达多个条件主要有一个条件满足就可以的时候，相当于生活中的或者
运算规则：两个都是False结果才是False,否则就是True
True or True 结果：True
True or False 结果：True
False or True 结果：True
False or False 结果：False

练习1：写出一个整数是否能够被3或者7整除的条件

num = 24
print('是否能够被3或7整除：',num % 3 == 0 or num % 7 ==0)
# 是否能够被3或7整除： True

num = 14
print('是否能够被3或7整除：',num % 3 == 0 or num % 7 ==0)
# 是否能够被3或7整除： True

num = 16
print('是否能够被3或7整除：',num % 3 == 0 or num % 7 ==0)
# 是否能够被3或7整除： False

练习2：写程序判断指定的年是否是闰年p

情况1：能被4整除但是不能被100整除的年（普通闰年）

情况2：能被400整除的年（世纪闰年）

year = 2020
print('是否是闰年：',(year % 4 == 0 and year % 100 != 0) or year % 400 == 0)
# 是否是闰年： True

year = 2021
print('是否是闰年：',(year % 4 == 0 and year % 100 != 0) or year % 400 == 0)
# 是否是闰年： False

not

应用场景：如果一个条件正向写的时候情况很多很复杂，反向写反而很简单的时候就将条件反向写然后在前面使用not
运算规则：
not True 结果：False
not False 结果：True

练习1：年龄不大于18

age = 24
print('年龄不大于18：',not age <= 18)
# 年龄不大于18： True

练习2：写出判断一个数是否不能同时被3和7整除

num = 18
# 方法一
print('是否不能同时被3和7整除:',(num % 3 == 0 and num % 7 != 0) or (num % 7 == 0 and num % 3 != 0) or (num % 3 != 0 and num % 7 != 0))
# 方法二
print('是否不能同时被3和7整除:',not num % 21 == 0)
# 是否不能同时被3和7整除: True

06 logicExtend

短路操作 (了解)

and的短路:

条件1 and 条件2 - 如果条件1是False,程序不会去执行条件2对应的代码
or的短路:

条件1 or 条件2 - 如果条件1是True,程序不会去执行条件2对应的条码

False and print(‘and：条件2’)
True or print(‘or：条件2’)
print(’============’)

运算对象不是布尔 - 逻辑运算符通用运算规则（了解）
- 数据1 and 数据2 - 如果数据1的布尔值是True,整个逻辑运算的结果是数据2；否则整个逻辑运算的结果是数据1
- 数据1 or 数据2 - 如果数据1的布尔值是True,整个逻辑运算的结果是数据1; 否则整个逻辑运算的结果是数据2
- not 数据 - 结果是数据对应的布尔取反
```
print(True and 10)    # 10
print(7 and 10)   # 10
print(0 and 10)   # 0
print(0.0 and 4)  # 0.0
print(True and False) # False
print(False and True) # False

print(9 or 8)   # 9
print(0 or 8)   # 8

print(not 0)   # True
print(not 10)  # False
```

数据的布尔值（数据转换成布尔的结果） - 非常重要

python中每个数据都有一个布尔值(不管类型的数据都可以转换成布尔)
所有零值、空值对应的布尔值是False，其他都是True.

print(bool(0))    # False
print(bool(0.00))  # False
print(bool(''))    # False
print(bool(None))  # False

print(bool(-23), bool(4))   # True True
print(bool(0.001), bool(-23.9))   # True True
print(bool(' '), bool("你好"))     # True True

07assigment

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

注意：

1）任何赋值运算表达式没有结果（不能用赋值运算来提供数据）

2）所有的赋值运算符的左边必须是变量（不管是简单赋值运算符还是复合的赋值运算符的功能都是将数据存储到变量中）

= - 普通的赋值运算符

a = 10
a = 100
print(10 + a)

复合赋值运算

变量 += 数据 - 先将变量中的数据取出来和后面数据进行加法运算，最后将运算的结果重新赋给前面的变量（变量必须是已经赋值过的变量）

x = 100
x += 10    # x = x + 10 = 100 + 10 = 110
print(x)   # 110

x -= 20
print(x)   # 90

x = 100
x %= 2     # x = x % 2
print(x)   # 0

运算符的优先级

数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符(最低)
** > *、/、%、// > +、-
有括号先算括号里面（只有小括号）

08if

流程控制的三种结构：

顺序结构：代码从上往下一条一条的执行，而且每条代码只执行一次（默认）

print(1)
print(2)
print(3)
# 1 
# 2
# 3

分支/选择结构：满足某个条件才执行某段代码，如果条件不满足就不执行或者执行其他的代码

单分支结构 - if

语法：
if 条件语句:
代码段

说明：
1. if - 关键字；固定写法
2. 条件语句 - 任何有结果的表达式（赋值语句不可以）：具体的数据、已经赋值过的变量、运算表达式
3. : - 固定写法，不能省略
4. 代码段 - 和if保持一个缩进(一般用tab键产生)的一条或者多条语句；
  就是满足条件才执行的代码

执行过程：如果条件语句为True(成立)，就执行代码段，否则代码段不执行

练习：如果指定的数据是奇数就控制台打印’奇数’

num = 29
# 方法一：
if num % 2 != 0:
    print('奇数') 

# 方法二：
if num % 2:
    print('奇数')

双分支结构 - if…else…
语法：
if 条件语句:
代码段1（条件成立的时候会执行的代码）
else:
代码段2（条件不成立的时候会执行的代码）

age = 17
if age >= 18 :
    print('成年' )
else:
    print('未成年')
# 未成年

age = 80
if age >= 18 :
    print('成年' )
else:
    print('未成年')
# 成年

循环结构：让代码重复执行多次

作业：

选择题

print(100 - 25 * 3 % 4)` 应该输出什么? （B）

A. 1

B. 97

C. 25

D. 0
下列哪种说法是错误的（A）。

A. 除字典类型外，所有标准对象均可以⽤于布尔测试

B. 空字符串的布尔值是False

C. 空列表对象的布尔值是False

D. 值为0的任何数字对象的布尔值是False
下列表达式的值为True的是（B）。

A. 3>2>2

B. 1 and 2 != 1

C. not(11 and 0 != 2)

D. 10 < 20 and 10 < 5
Python不⽀持的数据类型有（D）。

A. char

B. int

C. float

D. list
（多选）n = 6784，以下能够获取到7 的方法有（B C）。

A. n / 1000 % 100

B. n % 1000 / 100

C. n // 100 % 10

D. n // 10 % 100 // 10
运⾏以下程序，当从键盘上输⼊12,运⾏结果是（A）。
```
x = (input())
print(type(x))
```
A. <class 'str'>

B. <class 'int'>

C. 出错

D. <class 'dict'>
下列表达式的运算结果是( D) 。
```
a = 100
b = False
print(a * b > -1)
```
A. False

B. 1

C. 0

D. True

填空题
1. 查看变量中数据的类型的函数名是（tape）。
2. 已知 x = 3 == 3 ,执⾏结束后，变量x的值为（True）。
3. 已知 x = 3 ，那么执⾏语句 x += 6 之后，x的值为（9）。
4. 表达式 3 ** 2 的值为（9）,表达式 3 * 2 的值为（6），表达式 4 ** 0.5 的值为（2.0）。
编程题
1. 写出判断⼀个数是否能同时被2和5整除的条件语句, 并且打印对应的结果。
```
num = 10
print('是否能够同时被2和5整除:',num % 2 == 0 and num % 5 == 0)
print('是否能够同时被2和5整除:',num % 10 == 0)
# 是否能够同时被2和5整除: True
```
2. 写出判断⼀个数是否能够被2或者5整除，但是不能同时被2或者5整除的条件语句，并且打印对应的结果。
```
num = 10
print('是否能够被2或者5整除，但是不能同时被2或者5整除:',(num % 2 == 0 or num % 5 == 0) and num % 10 != 0)
# 是否能够被2或者5整除，但是不能同时被2或者5整除: False
```
假设今天的上课时间为15678秒，编程计算今天上课时间是多少⼩时，多少分钟，多少秒；以‘XX

时XX分XX秒’的⽅式表示出来。

例如：100秒表示成 0时1分40秒
```
time = 15678
hour = time //3600
minute = time % 3600 // 60
second = (time - hour * 3600 - minute * 60)
print('15618秒表示成',hour,'时',minute,'分',second,'秒',sep="")
# 15618秒表示成 4时21分18秒
```
1. 定义两个变量保存⼀个⼈的身⾼和体重，编程实现判断这个⼈的身材是否正常!
  
  公式: 体重(kg) / (身⾼(m)的平方值 ) 在18.5 ~ 24.9之间属于正常。
  
  输出格式：是否正常：True/False
```
weight = 45
high = 1.55
 a =weight / high ** 2
print('是否正常:',18.5 < a < 24.9)
# 是否正常:True
```

z.354

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
2021.3.3总结

2021.3.3总结：01review注释语句标识符关键字数据和数据类型输出和输入变量02variable内存大小的单位位(bit)1字节(byte) = 8位1kb = 1024字节1Mb = 1024kb1G = 1024Mb1T = 1024G定义变量和重新给变量赋值的底层原理定义变量的时候会先根据数据去申请内存，内存申请多大看数据需要多大。然后将数据保存对应的内存中，最后将内存空间和变量进行关联。重新给变量赋
复制链接

扫一扫