python之三元表达式，列表|字典推导式，函数对象

#### 三元表达式： 就是if....else...的语法糖
#       -- 1) 只能解决if...else...结构，其他if分支结构都不管
#       -- 2）一个分支提供一个结果: 如果一个分支提供了多个结果, 将多个结果通过元组返回
# eg
# num = int(input('num:'))
# if num > 0:
#     print('正数')
# else:
#     print('非整数')
# 这是之前的用法
# 三元表达式简化写法
# num = int(input('num:'))
# print('正数' if num > 0 else '非整数')  # num =- 9 时 打印 非整数
# print('正数') if num > 0 else (print('非正数'), print('非正数'))  # num =- 9 时 打印 非整数  非整数

# a = int(input('a:'))
# b = int(input('b:'))
# res = a if a > b else (a, b) # a= 4  b= 6 结果（4，6）
# print(res)

# if a > b:
#     res = a
# else:
#     res = b

######列表与字典推导式：就是快速生成列表和字典  ,中间运用到for循环 格式都是 所需要的元素 元素在某某中循环得到所需要的元素

###### 列表推导式 :能被列表推导式推导的数据源必须在循环取值时可以得到一个值
# ls = [1, 2, 3, 4, 5]
# print(ls)
ls = []
for i in range(1, 6):
    ls.append(i)
print(ls)  # [1, 2, 3, 4, 5]

# 推导式
ls = [i for i in range(1, 6)]
print(ls)  # [1, 2, 3, 4, 5]
# ①多场景应用
print([v for v in range(1, 31)])
# ②推导式可以有简单的逻辑
# 求30以内的奇数，偶数
res = ['奇数' if i % 2 != 0 else '偶数' for i in range(1, 31)]  # '奇数' if i % 2 != 0 else '偶数'  对i  进行展开
print(res)
# 需求：解决10以内是3的倍数与不是3的倍数的排列方式  就是1- 9 中的三的倍数
res = ['3的倍数' if i % 3 == 0 else '不是3的倍数' for i in range(1, 10)]
print(res)

######  字典推导式 :能被字典推导式推导的数据源必须在循环取值时可以被解压赋值为两个值
dic = {'a': 1, 'b': 2}
res = {k: v for k, v in dic.items()}
print(res)  # {'a': 1, 'b': 2}

for k,v in dic.items():  # dic.items()  就是运用字典的for循环 就是把字典的k v 弄出来
    print(k, v)

ls = {'A': 1, 'B': 2}
res = {k: v for k, v in ls.items()}
print(res)  # {'A': 1, 'B': 2}

ls = {'A': 1, 'B': 2}
res = {k.lower(): v for k, v in ls.items()}  # k.lower() 是字符串字母转化为小写
print(res)  # {'a': 1, 'b': 2}  #  可以对k，v进行一些操作

ls = [['A', 1], ('B', 2)]    # 只要是分离的 就可以转化为k v模式
res = {k: v for k, v in ls}
print(res)  # {'A': 1, 'B': 2}

ls = [['A', 1], ('B', 2)]
res = {v: k.lower() for k, v in ls}   # 此时之后字母才能变成小写 则k对应的就是A和B
print(res)  # {1: 'a', 2: 'b'}

###### 函数对象;函数名
# 函数对象的应用场景
# 1.函数对象()就是调用函数
# 2.函数对象可以直接作为变量赋值给其他变量
# 3.函数对象可以作为函数的参数
# 4.函数对象可以作为函数的返回值
# 5.函数对象可以作为容器类型的成员
a = 10  # a存放的就是10的地址 a就是整形对象
b = [1, 2, 3]  # b存放的就是列表[1,2,3,]的地址，b就是列表对象
with open('1.txt', 'wb') as fn:
    print(fn, id(fn))
def fs():
    pass
print(fs,id(fs))  # 打印函数对象地址和内存地址 <function fs at 0x000001C94054C1E0> 1963879350752

### 函数对象的应用场景
# ①1.函数对象()就是调用函数
def fn1():
    pass
fn1() # 函数对象（）  模式就是调用函数
# ②：函数对象可以直接作为变量赋值给其他变量
def fn2():
    pass
