Python自动化学习笔记（五）——函数（传参、参数类型）、全局变量、常用模块（json模块、os模块、time模块）

1.函数

1.1 return的作用

• 把函数处理结果返回
• 结束函数，函数里面遇到return立马结束

1.2 return包含多个值

返回多个值时，系统用一个元组来接收多个返回值，示例如下:

def get_user():
    s='abc,123'
    username,password=s.split(',')
    return username,password

a=get_user()
print(a)

输出结果为：('abc', '123')，a的类型为一个元组

1.3函数的参数类型详解

 

位置参数、默认参数、可变参数、关键字参数

• 必填参数，位置参数，必传
• 默认值参数，非必传,默认参数调用的时候，既可以按顺序提供默认参数，也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上

• 可变参数，非必传，允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。形参使用*args形式
• 关键字参数，非必传，允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。形参使用**args形式，传参的时候必须得用k=v这种形式来传

一个默认参数的函数例子

#一个读写文件的函数，传入content则写入，不传则读取文件
def op_file(filename,content=None):
    with open(filename,'a+',encoding='utf-8') as fw:
        fw.seek(0)      #移动文件指针
        if content:
            fw.write(content)       #指针移动到文件头部，还是会追加到文件末尾
        else:
            return fw.read()

一个可变参数的函数例子

def mysql2(*info):
     print(info)
mysql2() #转为一个空元组传入
#mysql2(user='root')   #调用方法错误
mysql2('root',123)  #输出('root', 123)，转为元组传入函数
info=[1,2]
mysql2(*info)  #将list中的元素拆开传入函数，输出(1,2)

def calc(a,b):  #只有位置参数的函数
    print(a+b)
    return a+b
l=[1,2]
calc(*l)  #也可以这样传参，将list中的元素拆开传入函数，输出3

一个关键字参数的函数例子

def mysql(**mysql_info):
    print(mysql_info)

mysql()  #传入一个空字典，输出为{}
#mysql('ip','user')  #错误传入方式
mysql(ip='ip',user='user') #关键字形式传入，输出{'ip': 'ip', 'user': 'user'}

info={'ip':'ip1','user':'user1'}
mysql(**info)  #字典拆开再传入，输出{'ip': 'ip1', 'user': 'user1'}

def mysql1(ip,user):#只有位置参数的函数
    print(ip,user)
mysql1(**info) #也可以这样传参，字典拆开再传入字典的value，输出ip1 user1

一个同时包含位置参数和关键字参数的例子

def request(url,method,**info): #位置参数和关键字参数都有的函数
    print(url)
    print(method)
    print(info)
    if info.get('data'):  #关键字参数中是否传入data这个参数
        data=info.get('data')
        print(data)
request('www.baidu.com','get',data='哈哈哈',file='aaa.txt')

输出结果：

2.全局变量

 应该尽量避免使用全局变量。不同的模块都可以自由的访问全局变量，容易出错。全局变量降低了代码的可读性，并且一直占用内存

代码示例：

name='小明'   #字符串类型的全局变量
stus=[] #全局变量是list、字典、集合时，修改时不需要声明global
def a():
    name='哈哈哈'
    print(name)  #局部变量，不影响全局name的值，调用函数输出‘哈哈哈’

def c():
    global name    #声明name是全局的
    stus.append('abc')  #全局变量是list，没有声明global也可以修改，在函数外部打印stus会输出['abc']
    name='哈哈哈'   #声明后修改全局变量的值
    print(name)　　#调用函数输出‘哈哈哈’

3.常用内置模块

3.1 json模块

 四个常用方法：

• dic=json.loads(json_str) #把字符串(json串)转成字典,传入一个json格式的字符串，返回一个字典
• str=json.dumps(dic,ensure_ascii=False) #把字典转成json串（字符串），传入一个字典，返回一个json格式的字符串；ensure_ascii=False意思是不进行ascii编码，如果省略此参数，字符串中的中文将是ASCII编码后的
• dic=json.load(f)　　　　　　#直接从文件里读出来json再转成字典返回，传入f为文件句柄，返回一个字典
• json.dump(dic,f,ensure_ascii=False,indent=4)　　#直接将字典按json格式写入文件，不需要先转成json,返回None，传入一个字典dic和文件句柄f，并按照缩进四格来格式化

loads方法示例代码

import json
json_str='''
{"name":"xiaohei","age":18,"sex":"男","age":18}
'''
res=json.loads(json_str)    #把字符串(json串)转成字典
print(res)

输出：

dumps方法示例代码

import json
dic={"name":"xiaohei","age":18,"sex":"男","age":18}
#把字典转成json串（字符串）
res=json.dumps(dic,ensure_ascii=False,indent=4)       #把字典转成json串（字符串）
print(res)

