python-內置函數：

閱讀須知：

• 本文章，內置函數需自己查找，共介紹36個(eval、exec、hash、help、callable、int、float、complex、bin、oct、hex、divmod、round、pow、bytes、ord、chr、repr、all、any、print()、str()、bool()、set()、list() 、tuple() 、dict()、abs()、sum()、reversed()、zip() 、min、sorted、filter、map 、reduce)

內置函數：

​ 函數就是以功能爲導向，一個函數封裝一個功能，那麼Python將一些常用的功能（比如len）給我們封裝成了一個一個的函數，供我們使用，他們不僅效率高（底層都是用C語言寫的），而且是拿來即用，避免重複早輪子，那麼這些函數就稱爲內置函數，到目前爲止python給我們提供的內置函數一共是68個

1.匿名函數：

• 爲了解決那些功能很簡單的需求而設計的一句話函數

• 函數名 = lambda 參數 ：返回值

  • 參數可以有多個，用逗號隔開
  • 匿名函數不管邏輯多複雜，只能寫一行，且邏輯執行結束後的內容就是返回值
  • 返回值和正常的函數一樣可以是任意數據類型

#這段代碼
def calc(n):
    return n**n
print(calc(10))  # 100
#換成匿名函數
calc = lambda n:n**n
print(calc(10))  # 100

練一練：

請把以下函數變成匿名函數
def add(x,y):
    return x+y
# 匿名函數
add = lambda x,y:x+y

2.內置函數

1.eval：

• 剝去字符串的外衣 運算裏面的代碼 — 執行字符串類型的代碼，並返回最終結果。

s1 = '1+3'
print(s1,type(s1))  # 1+3 <class 'str'>
print(eval(s1))  # 4
# 網絡傳輸 str input 輸入，sql注入的時候等等絕對不能使用 eval
# eval('2 + 2')  # 4
n=81
eval("n + 4")  # 85
eval('print(666)')  # 666

2.exec：

• exec 與eval幾乎一樣，處理代碼流 執行字符串類型的代碼。

msg = '''
  for i in range(10):
      print(i)
'''
print(msg)  # 打印字符串
exec(msg)  # 執行字符串裏面的代碼

3.hash：

• 獲取一個對象（可哈希對象：int，str，Bool，tuple）的哈希值。

# 可變（不可哈希）的數據類型：list dict set  -------修改後，原對象發生變化
# 不可變（可哈希）的數據類型： str bool int tuple(元組)  -----修改原對象，不會對原對象產生任何改變

print(hash(12322))
print(hash('123'))
print(hash('arg'))
print(hash('alex'))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

4.help：

• 函數用於查看函數或模塊用途的詳細說明

print(help(list)) 
print(help(str.split))

5.callable：

• 用於檢查一個對象是否是可調用的。如果返回True，object仍然可能調用失敗；但如果返回False，調用對象ojbect絕對不會成功。

s1='smierwr'
def func():
    pass
print(callable(s1))  # False
print(callable(func))  # True

6.int：

• 用於將一個字符串或數字轉換爲整型。

print(int())  # 0
print(int('12'))  # 12
print(int(3.6))  # 3

7.float：

• 用於將整數和字符串轉換成浮點數。

print(type(3.6))  # <class 'float'>
print(float(3))  # 3.0

8.complex：

• 函數用於創建一個值爲 real + imag * j 的複數或者將一個字符串或數轉化爲複數。
  • 如果第一個參數爲字符串，則不需要指定第二個參數。

print(complex(1,2))  # (1+2j)

9.bin：

• 將十進制轉換成二進制並返回。

print(bin(100))  # 0b(標識二進制)       1100100   字符串數據類型

10.oct：

• 將十進制轉化成八進制字符串並返回。

print(oct(10))  # 0o                   12        字符串數據類型

11.hex：

• 將十進制轉化成十六進制字符串並返回。

print(hex(10))  # 0x                   a       字符串數據類型
print(hex(13))  # 0x                   d       字符串數據類型

12.divmod：

