三元表达式,生成式,匿名函数与内置方法

1. 三元表达式

"""
使用场景:如果成立执行这个代码,不成立执行另一个代码的时候 推荐使用三元表达式
"""
# 编写一个求两个数大小的函数
# def index(num1, num2):
#     if num1 > num2:
#         return num1
#     else:
#         return num2


"""
三元表达式
    值1 if 条件 else 值2
条件如果成立则使用值1(if前面的数据)
条件如果不成立则使用值2(else后面的数据)
"""
cat = input('cat>>>:').strip()
res = 'python_cat' if cat == 'python_cat' else 'python cat'
print(res)
'''三元表达式只用于如果成立执行这个代码,不成立执行另一个代码的情况 最好不要嵌套使用(语法不简洁)'''
# res = '下午' if 1 == 1 else (2 if 2==3 else '上午')  # 不推荐

# 补充:针对if分支结构 也有简化版本(了解即可)
'''子代码块都只有简单的一行情况下 也可以简写  没有三元表达式简单 但是也有人用'''
name = 'python_cat'
if name == 'python_cat': print(name)
else: print('python cat')

 

2. 生成式

# 1.列表生成式
name_list = ['jason', 'kevin', 'tony', 'oscar', 'jerry']
'''需求:将列表中所有的人名后面加上_DSB'''
# 1.创建一个空的列表用于存储修改之后的数据
new_list = []
# # 2.for循环列表获取每一个人名
for name in name_list:  # 'jason'    'kevin'   字符串
#     # 3.字符串末位拼接_DSB
    res = name + '_python_cat'
#     # 4.添加到新的列表中
    new_list.append(res)
print(new_list)
# >>>['jason_python_cat', 'kevin_python_cat', 'tony_python_cat', 'oscar_python_cat', 'jerry_python_cat']
# 列表生成式:该技术可以简化代码 也可以不用 无外乎写的复杂一点而已
res = [name+'_python_cat' for name in name_list]
print(res)
# >>>['jason_python_cat', 'kevin_python_cat', 'tony_python_cat', 'oscar_python_cat', 'jerry_python_cat']
# 列表生成式复杂用法:还具备筛选能力
res = [name + '_python_cat' for name in name_list if name == 'jason']
print(res)
# >>>['jason_python_cat']
res = [name + '_python_cat' for name in name_list if name not in ['jason', 'kevin']]
print(res)
# >>>['tony_python_cat', 'oscar_python_cat', 'jerry_python_cat']
'''列表生成式中值允许出现for和if 不能出现else 因为会产生歧义(for和if都能结合else)'''

# 2.字典生成式
l1 = ['name', 'age', 'pwd']
l2 = ['jason', 18, 123]
# 需求:将上述两个列表分别制作成字典的键值
# 1.定义一个空字典
new_dict = {}
# 2.每次循环都要拿到两个列表中对应的元素(索引相等)
for i in range(len(l1)):
# 3.索引取值即可
    new_dict[l1[i]] = l2[i]
print(new_dict)
# >>>{'name': 'jason', 'age': 18, 'pwd': 123}
# 字典生成式
res = {l1[i]: l2[i] for i in range(len(l1))}
print(res)
# >>>{'name': 'jason', 'age': 18, 'pwd': 123}
res = {l1[i]: l2[i] for i in range(len(l1)) if i in [0, 1]}
print(res)
# >>>{'name': 'jason', 'age': 18}

# 3.集合生成式
# 生成0-10的集合
res = {i for i in range(10)}
print(res)
# >>>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
# 生成0-10集合,取出1与3
res = {i for i in range(10) if i not in [1, 3]}
print(res)
# >>>{0, 2, 4, 5, 6, 7, 8, 9}

'''其实生成式就是使用对应的符号括起来,里面增加for循环再写具体的操作'''

"""没有元组生成式 依据上述写法得到的时候后续我们要学习的知识:迭代器"""

 

3. 匿名函数

# 匿名函数的意思就是没有函数名
# 没有函数名的函数如何调用呢?
# 需要与其他函数一起使用的时候进行书写

# 定义匿名函数
# lambda index: index + 2
"""
匿名函数的结构：
lambda 形参:返回值
如果用普通函数来表示
等价于
def index(x):
    return x + 2
"""
print(lambda x: x+2)
# >>><function <lambda> at 0x000002CD11A1D310>

# max:统计最大值
index_list = [11, 33, 44, 55, 77, 88, 22, 101]
#  max() 直接获取数据集中最大的元素值
print(max(index_list))
# >>> 101

info = {
    'Easy': 9999999,
    'Tank': 123,
    'dragon': 1000,
    'zombie': 33
}
# 求:薪资最高的人的姓名
print(max(info))
# zombie

