自动化运维Python系列之基础函数和文件操作

Posted 2020-08-14

函数作用

 增强代码的重用性和可读性

 在没有使用函数编程之前，我们可能一直遵循的都是面向过程编程，即根据业务逻辑从上到下实现各个功能，这样的做的坏处是代码可读性不强，大量冗余代码，而且执行效率不高；有了函数后，我们就可以将多次使用到的相同代码模块放在单独的函数定义中，在任何想要调用它的地方随时调用，这就叫做函数式编程。

 面向对象编程其实就是对函数进行再分类和封装，让开发"更快更好更强..."

 

函数的定义

def 函数名(参数):

       

    ...

    函数体

    ...

    返回值

函数的定义主要有如下要点：

1）def：表示函数的关键字

2）函数名：函数的名称，日后根据函数名调用函数

3）函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...

4）参数：为函数体提供数据

5）返回值：当函数执行完毕后，可以给调用者返回数据

     

函数参数

可以对Python函数传以下几种形式的参数：

1、普通参数（严格按照顺序，将实际参数赋值给形式参数）
2、默认参数（必须放置在参数列表的最后）
3、指定参数（将实际参数赋值给指定的形式参数）
4、动态参数：
   *        默认将传入的参数，全部放置在元组中
   **       默认将传入的参数，全部放置在列表中

5、万能参数 *args，**kwargs

   

这几种参数原理有点类似字符串的格式化输出

# str.format() 格式化输出
s1 = "i am {0}, age {1}".format("kobe",18)
print(s1)
s2 = "i am {0}, age {1}".format(*["kobe",18])
print(s2)
s3 = "i am {name}, age {age}".format(name=‘kobe‘,age=‘18‘)
print(s3)
dic_01 = {‘name‘:‘kobe‘,‘age‘:18}
s4 = "i am {name}, age {age}".format(**dic_01)
print(s4)
输出：
i am kobe, age 18
i am kobe, age 18
i am kobe, age 18
i am kobe, age 18

  

1）普通参数

def login(user,pwd):
  print（user,pwd）
login(user,pwd)

  

2）默认参数

def login(user="kobe", pwd=123):
    print(user,pwd)
login()

  

3）指定参数

def login(user, pwd):    print(user,pwd)
login(pwd=123, user="kobe")
#指定参数的话，参数顺序就可以随便

  

4）动态参数

*args 一个星号

def f1(*args):
   print(args,type(args))
f1(11,22,‘hhhh‘)li = [22,33,‘hehe‘]f1(li,‘44‘)f1(*li)  # 给全部的参数作为元组的每一个元素添加lii = ‘kobe‘f1(*lii)  # 循环字符串每一个元素
输出
(11, 22, ‘hhhh‘) <class ‘tuple‘>  # 函数接受所有参数，还是原来的元组
([22, 33, ‘hehe‘], ‘44‘) <class ‘tuple‘> # 函数接受列表元素，并将他的整体作为一个元组的一部分
(22, 33, ‘hehe‘) <class ‘tuple‘> # 用一个星号可以将列表中的每一个元素添加进元组
(‘k‘, ‘o‘, ‘b‘, ‘e‘) <class ‘tuple‘> # 字符串循环的话，是每一个字符

   

**args 两个星号

def f2(**args):    print(args,type(args))f2(n1="kobe")dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}f2(kk=dic)   # 只有一个键值对f2(**dic)
输出
{‘n1‘: ‘kobe‘} <class ‘dict‘> # 两个星号动态参数会将键值保存为字典
{‘kk‘: {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}} <class ‘dict‘> # 传字典参数要是不加两个**，只会出现一个键值对
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘} <class ‘dict‘> # 传字典参数，正确做法是加两个**

  

混合传参

def f3(*args,**kwargs):     # 万能参数只能放置在args后    print(args)    print(kwargs)
f3(11,22,33,k1="v1",k2="v2")
输出
(11, 22, 33) # Python会自动将列表通过*args接收为元组
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘} # 键值对会自动通过**args接收为字典

  

函数扩展01：重复函数定义

def f4(a1,a2):    return a1 + a2def f4(a1,a2):    return a1 * a2ret = f4(8,8)
print(ret)
输出
64
# 原因是因为Python执行代码自上而下，之前被执行的 a1+a2 =16由于在内存中没人使用，很快会被Python的垃圾回收机制所回收

  

函数扩展02：函数传参是原值引用还是重新创建的新值？

def f5(a1):    a1.append(999)li_01 = [11,22,33]f5(li_01)
print(li_01)
输出
[11, 22, 33, 999]
# 结果表明函数传参是使用的引用，增加的话会改变原列表

  

函数扩展03：全局变量

NAME = "kobe"      
# 全局变量(潜规则：全局变量都用大写)
def f6():    
    age = 18       
