python 三元表达式、列表推导式、生成器表达式、递归、匿名函数、内置函数

• Z时代
• 2024-01-10
• 分类：综合

一、三元表达式

语法：
   [成立1 if condition1 else
   成立2 if condition2 else ...
   if 成立N conditionN else 不成立]

sex = 'man'
print('正确' if sex == 'man' else '错误')
# 正确
'''
语句解析：
sex = 'man'
if sex == 'man':
    print('正确')
else:
    print('错误')
'''
age = 23
res = '猜大了' if age > 23 else '猜小了' if age < 23 else '猜对了'
print(res)
# '猜对了'
'''
语句解析：
age = 23
if age >23:
    res = '猜大了'
elif age <23:
    res = '猜小了'
else:
    res = '猜对了'
'''

二、列表推导式

# 语法
'''
[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]
'''

res = ['ege%s'%i for i in range(10) if i%2 ==0]
print(res,type(res))
# ['ege0', 'ege2', 'ege4', 'ege6', 'ege8'] <class 'list'>
# 类似于
res = []
for i in range(10):
    if i%2 == 0:
        res.append('ege%s'%i)
print(res)

三、字典生成器

d={i:i for i in range(10) if i > 0}
print(d)
# {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
# 类似于：
dic = {}
for i in range(10):
    if i >0:
        dic[i] = i
print(dic)
userinfo=[('egon','123'),('alex','456'),('wxx','679')]
dic={k:v for k,v in userinfo}
print(dic)
# {'egon': '123', 'alex': '456', 'wxx': '679'}

四、生成器表达式

# 把 列表推导式中的[] 变成() 就是 生成器表达式
# 生成器表达式
res = (i for i in range(10000000000000000000000000000000000000000000))
print(res)
# <generator object <genexpr> at 0x00000000022AD150>
# 生成器
def test():
    yield 1
test = test()
print(test)
# <generator object test at 0x00000000021FD200>
print(next(test))
# 1

names = ['jmz','qqq','egon']
names = [name.upper() for name in names]
print(names)

练习 列表元素小写转大写

五、递归与简单二分法

　　递归

# 递归调用就是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用自身，这就是递归调用

def sum(count):
    if count == 1:
        return 100
    return sum(count-1) + 20
print(sum(5))
# 图解
'''
sum(5)  == sum(4) +20
sum(4)  == sum(3) + 20
sum(3)  == sum(2) + 20
sum(2)  == sum(1) + 20
sum(1) == 100
'''

# 递归总结
# 1、 有可以明确地结束条件
# 2、每次进入更深一层递归是，问题规模相比上次递归都应有所减少
# 3、递归效率不高，递归层次过多会导致栈溢出
#python中的递归
# python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，尾递归优化
# 但是python又没有尾递归，且对递归层级做了限制

　　二分法

想从一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法（算法的一种，算法是解决问题的方法）可以极大低缩小问题规模

nums = [1,2,5,13,16,35,67,87,181,197,200]
def search(nums, n):
    midden_index = len(nums) // 2
    if midden_index == 0:
        print('找到了' if nums[0] == n else '不存在该数据')
        return
    num = nums[midden_index]
    if num == n:
        print('找到了')
        return
    elif num > n:
        search(nums[:midden_index], n)
    else:
        search(nums[midden_index:], n)

# 二分法总结，
# 总是取中间值比较，想要找的值比中间值大就想后找
#比中间值小就往前找
#切片一直切到最后就只剩下一个数值，当只剩下一个数值时直接比较即可，无需再比什么中间值了

六、匿名函数

 什么是匿名函数

#     匿名函数就是没有名字的函数
def foo():
    print('我是有名字的函数，函数名foo')
# 匿名函数
lambda x,y,z=1:x+y+z # 与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字
func = lambda x,y,z:z+y+z
# 将匿名函数 赋值给 func 使其有名，与有名函数一样的调用方式，反而无意义了
print(func(1,2,3))
# 8

匿名函数与有名字的函数对比

# 有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能
# 匿名函数：一次性使用，随时随时定义
# 应用：max，min，sorted,map,reduce,filter

七、内置函数

