python之内置函数(二)与匿名函数、递归函数初识

一、内置函数(二)

1、和数据结构相关（24）
列表和元祖（2）
list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
tuple：将一个可迭代对象转化成元组（如果是字典，默认将key作为元组的元素）

2、相关内置函数（2）
reversed：将一个序列翻转，并返回此翻转序列的迭代器。 *****
slice：构造一个切片模板，用于列表的切片。***

2-1、reversed()与列表的reverse()区分：
列表的reverse()只能列表使用：列表.reverse()，对原列表进行翻转，结果返回的还是列表。
内置函数reversed()，将一个序列翻转，结果是返回一个迭代器。

列表的reverse()

l1 = [1,3,4,2,6]
l1.reverse() #将列表进行翻转
print(l1)    #返回修改后的列表[6, 2, 4, 3, 1]

内置函数reversed()

reversed(l1) #生成一个迭代器
print(reversed(l1))  #一个地址
for i in reversed(l1):
    print(i)
# 结果：
# 用for循环输出迭代器的值
# 6 2 4 3 1

# 字符串使用reversed()
s1 = 'abcdefg'
for i in reversed(s1):
    print(i)
结果：
g f e d c b a

# 字典使用reversed() 报错
dic = {'name':'xiaoming','age':1000,'hobby':'oldwomen'} # 不行

2-2、slice：构造一个切片模板，用于列表的切片。 ***
l3 = [1,2,3,4,5,6,7,8,9,10]
sli_obj = slice(0,5,2)     #制作切片模板，索引从0到4，间隔取值
print(l3[sli_obj])            # [1 3 5]

l4 = ['a', 'b', 'c', 'd', 'e']
print(l4[sli_obj])            # ['a', 'c', 'e']

3、字符串相关（9）
3-1、str：将数据转化成字符串。

3-2、format:与具体数据相关，用于计算各种小数，精算等。 **
平常使用format情况较少，下面这种形式已经是最多的了，剩下的科学运算，需要用到的可自行研究。
字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test', '<20')) # 左对齐 (20是长度)
print(format('test', '>20')) # 右对齐
print(format('test', '^20')) # 居中对齐

3-3、bytes：unicode ---> bytes类型(单向的编码) ****

# 编码encode():
s1 = '小明'
b1 = s1.encode('utf-8')
print(b1)  # b'\xe5\xb0\x8f\xe6\x98\x8e'

# 解码decode():
s2 = b1.decode('utf-8')
print(s2) # 小明

# 用bytes()方法编码(单向)
a1 = '小白'
b1 = bytes(a1,encoding='utf-8')
print(b1)  # b'\xe5\xb0\x8f\xe7\x99\xbd'

# 不能用bytes()方法解码
a2 = bytes(b1,encoding='utf-8')
print(a2) # 报错

# 只能用decode()解码
a2 = b1.decode('utf-8')
print(a2) #小白

3-4、bytearry：返回一个字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
(bytearray其实也是一种编码的方法，不过bytearray可对编码后的字节进行修改，即对原数据进行修改)
例如：字符串 小明
b1 = bytearray('小明',encoding='utf-8')       #对小明进行编码，生成一串字节码(utf-8一个中文代表三个字节)
print(b1)           # bytearray(b'\xe5\xb0\x8f\xe6\x98\x8e')
print(b1[0])       # 229
b1[0] = 65        #对前三个字节进行修改(即修改中文'小')
b1[1] = 97
b1[2] = 104
print(b1)          # bytearray(b'Aah\xe6\x98\x8e')
print(b1.decode('utf-8'))     # 解码出来：Aah明

例如：字符串 hot
ret = bytearray('hot',encoding='utf-8')
print(id(ret))         # 2997820203056
print(ret)              # bytearray(b'hot')
print(ret[0])         # h的ASCII:104
ret[0] = 65          # 把索引0的ASCII值改为65(A)
print(ret)             # bytearray(b'Aot') hot索引0就改成了A
print(id(ret))       # 2997820203056 内存地址不变

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

3-6、ord:输入字符找该字符unicode编码的位置 **
print(ord('a'))    # 97
print(ord('中'))  # 20013

3-7、chr:输入位置数字找出其对应的unicode编码的字符 **
print(chr(97))         # a
print(chr(20013))   # 中

3-8、ascii:在ascii码中的就返回该值，不是则返回它在unicode的位置（16进制。） **
print(ascii('a'))     # 'a'
print(ascii('中'))   # '\u4e2d'

3-9、repr:返回一个对象的string形式（原形毕露） *****

print(repr('{"name":"xiaoming"}'))  #'{"name":"xiaoming"}'
print('{"name":"xiaoming"}')        # {"name":"xiaoming"}

格式化输出%r--->原封不动的写出来(基础数据类型都可接收)
字符串单双引号都默认是单引号
msg = 'xiaoming是%r的人' % ('德高望重')
print(msg) # xiaoming是'德高望重'的人

msg = 'xiaoming是%r的人' % ("德高望重")
print(msg) # xiaoming是'德高望重'的人

msg = 'xiaoming是%r的人' %(18)
print(msg) # xiaoming是18的人

msg = 'xiaoming是%r的人' %(True)
print(msg) # xiaoming是True的人

msg = 'xiaoming是%r的人' %({'name':'xiaming','age':18})
print(msg)  # xiaoming是{'name': 'xiaming', 'age': 18}的人

repr():可用于判断json pickle序列化模块 特殊字符串，python字符串的区别

4、数据集合（3）
4-1、dict：创建一个字典。
4-2、set：创建一个集合。
4-3、frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