info = {
    'Easy': 9999999,
    'Tank': 123,
    'dragon': 10000,
    'zombie': 33
}
print(max(info))
# zombie

info = {
    'Easy': 9999999,
    'Tank': 123,
    'dragon': 10000,
    'aombie': 33
}
print(max(info))
# dragon

# 发现如果字典中直接使用max函数,直接就返回key值,但是我们对value值进改变,那么max函数依旧输出zombie
# 但是改变zombie,改为aombie,那么max函数输出的是dragon,发现,max函数对比的是key值,并且还是key的首字母的ASCII码
'''
max底层可以看成是for循环依次比较 针对字典默认只能获取到k
获取到k之后如果是字符串的英文字母 则会按照ASCII码表转成数字比较
    A~Z:65-90
    a~z:97-122
'''
# 查看max函数的源码,可以填写第二个参数,第二个参数可以时一个函数,那么我们写一个返回value的函数,进行对比
def index(k): 
    return info[k]
print(max(info,key=index))  # key对应的函数返回什么 max就以什么做比较的依据
# 比较的是v 返回的是k    key相当于是可以更改比较规则的参数

print(max(info, key=lambda key: info[key]))  # Easy

 

4. 常见重要的内置函数

# 1.内置函数之 map映射
index_list = [11, 22, 33, 44, 55, 66, 77]
# 需求:元素全部自增10
# 方式1:列表生成式
def index(n):
    return n + 10
res = map(index,index_list)
print(res)  # 迭代器(节省空间的 目前不用考虑)
print(list(res))
# >>>[21, 32, 43, 54, 65, 76, 87]

# 方式2:内置函数
res = map(lambda x: x + 10, index_list)
print(list(res))
# >>>[21, 32, 43, 54, 65, 76, 87]
# 目前我们不能对迭代器直接进行查看,那么我们就先使用list()方法,转化为列表进行输出
# 虽然两个方法都是可以运行的,但是第二种使用map内置函数可以更加的快捷,代码也更加简洁

# 2.内置函数之zip拉链
index_list = [1, 2, 3, 4]
str_list = ['tony', 'tank', 'dragon', 'python_cat']
# 需求:将两个列表中的元素一一对应成对即可
res = zip(index_list, str_list)  # 结果是一个迭代器
print(res)  # 目前我们不能对迭代器直接进行查看,那么我们就先使用list()方法,转化为列表进行输出
print(list(res))
# >>>[(1, 'tony'), (2, 'tank'), (3, 'dragon'), (4, 'python_cat')]
'''zip函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。'''
index_list = [11, 22, 33, 44]
str_list = ['tony', 'tank', 'dragon', 'python_cat']
index_list1 = [1, 2, 3, 4]
index_list2 = [111, 333, 444]
res = zip(index_list, str_list, index_list1, index_list2)
print(list(res))
# >>>[(11, 'tony', 1, 111), (22, 'tank', 2, 333), (33, 'dragon', 3, 444)]
# 不使用zip也可以
res1 = [(index_list[i], str_list[i], index_list1[i], index_list2[i]) for i in range(len(index_list2))]
print(res1)
# >>>[(11, 'tony', 1, 111), (22, 'tank', 2, 333), (33, 'dragon', 3, 444)]
'''zip可以整合多个数据集 如果数据集之间个数不一致 那么依据短的'''
index_list = [1, 2, 3, 4, 5]
str_list = ['dragon', 'python_cat']
res = zip(index_list, str_list)
print(list(res))
# >>[(1, 'dragon'), (2, 'python_cat')]

# 3.内置函数之filter过滤
index_list = [11, 22, 33, 44, 55, 66, 77, 88, 99]
'''需求:筛选出大于30的元素'''
# 方式1:列表生成式
res = [index for index in index_list if index > 30]
print(res)
# >>>[33, 44, 55, 66, 77, 88, 99]

# 方式2:内置函数
# 使用自定义函数
def check_index(x):
    return x > 30
res = filter(check_index,index_list)
print(list(res))
# >>>[33, 44, 55, 66, 77, 88, 99]

# 使用匿名函数
res = filter(lambda x: x > 30, index_list)
print(list(res))
# >>>[33, 44, 55, 66, 77, 88, 99]

# 4.内置函数之reduce归总
# 本来是内置函数,但是因为某些原因,被移入到functools中了
from functools import reduce

index_list = [11, 22, 33, 44]
'''需求:讲列表中所有的元素相加'''
def check_index(x,y):
    return x + y
res = reduce(check_index, index_list)
print(res)
# >>>110
res = reduce(lambda x, y: x + y, index_list)
print(res)
# >>>110
res = reduce(lambda x, y: x + y, index_list, 200)
print(res)
# >>>310

 