#注意：内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，
即不够精准，最精准的还是以内存地址为准。is运算符用于比较两个对象的身份，等号比较两个对象的值，内置函数type()则返回一个对象的类型
#更多内置函数：https://docs.python.org/3/library/functions.html?highlight=built#ascii

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz
# min max 与匿名函数的运用
l = [1,2,3,4,5,6,7,8,9]
dic = {'x':11,'y':32,'z':3}
print(max(l))
print(min(l))
print(max(dic))  # z  这个取的是key的最大值
print(max(dic,key=lambda k:dic[k]))  # y   # 这个取的是value最大值的那个key
print(min(dic)) # x  这个取的是key的最小值
print(min(dic,key=lambda k:dic[k]))  # z   # 这个取的是value最小值的那个key
print(max([-11,1,21,-31],key=abs))   # -31    # 比较谁的绝对值最大   abs 内置函数取绝对值
# sorted 与 匿名函数的运用
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
# 将姓名已工资排序
print(sorted(salaries,key=lambda k:salaries[k]))   # 默认升序
# ['yuanhao', 'egon', 'wupeiqi', 'alex']
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))   # 降序了
# ['alex', 'wupeiqi', 'egon', 'yuanhao']
salaries_t = zip(salaries.keys(),salaries.values()) # 迭代器
print(salaries_t)  # <zip object at 0x0000000002502E88>
#list(salaries_t)  == >  [('egon', 3000), ('alex', 100000000), ('wupeiqi', 10000), ('yuanhao', 2000)]
# zip 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表或者字典
print(sorted(salaries_t,key=lambda v:v[1]))    # 表示已每个元组的第2个数排序
# [('yuanhao', 2000), ('egon', 3000), ('wupeiqi', 10000), ('alex', 100000000)]
# map 与匿名函数运用（重要）
names = [' jMZ',' jaCk  ','   jIm ']
# 将名字 转成 首字母 大写，并去除两边空格
names = map(lambda x:x.strip().title(),names)
print(list(names))
# ['Jmz', 'Jack', 'Jim']
# filter与匿名函数运用    函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
names=['alex_sb','wupeiqi_sb','egon','yuanhao_sb','liuqingzheng_sb']
res=filter(lambda x:x.endswith('sb'),names)
print(list(res))
print((i for i in range(10)))  # <generator object <genexpr> at 0x00000000021E00A0>  生成器

min,max,sorted,map,filter与匿名函数的运用

# # 数据类型函数
# set()    # 集合类型
# list()   # 列表类型
# int()    # 整型类型
# str()    # 字符串类型
# tuple()  # 元组类型
# dict()   # 字典类型
# float()  # 浮动型
# bool()   # 布尔类型
# # long()  # python 2 中有长整型类型，Python3 统一都是int类型
info = bool('1')
print(info,type(info))
info1 = set(['jmz',12,('11',23,1)])    # set([元素])   每一个元素都必须是不可变类型，即可hash类型
print(info1,type(info1))
info2 = str(123.1)    # 集合类型内部必须是可hash 类型，即不可变类型
print(info2,type(info2))
info3 = int("1231")   # 内部必须是可以转化成整型的其他类型
print(info3,type(info3))
info4 = list([1,23,34,(1,2,3)])
print(info4,type(info4))
info5 = dict([('name','jmz'),('age',13)])
# info5 = dict(name='jmz',age=12)
# info5 = dict([['name','jmz'],['age',12]])
# info5 = dict({'name':'jmz','age':12})
print(info5,type(info5))
info6 = tuple((1,2,3))
# info6 = tuple([1,2,3])
# info6 = tuple({1,2,3})
print(info6,type(info6))
info7 = float(12)
# info7 = float('12')
print(info7,type(info7))

数据类型内置函数

# # 类有关的方法
# isinstance()
# issubclass()
# hasattr()
# getattr()
# setattr()
# delattr()
class A:
    def __init__(self):
        pass
class A1(A):
    def get(self):
        print('A1')
    @staticmethod
    def cat(self):
        print('我是静态方法')
# issubclass()
if issubclass(A1,A):
    print('A1 是 A 的子类')
# isinstance()
obj = A1()
if isinstance(obj,A1):
    print('obj 是 A1的实例')
# hasattr()
if hasattr(A1,"get"):
    print('A1 存在get 方法会属性')
if hasattr(obj,"get"):
    print('obj实例 存在get 方法会属性')
# setattr()
setattr(A1,"name","jmz")
print(A1.__dict__)
# {'__module__': '__main__', 'get': <function A1.get at 0x00000000025099D8>, '__doc__': None, 'name': 'jmz'}
# getattr()
get_func = getattr(obj,"get")
get_func()
# A1
# delattr
delattr(A1,"name")
print(A1.__dict__)
# {'__module__': '__main__', 'get': <function A1.get at 0x00000000021799D8>, '__doc__': None}
# callable()   #  函数用于检查一个对象是否是可调用的
if not callable(obj):
    print('obj 实例不可再调用了')
if callable(A1):
    print('A1 类可以调用')

类有关内置函数

