4-函數

時間 2019-11-24

標籤函數简体版

原文原文鏈接

裝飾器（docorator）html

本質是函數，起裝飾其餘函數做用，爲原函數添加附加功能python

原則：不能修改被裝飾函數的源代碼json

不修改被裝飾函數的調用方式數組

裝飾器須要的知識：數據結構

函數即變量less

高階函數ide

嵌套函數函數

裝飾器=高階函數+嵌套函數post

含參方式測試

import time
def times(func):  #times=deco(test) func=test
def deco(*arge,**kwarge):
        start_time=time.time()
        func(*arge,**kwarge)
        stop_time=time.time()
        print("in the test run %s"%(stop_time-start_time))
    return deco

@times
def test(name):
    time.sleep(2)
    print(name)
    print(" in the test")
#test=times(test)=@time
test('zyp')

當被裝飾函數有幾個不一樣的需求，可是大部分代碼相同能夠以下：

user,passwd = 'aaa','123456'
def outer(auth_type):
    def waper(func):
        def into(*args,**kwargs):
            if auth_type == "local":
                username = input("Username:").strip()
                password = input("Password:").strip()
                if user == username and passwd == password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    func(*args, **kwargs)
                    print("--------待續。。。。 ")
                    return func
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == "ldap":
                print("待續。。。。")
        return into
    return waper

def index():
    print("welocome in the index ")
@outer(auth_type="local")
def home():
    print("welocome in the home ")
@outer(auth_type="ldap")
def bbs():
    print("welocome in the bbs ")

index()
print(home())
bbs()

生成器（generator）

一、邊循環邊計算的機制

二、只有在調用的時候纔會生成相應的數據

三、__next()__() 取元素和next() 同樣用法

四、yield使生成器只有在調用的時候纔會運行

五、協同程序就是能夠獨立運行的獨立函數的調用，函數能夠暫停或者掛起，並在須要的時候從程序離開的地方繼續或從新開始

>>> a=(i for i in range(10))
>>> print(a)
<generator object <genexpr> at 0x0061B930>
>>> b=[i for i in range(10)]
>>> print(b)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

六、generator執行循序和函數不同，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句開始執行

七、for循環條用生成器是，拿不到返回值，若要返回值必須捕獲stopIteration錯誤

迭代器

可迭代對象（Iterator）：能夠做用於for循環的對象

使用isinstance()可判斷是不是可迭代對象

可被next（）函數調用並不斷返回下一個值的對象稱迭代器

將可迭代對象轉迭代器：Iter()

python3內置函數

python內置了一系列的經常使用函數，以便於咱們使用，python英文官方文檔詳細說明：https://docs.python.org/3/library/functions.html?highlight=built#ascii

abs() 獲取絕對值

>>> abs(-5)
5

all() 接受一個迭代器，若迭代器中全部元素都爲真，則返回True，不然返回False (非0即爲真)

a=[1,2,3,4]
b=[0,1,2,3,4]
c=b[1:] #切片去掉零
print(all(a))  #True
print(all(b))   #False
print(all(c))    #True

any() 接受一個迭代器，若迭代器中有一個元素都爲真，則返回True，不然返回False

b=[0,1,2,3,4]
print(any(b))   #True
a=[0,0,0,1]
print(any(a))   #True

ascii() 調用對象的__repr__()方法，得到該方法的返回值.

bin(),　 oct(), hex() 　　三個函數功能爲：將十進制數分別轉換爲2/8/16進制

bool()　　測試一個對象是True仍是False

bytes()　　將一個字符串轉換成字節類型

>>> a='123avx'
>>> print(bytes(a,encoding='utf-8'))
b'123avx'
>>> a='中國'
>>> print(bytes(a,encoding='utf-8'))
b'\xe4\xb8\xad\xe5\x9b\xbd'

bytearray() 方法返回一個新字節數組。這個數組裏的元素是可變的，而且每一個元素的值範圍: 0 <= x < 256。

參數

若是 source 爲整數，則返回一個長度爲 source 的初始化數組；
若是 source 爲字符串，則按照指定的 encoding 將字符串轉換爲字節序列；
若是 source 爲可迭代類型，則元素必須爲[0 ,255] 中的整數；
若是 source 爲與 buffer 接口一致的對象，則此對象也能夠被用於初始化 bytearray。
若是沒有輸入任何參數，默認就是初始化數組爲0個元素。

返回值

返回新字節數組。

a=bytearray('abcd',encoding='utf-8')
a[0]=100
print(a)        #bytearray(b'dbcd')
b=bytearray()
print(b)       #bytearray(b'')

callable() 判斷變量是否能夠被調用，能被調用的對象就是一個callables對象，好比函數和帶有__call__()的實例

def add():
    print('函數可被調用')
print(callable(add))    #True
a=[1,2,3,4]
print(callable(a))   #False

chr() 輸出十進制對應的ASCII值，ord() 輸出ASCII對應的十進制

>>> chr(100)
'd'
>>> chr(65)
'A'
>>> ord('a')
97
>>> ord('A')
65
>>> ord('0')
48

