python基礎篇（四）

PYTHON基礎篇（四）

---

• 內置函數
  • A：基礎數據相關（38）
  • B：做用域相關（2）
  • C：迭代器，生成器相關（3）
  • D：反射相關（4）
  • E：面向對象相關（9）
  • F：其餘（12）
• 匿名函數
  • A：匿名函數基礎格式
• 遞歸函數
  • A：初識遞歸函數
  • B：遞歸函數實例

 

---

♣一：內置函數

內置函數是python自己攜帶的功能，當你打開解釋器的時候就隨之啓動存在了，能夠直接去調用，通過python這麼多年的發展內置函數也在變多，這個能夠去python官網去查詢內置函數的說明，這些函數都有一個特色就是能夠在函數名後面加上（）。

內置函數表：

 

abs()	callable()	enumerate()	globals()	isinstance()	memoryview()	print()	silce()	vars()
all()	chr()	eval()	hasattr()	issubclass()	min()	property()	sorted()	zip()
any()	classmethod()	exec()	hash()	iter()	next()	range()	staticmethos()	import()
ascii()	compoile()	filter()	help()	len()	object()	repr()	str()
bin()	delattr()	float()	hex()	list()	oct()	reversed()	sun()
bool()	dict()	format()	id()	locals()	open()	round()	super()
bytearray()	dir()	frozenset()	input()	map()	ord()	set()	tuple()
bytes()	divmod()	getattr()	int()	max()	pow()	setattr()	type()

 

A：基礎數據相關（38）

和數字相關（數據類型）

bool，int，float，complex（複數）

和數字相關（進制轉換）：

bin（二進制），oct（八進制），hex（十六進制）

和數字相關（數學運算）：

abs，divmod（求模取餘），round（小數精確），pow（冪運算），sum，min，max

with open('userinfo',encoding='utf8')as f:  #打開userinfo文件
    l = f.readlines()
page_num = int(input('請輸入頁碼：'))  #然用戶輸入頁數
pages,mod = divmod(len(l),5)#判斷總頁數，有沒有剩餘的行數
if mod:    #若是有剩餘的行數+1
    pages += 1 
if page_num > pages or page_num <=0: #判斷用戶輸入大於頁數或者小於等於0的狀況
    print('輸入有誤')
elif page_num == pages and mod !=0:  #若是用戶輸入的頁是最後一頁，且以前有過剩的行數
    for i in range(mod):
        print(l[(page_num-1)*5 +i].strip()) #只輸出這一頁上剩餘的行數
else:
    for i in range(5):  
        print(l[(page_num-1)*5 +i].strip()) #輸入正常的5行

divmod（翻頁案例）

數據結構相關（列表和元祖）

list，tuple

數據結構相關（相關內置函數）

reversed，slice

數據結構相關（字符串）

str，format，bytes，bytearray，memoryview，ord，chr，ascii，repr

數據結構相關（數據集合）

dict，set，frozenset

數據結構相關（相關內置函數）

len，enumerate，all，any，zip，filter，map

內置函數裏面max，min，filter，map，sorted這幾個是最經常使用的，並且同時也是匿名函數裏面經常使用的。

stockinfo = [
    {'name':'德新交運','num':200,'price':21.18},
    {'name':'縱橫通信','num':2000,'price':27.19},
    {'name':'白雲電器','num':100000,'price':11.14},
    {'name':'玉龍股份','num':500,'price':6.08}
]
#計算股票總價
ret = map(lambda dic : {dic['name']:dic['num']*dic['price']},stockinfo)
print(list(ret))
執行結果
[{'德新交運': 4236.0}, {'縱橫通信': 54380.0}, {'白雲電器': 1114000.0}, {'玉龍股份': 3040.0}]

map（算總價）

