Python自動化運維開發----基礎（十二）函數

1.函數的定義

函數是對代碼塊起了一個名字，在須要執行代碼塊的時候，直接調用函數

>>> def test():
...     print(test)
... 
>>> test()
<function test at 0x7ff784f51e18>

>>> def test(a,b):                          
...     print("{0}+{1}={2}".format(a,b,a+b))
... 
>>> test(1,2)
1+2=3

2.return以後的函數是不會在作執行代碼的

如圖：當return後的

>>> def test(): 
...     return 1
...     print(2)
... 
>>> test()
1

3.函數參數

(1)第一種無默認值

>>> def test(a):
...     print(a)
... 
>>> test(1)
1

(2)有默認值的參數，默認值參數必須在函數參數以後

若是在調用的時候不寫默認值就不會傳遞默認值，若是傳遞值的話就會覆蓋原來的默認值

>>> def test(a,b=1):
...     print(a,b)
... 
>>> test(1)
1 1
>>> test(1,2)
1 2

(3).忽略返回值（解包）

只接收前兩個參數

>>> a,b,*c = range(10)
>>> a
0
>>> b
1
>>> c
[2, 3, 4, 5, 6, 7, 8, 9]

只接收後兩個參數

>>> *a,b,c = range(10)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7]
>>> b
8
>>> c
9

只接收前兩個參數和後兩個參數

>>> a,b,*c,d,e = range(10)
>>> a
0
>>> b
1
>>> c
[2, 3, 4, 5, 6, 7]
>>> d
8
>>> e
9

列表解包

test(*nums)   ==》 test(10,20)

In [9]: def test(a,b): 
   ...:     print(a,b) 
   ...:                                                                                    

In [10]: nums = [10,20]                                                                    

In [11]: test(*nums)                                                                       
10 20

列表解包(把一個列表的參數所有所有傳遞給函數循環打印出每個元素)

In [12]: def test(*args): 
    ...:     for i in args: 
    ...:         print(i) 
    ...:                                                                                   

In [13]: nums = [1,2,3,4]                                                                  

In [14]: test(*nums)                                                                       
1
2
3
4

字典解包

字典解包 前邊加兩個 *

In [15]: def test(p1,p2): 
    ...:     print(p1,p2) 
    ...:                                                                                   

In [16]: nums = {"p1":100,"p2":200}                                                        

In [17]: test(**nums)                                                                      
100 200

(4).函數的關鍵字參數調用

關鍵字參數調用和參數的位置沒有關係

>>> def default(a,b,c):
...     print(a,b,c)
... 
>>> default(c=1,b=2,a=3)
3 2 1

字符串中的關鍵字參數調用

>>> '{name} is {age}'.format(name='likuan',age=25)
'likuan is 25'

(5).實參強制關鍵字參數

在函數定義參數的時候，第一個參數是 * 表示後邊的參數必需要用 key value的形式表示出來

In [2]: def test(*,a,b): 
   ...:     print(a,b) 
   ...:                                                                                    

In [3]: test(1,2)                                                                          
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-59e40cf39b25> in <module>
----> 1 test(1,2)

TypeError: test() takes 0 positional arguments but 2 were given

In [4]: test(a=1,b=2)                                                                      
1 2

4.函數的做用域

遵循LGB原則（先從L找再從G找最後在B中找）

L  local 函數體 和函數參數

G gloabal 模塊內

B python內置的參數

5.值傳遞和地址傳遞

（1）基本數據類型在函數傳遞時，直接傳遞值，在函數內修改值不影響函數體外的值

（2）引用類型在函數傳遞時，傳遞數據的地址，在函數內修改會影響函數體外的值（在內存中的地址一致因此函數體內的值修改都會修改）

地址傳遞

>>> a = []
>>> def test(p1):
...     p1.append(1)
... 
>>> test(a)
>>> a
[1]

6.函數的可變參數

（1）列表可變參數（是一個元組）