compile()　　將字符串編譯成python能識別或能夠執行的代碼，也能夠將文字讀成字符串再編譯

參數

source -- 字符串或者AST（Abstract Syntax Trees）對象。。
filename -- 代碼文件名稱，若是不是從文件讀取代碼則傳遞一些可辨認的值。
mode -- 指定編譯代碼的種類。能夠指定爲 exec, eval, single。
flags -- 變量做用域，局部命名空間，若是被提供，能夠是任何映射對象。。參數爲可選參數。
flags和dont_inherit是用來控制編譯源碼時的標誌,參數爲可選參數。

返回值: 返回表達式執行結果。

f = open("fib.py")
data =compile(f.read(),' ','exec')
exec(data)
#執行了fib函數，輸出斐波那契數列

>>>str = "for i in range(0,10): print(i)"

>>> c = compile(str,'','exec') # 編譯爲字節代碼對象

>>> c

>>> exec(c)

>>> str = "3 * 4 + 5"

>>> a = compile(str,'','eval')

>>> eval(a)

delattr()　　刪除對象的屬性

dict()　　建立數據字典

dir() 查看內置函數

divmod() 分別取商和餘數

>>> divmod(10,2)
(5, 0)
>>> divmod(10,3)
(3, 1)

enumerate() 返回一個能夠枚舉的對象，該對象的next()方法將返回一個元組

>>> a=[1,2,3,4]
>>> for index,i in enumerate(a):print(index,i)
...
0 1
1 2
2 3
3 4

eval() 將字符串str當成有效的表達式來求值並返回計算結果

1 >>> s = "1+2*3"
2 >>> type(s)
3 <class 'str'>
4 >>> eval(s)
5 7

exec()　　執行字符串或complie方法編譯過的字符串，沒有返回值

filter() 過濾器，構造一個序列，等價於[ item for item in iterables if function(item)]，在函數中設定過濾條件，逐一循環迭代器中的元素，將返回值爲True時的元素留下，造成一個filter類型數據

 filter(function, iterable)
2 參數function：返回值爲True或False的函數，能夠爲None。 3 參數iterable：序列或可迭代對象。

>>> r=filter(lambda x: x>5,range(10))
>>> for i in r:
...     print(i)
6
7
8
9

float()　　講一個字符串或整數轉換爲浮點數

format()　　格式化輸出字符串

frozenset()　　建立一個不可修改的集合

1 frozenset([iterable])
2 set和frozenset最本質的區別是前者是可變的，後者是不可變的。當集合對象會被改變時（例如刪除，添加元素），只能使用set，
3 通常來講使用fronzet的地方均可以使用set。
4 參數iterable：可迭代對象

globals()　　返回一個描述當前全局變量的字典(變量爲key,值爲value)

locals() 返回一個描述當前局部變量的字典(變量爲key,值爲value)

hash()　　哈希值

1 hash(object)
2 若是對象object爲哈希表類型，返回對象object的哈希值。哈希值爲整數，在字典查找中，哈希值用於快遞比價字典的鍵。
3 兩個數值若是相等，則哈希值也相等。

help()　　返回對象的幫助文檔

id()　　返回對象的內存地址

int()　　將一個字符串或數值轉換爲一個普通整數

1 int([x[,radix]])
2 若是參數是字符串，那麼它可能包含符號和小數點。參數radix表示轉換的基數（默認是10進制）。
3 它能夠是[2,36]範圍內的值，或者0。若是是0，系統將根據字符串內容來解析。
4 若是提供了參數radix，但參數x並非一個字符串，將拋出TypeError異常；
5 不然，參數x必須是數值（普通整數，長整數，浮點數）。經過捨去小數點來轉換浮點數。
6 若是超出了普通整數的表示範圍，一個長整數被返回。
7 若是沒有提供參數，函數返回0。

isinstance()　　檢查對象是不是類的對象，返回True或False

a=[1,2,3,4]
print(isinstance(a,str))   #False
print(isinstance(a,list))   #True
print(isinstance(123,int))   #True

issubclass()　　檢查一個類是不是另外一個類的子類。返回True或False

issubclass(sub, super)
 1 檢查sub類是不是super類的派生類（子類）。返回True 或 False

iter()

1 iter(o[, sentinel])
2 返回一個iterator對象。該函數對於第一個參數的解析依賴於第二個參數。
3 若是沒有提供第二個參數，參數o必須是一個集合對象，支持遍歷功能（__iter__()方法）或支持序列功能（__getitem__()方法），
4 參數爲整數，從零開始。若是不支持這兩種功能，將處罰TypeError異常。
5 若是提供了第二個參數，參數o必須是一個可調用對象。在這種狀況下建立一個iterator對象，每次調用iterator的next()方法來無
6 參數的調用o，若是返回值等於參數sentinel，觸發StopIteration異常，不然將返回該值。

len()　　返回對象長度，參數能夠是序列類型（字符串，元組或列表）或映射類型（如字典）

list()

list([iterable])
2 list的構造函數。參數iterable是可選的，它能夠是序列，支持編譯的容器對象，或iterator對象。
3 該函數建立一個元素值，順序與參數iterable一致的列表。若是參數iterable是一個列表，將建立
4 列表的一個拷貝並返回，就像語句iterables[:]

