Python学习笔记-Day14

今日大纲

一、内置函数2

二、匿名函数

三、递归函数

一、内置函数2

接Python学习笔记-Day13  1.4.1

1.4.2 数据结构相关

① 列表和元组

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

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

l1 = list((1,2,3))
print(l1)  #[1, 2, 3]
l2 = list({1,2,3})
print(l2)  #[1, 2, 3]
l3 = list({'name':'xiaoming','age':13})
print(l3)  #['name', 'age']

tup1 = tuple([1,2,3])
print(tup1)  #(1, 2, 3)
tup2 = tuple({'name':'xiaoming','age':13})
print(tup2)  #('name', 'age')

②相关内置函数

reversed：将一个序列反转，并返回此反转序列的迭代器，字典不能反转。

l1 = [1,2,3,4]
print(reversed(l1))  #<list_reverseiterator object at 0x0000026B679FA4E0>
for i in reversed(l1):
    print(i)   # 4 3 2 1

s = 'asdf'
for i in reversed(s):
    print(i)  # f d s a

dic = {'name':'xiaoming','age':13}
for i in reversed(dic):
    print(i)  #字典不能反转  TypeError: 'dict' object is not reversible

slice：构建一个切片对象，用于列表的切片

l1 = [i for i in range(10)]
l2 = l1[:5:2]
print(l2)   #[0, 2, 4],按照普通切片方法

sli_obj = slice(0,5,2)  #构建一个切片对象
print(l1[sli_obj])   #[0, 2, 4]

sli_obj1 = slice(3)
print(l1[sli_obj1])   #[0, 1, 2]

③ 字符串相关

str：将数据转化成字符串

format：1、提供参数，指定对其方式，<是左对齐，>是右对齐，^是居中

　　　　2、将整数转化成二进制’b‘、’n‘、unicode ’c‘、八进制’o‘、十六进制’x’、’X‘等

　　　　3、将浮点数用科学计数法或小数点计数法表示

bytes：unicode ----> bytes类型

a1 = '你好'
b1 = a1.encode('utf-8')  #用encode将utf-8转化成bytes类型
print(b1)  #b'xe4xbdxa0xe5xa5xbd'

b2 = bytes(a1,encoding='utf-8')  #用bytes函数转化成bytes类型
print(b2)   #b'xe4xbdxa0xe5xa5xbd'

bytearray：返回一个新字节数组，这个数组里的元素是可变的，并且每个元素值的范围是 0<= x < 256  。没啥用

ret = bytearray('hello',encoding='utf-8')
print(ret)  #bytearray(b'hello')
print(id(ret))  #1979800230744
print(ret[0])  #104  h在ascii码中的位置
ret[0] = 97  #将第一位改为a
print(ret)  #bytearray(b'aello')
print(id(ret))  #1979800230744  Id是相同的

memoryview：没啥用

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

ord：输入字符，找该字符在unicode编码的位置

chr：输入位置数字，找出相对应的字符，与ord相反

ascii：是ascii码表中的内容返回原值，不是返回u + 他在Unicode中的位置

print(ord('a'))  #97
print(ord('你'))  #20320

print(chr(97))  # a
print(chr(20320))  # 你

print(ascii('q'))  #'q'
print(ascii('你'))  #'u4f60'  转化成十进制就是 20320

repr：返回一个对象的str形式，原形毕露

　　   json、pickle序列化模块、特殊字符串、python字符串的区别

　　   格式化输出 %r

print('hello')  # hello
print(repr('hello'))  # 'hello'

print('今天天气%r' % ('很好'))  #今天天气'很好'
print('今天天气%s' % ('很好'))   #今天天气很好

④ 数据集合

dict：创建一个字典

set：创建一个集合

frozenset：返回一个冻集合，冻结后的集合不能再添加或删除任何元素

⑤相关内置函数

len：返回一个对象中元素的个数

sorted：对可迭代对象进行排序操作，只能列表使用，可加key，key为函数名，通过函数的规则进行排序。

　　　　默认是从小到大，加入reverse = True时按照从大到小。与 l1.sort()相比，原列表不发生改变

l1 = [1,3,3,2,9]
l1.sort()
print(l1)  #[1, 2, 3, 3, 9]  原列表改变

l2 = [2,3,4,6,4,1]
print(sorted(l2))  #[1, 2, 3, 4, 4, 6]
print(l2)  #[2, 3, 4, 6, 4, 1]  原列表不发生改变

l3 = [(1,100),(2,18),(4,250),(3,500)]
def func1(x):
    return x[1]
print(sorted(l3,key=func1))  #[(2, 18), (1, 100), (4, 250), (3, 500)]

enumerate：枚举，返回一个枚举对象

print(enumerate([1,2,3]))  #<enumerate object at 0x00000256F8351630>  迭代器

for i in enumerate([1,2,3]):
    print(i)  #(0, 1) (1, 2)  (2, 3)
    
for i in enumerate([1,2,3],100):
    print(i)   # (100, 1)  (101, 2)  (102, 3)

all：可迭代对象中，全是True才是True

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

print(all([1,2,3,0]))  #False
print(all([1,2,3,4]))  #True

print(any([1,[],{},0,()]))  #True

zip：将可迭代对象作为参数，将对象中的元素打包成一个元组，返回由这些元组组成的迭代器。

        如果可迭代对象中元素的数量不一致，则返回元组个与最短的对象相同。

        拉链方法：将多个iter纵向组成一个个的元组

l1 = [1,3,4,5]
tul = ('china','america','japan','korean')
dic = {'name':1,'age':2,'hobby':3}
for i in zip(l1,tul,dic):
    print(i)  #(1, 'china', 'name')    (3, 'america', 'age')    (4, 'japan', 'hobby')

filter：通过函数过滤可迭代对象，函数中return的是一个条件，返回一个迭代器。相当于生成器表达式的筛选模式

l = [i for i in range(10)]
def func1(x):
    return x>5
for i in filter(func1,l):
    print(i)  # 6 7 8 9

map：根据提供的函数对指定的序列做映射，返回一个迭代器，相当于生成器表达式中的循环模式

l = [i for i in range(3)]
def func(x):
    return x**2
for i in map(func,l):
    print(i)  #0 1 4 

二、匿名函数

匿名函数：lambda 表达式。普通函数有且只有返回值的寒素才能用匿名函数进行简化成一行函数。

　　　　    匿名函数不单独适应，一般和内置函数结合使用。

　　　　　内置函数中，可加入函数的有  min、max、sorted、map、filter

三、递归函数

递归函数：在一个函数中，调用这个函数本身。递归的默认最大深度为998。

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

可以对默认参数进行修改：

import sys
sys.setrecursionlimit(100000)
def func(n):
    print(n)
    n+=1
    func(n)
func(1)

def func(n):
    if n == 1:
        return 18
    else:
        return func(n-1) +2
print(func(4))