文章目录

• 今日测验
• 知识补充
• 今日内容
• 今日内容详解
• • 可变不可变类型
  • • 验证
    • • int是不可变类型
      • float是不可变类型
      • str是不可变类型
      • list是可变类型
      • dict
      • bool不可变
      • 关于字典补充：
  • 条件
  • • 第一大类：显式布尔值
    • 第二大类：隐式布尔值，所有的值都可以当成条件去用
  • 逻辑运算符
  • • not、and、or的基本使用
    • 优先级not > and > or
  • 成员运算符和逻辑运算符
  • • 成员运算符
    • 身份运算符
  • 流程控制之if判断

今日测验

1、简单描述定义一个变量x=10，在内存中的栈区域堆区的存放情况 栈区：存放是变量名与内存地址的对应关系，所以可以简单理解为：变量名存内存地址 堆区：存放的是变量值
强调：只站在变量的名的角度去谈一件事情，变量名的赋值（x=y），还有变量名的传参（print(x)），传递的都是栈区的数据 ，而且栈的数据是变量名与内存地址的对应关系，或者说是对值的引用
python是引用传递

示例1：
       x=10
       y=20
       x=y
   示例2：
       l=[111,222,333]
       l1=[22222222,333333333,4444444]
		l2=l

2、简述什么是直接引用、什么是间接引用
直接引用指的是从栈区出发直接引用到的内存地址。 间接引用指的是从栈区出发引用到堆区后，再通过进一步引用才能到达的内存地址。
3、简单描述python解释器垃圾回收机的引用计数、标记清除、分代回收
垃圾回收机制（简称GC）是Python解释器自带一种机，专门用来回收不可用的变量值所占用的内存空间，Python的GC模块主要运用了“引用计数”（reference counting）来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用的问题，并且通过“分代回收”（generation collection）以空间换取时间的方式来进一步提高垃圾回收的效率。
引用计数就是： 变量值被变量名关联的次数
标记/清除：当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除
分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低，具体实现原理如下： 1. 分代指的是根据存活时间来为变量划分不同等级（也就是不同的代） 2. 新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的
4、写一段程序 接收用户输入的用户名、年龄、性别，然后选取最优格式化字符串的方式，按照如下 格式输出

我的名字是：xxx
	我的年龄是：xxx
	我的性别是：xxx


	格式化输出
	    %
	    str.format()
	    f''

5、算数运算符相关

/
   	//
   	用示例演示
   		取模运算
   		
   		增量赋值
   			age += 1 # age = age + 1
   		交叉赋值
   			x,y=y,x
   		链式赋值
   			x=y=z=10
   		解压赋值
   			x,y,*_,z=[10,20,30,40,50]
   			_,_,*m,_=[10,20,30,40,50]

知识补充

l = [111, 222, 333]
l2 = l  # 把l的内存地址给l2


l[0] = 'balabla'
print(l)

print(l2)

l2[1] = 4444444444444
print(l2)
print(l)

del l2

格式化输出
print('my name is %s age is %s' % ('egon', 18))
print('成功的概率 %s%% ' % (97,))

"""
name:{}
age:{}
sex:{}
""".format('egon', 18, 'male')

"""
name:{x}
age:{y}
sex:{z}
""".format(z='male', x='egon', y=18)

format新增(了解)：
print('{x}=============='.format(x='开始执行'))  # 开始执行******
print('{x:=<10}'.format(x='开始执行'))  # 开始执行******
print('{x:=>10}'.format(x='开始执行'))  # 开始执行******
print('{x:=^10}'.format(x='开始执行'))  # 开始执行******

四舍五入
# 精确到小数点后3位，四舍五入，结果为：1232132.124
print('{salary:.3f}'.format(salary=1232132.12351))


x = 'egon'
y = 18
res = f'name:{x} age {y}'
print(res)


x = 'egon'
y = 18
res = f'name:{{{x}}} age {y}'
print(res)

了解f的新用法：{}内的字符串可以被当做表达式运行
res = f'{10+3}'
print(res)

f'{print("aaaa")}'

今日内容

1：可变不可变类型

2、什么是条件？什么可以当做条件？为何要要用条件？
    显式布尔值：True、False
    隐式布尔值：所有数据类型，其中0、None、空为假

3：逻辑运算符：用来
    # not、 and 、 or
    # 区分优先级：not > and > or

4、成员运算符

5、身份运算符

6、流程控制之if判断

今日内容详解

可变不可变类型

可变类型：值改变，id不变，证明改的是原值，证明原值是可以被改变的
不可变类型：值改变，id也变了，证明是产生新的值，压根没有改变原值，证明原值是不可以被修改的

验证

int是不可变类型

x = 10
print(id(x))
x = 11  # 产生新值
print(id(x))
结果是变量的id被改变了

float是不可变类型

x = 3.1
print(id(x))
x = 3.2
print(id(x))

str是不可变类型

x = “abc” print(id(x)) x = ‘gggg’ print(id(x))

小结：int、float、str都被设计成了不可分割的整体，不能够被改变

list是可变类型

l = ['aaa', 'bbb', 'ccc']
print(id(l))
l[0] = 'AAA'
print(l)
print(id(l))

dict

dic = {'k1': 111, 'k2': 222}
print(id(dic))
dic['k1'] = 3333333333
# print(dic)
print(id(dic))

bool不可变

关于字典补充：

定义：{}内用逗号分隔开多key: value,
其中value可以是任意类型
但是key必须是不可变类型

dic = {
    'k1': 111,
    'k2': 3.1,
    'k3': [333, ],
    'k4': {'name': 'egon'}
}

