标签：return 函数 列表 匿名 joseph result print 三元 表达式

三元表达式与匿名函数

三元表达式

# 1.获取用户输入并且对比是否符合姓名否则判断失败
name = input('请输入您的用户名>>>:').strip()
if name == 'joseph':
    print('欢迎光临')
else:
    print('登陆失败')
"""
请输入您的用户名>>>:joseph
欢迎光临
"""
# 当我们使用三元表达式的时候就可以将上方的四行代码缩成一行节省我们的行数，并且一眼就可以看出我们想要写出的
是什么意思
print('欢迎光临' if name == 'joseph' else '登陆失败')
"""
欢迎光临
"""
2.比较两个数值之间的大小a == 18，b==20
a = 18
b = 20
if a > b :
    print(a)
else:
    print(b)
"""
20
"""
# 我们以前进行判断时需要进行判断就需要四步才可以写完整个程序使用三元表达式那么也可以节省使用行数
def max(a, b):
    return a if a > b else b
result = max(18, 20)
print(result)
# 我们使用三元表达式可以在一行完成整个式子，在if前方填写如果这个条件判断成功那么使用if前方的结果如果不成
功那么就使用后面的结果

各种生成式

1.列表生成式
	1.1在列表中给数值后面加66
   l1 = ['joseph', 'jason', 'kevin', 'tom', 'trump']# 首先建立一个列表给她传值
	l2 = []  # 建立一个新列表接受改变后的值
	for i in l1:  # 将列表1后面的数值一次循环出来
    	l2 = i + '66'  # 给数值加字符并传入l2
    	print(l2)  # 打印l2列表
   """
   joseph66
	jason66
	kevin66
	tom66
	trump66
   """
	1.2利用列表生成式传值
   l1 = ['joseph', 'jason', 'kevin', 'tom', 'trump']  # 建造一个列表
	l2 = [i + '66' for i in l1]  # 创建一个新列表并直接给她赋值，在括号中我们应该先看for再看左边，
	利用for将l1中的数值一次循环出来，我们再看左边需要给数值增加字符那么我们就在这个循环中一次给这些数
	值全部增加66
   print(l2)  # 打印l2列表
	"""
	['joseph66', 'jason66', 'kevin66', 'tom66', 'trump66']
	"""
   1.3利用列表生成式但是排除给kevin66
	l1 = ['joseph', 'jason', 'kevin', 'tom', 'trump']  # 建造一个列表
	l2 = [i + '66' for i in l1 if i != 'kevin']  # 在之前列表的基础上给他加个判断，如果不等于
	kevin才会执行前面的增值行为等于那么直接跳过
   print(l2)  # 打印l2
	"""
	['joseph66', 'jason66', 'tom66', 'trump66']
	"""
2.字典生成式
	2.1使用字典生成式循环0-5顾头不顾尾将他赋值给dic1列表
	dic1 = {i:'joseph' for i in range(5)}  # 利用字典生成式达式循环出来直接赋值
	print(dic1)  # 打印dic1
   """
   {0: 'joseph', 1: 'joseph', 2: 'joseph', 3: 'joseph', 4: 'joseph'}
   """
	2.2将我们不想让3增为字典时，那么就需要加一个条件
   dic1 = {i:'joseph' for i in range(5) if i != 3}  # 利用字典生成式直接赋值，并判断是否等于3，如
   果不等于3都继续执行如果等于3下一个
	print(dic1)  # 打印dic1
   """
   {0: 'joseph', 1: 'joseph', 2: 'joseph', 4: 'joseph'}
   """
3.集合生成式
	3.1
   set1 = {i for i in range(5)} # 生成一个集合生成式
	print(set1)  # 打印set1
	"""
	{0, 1, 2, 3, 4}
	"""
   3.2
	set1 = {i for i in range(5) if i != 3}  # 生成一个集合生成式并判断是否等于3
	print(set1)  # 打印set1
   """
   {0, 1, 2, 4}
   """

匿名函数简介

1.匿名函数的本质
	匿名函数本质上就是没有名字的函数，匿名函数一般搭配其他函数一起使用，用来节省代码行数，匿名函数一般
	都只有一行，里面不能有return，可以没有参数也可以有一个或多个参数
