'''

把列表推导中的[]换成()生成器表达式

其优点是节省内存，一次在内存中只产生一个值

'''

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))#

def age(n):

    return 18 if n==1 else age(n-1)+2

print(age(5))#

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'))#

print(chr(77))#M

print(bytes('大王叫我来巡山',encoding='utf-8'))

#b'\xe5\xa4\xa7\xe7\x8e\x8b\xe5\x8f\xab\xe6\x88\x91\xe6\x9d\xa5\xe5\xb7\xa1\xe5\xb1\xb1'

print(abs(-11))#

print(all(['a',0,1]))#False

print(any(['a',0,1]))#True

print(ascii('花花世界'))#'\u82b1\u82b1\u4e16\u754c'

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') #转换成二进制

 ''

 >>> format(97,'c') #转换unicode成字符

 'a'

 >>> format(11,'d') #转换成10进制

 ''

 >>> format(11,'o') #转换成8进制

 ''

 >>> format(11,'x') #转换成16进制 小写字母表示

 'b'

 >>> format(11,'X') #转换成16进制 大写字母表示

 'B'

 >>> format(11,'n') #和d一样

 ''

 >>> format(11) #默认和d一样

 ''

 #浮点数可以提供的参数有 '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位小数点

 ''

 >>> 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'

了解一下：format

 #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)'))

eval()和exec()

 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)

compile