my_fn = fn2
print('>>>>', my_fn(), fn2)
my_fn()
# ③ 函数对象可以作为函数的参数

def fn3(func):  # func = my_fn = fn2
    func
fn3(my_fn)  # 这是把实参my_fn赋值给形参func ,my_fn 就是一个函数对象

# ④函数对象可以作为函数的返回值
def fn4():
    return my_fn
my_fn2 = fn4()
# ⑤ 函数对象可以作为容器类型的成员
ls = [my_fn, my_fn2]

##### 函数对象的案例
# part1
def add(n1, n2):  #  第一个函数
    return n1 + n2
def low(n1, n2):
    return n1 - n2
def computed(n1, n2, func): # 第三个函数
    return func(n1, n2,)  # r1 时相当于add(n1,n2)  即 30
r1 = computed(10, 20, add)  # 10 赋值给n1 20 赋值给n2  add赋值给func 这时调用第三个函数，因为add是函数名，
print(r1) # 结果是30  # 调用（）add时相当于调用第一个函数 则是10 + 20 = 30
r2 = computed(10, 20, low)
print(r2)

# part2

def add(n1, n2):
    return n1 + n2
def low(n1, n2):
    return n1 - n2
def computed(n1, n2, func):
    return func(n1, n2)
cmd = input('cmd: ')  # 只能等于字符串add、low => 什么方式可以将字符串add、low对应上函数,则想到对应关系 就是字典的映射
fn_map = {
    'add': add,
    'low': low
}
if cmd in fn_map:  # 作为容器的成员可以简化判断逻辑
    fs = fn_map[cmd]    # 判定fs是否在字典映射里
    res = computed(10, 20, fs)
    print(res)
else:
    print('该运算暂不支持')

#####
# part4
# 当输入对应 两个数进行运算  当输入q时就退出
# 功能层
def add(n1, n2):
    return n1 + n2
def low(n1, n2):
    return n1 - n2
def jump(n1, n2):
    return n1 * n2
# 实现层
def computed(n1, n2, func):
    return func(n1, n2)

# 映射层
fn_map = {
    'add': add,
    'low': low,
    'jump': jump
}

# 完成映射对应
def get_fn(cmd):
    f = add  # 默认为add函数
    if cmd in fn_map:
        f = fn_map[cmd]  # 如果指令正确就返回对应的函数，如果不正确，就是采用默认的函数
    return f

# 程序入口
while True:
    cmd = input('cmd: ')
    if cmd == 'q':
        break

    fn = get_fn(cmd)
    res = computed(10, 20, fn)
    print(res)

# 名称空间
# 名称空间：就是名字与地址的对应关系，可以被Python解释器遍历查找，采用堆栈存储方式

# 三种名称空间
# Built-in：内置名称空间；系统级，一个；随解释器执行而产生，解释器停止而销毁
# Global：全局名称空间；文件级，多个；随所属文件加载而产生，文件运行完毕而销毁
# Local：局部名称空间；函数级，多个；随所属函数执行而产生，函数执行完毕而销毁

# 注:文件中的if、while、for、with这些能产生缩减的关键字并不能产生名称空间
# 加载顺序：Built-in > Global > Local

######  函数嵌套定义
# 概念：在一个函数内部定义另一个函数
def outer():
    print('outer run')
    a = 10
    # 函数对象(变量)与普通对象(变量)一样，在函数内部定义，随函数调用而产生，
    # 调用结束而销毁，所以只能在函数内部调用
    def inner():
        print('inner run')
    inner()
outer()

####  作用域
# 作用域：变量(名字|对象)起作用的范围
# 四种作用域
# Built-in：内置作用域：作用所有文件的所有地方
# Global：全局作用域：作用当前文件的所有地方
# Enclosing：嵌套作用域：作用当前函数已内部被嵌套函数
# Local：局部作用域：作用当前函数内部

# 注：
# 不同作用域之间名字不冲突，以达到名字的重用
# 每个作用域优先使用自己作用域中的名字，没有再找更大的名称空间的名字，直到内置，还没有就报错
# 查找顺序：Local > Enclosing > Global > Built-in