Day14 python基础---内置函数2、匿名函数、递归函数初识

一，内置函数2

1.数据结构相关（24个）

# 　list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）
# 　tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）
#   str：将数据转化成字符串

# 　reversed：将一个序列翻转，并返回此翻转序列的迭代器。  *****
#
l1 = [1,3,4,2,6]
s1 = 'abcdefg'
dic = {'name':'alex','age':1000,'hobby':'oldwomen'}   # 报错

print(reversed(l1))
for i in reversed(l1):
    print(i)
for i in reversed(s1):
    print(i)
for i in reversed(dic):
    print(i)

# 　slice：构造一个切片对象，用于列表的切片。  ***
l1 = [i for i in range(10)]
l2 = l1[:5:2]
l3 = [i for i in range(10,20)]
sli_obj = slice(0,5,2)
print(l3[sli_obj])
l4 = ['a', 'b', 'c', 'd', 'e']
print(l4[sli_obj])

# format:与具体数据相关，用于计算各种小数，精算等。 **
print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))

#  bytes：unicode类型单方面转为bytes 类型  ****
a1 = '太白'
b1 = bytes(a1,encoding='utf-8')
print(b1)

#对比encode 和 decode
a1 = '太白'
print(a1.encode('utf-8'))
print(a1.encode('utf-8').decode())

#  bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
 # [97,108,101,120]
ret = bytearray('alex',encoding='utf-8')
print(id(ret))
print(ret)        # bytearray(b'alex')  十进制utf-8码
print(ret[0])      # 97     通过切片得出单个字符的十进制utf-8码
ret[0] = 65       # 根据切片修改
print(ret)  # bytearray(b'Alex')
print(id(ret))     #修改后，内存地址不变

# memoryview
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))  # 6     #[xe4,xbd,xa0,xe5,xa5,xbd]
print(ret)  # <memory at 0x000001D3D6FCD048> 
print(bytes(ret[:3]).decode('utf-8'))  # 你
print(bytes(ret[3:]).decode('utf-8'))  # 好

# ord:输入字符找该字符编码 unicode  的位置  **
print(ord('a'))
print(ord('中'))

# chr:输入位置数字找出其对应的字符 unicode **
print(chr(97))
print(chr(20013))

# ascii:是ascii码中的返回该值，不是则返回他在unicode的位置（16进制。） **
print(ascii('a'))
print(ascii('中'))   # 'u4e2d'

# repr:返回一个对象的string形式（原形毕露）。  *****
print('alex')
print(repr("ale,x"))
print(repr("{'alex':'sb'}"))

#repr应用1：
  json pickle序列化模块 特殊字符串，python字符串的区别

# repr应用2: 格式化输出 %r
msg = 'alex 是 %r的人' % ('德高望重')
print(msg)

#  sorted：对所有可迭代的对象进行排序操作。 *****
l1 = [2,3,5,3,1,9,8,6]
l1.sort()
print(l1)
print(sorted(l1))  # 形成了一个新列表:[1, 2, 3, 3, 5, 6, 8, 9]
print(l1)          # 原列表不变:[2, 3, 5, 3, 1, 9, 8, 6]

l2 = [(1,1000),(2,18),(4,250),(3,500)]
print(sorted(l2))  #按元素的第一个元素大小排序

def func1(x):
    return x[1]
print(sorted(l2,key=func1,reverse=True))  #按元祖的第二个元素大小排序

#　enumerate:枚举，返回一个枚举对象。
print(enumerate([1,2,3]))
for i in enumerate([1,2,3]):
    print(i)
for i in enumerate([1,2,3],100):
    print(i)

#  all：可迭代对象中，全都是True才是True  ***  多做条件判断
print(all([1,'',[1,3],(2,4)]))
#  any：可迭代对象中，有一个True 就是True ***  多做条件判断
print(any([1,0,'',()]))

#  zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。 *****
#  如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
#  又称：拉链方法：将多个iter 纵向组成一个个元组，通俗的讲：就是以最短的可迭代对象为主，纵向按传入顺序组成一个元组。

l1 = [1, 2, 3, 4, 5, 6]
tu1 = ('alex', '太白', 'wusir', '女神')
dic = {'name': '日天', 'age': 28, 'hobby': 'tea', 'weight': 100,'face':'cool'}
print(zip(l1,tu1,dic))
print('__next__' in dir(zip))
for i in zip(l1, tu1, dic):
        print(i)

#执行结果：

(1, 'alex', 'name')
(2, '太白', 'age')
(3, 'wusir', 'hobby')
(4, '女神', 'weight')

# 　filter：过滤· 迭代器。 *****   筛选模式
l1 = [i for i in range(10)]
def func1(x):
    return x % 2 == 0
print(list(filter(func1,l1)))

# map:会根据提供的函数对指定序列做映射。***** 循环模式
l1 = [1,2,3,4]
def func(x): return x**2
print(list(map(func,l1)))

#对比：列表推导式
# print([i**2 for i in l1])

总结：

#常用且重要：
print sum reversed
# 参数含key的内置函数 :
min max map sorted filter zip

二，匿名函数  lambda表达式

#   普通函数，有且只有返回值的函数才可以用匿名函数进行简化，简化为一行函数
#   匿名函数，不单独使用，多与内置函数结合
#结构：
#函数名 = lambda 参数 ： 返回值
#例：
    func2 = lambda x: x*2

    l2 = [(1,1000),(2,18),(4,250),(3,500)]
    print(sorted(l2,key=lambda x:x[1]))

　　func = lambda x:x if x > 2 else x * 2　 #匿名函数与三元表达式结合使用

#匿名函数与内置函数结合使用
#练习：
#利用内置函数匿名函数将dic={'k1':10,'k2':100,'k3':30}按照值进行排序。
#print(sorted(dic,key=lambda x:dic[x]))
print(sorted(dic.items(),key=lambda x:x[1]))

# 利用内置函数匿名函数 计算列表[1,5,7,4,8]的每个数的2倍。
print(list(map(lambda x:x*2,[1,5,7,4,8])))

# 利用内置函数匿名函数，[5,8,11,9,15]将值大于10的留下来。
print(list(filter(lambda x: x>10,[5,8,11,9,15])))

三，递归函数初识

    递归函数概念：在一个函数里再调用这个函数本身。

　递归最大深度：998

#递归深度验证：
n = 0
def func(x):
    x += 1
    print('第%d次'% x)
    func(x)
func(n)

　  修改递归深度：

#修改递归深度为100000（实际上只能到达3222左右，与性能关系较大）
import sys
print(sys.setrecursionlimit(100000))

　 递归函数示例：

def age(n):
    if n == 1:
        return 40
    else:
        return age(n-1)+2

print(age(4))


#age(4) = age(3) + 2 
#age(3) = age(2) + 2
#age(2) = age(1) + 2
#age(1) = 40