5、相关内置函数（8）
5-1、len:返回一个对象中元素的个数。

5-2、sorted：对所有可迭代的对象进行排序操作。 *****
与列表的sort区分：
列表的sort方法是对原列表进行排序修改，并没有生成新的列表
内置函数sorted方法会形成一个新列表

l1 = [2,3,5,3,1,9,8,6]
l1.sort()
print(l1)   

print(sorted(l1)) # 形成了一个新列表
print(l1)         # 原列表不变

内置函数sorted还可以与函数结合使用
l2 = [(1,1000),(2,18),(4,250),(3,500)]

def func1(x):
    return x[1]

print(sorted(l2,key=func1))
#按第二个元素升序排序 [(2, 18), (4, 250), (3, 500), (1, 1000)]

print(sorted(l2,key=func1,reverse=True))
#按第二个元素降序排序 [(1, 1000), (3, 500), (4, 250), (2, 18)]

5-3、enumerate:枚举，返回一个枚举对象。****
返回的每个元素是元组，元组第一个元素是索引(默认从0开始)
第二个元素是可迭代对象的每个元素。
for i in enumerate([1,2,3]):
　　print(i)
结果：
(0, 1)
(1, 2)
(2, 3)

for i in enumerate([1,2,3],100):  # 修改索引，把索引设置成从100开始
　　print(i)
结果：
(100, 1)
(101, 2)
(102, 3)

for i,j in enumerate([1,2,3],100):
　　print(i,j)
结果：
100 1
101 2
102 3

5-4、all：可迭代对象中，全都是True才是True *** 多做条件判断
l1 = [1,'',[1,3],(2,4)]
print(all(l1))      #False 有一个元素是空

5-5、any：可迭代对象中，有一个True就是True *** 多做条件判断
l2 = [1,0,'',()]
print(any(l2))   #True

5-6、拉链方法：zip() 将多个iter纵向组成元素为元组的迭代器，以长度最小的iterable为标准长度 *****

l1 = [1,2,3,4]
tu1 = ('a','b','c')
dic = {'name':'xiaoming','age':18,'hobby':'girl','hometown':'guangzhou'}

zip(l1,tu1,dic)  #迭代器(生成器对象)

print(zip(l1,tu1,dic)) #迭代器地址：<zip object at 0x000002C878E6A6C8>

for i in zip(l1,tu1,dic):
    print(i)

#循环输出迭代器的内容：
(1, 'a', 'name')
(2, 'b', 'age')
(3, 'c', 'hobby')

5-7、filter：过滤，通过你的函数，过滤一个可迭代对象(类似于生成器表达式的筛选模式) 生成一个迭代器。 *****

l1 = [1,2,3,4,5,6]
def fun(x):
    return x % 2 == 0 #筛选出偶数
g = filter(fun,l1)  # filter(fun,l1)生成的是一个迭代器
print(g)
for i in g:
    print(i)
结果：
2 4 6

l2 = [(2,1),(3,4),(4,5)]
def fun2(x):
    return x[1] % 2 == 1 #筛选出第二个元素为奇数的元组
g = filter(fun2,l2)
for i in g:
    print(i)
结果：
(2, 1)
(4, 5)

5-8、map:会根据提供的函数对指定序列做映射。(循环修改并返回) 生成一个迭代器*****

l1 = [1,2,3,4,5,6]
def fun(x):
    return x**2 #返回每个元素的平方
g = map(fun,l1)
for i in g:
    print(i)
结果：1 4 9 16 25 36

 (min max filter返回的都是遍历的参数，map返回的是return的值)

二、匿名函数

有且只有返回值的函数才可以用匿名函数进行简化，一行函数，多与内置函数结合使用。
1、匿名函数表达式：
函数名 = lambda 参数 ：返回值

参数可以有多个，用逗号隔开
匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
返回值和正常的函数一样可以是任意数据类型

2、
def func2(x):
　　return x**2
上面函数就有且只有返回值，所以可以写成匿名函数：
func2 = lambda x: x*2      #func2是函数名，func2(参数)才是调用
print(func2(6))                  #调用并打印结果

3、匿名函数 不单独使用，多与内置函数结合。
l2 = [(1,1000),(2,18),(4,250),(3,500)]
print(sorted(l2,key=lambda x:x[1]))

4、例子

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

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

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

4,匿名函数可与三元运算结合
func = lambda x:x if x > 2 else x * 2

三、递归函数(自己调用自己)

1、人理解函数，神理解递归。
def func():
　　print(666)
　　func()
func()
结果：输出一段时间后会报错，因为
默认递归深度为998次，(官方给出的默认深度是1000，但实际上只有998次左右)
超过了就会报错

2、引用模块修改递归次数
import sys
sys.setrecursionlimit(100000)
n = 1
def func(x):
　　print(x)
　　x += 1
　　func(x)
func(n)
结果：3222
虽然设置了100000次，但是电脑跑不起呀，
一般电脑就跑3222次左右，这个会根据电脑性能而定。

3、
小明比小白大两岁 n = 4
小白比小狗大两岁 n= 3
小狗比小红大两岁 n = 2
小红24岁 n = 1
小明多少岁？

def age(n):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(n-1) + 2
age(4)   # 30

详解：
age(4)传进参数n=4：

def age(4):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(4-1) + 2
结果：age(3)+2

def age(3):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(3-1) + 2
结果：age(2)+2+2

def age(2):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(2-1) + 2
结果：age(1)+2+2+2

def age(1):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(n-1) + 2
结果：age(1)+2+2+2 ---> 24+2+2+2--->30