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

目录

• 一 三元表达式
• 二 列表推到
• 三 生成器表达式
• 四 递归
• 五 匿名函数
• 六 内置函数

---

一、三元表达式

def max(x,y):
    return x if x>y else y
print(max(10,12))

name=input('>>>')
res='sb' if name=='alex' else 'nb'
print(res)
'''
name=input('>>>')
res='sb'
if name=='alex':
    print(res')
else:
    print('nb')
'''

二、列表推导

egg_list=[]
for i in range(10):
    egg_list.append('鸡蛋%s'%i)
print(egg_list)

egg_list=['鸡蛋%s'%i for i in range(10)]
print(egg_list)

'''
优点是方便、改变了编程习惯，可被称为声明式编程
'''

扩展：

（一）字典推导式

　　将字典的值和键对调

dic = {'a':10,'b':12}
dic_frequery = {dic[k]:k for k in dic}#字典推导式
print(dic_frequery)
{10: 'a', 12: 'b'}

　　合并大小写对应的value，将键改为全小写

dic={'a':12,'b':21,'A':32,'Z':44}

dic_frequery = {
    k.lower():dic.get(k.lower(),0)+dic.get(k.upper(),0) 
    for k in dic.keys()
}

print(dic_frequery)

{'a': 44, 'b': 21, 'z': 44}

（二）集合推导式

li = {1,2,3,4,5,2,3,5,7,8}
s = {i*i for i in li}
print(s)
{64, 1, 4, 9, 16, 49, 25}

三、生成器表达式

'''
把列表推导中的[]换成()生成器表达式
其优点是节省内存，一次在内存中只产生一个值
'''
bamboo=('竹节%s节'%i for i in range(1,11))
print(bamboo)#生成器表达式内存地址
print(next(bamboo))
print(list(bamboo))

names=['cindy','sara','chengjie','mark']
li=(i.capitalize() for i in names)
print(list(li))#['Cindy', 'Sara', 'Chengjie', 'Mark']

with open('a.txt',encoding='utf-8') as f:
    print(max(len(line) for line in f))# 选出最长一行
    print(sum(len(line) for line in f))
    info=[line.split() for line in f]
    print(info)

四、递归

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

#直接调用
items=[1,[2,[3,[4,[5,[6,[7,[8,[9,[0,]]]]]]]]]]
def tell(l):
    for item in l:
        if type(item) is not list:
            print(item)
        else:
            tell(item)
tell(items)

#间接调用
def age(n):
    if n==1:
        return 18
    return age(n-1)+2

print(age(5))#26

def age(n):
    return 18 if n==1 else age(n-1)+2
print(age(5))#26

def foo():
    print('from foo')
    foo()
foo()#递归报错，超过最大限制

# 调用函数会产生局部的名称空间，占用内存，因为上述这种调用会无需调用本身，python解释器的内存管理机制为了防止其无限制占用内存，对函数的递归调用做了最大的层级限制

# 可以修改递归最大深度

#import sys
#sys.getrecursionlimit()
#sys.setrecursionlimit(2000)
#
#def f1(n):
#    print('from f1',n)
#    f1(n+1)
#f1(1)

#虽然可以设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能无限递归，而且无限制地递归调用本身是毫无意义的，递归应该分为两个明确的阶段，回溯与递推

'''

回溯就是从外向里一层一层递归调用下去，回溯阶段必须要
　　1.有一个明确地结束条件，
　　2.每进入下一次递归时，问题的规模都应该有所减少（否则，单纯地重复调用自身是毫无意义的）,递推就是从里向外一层一层结束递归
　　3.python中没有递归优化

'''

五、匿名函数

匿名函数就是没有名字，与函数有相同的作用域，但匿名意味着引用计数为0。使用一次就释放，除非让它有名字，但是让它有名字就失去意义了。

应用：

　　1. 使用Python写一些执行脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。

　　2. 对于一些抽象的，不会别的地方再复用的函数，有时候给函数起个名字也是个难题，使用lambda不需要考虑命名的问题。

　　3. 使用lambda在某些时候让代码更容易理解。

lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值。lambda语句构建的其实是一个函数对象。

print(lambda x,n:x**n)

filter(lambda x: x % 3 == 0, foo)
map(lambda x: x * 2 + 10, foo)
reduce(lambda x, y: x + y, foo)

六、内置函数

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

salaries={
    'aa':1200,
    'bb':342,
    'cc':3456,
    'dd':3455
}
def get(k):
    return salaries[k]
print(max(salaries,key=get))#key必须是个函数，该函数必须有返回值

#max()
print(max(salaries,key=lambda k:salaries[k]))

#min()
print(min(salaries,key=lambda k:salaries[k]))

#sorted()默认升序即从小到大，以列表形式返回
salaries=sorted(salaries,key=lambda k:salaries[k])
print(salaries)
#sorted()降序即从大到小
salaries=sorted(salaries,key=lambda k:salaries[k],reverse=True)
print(salaries)

res=map(lambda k:salaries[k],salaries)#得到map的映射对象,是个迭代器
#print(res.__next__())
print(list(res))

name=['aa','bb','cc']
res=map(lambda x:x+'__nb' if x=='cc' else x+'__sb',name)
print(list(res))#['aa__sb', 'bb__sb', 'cc__nb']

from functools import reduce
l=['it','name','is','mage','mage','is','a','little','dog']
res=reduce(lambda x,y:x+' '+y,l)
print(res)

names=['aa_','bb_','cc*','dd_']
res=filter(lambda x:True if x.endswith('_') else False,names)
print(list(res))

res=filter(lambda x:x.endswith('_'),names)
print(list(res))

num=[1,3,3,65,3,4,6,8,5,65]
res=filter(lambda x:x>22,num)
print(list(res))

print(ord('A'))#65
print(chr(77))#M
print(bytes('大王叫我来巡山',encoding='utf-8'))
#b'xe5xa4xa7xe7x8ex8bxe5x8fxabxe6x88x91xe6x9dxa5xe5xb7xa1xe5xb1xb1'

print(abs(-11))#11
print(all(['a',0,1]))#False
print(any(['a',0,1]))#True
print(ascii('花花世界'))#'u82b1u82b1u4e16u754c'

print(bin(3))#0b11
print(bool(0))#False
print(callable(int))#True
print(classmethod(int))#<classmethod object at 0x00000166BD7BB278>

#字符串可以提供的参数 's' None
>>> format('some string','s')
'some string'
>>> format('some string')
'some string'

#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #转换成二进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'
>>> format(11,'X') #转换成16进制 大写字母表示
'B'
>>> format(11,'n') #和d一样
'11'
>>> format(11) #默认和d一样
'11'

#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科学计数法，默认保留6位小数
'3.141593e+08'
>>> format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
>>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
'3.14E+08'
>>> format(314159267,'f') #小数点计数法，默认保留6位小数
'314159267.000000'
>>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数
'3.141593'
>>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
'3.14159267'
>>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
'3.1415926700'
>>> format(3.14e+1000000,'F')  #小数点计数法，无穷大转换成大小字母
'INF'

#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'

#1、语法
# eval(str,[,globasl[,locals]])
# exec(str,[,globasl[,locals]])

#2、区别
#示例一：
s='1+2+3'
print(eval(s)) #eval用来执行表达式，并返回表达式执行的结果
print(exec(s)) #exec用来执行语句，不会返回任何值
'''
6
None
'''

#示例二：
print(eval('1+2+x',{'x':3},{'x':30})) #返回33
print(exec('1+2+x',{'x':3},{'x':30})) #返回None

# print(eval('for i in range(10):print(i)')) #语法错误，eval不能执行表达式
print(exec('for i in range(10):print(i)'))

compile(str,filename,kind)
filename:用于追踪str来自于哪个文件，如果不想追踪就可以不定义
kind可以是：single代表一条语句，exec代表一组语句，eval代表一个表达式
s='for i in range(10):print(i)'
code=compile(s,'','exec')
exec(code)


s='1+2+3'
code=compile(s,'','eval')
eval(code)