今日主要內容：
內建函式
匿名函式

一，關於資料

資料型別 ：int bool 。。。
資料結構 : dict list tuple set str
冷知識：dict 和 tuple 是python中獨特的

二，內建函式

1,reversed

# reversed()
l = [1, 2, 3, 4, 5]
l.reverse()
print(l)

l = [1, 2, 3, 4, 5]
l2 = reversed(l)  #並沒有真的去返回一個列表，而是給一個迭代器。節省空間
print(l2)
# 保留原列表，返回一個反向的迭代器

for i in l2:
    print(i)
 

輸出結果：
[5, 4, 3, 2, 1]
<list_reverseiterator object at 0x000001220DCE2F98>
5
4
3
2
1

2，切片：slice

l = (1, 2, 23, 213, 5612, 342, 43)
sli = slice(1, 5, 2)  #隔一個切一個
print(l[sli])
print(l[1:5:2])

輸出結果：
(2, 213)
(2, 213)

3，格式調整

#一個調整格式的方式
print(format('test', '<20'))  #開20個空間左對齊
print(format('test', '>40'))  #開40個空間右對齊
print(format('test', '^40'))  #開40個空間居中
 

輸出結果：
不方便顯示，，，理解就行！

4，位元組型別

# bytes:轉換成bytes型別
# 我拿到的是gbk編碼的，我想轉成utf-8編碼
print(bytes('你好', encoding='GBK'))     # unicode轉換成GBK的bytes
print(bytes('你好', encoding='utf-8'))   # unicode轉換成utf-8的bytes
print(bytes('你好', encoding='utf-8').decode('utf-8'))



# 網路程式設計 只能傳二進位制
# 照片和視訊也是以二進位制儲存
# html網頁爬取到的也是編碼
 

輸出結果：
b’\xc4\xe3\xba\xc3’
b’\xe4\xbd\xa0\xe5\xa5\xbd’
你好

b_array = bytearray('你好', encoding='utf-8')
print(b_array)
print(b_array[0])  #可以用來修改字串 瞭解一下就行
# 優點：在修改的時候能夠節省記憶體

輸出結果：
bytearray(b’\xe4\xbd\xa0\xe5\xa5\xbd’)
228

5，memoryview()

# 函式:memoryview()
# 我們每次做切片，記憶體中都會生成一個新的，非常佔用記憶體
l = 'ahfjskjlyhtgeoahwkvnadlnv'
l2 = l[:10]

print(l)
print(l2)

v = memoryview(bytearray(l[0:10], 'utf-8'))
print(v)

輸出結果：
ahfjskjlyhtgeoahwkvnadlnv
ahfjskjlyh
<memory at 0x000002677EB52A08>

6，ord+chr+ascii

'''
ord: 字元按照Unicode轉數字
chr：數字按照Unicode轉字元
ascii：只要是ascii碼中的內容，就直接打印出來，不是就轉化成另一種形式

'''

print(ord('好'))
print(ord('1'))
print(chr(97))


print(ascii('好'))
print(ascii('1'))

輸出結果：
22909
49
a
‘\u597d’
'1’

7，repr

name = 'egg'
print('你好%s'% name)  #s-->str
print('你好%r'% name)  #r-->repr
print(repr('1'))  # 區分：repr 可以讓你顯現原型
print(str('1'))

輸出結果：
你好egg
你好’egg’
‘1’
1

8，all-any-zip

'''
all: Return True if bool(x) is True for all values x in the iterable.
any: 判斷是否有bool值為False的值
zip: 返回一個迭代器: 拉鍊形式

'''

print(all(['a', '', 123]))
print(all(['a', 123]))
print(all([0, 123]))

print(any(['', 1, 0, []]))


print('00000000000000000000000000000000000')

l = [1, 2, 3, 4, 5]
l2 = ['a', 'b', 'c', 'd']
l3 = ('*', '**', [1, 2])
d = {'k1': 1, 'k2': 2}
for i in zip(l, l2, l3, d):
    print(i)