• 計算除數與被除數的結果，返回一個包含商和餘數的元組(a // b, a % b)

print(divmod(10,3))  # (3,1)

13.round：

• 保留浮點數的小數位數，默認保留整數。
• 第二個參數，表示保留幾位小數

print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326

14.pow：

• 求x**y次冪。
  • （三個參數爲x**y的結果對 z 取餘）

print(pow(2,3))  # 兩個參數爲2**3次冪  # 8
print(pow(2,3,3))  # 三個參數爲2**3次冪，對3取餘。  # 2

15.bytes：

• 用於不同編碼之間的轉化。

s = '你好'
轉換一：
bs = s.encode('utf-8')
print(bs)  # b'\xe4\xbd\xa0\xe5\xa5\xbd'
轉化二：
bs = bytes(s,encoding='utf-8')
print(bs)  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

16.ord:

• 輸入字符找該字符編碼ASCII或Unicode的位置

如果字符是ASCII就找ASCII對應的
如果字符不是ASCII中的，就在Unicode中找
print(ord('a'))  # 97        ASCII
print(ord('中'))  # 20013    Unicode

17.chr:

• 輸入位置數字找出其對應的字符

print(chr(97))  # a
print(chr(20013))  # 中

18.repr:

• 返回一個對象的string形式

s1 = '太白'
print(s1)  # 太白
print(repr(s1))  # '太白'
msg = '我叫%s' %(s1)
print(msg)  # 我叫太白

msg1 = '我叫%r'%(s1)
print(msg1)  # 我叫'太白'

print(repr('{"name":"alex"}'))  # '{"name":"alex"}'
print('{"name":"alex"}')  # {"name":"alex"}

19.all：

• 可迭代對象中，全都是True纔是True

# 可迭代對象：str  list   tuple  dic  set  range 文件句柄
# int bool 不是可迭代對象
print(all([1, 2, True, 0]))  # False

20.any：

• 在可迭代對象中，有一個True 就是True

l1 = [0,'太白',False,[],'',()]
print(any(l1))  # True

21.print()

''' 源碼分析        print
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默認是輸出到屏幕，如果設置爲文件句柄，輸出到文件
    sep:   打印多個值之間的分隔符，默認爲空格
    end:   每一次打印的結尾，默認爲換行符
    flush: 立即把內容輸出到流文件，不作緩存
'''

# sep:
print(1,2,3,4)  # 1 2 3 4
print(1,2,3,4,sep='|')  # 1|2|3|4
# end:
print(1,end=' ')
print(2)  # 1 2

22.str()

s = 'RUNOOB'
print(str(s))  # RUNOOB
dict = {'runoob': 'runoob.com', 'google': 'google.com'};
print(str(dict))  # {'runoob': 'runoob.com', 'google': 'google.com'}

23.bool()

• 用於將給定參數轉換爲布爾類型，如果沒有參數，返回 False。
• bool 是 int 的子類。

>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int)  # bool 是 int 子類
True

24.set()

• set() 函數創建一個無序不重複元素集，可進行關係測試，刪除重複數據，還可以計算交集、差集、並集等。

# 可變（不可哈希）的數據類型：list dict set  -------修改後，原對象發生變化
# 不可變（可哈希）的數據類型： str bool int tuple-----修改原對象，不會對原對象產生任何改變**


# 集合 set。容器型的數據類型，它要求它裏面的 元素 是 不可變 的數據，
# 但是它本身是可變的數據類型。集合是無序的。 {}。

# 集合的創建：
set1 = {1, 3, '太白金星', 4, 'alex', False, '武大'}
print(set1)

# 空集合：
print({}, type({}))  # 空字典
set1 = set()
print(set1)

# 集合的有效性測試-------   str bool int tuple
set1 = {[1,2,3], 3, {'name': 'alex'}}
print(set1)  # TypeError: unhashable type: 'list'  TypeError: unhashable type: 'dict'
'''增刪'''
set1 = {'太白金星', '景女神',  '武大', '三粗', 'alexsb', '吳老師'}

'''增：'''
add
set1.add('xx')
print(set1)

update    迭代着增加
set1.update('fdsafgsd')
print(set1)

'''刪'''
remove
remove 按照元素刪除
set1.remove('alexsb')
print(set1)

# pop 隨機刪除
set1.pop()
print(set1)

'''變相改值'''
set1.remove('太白金星')
set1.add('男神')
print(set1)

