DAY14 内置函数-2，匿名函数

内置函数-2

　　数据结构相关：

　　　　str()：把数据类型转换为字符串类型。

　　　　list（）：将一个可迭代对象转换为列表（如果是字典的话，将字典的键转换为列表）

 

#把字符串转换为列表，会把字符串的每一个元素当成列表的元素
s1 = 'djfkdjf'
print(list(s1))
>>>
['d', 'j', 'f', 'k', 'd', 'j', 'f']

#把元组转换为列表
tu1 = (1,2,3,4)
print(list(tu1))
>>>
[1, 2, 3, 4]

#把字典转换为列表，会把字典的键转换为列表
dic1 = {'name':'he','age':23,'sex':'male'}
print(list(dic1))
>>>
['name', 'age', 'sex']

#把集合转换为列表
set1 = {1,2,3,4}
print(list(set1))
>>>
[1, 2, 3, 4]

 

　　　　tuple（）：将一个可迭代对象转换为元组（如果是字典的话，将字典的键转换为元组）

 

#把字符串变成元组，同列表一样的效果
s1 = 'jkjdk'
print(tuple(s1))
>>>
('j', 'k', 'j', 'd', 'k')

#把列表转换为元组
l1 = [1,2,3,4]
print(tuple(l1))
>>>
(1, 2, 3, 4)

#把字典转化为元组，会把字典的键变成元组的元素
dic1 = {'name':'he','age':23,'sex':'male'}
print(tuple(dic1))
>>>
('name', 'age', 'sex')

#把集合转换为元组
set1 = {1,2,3,4}
print(tuple(set1))
>>>
(1, 2, 3, 4)

 

　　　　dict(): 创建一个字典。

#用dict（）方法创建一个字典
dic1 = dict(name='he',age=23,sex='male')
print(dic1)
>>>
{'name': 'he', 'age': 23, 'sex': 'male'}

　　　  set()：创建一个集合。

#用set（）方法创建一个集合
set1 = set({1,2,3,4})
print(set1)
>>>
{1, 2, 3, 4}

　　　跟字符相关：

　　　　　ord（）：输入字符，返回unicode对应的编码位置。

print(ord('a'))
>>>
97
print(ord('b'))
>>>
98
print(ord('何'))           #能够返回中文，所以说明是unicode编码，而非ascii
>>>
20309

　　　　chr（）：输入unicode对应的编码位置，返回相应的字符。

print(chr(20309))
>>>
何
print(chr(98))
>>>
b

　　　 ascii（）：测试字符是否在ascii中，\u表示不在。

print(ascii('a'))
>>>
'a'
print(ascii('何'))
>>>
'\u4f55'

　　　repr（）：返回一个对象的string形式

print('alex')
print(repr('alex'))
print(repr('{“name":"he"}'))
>>>
alex
'alex'
'{“name":"he"}'

　　bytes（）：用于字符串转为bytes类型

s = '中国'
b = bytes(s,encoding='utf-8')
print(b)
>>>
b'\xe4\xb8\xad\xe5\x9b\xbd'

　　 可迭代类型相关：

　　　　all（）：检测可迭代对象中的元素，如果全是True，才返回True。

　　　any（）：检测可迭代对象中的元素，如果有一个True，则返回True。

l1 = [1,2,3,4,'']        #all()全部为True，才返回True。""空字符串对应的布尔值为False
print(all(l1))
>>>
False


l1 = [True,1,2,0,False]
print(any(l1))
>>>
True

　　　zip（）：俗成拉链方法，传入多个可迭代对象，把对应的元素打包成一个元组，并返回有这些元组的类表。

l1 = [1,2,3]
l2 = ['wusir','alex','taibai']
dic1 = {'name':'he','age':23,'sex':'male','city':'gz'}
>>>
[(1, 'wusir', 'name'), (2, 'alex', 'age'), (3, 'taibai', 'sex')]

谨记：以最短的可迭代对象为主，超过的方法无法合并。

　　　   reversed（）：翻转可迭代对象的元素，变成迭代器。

l1 = [11,22,33,44]
l2 = reversed(l1)
for i in l2:
    print(i)
>>>
44
33
22
11

　　　　sorted（）: 对可迭代对象进行排序，返回的是一个新列表，不影响原列表。因为底层是C写的，所以效率很高。

 

#一。复习之前列表的sort（）方法：
l1 = [1,2,3,6,5,8]
l1.sort()
print(l1)                #利用列表的sort（）方法排序，会影响原列表
>>>
[1, 2, 3, 5, 6, 8]


#二。使用内置函数sorted()排序
l1 = [1,2,3,6,5,8]
print(sorted(l1))
>>>
[1, 2, 3, 5, 6, 8]
print(l1)
>>>                               #利用sorted（）排序，返回的是一个新列表，不影响原列表。
[1, 2, 3, 6, 5, 8]


#三。sorted（）方法可以接受key，自定义排序的规则
l1 = ['dfjkfj','dkfjdjf','dkfkdfjkdfjkdjf','dkjfkdfjfdfdkfdkfj']

def lstlen(x):
    return len(x)

print(sorted(l1,key=lstlen,reverse=True))
>>>
['dkjfkdfjfdfdkfdkfj', 'dkfkdfjkdfjkdjf', 'dkfjdjf', 'dfjkfj']

 

　　　map（）：把一个可迭代对象中的每一个元素，放到函数中执行，返回一个迭代器。类似于列表推导式的循环模式。

def func1(x):
    return x**2
l1 = [0,1,2,3,4]
print(list(map(func1,l1)))
>>>
[0,1,4,9,16]

print([i**2 for i in range(0,5)])   #使用列表推导式的循环模式亦可完成
>>>
[0, 1, 4, 9, 16]

　　filter（）：把一个可迭代对象的每一个元素，放到函数中执行，满足条件的放入filter迭代器中，不满足的过滤掉；类似列表推导式的筛选莫斯。

def fun1(x):
    return x % 2 ==0

for i in filter(fun1,[1,2,3,4,5,6]):
    print(i)
>>>
2
4
6

 

匿名函数

　　匿名函数，以lambda关键字定义的函数，为了满足用一句话解决功能简单的函数。

　　格式：

　　　　　lambda  形参[..] :  返回值

　　使用方法：

 

#一.把lambda函数赋值给一个变量
plus_1 = lambda x : x+1
res = plus_1(1)
print(res)
>>>
2

#例子二：
#普通函数
def all_upp(s):
    '''把字符串全部转为大写'''
    return s.strip().upper()
print(all_upp('python'))

#匿名函数
all_upp = lambda s:s.strip().upper()
print(all_upp('python'))


#lambda的推荐使用
#如果有一些内置方法,带key参数，即接受函数为参数的，例如:min(),max(),sorted(),map(),filter()等
#那么lambda就可以作为其参数

my_list = [1,2,3,4,5,6,7]
def odd(*args):
    '''找到列表里面的所有奇数，并返回一个新列表'''
    new_list = []
    for i in args:
        if i % 2 ==1:
            new_list.append(i)
    return new_list
print(odd(*my_list))