# # 其他类型
# divmod()  #
# input()   # 输入数据，
# open()    # 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
# enumerate() # 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
# pow()      # 方法返回 xy（x的y次方） 的值。pow(x,y)
# sum()      # 求和 sum(iterable)  如：sum([1,2,3])
# print()    # 打印
# super()    # 用于调用父类(超类)的一个方法
# filter()   # 过滤主要与匿名函数配合使用，过滤出符合条件的数据
# len()      # 获取数据长度
# range()    # 函数可创建一个整数列表，一般用在 for 循环中。  range(start, stop[, step])
# type()     # 1 可创建类（元类中介绍），2 可返回数据类型
# format()  # 格式化数据
# map()     # 主要和内置函数一起使用，map(func,iter)
# globals() # 返回所以的全局变量
# locals()  # 返回所有的局部变量
# help()    # 函数用于查看函数或模块用途的详细说明。如：help('getattr')
# iter()    # 函数用来生成迭代器
# next()    # 返回迭代器的下一个项目。
# id()      # 返回数据的内存地址
# 测试一下，未见过的
# bin()      #返回一个整数 int 或者长整数 long int 的二进制表示。
# bytearray()
# slice()
# dir()
# hex()
# hash()
# complex()
# __import__()
# compile()
# memoryview()
# round()
# zip()
# repr()
# vars()    # 函数返回对象object的属性和属性值的字典对象。
# frozenset()
# callable()
# divmod()  # 函数把除数和余数运算结果结合起来，
# bin()      #返回一个整数 int 或者长整数 long int 的二进制表示。
print(bin(10))
# 0b1010
print(bin(2))
# 0b10
# bytearray()   # 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
# class bytearray([source[, encoding[, errors]]])
print(bytearray([1,2,3]))
# bytearray(b'\x01\x02\x03')
print(bytearray('中国', 'utf-8'))
# bytearray(b'\xe4\xb8\xad\xe5\x9b\xbd')
# slice()   # 切片
arr = range(10)
print(arr[0:5:2])
print(arr[slice(None,5,2)])
# range(0, 5, 2)  两个都一样
print(arr[5])
# 5
print(arr[slice(5)])  # ==> slice(5)  == slice(None,5)
# range(0, 5)
# dir()    # 获取当前模块的属性列表。
print(dir())
# hex()   # 函数用于将10进制整数转换成16进制，以字符串形式表示
print(hex(10))
# 0xa
print(hex(1))
# 0x1
print(hex(16))
# 0x10
# hash()   # 用于获取取一个对象（字符串或者数值等）的哈希值。
print(hash('test'))
# -8237931458019123489
print(hash('dsjaidhadiaidhaishodiahodhaohdo'))
# -7824806465354315596
# print(hash([1,1,3]))    #  可变类型不可hash
# complex()  #函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
# class complex([real[, imag]])
# real -- int, long, float或字符串；
# imag -- int, long, float；
# __import__()
# 函数用于动态加载类和函数 。
# 如果一个模块经常变化就可以使用 __import__() 来动态载入。
# 和Python import 导入模块用法相同
# import sys <==>sys = __import__('sys')。
# import作用:
# 导入/引入一个python标准模块，其中包括.py文件、带有__init__.py文件的目录
# compile()   # 函数将一个字符串编译为字节代码。
str = 'for i in range(10):print(i)'
c = compile(str,'','exec')
exec(c)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# memoryview()  # 函数返回给定参数的内存查看对象(Momory view)
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])  # b
# 98
print(v[2])  # c
# 99
# round()  # 方法返回浮点数x的四舍五入值。 必须是数值
print(round(2.3))
# 2
print(round(3.6))
 #
# zip()  # 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
data = zip([1,2,3,4],['jmz','fff'])
print(data)  # <zip object at 0x000000000233E388> 迭代器
print(list(data))
# [(1, 'jmz'), (2, 'fff')]
# repr()  # 函数将对象转化为供解释器读取的形式。
# vars()    # 函数返回对象object的属性和属性值的字典对象。
class test:
    def __init__(self,name):
        self.name = name
    def set(self,name,value):
        self.name = value
print(test.__dict__)
print(vars(test))     # 两个一样
'''
 {'__module__': '__main__', '__init__': <function test.__init__ at 0x00000000024D99D8>, 
'set': <function test.set at 0x00000000024D9A60>, '__dict__': <attribute '__dict__' of 'test' objects>,
'__weakref__': <attribute '__weakref__' of 'test' objects>, '__doc__': None}
'''
# frozenset()   # 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
a =frozenset(range(10))
print(a)
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b = frozenset('runoob')
print(b)
# frozenset({'o', 'u', 'r', 'n', 'b'})
# divmod()  # 函数把除数和余数运算结果结合起来，
# divmod(a,b)
# a: 数字
# b: 数字
print(divmod(2,4))
# (0, 2)
print(divmod(5,4))
# (1, 1)

其他内置函数

以上是 python 三元表达式、列表推导式、生成器表达式、递归、匿名函数、内置函数 的全部内容， 来源链接： utcz.com/z/388912.html