输出：

load&dump方法示例代码

import json
dic = {
    "xiaohei":{
        "age":18,
        "password":12345,
        "sex":"男",
        "addr":"北京"
    },
    "xiaoming":{
        "age":18,
        "password":12345,
        "sex":"男",
        "addr":"北京"
    },
    "xiaodong":{
        "age":18,
        "password":12345,
        "sex":"男",
        "addr":"北京"
    }
}
#直接从文件里读出来json再转成字典返回
with open('user_new.json',encoding='utf-8') as f:
    res=json.load(f)
    print(res)

#直接将字典按json格式写入文件，不需要先转成json
with open('user_new.json','w',encoding='utf-8') as fw:
    res=json.dump(dic,fw,ensure_ascii=False,indent=4)

3.2 os模块

 常用方法：

• os.listdir('e:/') #列出目录下的所有文件和文件夹
• os.remove() #删除文件
• os.rename()#重命名文件
• os.mkdir(r'testday5') #创建文件夹 r代表原字符串
• os.makedirs(r'test\testday5') #递归创建，父目录不存在时一起创建
• res=os.path.exists(r'test\testday5') #文件或文件夹是否存在
• res=os.path.isfile(r'test\testday5') #判断是否为文件
• res=os.path.isdir(r'test\testday5') #判断是否为文件夹
• res=os.path.split(r'test\testday5\aa') #将路径和文件名区分开，返回一个包含两个元素的元组
• res=os.path.dirname(r'test\testday5') #获取父目录
• res=os.getcwd() #获取当前目录
• os.chdir('../day5') #切换目录
• print(os.environ) #获取计算机的环境变量
• res=os.path.join('test','abc','a.txt') #拼接路径,不需要指定分隔符
• res=os.path.abspath('..') #根据相对路径获取绝对路径
• res=os.system('ipconfig') #执行操作系统命令,无法获取结果，#命令执行成功返回0，失败返回1
• res=os.popen('ipconfig').read() #执行操作系统命令,并获取结果

 

 

3.3 time模块

#格式化好的时间 20181202
#时间戳  计算机诞生的时间到现在过了多少秒
#时间元组 格式化好的时间和时间戳相互转换的媒介

常用方法：

• time.time()　　#获取当前时间戳
• time.strftime('%Y-%m-%d %H:%M:%S')) #按指定格式获取格式化好的当前时间
• time.gmtime(234466755) #指定时间戳转换为时间元组
• time.gmtime(int(time.time())) #将标准时区的当前时间戳转换为时间元组
• time.localtime(int(time.time())) #将当前时区的当前时间戳转换为时间元组
• time.strftime('%Y-%m-%d %H:%M:%S',time1) #时间元组time1转成格式化时间,不传时间元组，则转换当前时间
• time.strptime('20181023153856','%Y%m%d%H%M%S') #格式化时间先转成时间元组
• time.mktime(timep) #时间元组转为时间戳
• time.sleep(seconds)　　#程序休眠几秒

代码示例，时间戳和格式化时间相互转换的两个函数：

import os
#时间戳转格式化时间
def timestampToStr(timestamp=None,format='%Y-%m-%d %H:%M:%S'):
    if timestamp:           #传入timestamp,则转换指定的时间戳
        time1=time.gmtime(timestamp)  #时间戳转换为时间元组,
        res = time.strftime(format, time1)  # 时间元组转成格式化时间

    else:                   #没有传入timestamp，默认返回格式化好的当前时间
        res = time.strftime(format)  # 获取当前格式化的时间   
    return res

#格式化时间转时间戳
def strTotimestamp(str=None,format='%Y-%m-%d %H:%M:%'):
    if str:                 #传入时间,则转换指定的时间
        timep = time.strptime(str, format)  # 格式化时间先转成时间元组
        res = time.mktime(timep)
    else:                   #没有传入时间，默认返回当前的时间戳
        res=time.time()     #获取当前时间戳
    return int(res)

4.列表生成式,浅拷贝，深拷贝，了解一下

4.1列表生成式

s=[1,2,3,4,5]
for i in s:
    print(i+1)

res=[i+1 for i in s]
print(res)  #等同于上面2.3行的循环，[[i+1 for i in s]]被称为列表生成式，可以使代码更简洁

 4.2浅拷贝&深拷贝

#浅拷贝：两个变量指向同一块内存地址：

list1=[1,2]
list2=list1 #两个变量的内存地址一致，修改list2时，list1的值也会修改，本质上其实是一个变量

#深拷贝：开辟一块新的内存地址

list1=[1,2]
list2=list[:]