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()