5. 常见内置函数

# 1.abs()  获取绝对值(不考虑正负号)
print(abs(-123))
# >>>123
print(abs(123))
# >>>123

# 2.all()与any()
# all函数:数据集中必须所有的元素对应的布尔值为True返回的结果才是True
# any函数:数据集中只要所有的元素对应的布尔值有一个为True 返回的结果就是True
l1 = [0, 0, 1, 0, True]
print(all(l1))
# >>>False
print(any(l1))
# >>>True

# 3.bin() oct() hex()  产生对应的进制数
# bin函数将十进制转转换成二进制
# oct函数将十进制转换成八进制
# hex函数将十进制转换成十六进制
print(bin(100))
# >>>0b1100100
print(oct(100))
# >>>0o144
print(hex(100))
# >>>0x64

# 4.bytes(x  类型转换
python_cat_str = '我想要看 python cat'
print(python_cat_str.encode('utf8'))
# >>>b'\xe6\x88\x91\xe6\x83\xb3\xe8\xa6\x81\xe7\x9c\x8b python cat'
print(bytes(python_cat_str, 'utf8'))
# >>>b'\xe6\x88\x91\xe6\x83\xb3\xe8\xa6\x81\xe7\x9c\x8b python cat'
'''针对编码解码 可以使用关键字encode与decode  也可以使用bytes和str'''
# bytes(xx, 'utf8')与xx.encode('utf8')转换的数据是一致的


# 5.callable()  判断当前对象是否可以加括号调用
python_cat_str = 'python_cat'
def print_python_cat():
    print('python cat')
print(callable(python_cat_str))
# >>>False  变量名不能加括号调用
print(callable(print_python_cat))
# >>>True  函数名可以加括号调用

# 6.chr()、ord()  ASCII码与数字的对应转换
print(chr(65))
# >>>A  根据数字转字符  依据ASCII码
print(ord('A'))
# >>>65  根据字符转数字  依据ASCII码

# 7.dir()  返回数据类型可以调用的内置方法(查看对象内部可调用的属性)
# print(dir(1))
# >>>['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__',
# '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__',
# '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__',
# '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__',
# '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__',
# '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__',
# '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
# print(dir('python_cat'))
# >>>['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__',
# '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__',
# '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map',
# 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle',
# 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', '
# rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

# 8.divmod() 输出的样式 (第一个参数, 第二个参数) 第一个参数是整数部分 第二个是余数部分
print(divmod(250, 15))
# >>>(16, 10)
print(divmod(251, 15))
# >>>(16, 11)
print(divmod(249, 15))
# >>>(16, 9)

# 需求:当输入总共的数量与每页的长度,算出一共需要多少页
def get_page_num(page_num, length_page):
    page, residue = divmod(page_num, length_page)
    if residue:
        page += 1
    print('需要%s页' % page)
get_page_num(1000,35)
# >>>需要29页


# 9.enumerate()  枚举
# 列表使用枚举很像字典的item方法
# 列表使用枚举,显示的是索引与索引对应的value值
str_list = ['tank', 'tony', 'cat', 'python_cat']
for name in str_list:
    print(name)
# >>>tank
# >>>tony
# >>>cat
# >>>python_cat

for i, j in enumerate(str_list):
    print(i, j)  # i类似于是索引 默认从0开始,后面为对应的值
# >>>0 tank
# >>>1 tony
# >>>2 cat
# >>>3 python_cat

for i, j in enumerate(str_list, start=1):
    print(i, j)  # 还可以控制起始位置 默认从0开始,改为1
# >>>1 tank
# >>>2 tony
# >>>3 cat
# >>>4 python_cat

for i, j in enumerate({'name': 'tony', 'age': 18}):
    print(i, j)   # i类似于是索引 默认从0开始, 后面为字典对应的key值
# >>>0 name
# >>>1 age

# 10.eval() exec()  识别字符串中的python代码  使用频率很低
print('print("有点饿了")')
# >>>print("有点饿了")
eval('print("有点饿了111")')
# >>>有点饿了111
exec('print("有点饿了222")')
# >>>有点饿了222
res = """
for i in range(10):
    print(i)
"""
# eval(res)  # 计算指定表达式的值。也就是说它要执行的Python代码只能是单个运算表达式（注意eval不支持任意形式的赋值操作），而不能是复杂的代码逻辑
exec(res)  # 动态执行Python代码。也就是说exec可以执行复杂的Python代码，而不像eval函数那么样只能计算一个表达式的值。
# >>>0
# >>>1
# >>>2
# >>>3
# >>>4
# >>>5
# >>>6
# >>>7
# >>>8
# >>>9