内置函数2 递归函数

列表和元祖

list ： 将一个可迭代对象转换化列表（如果是一个字典，默认将key 作为列表的元素，那个值是不会加进来的）

tuple： 将一个可迭代对象转化成元组（如果是字典，默认将key作为列表的元素）

l = list({'k1':1,'k2':2})
print(l)
tu = tuple({'k1':1,'k2':2})
print(tu)

['k1', 'k2']
('k1', 'k2')

reversed : 将一个序列翻转，并返回此翻转序列的迭代器

l = [1,5,7,9,3,2,4]
print(list(reversed(l)))---------------------》[4, 2, 3, 9, 7, 5, 1]
  结果是一个迭代器  注意

如果不用 list 包起来的话 ---》<list_reverseiterator object at 0x00000000028E0A58>
 这样人是识别不了的  不然就for循环 可以循环打印出来     

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：构造一个切片对象，用于列表的切片，其实就是做一个切片的东西设好配置，对列表用就直接切之前配置好的。

l3 = [i for i in range(10,20)]
sli_obj = slice(0,5,2)
print(l3[sli_obj])
-----------------------0到5 就是10，11，12，13，14  步长2
            输出  [10, 12, 14]    

str： 将数据转化成字符串

format：与具体数据相关，用于计算各种小数，精算等，展示一个有点意思的 其他的一般用不到。

# print(format('test', '<20'))
# print(format('test', '>20'))
# print(format('test', '^20'))

----------------    下面是效果  
test                
                test
        test        

bytes : unicode -------->bytes 类型  ---其实就是一个单方面的转换  没什么卵用 知道就行了

a1 = '太白'
b1 = bytes(a1,encoding='utf-8')
print(b1,type(b1))
------------------------
输出    b'xe5xa4xaaxe7x99xbd' <class 'bytes'>

id  内存地址：

数字在-5~256 的都在小数据池中，剩下的所有正数 因为存在同一个代码块复用所以id一样，而-6至更小的小数都是重新开辟空间。    负数就是不同  记住

ord：输入字符 查找该字符编码 unicode 的位置 加括号就用

chr：输入位置数字 找出其对应的字符 unicode   和上面 呼应

ascii： 在ascii码中 返回该值，不是则返回他在Unicode中的位置（注意：返回的是十六进制）

print （ascii（' 中 ' ））   #  ' u4e2d '

repr : 返回一个对象的string形式（原形毕露）。其实就是返回原原本本的，插一个比较重要的知识点

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

sorted：对所有可迭代的对象进行排序操作（立马有一个默认方法 reverse = False 不会显示 这个是从小到大，如果等于True 那就是从大到小）

l1 = [2,3,5,3,1,9,8,6]
l1.sort()
print(l1)
print(sorted(l1)) # 形成了一个新列表
print(l1) # 原列表不变
--------------------
sort  是只对列表可以用  
--------------- 下面这个要注意  总结的时候就搞混了

l2 = [(1,1000),(2,18),(4,250),(3,500)]
def func1(x):
    return x[1]
print(sorted(l2,key=func1,reverse=True))  #比的是第二位置的数  从大到小
　　[(1, 1000), (3, 500), (4, 250), (2, 18)]
print(sorted(l2,key=func1))  #比的是第二位置上的数  默认 从小到大
　　[(2, 18), (4, 250), (3, 500), (1, 1000)]
print(sorted(l2,reverse=True)) #写出等于True 从大到小（没写key= 没传元素进函数 直接比的第一位置数）
[(4, 250), (3, 500), (2, 18), (1, 1000)]  #，直接比第一个   一般不写出reverse默认从小到大 里面内置方法是reverse=False
l= [1,9,3,4,2,6,7,8]
print(list(reversed(l)))   #这个是reversed（翻转）   不是 reverse 这个是sorted的内置方法reverse
print(sorted(l))

all ： 可迭代对象中，全部都是True 才是True 全真 就真

any：可迭代对象中，有一个True 就是 True  有一个为真 就真

zip：函数用于将可迭代的对象作为参数，讲对象中对应的元素打包成一个个元组，然后返回这些元素组成的列表

 　　如果各个迭代器的元素 个数不一致，则返回列表长度和最短的对象相同

    记住  ！！！ 拉链方法！！！  看代码

l1 = [1,2,3,5,6,7]
tu1 = ('alex','太白', 'wusir', '女神')
dic = {'name': '日天', 'age':28, 'hobby': 'tea', 'weight':100}
print(zip(l1,tu1,dic))
for i in zip(l1,tu1,dic):
    print(i)
------------------
<zip object at 0x0000000002694188>
(1, 'alex', 'name')
(2, '太白', 'age')
(3, 'wusir', 'hobby')
(5, '女神', 'weight')
------------------------第二个元组中   只有4个元素 那么就最多4条数据，拉链方法
                                其他多的 没元素和他对齐 呈现一个列表了
                                  注意字典的话 就是key    没值的事情

filter ： 过滤 出来的是迭代器-------

l1 = [i for i in range(10)]
def func1(x):
    return x % 2 == 0
print(list(filter(func1,l1))) #过滤，筛选出来的就是迭代器
print(next(filter(func1,l1)))  #next一下 就是一个值  0
----------------
 结果  [0, 2, 4, 6, 8]
          0    

map： 会根据提供的函数对指定序列做映射，  循环模式  下面展示 一题两做

l1 = [1,2,3,4]
def func(x):
    return x**2
print(list(map(func,l1)))

print([i**2 for i in l1])   # 列表推导式  一行      列表中每一个数的平方 也可以i*i

重 # print() sum reversed
点 #可以有 key 的: min max map sorted filter zip

匿名函数： lambda 表达式

普通函数 有且只有返回值的函数才可以用匿名函数进行简化，一行函数 看下面 范例

def func2(x):
    return x*2
print(func2(2))
--------------------------
func2 = lambda x : x**2
print(func2(2))
-------------------------------------解释一波：lambda后面x 就是传到def func2括号里的
                                                            后面x*2  x怎么怎么样 就是return的
                                                        具体的我也没搞太懂

~~~~~~~~~~~~~~~~~~

l2 = (1,1000),(2,18),(4,250),(3,500)     照第二个值 从小到大 排序

print(sorted(l2,key=lambda x:x[1]))
-----------------------------------------------------------------------------
利用内置函数匿名函数将dic按照值进行排序。
dic={'k1':10,'k2':100,'k3':30}         

print(sorted(dic.items(),key=lambda x:x[1]))
----------------------------------------------------------
利用内置函数匿名函数 计算列表的每个数的2倍。

print(list(map(lambda x:x*2,[1,5,7,4,8])))
-------------------------------------------------
利用内置函数匿名函数，将值大于10的留下来。

print(list(filter(lambda x: x>10,[5,8,11,9,15])))

-------------------------------
# func = lambda x:x if x > 2 else x * 2  也可以三元运算  好像是这样说的 一种方式

 人理解函数，神理解递归~

默认递归深度 ：998

n = 1
def func(x):
    print(x)
    x += 1
    func(x)
func(n)


也可以自己加
# import sys
# sys.setrecursionlimit(100000)
n = 1
def func(x):
    print(x)
    x += 1
    func(x)
func(n)      

# alex  比 wusir 大两岁 n = 4
# wusir 比日天 大两岁  n= 3
# 日天 比太白 大两岁  n = 2
# 太白 24岁 n = 1
-----------------
def age(n):
    if n == 1:
        return 24
    else:
        return age(n-1) + 2
print(age(4))