map()

map(function, iterable,...)
 2 對於參數iterable中的每一個元素都應用fuction函數，並將結果做爲列表返回。
 3 若是有多個iterable參數，那麼fuction函數必須接收多個參數，這些iterable中相同索引處的元素將並行的做爲function函數的參數。
 4 若是一個iterable中元素的個數比其餘少，那麼將用None來擴展改iterable使元素個數一致。
 5 若是有多個iterable且function爲None，map()將返回由元組組成的列表，每一個元組包含全部iterable中對應索引處值。
 6 參數iterable必須是一個序列或任何可遍歷對象，函數返回的每每是一個列表(list)。
 7  
 8 li = [1,2,3]
 9 data = map(lambda x :x*100,li)
10 print(type(data))

11 data = list(data)
12 print(data)
13  
14 運行結果：
15  
16 <class 'map'>
17 [100, 200, 300]

max()　　返回給定元素裏最大值

min()　　返回給定元素裏最小值

next()　　返回一個可迭代數據結構（如列表）中的下一項

object()

 獲取一個新的，無特性(geatureless)對象。Object是全部類的基類。它提供的方法將在全部的類型實例中共享。
該函數時2.2.版本新增，2.3版本以後，該函數不接受任何參數。

open()　　打開文件

open(filename [, mode [, bufsize]])
打開一個文件，返回一個file對象。 若是文件沒法打開，將處罰IOError異常。
應該使用open()來代替直接使用file類型的構造函數打開文件。
參數filename表示將要被打開的文件的路徑字符串；
參數mode表示打開的模式，最經常使用的模式有：'r'表示讀文本，'w'表示寫文本文件，'a'表示在文件中追加。
Mode的默認值是'r'。
當操做的是二進制文件時，只要在模式值上添加'b'。這樣提升了程序的可移植性。
可選參數bufsize定義了文件緩衝區的大小。0表示不緩衝；1表示行緩衝；任何其餘正數表示使用該大小的緩衝區；
負數表示使用系統默認緩衝區大小，對於tty設備它每每是行緩衝，而對於其餘文件每每徹底緩衝。若是參數值被省卻。
使用系統默認值。

pow()　　冪函數

>>> pow(2,10)
1024

repr()　　將任意值轉換爲字符串，供計時器讀取的形式

1 repr(object)
2 返回一個對象的字符串表示。有時可使用這個函數來訪問操做。
3 對於許多類型來講，repr()嘗試返回一個字符串，eval()方法可使用該字符串產生對象；
4 不然用尖括號括起來的，包含類名稱和其餘二外信息的字符串被返回。

reversed()　　　反轉，逆序對象

reversed(seq)
2 返回一個逆序的iterator對象。參數seq必須是一個包含__reversed__()方法的對象或支持序列操做(__len__()和__getitem__())
3 該函數是2.4中新增的

round()　　四捨五入

round(x [, n])
對參數x的第n+1位小數進行四捨五入，返回一個小數位數爲n的浮點數。
參數n的默認值是0。結果是一個浮點數。如round(0.5)結果爲1.0
>>> round(4,6)
4
>>> round(5,6)
5

set() 集合

setattr()　　與getattr()相對應

slice()　　切片功能

sorted()　　排序

>>> sorted([36,6,-12,9,-22])  列表排序
[-22, -12, 6, 9, 36]
>>> sorted([36,6,-12,9,-22],key=abs) 高階函數，以絕對值大小排序
[6, 9, -12, -22, 36]
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])  字符串排序，按照ASCII的大小排序
['Credit', 'Zoo', 'about', 'bob']
若是須要排序的是一個元組，則須要使用參數key，也就是關鍵字。
>>> a = [('b',2), ('a',1), ('c',0)]
>>> list(sorted(a,key=lambda x:x[1]))   按照元組第二個元素排序
[('c', 0), ('a', 1), ('b', 2)]
>>> list(sorted(a,key=lambda x:x[0]))   按照元組第一個元素排序
[('a', 1), ('b', 2), ('c', 0)]
>>> sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower) 忽略大小寫排序
['about', 'bob', 'Credit', 'Zoo'] 
>>> sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower,reverse=True) 反向排序
['Zoo', 'Credit', 'bob', 'about']

>>>myslice = slice(5)    # 設置截取5個元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 個元素
[0, 1, 2, 3, 4]
>>>

str()　　字符串構造函數

sum()　　求和

super()　　調用父類的方法

tuple()　　元組構造函數

type()　　顯示對象所屬的類型

vars()　　函數返回對象object的屬性和屬性值的字典對象

zip()　　將對象逐一配對，多餘捨棄

items() 轉列表

python json.dumps() json.dump()的區別

dumps是將dict轉化成str格式，loads是將str轉化成dict格式。

dump和load也是相似的功能，只是與文件操做結合起來了。

dump須要一個相似於文件指針的參數（並非真的指針，可稱之爲類文件對象），能夠與文件操做結合，也就是說能夠將dict轉成str而後存入文件中；而dumps直接給的是str，也就是將字典轉成str。