0517Python基礎-內置函數
1、昨日內容回顧
可叠代對象：內部含有__iter__方法的
叠代器：內部含有__iter__方法並且還含有__next__方法的
可叠代對象.__iter__()
判斷可叠代對象，叠代器。
‘__iter__‘ in dir(可叠代對象)
‘__next__‘ in dir(可叠代對象)
isinstance(obj, Iterator)
isinstance(obj, Iterable)
叠代器：
節省內存。
惰性機制。
單向不可逆。
生成器：
生成器本質是叠代器，他是用python代碼寫的。
生成器函數。 yield
__next__ send()
生成器推導式。
[變量(加工後的變量) for 變量 in 可叠代對象] 遍歷模式。
[變量(加工後的變量) for 變量 in 可叠代對象 if 條件] 篩選模式。
() 生成器推導式
2、內置函數
重點記憶
用域相關
**globals() 已字典的形式返回全局變量
**locals() 已字典的形式返回當前位置的局部變量
q = 666
def wrapper(argv):
a = 3
print(locals()) # 1 {a:3,argv:2}
def inner(argv1):
b = 4
c = 5
print(locals()) # 2 {b:4 c:5,argv1:6}
inner(6)
wrapper(2)
print(globals()) # 3
其他相關
1.2.1 字符串類型代碼的執行 eval，exec，complie
***eval 去除字符串的引號，返回對應內部的值
s = ‘{"a":1,"b":3}‘
dic = eval(s)
print(dic,type(dic))
print(eval(‘2 + 2‘))
print(eval(‘print(666)‘))
*** exec 執行字符串內部的代碼
print(exec(‘1 + 1‘))
ret = ‘‘‘
name = input(‘請輸入名字：‘).strip()
if name == ‘alex‘:
print(666)
‘‘‘
exec(ret)
compile: pass
1.2.2 輸入輸出相關 input，print
name = input(‘請%s輸入名字:‘ % ‘alex‘)
print(name)
print(1, 2, 3,sep=‘*‘) # 設定打印元素的連接方式
print(‘alex‘, end=‘‘) # end控制的是換行
print(‘老男孩‘)
***f1 = open(‘log‘, encoding=‘utf-8‘, mode=‘w‘)
print(‘666‘, file=f1) # file 操作文件句柄，寫入文件。
f1.close()
1.2.3內存相關 hash id
*hash 將不可變的數據通過hash算法轉化成hash值
print(hash(‘name‘))
print(hash(‘age‘))
print(hash((1, 2, 3,)))
print(hash(1))
print(hash(100))
*print(id(‘name‘))
1.2.3文件操作相關
open：函數用於打開一個文件，創建一個 file 對象，相關的方法才可以調用它進行讀寫。
1.2.4模塊相關__import__
__import__：函數用於動態加載類和函數 。
1.2.5幫助
*help：函數用於查看函數或模塊用途的詳細說明。
print(help(str))
1.2.6調用相關
*** callable：函數用於檢查一個對象是否是可調用的。
如果返回True，object仍然可能調用失敗；但如果返回False，調用對象ojbect絕對不會成功。
def func1():
print(666)
age = 16
print(callable(‘name‘))
print(callable(age))
print(callable(func1))
1.2.7查看內置屬性
** dir：函數不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；
帶參數時，返回參數的屬性、方法列表。如果參數包含方法__dir__()，該方法將被調用。
如果參數不包含__dir__()，該方法將最大限度地收集參數信息。
print(dir(str))
1.3 叠代器生成器相關
*** range iter() next()
print(len(range(100)))
l = [1, 2, 3, 4, 5]
l_obj = l.__iter__()
l_obj = iter(l)
print(l_obj)
print(l_obj.__next__())
print(next(l_obj))
1.4.1數字相關（14）
數據類型（4）：
bool ：用於將給定參數轉換為布爾類型，如果沒有參數，返回 False。
int：函數用於將一個字符串或數字轉換為整型。
print(int(‘123‘))
print(int(1.234))
print(int(1.768))
float：函數用於將整數和字符串轉換成浮點數。
complex：函數用於創建一個值為 real + imag * j 的復數或者轉化一個字符串或數為復數。
如果第一個參數為字符串，則不需要指定第二個參數。。
i = 3.1415
print(i, type(i))
s = ‘1.234‘
print(int(1.234))
print(float(s))
print(float(100))
bin：將十進制轉換成二進制並返回。
print(bin(100))
oct：將十進制轉化成八進制字符串並返回。
print(oct(10))
hex：將十進制轉化成十六進制字符串並返回。
print(hex(13))
print(hex(18))
數學運算（7）：
**abs：函數返回數字的絕對值。
print(abs(-5))
***divmod：計算除數與被除數的結果，返回一個包含商和余數的元組(a // b, a % b)。
print(divmod(7, 3))
**round：保留浮點數的小數位數，默認保留整數。
print(round(1.234,2))
*pow：求x**y次冪。（三個參數為x**y的結果對z取余）
print(pow(2, 3)) # 2的三次冪
print(pow(2, 3, 3)) # 2的三次冪對3取余數
***sum：對可叠代對象進行求和計算（可設置初始值）。
print(sum([1, 2, 3, 4]))
print(sum([1, 2, 3, 4], 100))
*** min：返回可叠代對象的最小值（可加key，key為函數名，通過函數的規則，返回最小值）。
print(min([1, 3, 5, 7, -4]))
print(min([1, 3, 5, 7, -4], key=abs))
*** max：返回可叠代對象的最大值（可加key，key為函數名，通過函數的規則，返回最大值）。
print(max([1, 3, 5, 7, -4]))
print(max([1, 3, 5, 7, -9], key=abs))
1.4.2和數據結構相關（24）
列表和元祖（2）
list：將一個可叠代對象轉化成列表（如果是字典，默認將key作為列表的元素）。
tuple：將一個可叠代對象轉化成元祖（如果是字典，默認將key作為元祖的元素）。
tu = (1, 2, 3)
print(list(tu))
l1 = list((1, 2, 3))
l1 = list({‘name‘:‘alex‘,‘age‘:1000})
print(l1)
自己試
相關內置函數（2）
*** reversed：將一個序列翻轉，並返回此翻轉序列的叠代器。
l1 = [11, 22, 33, 44, 77, 66]
l_obj = reversed(l1)
# print(l_obj)
for i in l_obj:
print(i)
slice：構造一個切片對象，用於列表的切片。
l1 = [11, 22, 33, 44, 77, 66]
l2 = [111, 222, 333, 444, 777, 666]
# print(l1[1::2])
rule = slice(1, len(l2), 2)
print(l2[rule])
字符串相關（9）
str：將數據轉化成字符串。
format:與具體數據相關，用於計算各種小數，精算等。
print(format(‘test‘, ‘<20‘)) # 左對齊
print(format(‘test‘, ‘>20‘)) # 右對齊
print(format(‘test‘, ‘^20‘)) # 居中
*** bytes：str---> bytes
s1 = ‘alex‘
# b1 = s1.encode(‘utf-8‘)
b2 = bytes(s1,encoding=‘utf-8‘)
# print(b1)
print(b2)
bytearray
ret = bytearray(‘alex‘, encoding=‘utf-8‘) # 類比：[97,103,....]
print(id(ret))
print(ret) # bytearray(b‘alex‘)
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))
分字節去轉換成str
b1 = bytes(‘你好‘,encoding=‘utf-8‘)
print(b1)
ret = memoryview(b1)
# print(len(ret))
# print(ret)
print(bytes(ret[:3]).decode(‘utf-8‘))
print(bytes(ret[3:]).decode(‘utf-8‘))
ord:輸入字符找該字符編碼的位置
print(ord(‘a‘))
print(ord(‘中‘)) # unicode
chr:輸入位置數字找出其對應的字符
print(chr(65))
print(chr(20013)) # unicode
ascii:是ascii碼中的返回該值，不是就返回/u...
print(ascii(‘a‘))
print(ascii(1))
print(ascii(‘中‘))
*** repr:返回一個對象的string形式（原形畢露）。
msg = ‘小數%f‘ %(1.234)
print(msg)
msg = ‘姓名：%r‘ % ( ‘alex‘)
print(msg)
print(repr(‘{"name":"alex"}‘))
print(‘{"name":"alex"}‘)
數據集合（3）
dict：創建一個字典。
set：創建一個集合。
frozenset：返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素。
dic = dict({‘name‘: ‘alex‘})
print(dic)
set1 = set((‘alex‘,‘wusir‘))
print(set1)
相關內置函數（8）
*** len:返回一個對象中元素的個數。
*** sorted：對所有可叠代的對象進行排序操作。 返回的是列表
print(sorted([1, 2, 3, 4, 5, -6]))
print(sorted([1, 2, 3, 4, 5, -6], key=abs))
L = [(‘a‘, 1), (‘c‘, 2), (‘d‘, 4), (‘b‘, 3), ]
print(sorted(L))
def func1(x):
return x[1]
L = [(‘a‘, 1), (‘c‘, 2), (‘d‘, 4),(‘b‘, 3), ]
print(sorted(L, key=func1))
*all：可叠代對象中，全都是True才是True
*any：可叠代對象中，有一個True 就是True
print(all([1, ‘alex‘, True, (1,2,3)]))
print(all([0, ‘alex‘, True, (1,2,3)]))
print(any([0, ‘‘, False, (1,2,3)]))
print(any([0, ‘‘, False, ()]))
***zip 拉鏈方法 返回的是一個叠代器
l1 = [1, 2, 3, 4]
tu1 = (‘老男孩‘, ‘alex‘, ‘wusir‘)
l2 = [‘*‘, ‘**‘, ‘***‘, "****"]
obj = zip(l1,tu1,l2)
for i in obj:
print(i)
***map: 循環模式
def func2(x):
return x**2
obj = map(func2, [1, 2, 3, 4])
for i in obj:
print(i)
print((i**2 for i in [1, 2, 3, 4]))
def func2(x, y):
return x + y
obj1 = map(func2, [1, 2, 3, 4, 6], (2, 3, 4, 5))
for i in obj1:
print(i)
***filter 篩選模式
def func(x):
return x % 2 == 0
ret = filter(func,[1, 2, 3, 4, 5, 6, 7])
print(ret)
for i in ret:
print(i)
print((i for i in [1, 2, 3, 4, 5, 6, 7] if i % 2 == 0))
***lambda 匿名函數 一句話函數
def func(x): return x % 2 == 0
def func1(x, y):
return x + y
ret = lambda x, y: x+y
print(ret(2,3))
def func1(x, y):
return x if x > y else y
ret = lambda x, y: x if x > y else y
print(ret(2,3))
def func(x):
return x % 2 == 0
ret = filter(lambda x:x % 2 == 0, [1, 2, 3, 4, 5, 6, 7])
print(ret)
for i in ret:
print(i)
[1, 2, 3, 4, 5, 6, 7] [1,4,9,16...] map lambda
ret2 = map(lambda x:x**2,[1, 2, 3, 4, 5, 6, 7])
for i in ret2:
print(i)
def func1(x):
return x[1]
L = [(‘a‘, 1), (‘c‘, 2), (‘d‘, 4),(‘b‘, 3), ]
print(sorted(L, key=func1))
students = [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
l = sorted(students, key= lambda x: x[2],reverse=True)
print(l)
sorted max min map filter
0517Python基礎-內置函數