dic = {
    2222: 111,
    3.3: 3.1,
    'k3': [333, ],
    'k4': {'name': 'egon'}
}
print(dic[3.3])

dic = {[1, 2, 3]: 33333333}
dic = {{'a': 1}: 33333333}

条件

什么是条件？什么可以当做条件？为何要要用条件？

第一大类：显式布尔值

条件可以是：比较运算符
age = 18
print(age > 16)  # 条件判断之后会得到一个布尔值

条件可以是：True、False
is_beautiful = True
print(is_beautiful)

第二大类：隐式布尔值，所有的值都可以当成条件去用

其中0、None、空(空字符串、空列表、空字典) =》代表的布尔值为False，其余都为真

逻辑运算符

not、and、or的基本使用

not：就是把紧跟其后的那个条件结果取反
ps: not与紧跟其后的那个条件是一个不可分割的整体
print(not 16 > 13)
print(not True)
print(not False)
print(not 10)
print(not 0)
print(not None)
print(not '')

and：逻辑与，and用来链接左右两个条件，两个条件同时为True，最终结果才为真
print(True and 10 > 3)

print(True and 10 > 3 and 10 and 0)  # 条件全为真，最终结果才为True
print(10 > 3 and 10 and 0 and 1 > 3 and 4 == 4 and 3 != 3)  # 偷懒原则

or：逻辑或，or用来链接左右两个条件，两个条件但凡有一个为True，最终结果就为True，
两个条件都为False的情况下，最终结果才为False
print(3 > 2 or 0)
print(3 > 4 or False or 3 != 2 or 3 > 2 or True)  # 偷懒原则

优先级not > and > or

ps：
如果单独就只是一串and链接，或者说单独就只是一串or链接，按照从左到右的顺讯依次运算即可（偷懒原则）
如果是混用，则需要考虑优先级了

res = 3 > 4 and not 4 > 3 or 1 == 3 and 'x' == 'x' or 3 > 3
print(res)

#       False                 False              False
res = (3 > 4 and (not 4 > 3)) or (1 == 3 and 'x' == 'x') or 3 > 3
print(res)


res = 3 > 4 and ((not 4 > 3) or 1 == 3) and ('x' == 'x' or 3 > 3)
print(res)

成员运算符和逻辑运算符

成员运算符

print("egon" in "hello egon")  # 判断一个字符串是否存在于一个大字符串中
print("e" in "hello egon")  # 判断一个字符串是否存在于一个大字符串中

print(111 in [111, 222, 33])  # 判断元素是否存在于列表

判断key是否存在于字典
print(111 in {"k1": 111, 'k2': 222})
print("k1" in {"k1": 111, 'k2': 222})

not in
print("egon" not in "hello egon")  # 推荐使用
print(not "egon" in "hello egon")  # 逻辑同上，但语义不明确，不推荐

身份运算符

is  # 判断的是id是否相等

流程控制之if判断

print(1)
print(2)
print(3)
if 条件:
    代码1
    代码2
    代码3
print(4)
print(5)
'''
语法1:
if 条件:
    代码1
    代码2
    代码3

'''
age = 60
is_beautiful = True
star = '水平座'

if age > 16 and age < 20 and is_beautiful and star == '水平座':
    print('我喜欢，我们在一起吧。。。')

print('其他代码.............')


'''
语法2:
if 条件:
    代码1
    代码2
    代码3
else:
    代码1
    代码2
    代码3
'''

age = 60
is_beautiful = True
star = '水平座'

if age > 16 and age < 20 and is_beautiful and star == '水平座':
    print('我喜欢，我们在一起吧。。。')
else:
    print('阿姨好，我逗你玩呢，深藏功与名')

print('其他代码.............')


'''
语法3:
if 条件1:
    代码1
    代码2
    代码3
elif 条件2:
    代码1
    代码2
    代码3
elif 条件2:
    代码1
    代码2
    代码3
'''
score = 73
if score >= 90:
    print('优秀')
elif score >= 80 and score < 90:
    print('良好')
elif score >= 70 and score < 80:
    print('普通')

改进
score = input('请输入您的成绩：')  # score="18"
score = int(score)

if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 70:
    print('普通')


'''
语法3:
if 条件1:
    代码1
    代码2
    代码3
elif 条件2:
    代码1
    代码2
    代码3
elif 条件2:
    代码1
    代码2
    代码3
...
else:
    代码1
    代码2
    代码3
'''
score = input('请输入您的成绩：')  # score="18"
score = int(score)

if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 70:
    print('普通')
else:
    print('很差，小垃圾')

print('=====>')


'''
if嵌套if
'''
age = 17
is_beautiful = True
star = '水平座'

if 16 < age < 20 and is_beautiful and star == '水平座':
    print('开始表白。。。。。')
    is_successful = True
    if is_successful:
        print('两个从此过上没羞没臊的生活。。。')
else:
    print('阿姨好，我逗你玩呢，深藏功与名')

print('其他代码.............')

ore >= 80:
print(‘良好’)
elif score >= 70:
print(‘普通’)
else:
print(‘很差，小垃圾’)

print(’=====>’)

‘’’
if嵌套if
‘’’
age = 17
is_beautiful = True
star = ‘水平座’

if 16 < age < 20 and is_beautiful and star == ‘水平座’:
print(‘开始表白。。。。。’)
is_successful = True
if is_successful:
print(‘两个从此过上没羞没臊的生活。。。’)
else:
print(‘阿姨好，我逗你玩呢，深藏功与名’)

print(‘其他代码…’)