内置函数2
和数据结构相关
列表与元祖
- list:将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
- tuple:将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。
二者多用于数据类型的转换，需要注意的是以下三点：
- 二者只可用于可迭代对象类型的转换。
- 当被转换数据类型为字典时，默认只保留字典的键作为元素。
- 当被转换数据类型为字符串时，会将该元素迭代的增加到列表或元祖中。
# list
tu = (1,2,3,4)
se = {1,2,3,4}
di = {1:2,2:3,3:4,4:5}
s = '1234'
a = 1234
print(list(tu))
print(list(se))
print(list(di))
print(list(s))
print(list(a))
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]
['1', '2', '3', '4']
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
9 print(list(di))
10 print(list(s))
---> 11 print(list(a))
TypeError: 'int' object is not iterable
# tuple
li = [1,2,3,4]
se = {1,2,3,4}
di = {1:2,2:3,3:4,4:5}
s = '1234'
a = 1234
print(tuple(tu))
print(tuple(se))
print(tuple(di))
print(tuple(s))
print(tuple(a))
(1, 2, 3, 4)
(1, 2, 3, 4)
(1, 2, 3, 4)
('1', '2', '3', '4')
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
9 print(tuple(di))
10 print(tuple(s))
---> 11 print(tuple(a))
TypeError: 'int' object is not iterable
相关内置函数
- reversed：将一个序列翻转，并返回此翻转序列的迭代器。
- slice：构造一个切片对象，用于列表的切片。
reversed函数主要用于字符串、列表，在字典、元祖、集合中不可用，其会生成一个迭代器，若需对其取值，可通过for循环或者将其转换为list.
# reversed
li = [1,2,3,4]
s = '1234'
print(list(reversed(li)))
print(list(reversed(s)))
m = reversed(s)
for i in m:
print(i)
[4, 3, 2, 1]
['4', '3', '2', '1']
4
3
2
1
a = 1234
b = reversed(a) #int型不可使用reversed函数
b
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
1 a = 1234
----> 2 b = reversed(a)
3 b
TypeError: 'int' object is not reversible
se = {1,2,3,4}
sf = reversed(se) # 集合型不可使用reversed函数
sf
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
1 se = {1,2,3,4}
----> 2 sf = reversed(se)
TypeError: 'set' object is not reversible
di = {1:2,2:3,3:4,4:5}
dj = reversed(di) #字典不可使用reversed函数
dj
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
1 di = {1:2,2:3,3:4,4:5}
----> 2 dj = reversed(di)
3 dj
TypeError: 'dict' object is not reversible
slice函数主要用于生成一种切片规则，以对不同可切片对象按照相同规则进行切片。
# slice
l1 = [ i for i in range(10)]
l2 = [ i for i in range(20)]
l3 = ['h','i','D','a','L','a','o']
t1 = (1,2,3,4,5,6)
s1 = '123456'
sli_obj = slice(0,5,2)
print(l1[sli_obj])
print(l2[sli_obj])
print(l3[sli_obj])
print(t1[sli_obj])
print(s1[sli_obj])
[0, 2, 4]
[0, 2, 4]
['h', 'D', 'L']
(1, 3, 5)
135
字符串相关
- str:将数据转化成字符串
- format:与具体数据相关，用于计算各种小数，精算等。
- bytes：用于不同编码之间的转化。
- bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
- memoryview
- ord:输入字符找该字符编码的位置
- chr:输入位置数字找出其对应的字符
- ascii:是ascii码中的返回该值，不是则返回他在unicode的位置（16进制。）
- repr:返回一个对象的string形式（原形毕露）
str函数主要用于将对象转换为字符串类型
# str
li = [1,2,3,4]
se = {1,2,3,4}
di = {1:2,2:3,3:4,4:5}
a = 1234
tu = (1,2,3,4)
b = True
print(str(li))
print(str(se))
print(str(di))
print(str(a))
print(str(b))
[1, 2, 3, 4]
{1, 2, 3, 4}
{1: 2, 2: 3, 3: 4, 4: 5}
1234
True
format函数之前主要用于格式化字符串，但其同时还可用于设置对齐方式、计算各种小数，精算等。
#format
#字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))
#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
print(format(3,'b')) #转换成二进制
print(format(97,'c')) #转换unicode成字符
print(format(11,'d')) #转换成10进制
print(format(11,'o')) #转换成8进制
print(format(11,'x')) #转换成16进制 小写字母表示
print(format(11,'X')) #转换成16进制 大写字母表示
print(format(11,'n')) #和d一样
print(format(11)) #默认和d一样
test
test
test
11
a
11
13
b
B
11
11
bytes函数主要用于不同编码之间的转换，生成的是一个bytes类型的变量。
# bytes：unicode ---> bytes 类型
a1 = 'hi大佬'
print(a1.encode('utf-8'))
print(a1.encode('utf-8').decode())
# bytes：unicode ---> bytes 类型
a1 = 'hi大佬'
b1 = bytes(a1,encoding='utf-8')
print(b1)
b'hi\xe5\xa4\xa7\xe4\xbd\xac'
hi大佬
b'hi\xe5\xa4\xa7\xe4\xbd\xac'
bytearry函数，memoryview函数，略
ord,chr,ascii三者用法较为相似且息息相关，详见代码：
# ord:输入字符找该字符编码 unicode 的位置
print(ord('a'))
print(ord('中'))
# chr:输入位置数字找出其对应的字符unicode
print(chr(97))
print(chr(20013))
# ascii:是ascii码中的返回该值，不是则返回他在unicode的位置（16进制。）
print(ascii('a'))
print(ascii('中'))
97
20013
a
中
'a'
'\u4e2d'
repr函数可以理解为输出时将对象的string形式原型毕露，即加上引号。
#repr
print('alex')
print(repr('alex'))
alex
'alex'
数据集合
- dict：创建一个字典。
- set创建一个集合。
- frozenset:返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
此部分与之前类似，均无特殊用法，不多加赘述，
相关内置函数
- len:返回一个对象中元素的个数。
- sorted：对所有可迭代的对象进行排序操作。
- enumerate:枚举，返回一个枚举对象。
- all：可迭代对象中，全都是True才是True
- any：可迭代对象中，有一个True 就是True
- zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
- filter：过滤。
- map:会根据提供的函数对指定序列做映射
#len
len('123')
3
sorted函数的用法与之前的min函数和max函数较为相似，可通过key定制函数以拓展用法。同时，之前在列表部分曾学到过一个方法sort,与该函数的最大区别在于sorted函数是生成一个新的列表，并不改变原列表。而sort是改变原列表的排序方式。
l1 = [2,3,5,3,1,9,8,6]
l2 = [2,3,5,3,1,9,8,6]
l1.sort()
print(l1)
print(sorted(l2)) # 形成了一个新列表
print(l2) # 原列表不变
[1, 2, 3, 3, 5, 6, 8, 9]
[1, 2, 3, 3, 5, 6, 8, 9]
[2, 3, 5, 3, 1, 9, 8, 6]
# 需求：
# 将列表中的元祖按照元祖的第二个元素进行排序。
l3 = [(1,1000),(2,18),(4,250),(3,500)]
def func(x):
return x[1]
print(sorted(l3,key = func))
#小拓展，结合sort方法，猜测一下sorted函数如何倒序输出？
[(2, 18), (4, 250), (3, 500), (1, 1000)]
# all：可迭代对象中，全都是True才是True
l1 = [1,'',[1,3],(2,4)]
print(all(l1))
# any：可迭代对象中，有一个True 就是True
print(any([1,0,'',()]))
False
True
zip函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
需要注意的是，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
# zip
l1 = [1,2,3,5,6,7]
tu1 = ('hiDaLao','Cinderella', 'Nick', 'Holy')
dic = {'name': 'hiDaLao', 'age':22, 'hobby': 'tea', 'weight':65}
print(list(zip(l1,tu1,dic)))
[(1, 'hiDaLao', 'name'), (2, 'Cinderella', 'age'), (3, 'Nick', 'hobby'), (5, 'Holy', 'weight')]
filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是迭代器。注意其与列表推导式的区别。
#filter
#需求：输出1-10中的所有偶数。
print([i for i in range(1,11) if i % 2 == 0]) #列表推导式
l2 = [i for i in range(1,11)]
def func2(x):
return x % 2 == 0
print(list(filter(func2,l2)))
[2, 4, 6, 8, 10]
[2, 4, 6, 8, 10]
map函数为序列提供了一种新的定制方法。详见代码：
# map
# 需求：将输出l1列表中每个元素的平方
l1 = [1,2,3,4]
print([i**2 for i in l1])
def func3(x):
return x**2
print(list(map(func3,l1)))
[1, 4, 9, 16]
[1, 4, 9, 16]