2.匿名函数的结构
	lambda '参数': '返回值'  
	result = lambda x: x + 1  # 首先使用匿名函数定义一个参数加上冒号接受返回值再赋值给result结果
	print(result)  #打印出结果但是返回的是一堆我们看不懂的东西所以我们需要给她加上一个数据形式来识
	别和接受这个结果
3.匿名函数的使用
	在程序之执行一遍的时候，为了方便我们就不需要再来定义一个函数，就是用匿名函数来代替，节省变量定义空
	间，也为了让程序变得更加简洁

匿名函数实际应用

1.max的使用取列表中的最大值
l1 = [1, 51, 5, 1, 561, 56, 51, 531, 561, 86, 41, 8, 4, 651, 9, 784561, 89746513, 65, 89748615,
4978, 46, 155, 98748,615535, 49, 7461]  # 创造一个列表纯瞎打的
result = max(l1)  # 使用max内置方法取得这个列表中的最大值并赋值给result结果
print(result)  # 接受结果并打印出来
"""
89748615
"""
2.min的使用,正好与max相反取最小值
l1 = [1, 51, 5, 1, 561, 56, 51, 531, 561, 86, 41, 8, 4, 651, 9, 784561, 89746513, 65, 89748615,
4978, 46, 155, 98748,615535, 49, 7461]   # 上面那个列表
result = min(l1)  # 使用min内置方法取得这个列表中的最小值并赋值给result结果
print(result)  # 接受结果并打印出来
"""
1
"""
3.在字典中匿名函数的使用
dic1 = {
    'joseph': 999,
    'jason': 666,
    'tony': 555,
    'trump': 9999999
}

def index(k):
    return dic1.get(k)
result = max(dic1,key = index)
print(result)
"""
trump
"""
result = max(dic1,key = lambda k : dic1.get(k))
print(result)
"""
trump
"""

重要内置函数

1.reduce（相加）参数为一个可迭代对象的每一个元素，是对每一个元素执行迭代操作（通过函数实现具体的操作），返
回一个具体的值而不是对象，需要先将reduce调用出来（底层拥有循环）
from functools import reduce   # 在py3中需要先将reduce调用出来
def func(x,y):  # 设置两个形参
    return x + y  # 返回值为形参相加
result = reduce(func,range(1,11))   # 使用reduce相加范围中的所有值,并赋值给结果
print(result)  # 打印结果
"""
55
"""
2.filter（过滤）通常用于过滤的功能，需要加入过滤的条件，过滤的对象为一个可迭代对象的每一个元素，返回一个
filter 对象，通过强转换才可以显示内容
l1 = ['a','b','c','d']  # 创造一个列表

def func(s):   # 添加一个形参
         if s != 'a':   # filter 只能过滤，有过滤条件形参如果不等于a那么继续运行
             return s  # 返回值为s

result = filter(func,l1)  
print(result)                
print(list(result))
"""
<filter object at 0x0000026181A55BB0>
['b', 'c', 'd']
"""
3.map（映射）参数为一个可迭代对象的每一个元素，是对每一个元素执行相同的操作（通过函数实现具体的操作），返回
一个map 对象，同样可以用强制转换来显示内容
l1 = ['a','b','c','d']
for i in l1:
    res = map(lambda joseph:'joseph' + i,i)
    print(res)
    print(list(res))
"""
<filter object at 0x0000024D2DA45BB0>
['b', 'c', 'd']
<map object at 0x0000024D2DA0F2E0>
['josepha']
<map object at 0x0000024D2DA0F130>
['josephb']
<map object at 0x0000024D2DA0F190>
['josephc']
<map object at 0x0000024D2DA0F1F0>
['josephd']
"""
4.zip（拉链，缝合）可以接收多个可迭代对象，然后把每个可迭代对象中的第i个元素组合在一起
a = [1, 2, 3 ]
b = [4, 5, 6]
c = zip(a, b)
print(list(c))
"""
[(1, 4), (2, 5), (3, 6)]
"""
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
b = ['a', 'b', 'c', 'd', 'e', 'f']
c = 'joseph'
result = zip(a, b, c)
print(result)
print(list(result))
"""
<zip object at 0x000001E9C2B1F5C0>
[(1, 'a', 'j'), (2, 'b', 'o'), (3, 'c', 's'), (4, 'd', 'e'), (5, 'e', 'p'), (6, 'f', 'h')]
"""