'''關係測試'''
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
'''交集'''
print(set1 & set2)  # {4, 5}
# 並集：
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}
# 差集 -        即set1獨有
print(set1 - set2)  # {1, 2, 3}
# 反交集
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
# 子集
print(set1 < set2)  # True
# # 超集
print(set2 > set1)  # True

'''列表的去重'''
l1 = [1,'太白', 1, 2, 2, '太白',2, 6, 6, 6, 3, '太白', 4, 5, ]
set1 = set(l1)
print(set1)  # {1, 2, 3, 4, 5, 6, '太白'}
l1 = list(set1)
print(l1)  # [1, 2, 3, 4, 5, 6, '太白']
# 用處：數據之間的關係，列表去重

25.list()

• 將一個可迭代對象轉換成列表

l1 = [1,2,3,4]
l2 = list()  # 空列表  [] 
l3 = list('reioweroier')  # 傳遞一個可迭代對象  ['r', 'e', 'i', 'o', 'w', 'e', 'r', 'o', 'i', 'e', 'r']

26.tuple()

• 將一個可迭代對象轉換成元組

list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)
print(tuple1)  # ('Google', 'Taobao', 'Runoob', 'Baidu')

27.dict()

• 通過相應的方式創建字典。

dic1 = dict([(1,'one'),(2,'two'),(3,'three')])
print(dic1)  # {1: 'one', 2: 'two', 3: 'three'}
#     方式二：鍵值對的方式
dic2 = dict(one=1,two=2)
print(dic2)  # {'one': 1, 'two': 2}

28.abs()

• 返回絕對值

i = -5
print(abs(i))  # 5

29.sum()

• 求和

sum(iterable)  # 可迭代對象
print(sum([1,2,3]))  # 6
l1 = [i for i in range(10)]
print(sum(l1))  # 45
# 設置初始值
print(sum(l1,100))  # 145
# 錯誤
s1 = '123456'
print(sum(s1))  # TypeError: unsupported operand type(s) for +: 'int' and 'str'

30.reversed()

• 將一個序列翻轉, 返回翻轉序列的迭代器

reverse
l1 = [5, 4, 3, 7, 8, 6, 1, 9]
l1.reverse()  # 反轉,對原列表進行反轉
print(l1)  # [9, 1, 6, 8, 7, 3, 4, 5]

reversed   # 將可迭代對象翻轉, 返回翻轉序列的迭代器
l1 = [i for i in range(10)]
obj = reversed(l1)
print(obj)  # 迭代器  # <list_reverseiterator object at 0x0000017453B0EFA0>
print(list(obj))  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

31.zip() 拉鍊方法:

 類似於生成器
    函數用於將可迭代的對象作爲參數,將對象中對應的元素打包成一個個元組,
    然後返回由這些元祖組成的內容,如果各個迭代器的元素個數不一致,則按照長度最短的返回
    
    zip(a,b)函數分別從a和b中取一個元素組成元組，再次將組成的元組組合成一個新的迭代器。
    a與b的位數相同時，正常組合對應位置的元素。當a與b行或列數不同時，取兩者中的最小的行列數。

l1 = [1,2,3,4,5]
tu1 = ('太白','b哥','德剛')
s1 = 'abcd'
obj = zip(l1,tu1,s1)
print(obj)  # <zip object at 0x0000021E9EB42540>  # 一個zip對象---迭代器

for i in obj:
    print(i)
>>>(1, '太白', 'a')
>>>(2, 'b哥', 'b')
>>>(3, '德剛', 'c')

32.min

• 求最小值

l1 = [33,2,1,54,7,-1,-9]
print(min(l1))  # -9

# 按照絕對值方法取最小值
l2 = []
func = lambda a : abs(a)
for i in l1:
    l2.append(func(i))
print(min(l2))  # 1

# 方法二：
l1 = [33,2,1,54,7,-1,-9]
def abss(a):
    return abs(a)
print(min(l1,key=abss))   # 1           key = 函數名
# 凡是可以加 key 的，
# 它會自動的將可迭代對象中的每個元素按照順序傳入key對應的函數中，
# 以返回值比較大小

練習：

# 求出值最小的鍵
dic={'a':3,'b':2,'c':1}
print(min(dic))  # 默認按照字典的鍵去比較大小   a
    # 方法一：
dic={'a':3,'b':2,'c':1}
def func(a):
    return dic[a]