stockinfo = [
    {'name':'德新交運','num':200,'price':21.18},
    {'name':'縱橫通信','num':2000,'price':27.19},
    {'name':'白雲電器','num':100000,'price':11.14},
    {'name':'玉龍股份','num':500,'price':6.08}
]
求出單價超過20的股票
ret = filter(lambda dic:True if dic['price']>20 else False,stockinfo)
print(list(ret))
執行結果
[{'name': '德新交運', 'num': 200, 'price': 21.18}, {'name': '縱橫通信', 'num': 2000, 'price': 27.19}]

filter（算單價）

B：做用域相關（2）

locals()   #以字典的形式返回本地做用域中的名字
print(locals())
#執行結果
#{'__name__': '__main__', '__doc__': None, '__package__': None, '。。。。。。
def run(args):
    a = 'k'
    print(locals()) #在函數裏面使用會當前位置返回所有的局部變量
run(4)
執行結果：
{'a': 'k', 'args': 4}

locals()

globals()  #以字典的形式返回全局做用域中的名字
print(globals())
#執行結果
#{'__name__': '__main__', '__doc__': None, '__package__': None, '。。。。

globals()

C：迭代器，生成器相關（3）

這個裏面包含iter，next，range，這三種方法前面都用到過，不清楚能夠查看前面的用法。

D：反射相關（4）

後續補全

E：面向對象相關（9）

後續補全

F：其餘（12）