>>> def test(a,b,*arg):
...     print(a,b,arg)
... 
>>> test(1,2,3,4)
1 2 (3, 4)

（2）關鍵字可變參數（字典須要用賦值的方式）

>>> def test(a,b,*arg,**args):
...     print(a,b,arg,args)
... 
>>> test(1,2,3,4,c=1)
1 2 (3, 4) {'c': 1}

（3）混用（列表可變參數，關鍵字可變參數，默認參數，常規參數）

>>> def test(a,b,*arg,c=1,**args):
...     print(a,b,c,arg,args)
... 
>>> test(1,2,4,5,c=6,d=7)  
1 2 6 (4, 5) {'d': 7}

7.函數也是變量

函數放在列表中

>>> def test1(): print(test1)
... 
>>> def test2(): print(test2) 
... 
>>> def test3(): print(test3) 
... 
>>> test = [test1,test2,test3]
>>> for i in test:
...     print(i)
... 
<function test1 at 0x7f4bce855598>
<function test2 at 0x7f4bce855488>
<function test3 at 0x7f4bce855510>

函數在字典中

>>> fd = {'test1':test1,'test2':test2,'test3':test3}
>>> fd['test1']
<function test1 at 0x7f4bce855598>

在函數中定義函數

>>> def ceshi():
...     def ceshi2():
...         print(1)
...     ceshi2()
... 
>>> ceshi() 
1

8.匿名函數 lambda 

lamdba 函數只有一個函數體

>>> add = lambda a,b,c: a + b + c
>>> add(1,2,3)
6

9.sort 函數 和  sorted 函數

sort 函數,排序以第一個值排序

>>> l = [(1,2),(2,3),(3,1),(4,5),(2,3)]
>>> l.sort()
>>> l
[(1, 2), （2, 3), (2, 3), (3, 1), (4, 5)]

sort 函數，排序以第二個排序

>>> l.sort(key=lambda x: x[1])
>>> l
[(3, 1), (1, 2), (2, 3), (2, 3), (4, 5)]

sort() 函數 和 sorted() 函數的區別：

（1）sort() 函數只能對 list 進行排序， 對原數據進行修改

（2）sorted() 函數對任何可迭代的進行排序，不會對原來的 進行修改，返回一個新的列表

>>> a = [1,2,4,3]
>>> a.sort()
>> a
[1, 2, 3, 4]
>>> b = (1,2,6,5)
>>> c = sorted(b)
>>> c
[1, 2, 5, 6]
>>> b
(1, 2, 6, 5)

小練習 根據 字符串中字母的個數取出top5

>>> chars = {
...     'a' : 10,
...     'b' : 8,
...     'c' : 9,
...     'x' : 9,
...     'y' : 7,
...     'z' : 10,
...     'm' : 4,
...     'n' : 7
... }
>>> sorted(chars.items(),key=lambda x: x[1],reverse=True)
[('a', 10), ('z', 10), ('c', 9), ('x', 9), ('b', 8), ('y', 7), ('n', 7), ('m', 4)]
>>> sorted(chars.items(),key=lambda x: x[1],reverse=True)[:5]
[('a', 10), ('z', 10), ('c', 9), ('x', 9), ('b', 8)]

10.包

模塊（py腳本）

導入方式

import 文件名

 

導入包（文件夾裏必需要有__init__.py文件）

import 文件夾

 

mod.py 文件內容

#!/usr/bin/python

name = 'likuan'

 

#!/usr/bin/python

import mod

print(mod.name)

 

另外一種帶入方式

from mod import name

print(name)

 

導入函數與如今函數中有函數名衝突能夠用as去起一個別名

 

from mod import name as name_test

name = 'lizhi'

print(name,name_test)

 

以腳本運行的時候 __name__ == main

以模塊導入的方式 __name__ == 腳本名

 

name = 'likuan'

if __name__ == '__main__':

    print(name)

elif __name__ == 'mod':

print('test')

11，json字符串

格式化json

json.dumps()

還原以前的 json 字符串

json.loads()