Python运维基础（2）函数以及pickle序列化

函数

函数
函数是指在程序中将一组命令用特定的格式包装起来，定义一个名称，然后可以在程序的任何地方调用此函数名来执行函数里的那组命令。
使用函数的好处：
1. 程序的可扩展性
2. 减少程序代码
3. 方便程序架构的更改

* 函数的定义及调用 *

 def say_hi(name):
    print("%s hello world ! " % name)


n = 'zhuzhuzhu'
say_hi(n)

实现：从列表中取出名字，并且利用函数输出：xxx , hello world !

def say_hi(n):
    print("%s, hello world ! " % n)


f = open('info.txt')
dic = {}
for line in f.readlines():
    name = line.split()[1]
    say_hi(name)

函数进阶

参数

1. 默认参数（函数定义时）：
   默认参数是指函数的参数在定义时给出了初始值，这时如果函数在调用时没有给这个参数传入值，函数就会使用定义时的默认值，如果传了值给这个参数，则该值会覆盖默认值。

def name_info(name, age, job, nationality='China'):
    print("%s's information is here:\nName : \t%s\nAge : \t%d\nJob : \t%s\nNationality : \t%s" % (name, name, age, job, nationality))

name_info("zhuzhuzhu", 20, 'IT', 'MARS')
name_info('liuliuliu', 21, 'IT')

运行结果：

zhuzhuzhu's information is here:
Name :  zhuzhuzhu
Age :   20
Job :   IT
Nationality :   MARS
liuliuliu's information is here:
Name :  liuliuliu
Age :   21
Job :   IT
Nationality :   China

Process finished with exit code 0

总结：像nationality = ‘China’这样的参数表示即为默认参数，调用函数时，若用户传入参数，传入的参数会覆盖掉默认参数，如果没有传入参数，则在函数中使用默认参数。

2.关键字参数（函数调用时）
关键字参数是指在函数调用时，把参数名和对应的值一起传入函数，这时就不用考虑传入参数的顺序。
def fun(x, y)—fun(y = 5, x = 6)

3.必备参数（函数定义时）
函数的参数在定义时只有参数名，没有参数值，这种定义的方式使得只有传入参数才能正常进行函数调用。
必备参数的个数和顺序必须和定义时一致。调用时若使用了关键字参数就可以改变参数顺序

def fun(x,y)—fun(1,2)

4.不定长参数：
（1）*arg 元祖（会将输入的参数以变为元祖形式，但是注意这里不能输入列表）

def sum1(*arg):
    return sum(arg)


t = sum1(1, 2, 3, 4)
print(t)


def sum2(*arg):
    sum = 0
    for i in arg:
        sum += i
    return sum


s = sum2(1, 2, 3, 4)
print(s)

（2）**kw 字典

def fun(**kw):
    print(kw)


fun(a=1, b=2)     # 字典必须以 a = ?, b =?这种形式进行传参


def func(**zz):
    for i in zz:
        print(i)
    print(zz)


func(a=1, b=2)

也可以用*进行传参

tp = 'a', 2, 1


def ff(a, b, c):
    print(a)
    print(b)
    print(c)


ff(*tp)

或者用 * * 来传参

d = {'a': 1, 'b': 2, 'c': 3}


def ff(a, b, c):
    print(a)
    print(b)
    print(c)


ff(**d)

注意！！

def ff(a, b=5, *c, **d):
    print(a)
    print(b)
    print(c)
    print(d)
ff(1, 2)
> 输出1 2 () {}

ff(1, 2, 3, 4, 5, 6, 7, 8)
> 输出1 2 (3, 4, 5, 6, 7, 8) {}

ff(1, 2, 3, 4, x=1, y=2)        
> 输出1 2 (3, 4) {'x':1, 'y':2}

ff(1, 2, x=3, y=4)
> 输出1 2 () {'x':3, 'y':4}

变量
1. 全局变量
2. 局部变量
需要注意的是：global 只能把函数内部的变量变为全局变量，而不能对函数外部变量进行操作。

pickle序列化 (数据持久存储)

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

关于序列化与反序列化的一些收获：
Python中 pickle有什么意义，pickle了再恢复？ - 知乎
https://www.zhihu.com/question/38355589可以说是非常清楚了…

pickle语法：

参考：https://www.cnblogs.com/cobbliu/archive/2012/09/04/2670178.html

import pickle

pickle 模块提供了以下函数：

dump(object, file) 将对象（object）写到文件（file）中，这个文件可以是实际的物理文件，也可以是任何类似于文件的对象，这个对象具有 write() 方法，可以接受单个的字符串参数；

# 使用python的pickle模块将数据对象保存到文件
import pickle
account_info = {'123': ['zhuzhuzhu', 15000, 15000], '456': ['liuliuliu', 12000, 12000]}
f = open("account.pkl", 'wb')
pickle.dump(account_info, f)
f.close()

首先导入pickle模块，然后定义一个账户信息，之后将这些信息写入文件。

load(file) 返回包含在 pickle 文件中的对象。

f = open('account.pkl', 'r')
account_info = pickle.load(f)  # 需要读取文件内容时，可使用该方法反序列化出对象
print(account_info)
f.close()

dumps(object) 返回一个字符串，它包含一个 pickle 格式的对象；
loads(string) 返回包含在 pickle 字符串中的对象；
dump()函数能一个接着一个地将几个对象转储到同一个文件。随后调用 load()以同样的顺序检索这些对象
pickle.dumps()方法把任意对象序列化成一个str，然后，就可以把这个str写入文件。而用pickle.dump()时其格式如上例：要将对象序列化之后写入文件中。

a = {'x':'1', 'y':'2'}
f = open("file.txt", "wb")
pickle.dump(a, f)
f.close()

一个字典a = {‘name’:’Tom’,’age’:22}，用pickle.dump存到本地文件，所存数据的结构就是字典，而普通的file.write写入文件的是字符串。读取时，pickle.load返回的是一个字典，file.read返回的是一个字符串。