print(dir(()))
執行結果
['__add__', '__class__', '__contains__', .......
查看變量擁有的全部方法

dir()查看對象屬性

print(callable(print))
print(callable(range))
a = 1
print(callable(a))
執行結果
True
True
False
檢查一個對象是否能被調用

callable()

help()查看幫助

import()導入模塊

open()操做文件

id()查看內存地址

hash()是否能被hash，這個hash有個好處，例如你有一個文件裏面1萬個數字，另一個文件是從原文件拷貝出去的，怎麼檢查數據是否有差別，就能夠用hash，只要兩個裏面有個數字不同，兩個文件hash出來的結果就不同。

print()打印

import time
for i in range(0,101,2):
    time.sleep(0.2)
    char_num = i//2
    per = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
    print(per,end='',flush=True)

若是有不少進度條處理的建議研究progress bar
http://www.runoob.com/bootstrap/bootstrap-tutorial.html

print()打印進度條

inport()輸出

exec('print(123)')
eval('print(123)')
#執行結果
123
123
exec和eval都能執行後面內容是正常的python語句

print(exec('4+6+8'))  #exec能夠看到結果，其實特也執行了，只是沒有返回值而已，等同於不加print去計算1+2同樣
print(eval('2+6+8')) #eval這個函數有時候能將外面的代碼變得簡單，可是eval存在安全爭議，因此eval只能適合寫死的代碼部分。
#執行結果
None   exec適合處理簡單的流程控制
16

code = '''for i in range(3):
    print(i*'*')
'''
exec(code)
執行結果
*
**
能夠看到exec能將註釋的代碼給執行掉，由於裏面是正常的python語句

https://blog.csdn.net/hshl1214/article/details/46583149

exec和eval

compile()是將字符串類型的代碼編譯成計算機能識別的字節碼，這個執行須要交給exec和eval來執行。假如你有一段須要重複執行的代碼，就可使用compile一次編譯，屢次執行，實際用到的不多。

♣二：匿名函數

A：匿名函數基礎格式

函數都是def 函數名（位置參數）:要使用直接調用函數名便可，匿名函數的基本格式就是在調用的時候加上lambda，函數名 = lambda 參數：返回值的基本格式，若是有多個參數，參數與參數之間，號隔開。並且匿名函數還有一個特色就是參數：後面的返回值，無論多複雜多長，只能寫一行。 

def cacl(a):
    return a**a
print(cacl(10))
cacl=lambda n:n**n
print(cacl(10))
執行結果
10000000000
10000000000

匿名參數格式

# 找字典裏面最大值的key
# dic = {'a':10,'b':20,'c':50}
# def func(key):
#     return dic[key]
# print(max(dic,key=func))
# # 執行結果
# # c
# print(max(dic,key=lambda k:dic[k]))
# # 執行結果
# # c
# 能夠看到我使用匿名函數直接不須要使用我上面的func函數，直接傳值進來，func函數三行內容，匿名函數一行解決

# a = lambda k:k*2
# b = lambda k:k*3
# x = 2
# x = a(x)
# x = b(x)
# x = a(x)
# print(x)
# 執行結果
# 24

# print(list(map(lambda tup:{tup[0]:tup[1]},zip((('a'),('b')),(('c'),('d'))))))
# 執行結果
# [{'a': 'c'}, {'b': 'd'}]

lambda()的使用

num = [1,2,3,4,5,6,7,8,9]
ret=filter(lambda x:True if x%2==0 else False,num) 
#lambda後面能夠接列表推導式，三元運算符，一些簡單的判斷條件
print(list(ret))
執行結果
[2, 4, 6, 8]

用匿名函數取偶數

a = lambda i:i*1

咱們第一眼看上去是發現沒有函數名的，在匿名函數裏面實際上是有函數的名的，整個lambda就是函數，將執行的結果賦值給a，a就是函數名。

匿名函數有個很重要的點就是，要想去實現一些功能，必須結合咱們前面學習的內置函數方法，特別是一個簡單的功能，本身從頭至尾寫一個函數結果是能經過內置方法完成的時候，匿名函數就顯得尤其重要。

♣三：遞歸函數

A：初識遞歸函數

def stock():
    print('樂視股份漲幅百分之50')
    stock() #遞歸函數就是在函數內部調用函數自己
stock()
# 執行結果：
# 樂視股份漲幅百分之50
# 樂視股份漲幅百分之50Traceback (most recent call last):
# RecursionError: maximum recursion depth exceeded while calling a Python object
# 能夠看到遞歸函數不加以控制，到後面就會報錯，這個是由於遞歸函數在執行的時候回不停的開闢內存空間，python本身會加以控制
# 上面這個錯誤意思實際上是說超過了遞歸的最大深度

def stock():
    print('樂視股份漲幅百分之50')
    stock() #遞歸函數就是在函數內部調用函數自己
    print('這是下面一句話')
stock()
執行結果
樂視股份漲幅百分之50Traceback (most recent call last):
RecursionError: maximum recursion depth exceeded while calling a Python object
能夠發現一直執行到報錯了，仍是沒有打印函數最後面的那句話，可見遞歸函數具備一個特性就是在函數內部調用的地方並不會結束。

k = 0
def stock():
    global k
    k+=1
    print(k)
    stock()
stock()
執行結果
998Traceback (most recent call last):
RecursionError: maximum recursion depth exceeded while calling a Python object
能夠看到一直到報錯，python內部限制是998次

import sys
sys.setrecursionlimit(10000)
k = 0
def stock():
    global k
    k+=1
    print(k)
    stock()
stock()
執行結果
4048
4049
能夠經過上面的模塊方法解除python對遞歸函數的內存限制，可是我上面給的是10000，可是跑出來最後的結果是4049，這個是和電腦配置有關係，不是python的限制了

遞歸函數基礎格式

遞歸函數的缺點之一就是佔用內存空間，並且咱們也知道遞歸函數有個特性就是python對內存的限制，從幾個方面來看，若是你的程序是須要大量循環執行的，遞歸函數是不適合的。

固然遞歸函數也是有優勢的，他包含了全部函數共有的有點就是能夠重複調用和讓代碼變得簡單。

B：遞歸函數實例

經過上面遞歸函數的初步認識，咱們也能大體描述出來遞歸函數的使用場景，1：求解一個問題的結果是不能直接拿到的，須要經過解決另一個問題獲得答案，2：而另一個問題仍是須要解決在另一個問題的答案而獲得。

def num(k):
    if k == 4:
        return 40
    elif k>0 and k<4:
        return num(k+1)*2
print(num(2))
執行結果
160

遞歸函數