多层装饰器流程

def outter1(func1):
    print('执行到outter1')
    def inner1(*args,**kwargs):
        print('被装饰对像result1执行前所打印的对象')
        result1 = func1(*args,**kwargs)
        print('被装饰对象result1执行后所打印的对象')
        return result1
    return inner1

def outter2(func2):
    print('执行到outter2')
    def inner2(*args,**kwargs):
        print('被装饰对像result2执行前所打印的对象')
        result2 = func2(*args,**kwargs)
        print('被装饰对象result2执行后所打印的对象')
        return result2
    return inner2


def outter3(func3):
    print('执行到outter3')
    def inner3(*args,**kwargs):
        print('被装饰对像result3执行前所打印的对象')
        result3 = func3(*args,**kwargs)
        print('被装饰对象result3执行后所打印的对象')
        return result3
    return inner3


@outter1  #  index = outter1（outter2）
@outter2  #  outter2 = outter2（outter3）
@outter3  #   outter3 = outter3(index)
def index():
    print('执行到index')

index()

"""
首先我们在一个三重装饰器三重语法糖中，调用最下层的函数index然后看到上方有语法糖那么就是outer3 = outter3
（index）因为这是个多重语法糖所以不能先执行这个函数，先到上方outer3的地方开始执行，（执行到outer3）返回
下方语法糖运行到第二层语法糖 outer2 = outer2（outer3）执行到outer2所以我们要去上方函数outer处执行（执
行到outer2）返回下方第三重语法糖index = outer1（outer2）所以我们又需要取上方第一个函数寻找outer1执行
（执行到outer1）执行完outer1终于到index开始执行inner1，return返回 inner1所打印的结果执行前的值 执行
到inner2返回值return inner2 打印inner2结果执行前的值，接下来走到inner3的函数，inner3返回值return inner3 
打印inner3结果执行前的值，正式执行到我们的函数index的步骤到上方找到result3执行并得到返回结果打印执行后的
对象，转向result2执行并得到返回结果打印执行后的结果，最后走到result1执行并打印返回值。
"""

有参装饰器流程

def outter(stdcall):
    def func(user_name):
        def inner(*args,**kwargs):
            name = input('请输入您的用户名>>>:').strip()
            pwd = input('请输入您的密码>>>:').strip()
            if stdcall == 'list':
                print('调用列表中的数据值进行判断')
                result = user_name(*args,**kwargs)
                return inner
            elif stdcall == 'dict':
                print('调用字典中的数据值进行判断')
                result = user_name(*args,**kwargs)
                return inner
            elif stdcall == 'a.txt':
                print('调用文件中的数据值进行判断')
                result = user_name(*args,**kwargs)
                return inner
            else:
                print('暂无该调用方式')
        return inner
    return func


@outter('list')
def index():
    print('通过index打印的值')
index()
"""
首先我们在下方调用index函数，到上方找到index开始执行，看到上方有装饰器语法糖@outer并且语法糖内部有实参那
么我们就需要先拿着这个实参去上方找到对应的函数位置并将内部实参传入内部与实参对应的形参stdcall并继续往下执
行到func函数得到func的返回值func函数自己本身开始执行func内部的代码，函数inner由inner接受两个实参并继续
往下执行，获取用户名的输入，获取用户密码的输入并且获取用户选择的数据存储地址进行对接验证，如果选择列表那
么我们从列表中获取数据那么我们就从列表调取数据并使用for循环进行比对，如果成功通过那么打印成功并收到返回值
inner的返回值，失败的话呢就给用户提示您输入的用户名或密码错误，如果使用字典进行判断的话那么我们也是从字
典取值进行比对如果成功则打印成功并收到inner的返回值失败还是打印用户名或密码错误，如果选择的是文件的话就
需要从文件中调取数据with open（r'a.txt''r'encoding=utf8）as f:调取值进行比对成功得到返回值失败用户名
或密码错误。
"""

标签：return,函数,列表,匿名,joseph,result,print,三元,表达式
来源： https://www.cnblogs.com/joseph-bright/p/16455830.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。