print(min(dic,key=func))  # c
    # 方法二：匿名函數：
dic={'a':3,'b':2,'c':1}
print(min(dic,key=lambda a:dic[a]))  # c

l2 = [('太白',18),('alex',73),('wusir',35),('口天昊',41)]
print(min(l2,key=lambda x:x[1]))  # 傳入x  返回x[1]進行比較  ('太白', 18)

33.sorted

• sorted排序函數
• sorted(iterable,key=None,reverse=False)
• reverse :是否是倒敘,True 倒敘 False 正序
  • 默認升序
  • 原列表不會改變

l2 = [('太白',76),('alex',70),('wusir',94),('口天昊',98),('b哥',96)]
print(sorted(l2))  # [('alex', 73), ('wusir', 35), ('口天昊', 41), ('太白', 18)]
從低到高
print(sorted(l2,key=lambda x:x[1]))  # [('alex', 70), ('太白', 76), ('wusir', 94), ('b哥', 96), ('口天昊', 98)]
從高到低
print(sorted(l2,key=lambda x:x[1],reverse=True))  # [('口天昊', 98), ('b哥', 96), ('wusir', 94), ('太白', 76), ('alex', 70)]

# 定義一個列表,然後根據一元素的長度排序
lst = ['天龍八部','西遊記','紅樓夢','三國演義']

# 計算字符串的長度
def func(s):
    return len(s)
print(sorted(lst,key=func))  # ['西遊記', '紅樓夢', '天龍八部', '三國演義']

lst = ['天龍八部','西遊記','紅樓夢','三國演義']
print(sorted(lst,key=lambda s:len(s)))  # ['西遊記', '紅樓夢', '天龍八部', '三國演義']

34.filter

• 篩選過濾

  • 類似於列表推導式的篩選模式

  語法: filter(function,iterable)

• 語法: filter(function,iterable)

  • 用來篩選的函數,在filter中會自動的把iterable(可迭代對象)中的元素傳遞給function,
    然後根據function返回的True或者False來判斷是否保留此項數據

l1 = [2,3,4,1,6,7,8]

# 把 小於3 的去除
   # 方法一：列表推導式
print([i for i in l1 if i >= 3])  # [3, 4, 6, 7, 8]

    # 方法二
def func(a):
    return a>=3
ret = filter(func,l1)
print(list(ret))  # [3, 4, 6, 7, 8]

# 相當於
ret = filter(lambda x:x>=3,l1)  # 返回的是迭代器
print(ret)  # <filter object at 0x0000023A1EBCE790>   迭代器
print(list(ret))  # [3, 4, 6, 7, 8]

35.map

• 列表推導式的循環模式
• map(function,iterable)
  • 可以對可迭代對象中的每一個元素進映射,分別取執行function
    計算列表中每個元素的平方,返回新列表

計算列表中每個元素的平方,返回新列表

l1 = [1,4,9,16,25]
print([i*i for i in range(1,6,1)])  # [1, 4, 9, 16, 25]
ret = map(lambda x:x**2,range(1,6))  # <map object at 0x000001D4F819E640>
print(ret)
print(list(ret))  # [1, 4, 9, 16, 25]

36.reduce

• reduce(函數名,可迭代對象) # 這兩個參數必須都要有,缺一個不行
• reduce的作用是先把列表中的前倆個元素取出計算出一個值然後臨時保存着, 接下來用這個臨時保存的值和列表中第三個元素進行計算,求出一個新的值將最開始 臨時保存的值覆蓋掉,然後在用這個新的臨時值和列表中第四個元素計算.依次類推

from functools import reduce
def func(x,y):
    return x * 10 + y
    # 第一次的時候 x是1 y是2  x乘以10就是10,然後加上y也就是2最終結果是12然後臨時存儲起來了
    # 第二次的時候x是臨時存儲的值12 x乘以10就是 120 然後加上y也就是3最終結果是123臨時存儲起來了
    # 第三次的時候x是臨時存儲的值123 x乘以10就是 1230 然後加上y也就是4最終結果是1234然後返回了
l = reduce(func,[1,2,3,4])
print(l)

# 匿名函數版
l = reduce(lambda x,y:x*10+y,[1,2,3,4])
print(l)