輸出結果：
False
True
False
True
00000000000000000000000000000000000
(1, ‘a’, '’, ‘k1’)
(2, ‘b’, '’, ‘k2’)***

9，過濾

#case1: 過濾數字
def is_odd(x):
    return x % 2 == 1   #return  True/False， 只有結果是True才能結果濾波器



ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
print(ret)  # 可以看到這個地方又拿到一個迭代器---->又是為了節省記憶體
for i in ret:
    print(i)

輸出結果：
<filter object at 0x000002A5CF4F9710>
1
7
9
17

# case2：過濾字串,去掉空的
def is_str(s):
    return s and str(s).strip()

ret = filter(is_str, [1, 'hello', '', '  ', None, [], 6, 7, 'world', 12, 17])
print(ret)
for i in ret:
    print(i)

輸出結果：
<filter object at 0x0000028DD0269710>
1
hello
6
7
world
12
17

# case3: 過濾出1-100中開平方之後是整數的數字
from math import sqrt
def func(num):
    res = sqrt(num)
    return res % 1 == 0
ret = filter(func, range(1, 101))


for i in ret:
    print(i)

輸出結果：
1
4
9
16
25
36
49
64
81
100

10，map

'''
# filter 執行了filter之後的結果集合 <= 執行之前的個數
#        filter只管篩選，不會改變原來的值
# map    執行前後元素個數不變
#        值可能發生改變


'''

ret = map(abs, [1, -4, 6, -8])
print(ret)
for i in ret:
    print(i)

輸出結果：
<map object at 0x00000224A732FE48>
1
4
6
8

11，sorted

l = [1, -4, 6, 5, -10]
l.sort(key = abs)   # 在原列表的基礎上進行排序
print(l)

print(sorted(l, key=abs, reverse=True))# 生成了一個新列表,不改變原列表, but佔記憶體
print(l)   #排序之後，原列表依舊還在




l = ['   ', [1, 2], 'hello world']
new_l = sorted(l, key=len)   # 根據元素長度排序，同樣--->key可以給一個func
print(new_l)

輸出結果：
[1, -4, 5, 6, -10]
[-10, 6, 5, -4, 1]
[1, -4, 5, 6, -10]
[[1, 2], ’ ', ‘hello world’]

三，匿名函式

1，lambda

#匿名函式：lambda

# 把下面這個add函式改寫成匿名函式
# def add(x,y):
#     return x+y

add = lambda x, y: x+y

print(add(1, 2))

輸出結果：
3

dic = {'k1': 10, 'k2': 100, 'k3': 30}
def func(key):
    return dic[key]

print(max(dic, key=func))   #根據返回值判斷最大值，返回值最大的那個引數是結果
print(max(dic, key=lambda key: dic[key]))

輸出結果：
k2
k2

總結：帶key的內建函式
min
max
filter
map
sorted
note: 注意區分map and filter
------>都可以和func+lamba合作

2，map

#case1
def func(x):
    return x**2
ret = map(func, [-1, 2, -3, 4])

for i in ret:
    print(i)


print('00000000000000000000000000')


#case2
ret = map(lambda x: x**2, [-1, 2, -3, 4])
for i in ret:
    print(i)

輸出結果：
1
4
9
16
00000000000000000000000000
1
4
9
16

3，面試題：zip

# 面試題：
# 現有兩元組(('a'),('b')),(('c'),('d')),
# 請使用python中匿名函式生成列表[{'a':'c'},{'b':'d'}]


# max min sorted filter map
# 匿名函式 --> 想到：內建函式
# zip


ret = zip((('a'),('b')),(('c'),('d')))
res = map(lambda tup: {tup[0]: tup[1]}, ret)
print(list(res))

輸出結果：
[{‘a’: ‘c’}, {‘b’: ‘d’}]

4，變態題

# 這個題是真的很費勁， 沒法說出的好不好

def multipliers():
    return [lambda x:i*x for i in range(4)]   #return



print([m(2) for m in multipliers()])


print('000000000000000000000000')


def multipliers():
    return (lambda x: i*x for i in range(4))   #return

print([m(2) for m in multipliers()])

輸出結果：
[6, 6, 6, 6]
000000000000000000000000
[0, 2, 4, 6]