內置函數(shù)2

和數(shù)據(jù)結構相關

列表與元祖

• list:將一個可迭代對象轉化成列表（如果是字典，默認將key作為列表的元素）。
• tuple:將一個可迭代對象轉化成元祖（如果是字典，默認將key作為元祖的元素）。

二者多用于數(shù)據(jù)類型的轉換，需要注意的是以下三點：

• 二者只可用于可迭代對象類型的轉換。
• 當被轉換數(shù)據(jù)類型為字典時，默認只保留字典的鍵作為元素。
• 當被轉換數(shù)據(jù)類型為字符串時，會將該元素迭代的增加到列表或元祖中。

# 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)

<ipython-input-2-87f8ca005b20> in <module>()
      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)

<ipython-input-3-e47bbf8c4ddd> in <module>()
      9 print(tuple(di))
     10 print(tuple(s))
---> 11 print(tuple(a))


TypeError: 'int' object is not iterable

相關內置函數(shù)

• reversed：將一個序列翻轉，并返回此翻轉序列的迭代器。
• slice：構造一個切片對象，用于列表的切片。

reversed函數(shù)主要用于字符串、列表，在字典、元祖、集合中不可用，其會生成一個迭代器，若需對其取值，可通過for循環(huán)或者將其轉換為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函數(shù)
b

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-6-4a3b1d2974fa> in <module>()
      1 a = 1234
----> 2 b = reversed(a)
      3 b


TypeError: 'int' object is not reversible

se = {1,2,3,4}
sf = reversed(se)  # 集合型不可使用reversed函數(shù)
sf

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-7-5077bc629553> in <module>()
      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函數(shù)
dj

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-8-002d3aa73535> in <module>()
      1 di = {1:2,2:3,3:4,4:5}
----> 2 dj = reversed(di)
      3 dj


TypeError: 'dict' object is not reversible

slice函數(shù)主要用于生成一種切片規(guī)則，以對不同可切片對象按照相同規(guī)則進行切片。

# 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:將數(shù)據(jù)轉化成字符串
• format:與具體數(shù)據(jù)相關，用于計算各種小數(shù)，精算等。
• bytes：用于不同編碼之間的轉化。
• bytearry：返回一個新字節(jié)數(shù)組。這個數(shù)組里的元素是可變的，并且每個元素的值范圍: 0 <= x < 256。
• memoryview
• ord:輸入字符找該字符編碼的位置
• chr:輸入位置數(shù)字找出其對應的字符
• ascii:是ascii碼中的返回該值，不是則返回他在unicode的位置（16進制。）
• repr:返回一個對象的string形式（原形畢露）

str函數(shù)主要用于將對象轉換為字符串類型

# 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函數(shù)之前主要用于格式化字符串，但其同時還可用于設置對齊方式、計算各種小數(shù)，精算等。

#format
#字符串可以提供的參數(shù),指定對齊方式，<是左對齊， >是右對齊，^是居中對齊
print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))

#整形數(shù)值可以提供的參數(shù)有 '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函數(shù)主要用于不同編碼之間的轉換，生成的是一個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函數(shù)，memoryview函數(shù)，略

ord,chr,ascii三者用法較為相似且息息相關，詳見代碼：

# ord:輸入字符找該字符編碼 unicode  的位置 

print(ord('a'))
print(ord('中'))

# chr:輸入位置數(shù)字找出其對應的字符unicode

print(chr(97))
print(chr(20013))

# ascii:是ascii碼中的返回該值，不是則返回他在unicode的位置（16進制。）

print(ascii('a'))
print(ascii('中'))

97
20013
a
中
'a'
'\u4e2d'

repr函數(shù)可以理解為輸出時將對象的string形式原型畢露，即加上引號。

#repr
print('alex')
print(repr('alex'))

alex
'alex'

數(shù)據(jù)集合

• dict：創(chuàng)建一個字典。
• set創(chuàng)建一個集合。
• frozenset:返回一個凍結的集合，凍結后集合不能再添加或刪除任何元素。
  此部分與之前類似，均無特殊用法，不多加贅述，

相關內置函數(shù)

• len:返回一個對象中元素的個數(shù)。
• sorted：對所有可迭代的對象進行排序操作。
• enumerate:枚舉，返回一個枚舉對象。
• all：可迭代對象中，全都是True才是True
• any：可迭代對象中，有一個True 就是True
• zip：函數(shù)用于將可迭代的對象作為參數(shù)，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。如果各個迭代器的元素個數(shù)不一致，則返回列表長度與最短的對象相同。
• filter：過濾。
• map:會根據(jù)提供的函數(shù)對指定序列做映射

#len
len('123')

3

sorted函數(shù)的用法與之前的min函數(shù)和max函數(shù)較為相似，可通過key定制函數(shù)以拓展用法。同時，之前在列表部分曾學到過一個方法sort,與該函數(shù)的最大區(qū)別在于sorted函數(shù)是生成一個新的列表，并不改變原列表。而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函數(shù)如何倒序輸出？

[(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函數(shù)用于將可迭代的對象作為參數(shù)，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。
??需要注意的是，如果各個迭代器的元素個數(shù)不一致，則返回列表長度與最短的對象相同。

# 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 過濾 通過你的函數(shù)，過濾一個可迭代對象，返回的是迭代器。注意其與列表推導式的區(qū)別。

#filter

#需求：輸出1-10中的所有偶數(shù)。

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函數(shù)為序列提供了一種新的定制方法。詳見代碼：

# 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]