# 局部变量    
    global NAME    
# 修改全局变量
# 如果需要修改的变量是一个列表，则在函数里面可以读，可以append添加
但是不可以修改或者赋值    
    name = "jordan"    
    print(NAME,age)
f6()
输出
kobe 18

 

Python的内置函数

 

# abs取绝对值

n = abs(-1)

 
# all() 所有元素为真则为真

n = all([1, 2, 3, 4])
print(n)

# any() 只要有真则为真

n = any([1, 0, None])
print(n)

   
# ascii() 自动执行对象的__repr__方法
   
# bin() 10进制转换成2进制
# oct() 10进制转换成8进制
# hex() 10进制转换成16进制
  
# bool值

# 0,None,"",[],{},() 都为False
print(bool(0))

  

bytes()

# bytes()字符串转换字节类型
# bytearray()字符串转换字节生成列表
# utf-8 一个汉字占用3个字节
# gbk 一个汉字占用2个字节
# 真是这个原因才导致很多gbk文件用utf-8打开会出现乱码
s = "李杰"
n = bytes(s, encoding="utf-8")
print(n)
输出
b‘\xe6\x9d\x8e\xe6\x9d\xb0‘

  
# 将字节转换成字符串

n = str(bytes(s, encoding="utf-8"), encoding="utf-8")
print(n)
输出
李杰

  

函数示例小程序：用户登陆注册

def login(user,pwd):
    """
    用户用户登陆验证
    :param: user 用户名
    :param: pwd  密码
    :return: Ture 登陆成功 False 登陆失败
    """
    f = open(‘db‘,‘r‘)
    for line in f:
        if line.split(‘|‘)[0] == user and line.split(‘|‘)[1] == pwd:
            return True
    return False
def register(user, pwd):
    """
    用户用户注册
    :param user: 用户名
    :param pwd: 密码
    :return: 默认None
    """
    f = open(‘db‘, ‘a‘)
    temp = "\n" + user + "|" + pwd
    f.write(temp)
    f.close()
def main():
    select = input("请选择：【1】登陆 【2】注册 ：")
    if select == "1":
        print("正在登陆...")
        user = input("请输入用户名： ")
        pwd = input("请输入密码： ")
        ret = login(user, pwd)
        if ret is True:
            print("登陆成功！")
        else:
            print("登陆失败！")
    if select == "2":
        print("正在注册...")
        user = input("请输入用户名： ")
        pwd = input("请输入密码 ")
        ret = register(user, pwd)
        print("注册成功！")
main()

   

三元运算&三目运算

# 三元运算 通过一条命令代替if else语句

if 1==1:
    name = "kobe"
else:
    name = "jordan"
name = "kobe" if 1 == 1 else "jordan"

 
# lambda表达式

def f1(a1):
    return a1 + 100
f2 = lambda a1, a2: a1 + a2
ret = f1(10)
ret2 = f2(100,10)
print(ret,ret2)
输出
110 110

  

文件操作

1)打开文件

# f = open(‘db‘, ‘r‘)  # 只读
# f = open(‘db‘, ‘w‘)  # 只写，先清空
# f = open(‘db‘, ‘x‘)  # python 3.0 新加（如果文件存在报错，不存在则创建并写内容）
# f = open(‘db‘, ‘a‘)  # 追加
# f = open(‘db‘, ‘r‘, encoding="utf-8")  # 指定字符编码，防止乱码
# f = open(‘db‘, ‘rb‘)  # 以二进制打开

 

r+ a+ w+的区别

# r+ 能调整写文件指针位置,其他的总是写到末尾
# a+ 能读，但是写文件只能在末尾添加
# w+ 会先清空文件再写
f = open(‘db‘, ‘r+‘, encoding="utf-8")  # 如果模式没有加 b 中文默认按照一个字符读取数据
data = f.read(1)
f.seek(3)   # 调整文件指针到执行位置（以字节方式查找）
print(f.tell())
f.write("777")  # 会覆盖已经存在的元素

 
2）操作文件

f.read()  # 无参数默认读全部;有参数（b按字节;无b按字符）
f.tell()  # 查看指针位置
f.seek()  # 按字节调整指针位置
f.write()  # 写文件
f.close()  # 关闭
f.fileno()  # 文件的描述符
f.flush()  # 强刷文件到硬盘
f.readable()  # 是否可读
f.readline()  # 仅读取一行
f.truncate()  # 截断指针后面的所有数据

  
for循环文件对象

for line in f:
    print(line)

 
关闭文件

f.close()
with open(‘db‘) as f:
    pass

  
同时打开两个文件

with open(‘db01‘) as f1, open(‘db02‘) as f2:
    pass

本文出自 “改变从每一天开始” 博客，请务必保留此出处http://lilongzi.blog.51cto.com/5519072/1860873