Python函数式编程-动态参数、函数实战与Python常用库

一、动态参数

1、什么时候使用动态参数？

（1）：当函数的形式参数个数不确定时；

（2）：当函数的形式参数数据类型不确定时。

2、在Python中，“*”：代表的是元组，“**”：代表的是字典。

3、应用

应用1：

def func(*args,**kwargs):
    print(args)
    print(type(args))
    print("\n")
    print(kwargs)
    print(type(kwargs))
func(a=2) 
func(**{"name":"lucy","age":23,"city":"xi'an"})
func("a","b","c")
func(["a","b","c"])
func([x for x in range(3)])
func((1,2,3,4))

运行结果如下：

()
<class 'tuple'>


{'a': 2}
<class 'dict'>
()
<class 'tuple'>


{'name': 'lucy', 'age': 23, 'city': "xi'an"}
<class 'dict'>
('a', 'b', 'c')
<class 'tuple'>


{}
<class 'dict'>
(['a', 'b', 'c'],)
<class 'tuple'>


{}
<class 'dict'>
([0, 1, 2],)
<class 'tuple'>


{}
<class 'dict'>
((1, 2, 3, 4),)
<class 'tuple'>


{}
<class 'dict'>

Process finished with exit code 0

应用2：在接口测试中会用到，接口测试中有多个接口，有时候请求需要4个参数，有时候请求需要5个参数，有时候请求需要6个参数，有时候一个也不需要。

假设我们分别请求需要1个参数、3个参数：

按照我们原先的做法，我们会这样：

def data1():
    return{} #1个参数
print(data1()) 

def data2():
    return{"name":"lucy","age":23,"city":"xi'an"} #3个参数
print(data2())

运行结果如下：

{}
{'name': 'lucy', 'age': 23, 'city': "xi'an"}

Process finished with exit code 0

这样显然很麻烦，我们需要输入2个函数：data1()和data2()，而我们如果使用动态参数这种方法会简洁许多。动态参数法如下：

def data(**kwargs):
    return kwargs
print(data())
print(data(**{"name":"lucy","age":23,"city":"xi'an"})) 
#本身就是字典型，想要它返回输出也是字典，那么只需给它前面添加“**”即可。

运行结果如下：

{}
{'name': 'lucy', 'age': 23, 'city': "xi'an"}

Process finished with exit code 0

二、函数实战

要求：
1、注册登录
2、登陆成功后，显示个人主页
3、通过控制台的模式来交互

代码如下：

1-1：注册页面

def registred():
    username=input("What is your name?")
    password=input("Please write your password:")
    temp=username+"-"+password
    with open(file="login.txt",mode="w",encoding="UTF-8") as f:
        f.write(temp)
registred()

运行结果如下：

What is your name?Lucy
Please write your password:17166230

Process finished with exit code 0

1-2：登陆页面

def login():
    username=input("What is your name?")
    password=input("Please write your password:")
    with open(file="login.txt",mode="r",encoding="UTF-8") as f:
        lists=f.read().split("-")
    if username==lists[0] and password==lists[1]:
        return True
    else:
        print("登陆失败，请重新登陆！")
print(login())

运行结果1：

What is your name?Lucy
Please write your password:17166230
True

Process finished with exit code 0

运行结果2：

What is your name?Rose
Please write your password:20220620
登陆失败，请重新登陆！

Process finished with exit code 0

2：显示个人主页面

def profile():
    with open(file="login.txt",mode="r",encoding="UTF-8") as f:
        lists=f.read().split("-")
    print("Welcome to {person} page!".format(person=lists[0]))
profile()

运行结果如下：

Welcome to Lucy page!

Process finished with exit code 0

3：通过控制台的模式来交互

#公共部分，封装思想，减少重复代码书写
def out():
    username=input("What is your name?")
    password=input("Please write your password:")
    return username,password
#注册
def registered():
    username,password=out()#公共部分
    temp=username+"-"+password
    with open(file="login.txt",mode="w",encoding="UTF-8") as f:
        f.write(temp)
# 登陆
def login():
    username, password = out() #公共部分
    with open(file="login.txt",mode="r",encoding="UTF-8") as f:
        lists=f.read().split("-")
    if username==lists[0] and password==lists[1]:
        return True
    else:
        print("登陆失败，请重新登录！")
#访问主页面
def profile():
    with open(file="login.txt",mode="r",encoding="UTF-8") as f:
        lists=f.read().split("-") #字符串转列表，字符串的拆分：.split()数据类型是列表
    print("Welcome to {person} page!".format(person=lists[0]))
#主函数
def principal():
    while True:
        try:  #异常处理
            f=int(input("1、注册,2、登陆\n"))
            if f==1:
                registered()
            elif f==2:
                if login()==True:
                    profile()
                else:
                    print("Please login again")
            else:
                break
        except:continue
if __name__ == '__main__':#作为程序的入口，执行函数
    principal()

运行结果如下：

1、注册,2、登陆
1
What is your name?Lucy
Please write your password:17166230
1、注册,2、登陆
2
What is your name?Rose
Please write your password:20220620
登陆失败，请重新登录！
Please login again
1、注册,2、登陆
2
What is your name?Lucy
Please write your password:17166230
Welcome to Lucy page!
1、注册,2、登陆
3

Process finished with exit code 0

 

三、Python常用库

1、模块与包

在Python里面，每一个Python文件都可以成为一个模块，在一个包中可以包含多个Python文件，包与模块之间的关系如下：

1-1：如果是同包之间的模块调用，即这2个模块文件在同一个包下面，它的方式为：

假设我命名的包和文件是这样的：

在index.py和logout.py之间相互调用：

index.py文件如下：

name="Lucy"
def login():
    print("login success!")
a="Hello world！"

logout.py文件如下：

from package.package.module import *  #包里的包里的模块

from module.index.index import *  #包里的包里的模块
print(name)
login()
print(a)

运行结果如下：

Lucy
login success!
Hello world！

Process finished with exit code 0

1-2：如果是不同包之间的模块调用，即这2个模块文件不在同一个包下面，它的方式为：

假设我命名的包和文件是这样的：

在index.py和logout.py之间相互调用：

index1.py文件如下：

name="Lucy"
def login():
    print("login success!")
a="Hello world！"

logout.py文件如下：

from package.module import *   #导入全部的，包里的模块

from module.index1 import *  #包里的模块
print(name)
login()
print(a)

运行结果如下：

Lucy
login success!
Hello world！

Process finished with exit code 0

2、Python常用库

在Python中，可分为两类：

2-1：标准库：就是安装完Python解释器后，这些库就已经存在了，不需要单独的再次安装。即解释器自带的库。

2-2：第三方库：需要单独的进行安装。安装方式主要分为两类：一类是在线安装（建议），另一类是离线安装。即有组织或者是个人编写好的库，可以供全球的程序员使用。

安装：pip install 库的名称

卸载：pip uninstall 库的名称

常见的框架：

Django:WEB全栈开发框架

Flask:轻量级的WEB开发框架

Selenium:UI自动化测试框架

Requests:接口测试框架

2-3：随机数：random库

import random #使用第三方的库或者标准库
print(random.randrange(1,5,2))
print(random.randint(10,12))

运行结果如下：

1
11

Process finished with exit code 0

3、OS库实战

3-1：获取路径

import os
#获取当前路径
print(os.path.dirname(__file__))
#获取当前路径的上一级路径
print(os.path.dirname(os.path.dirname(__file__)))
#获取当前路径的上上一级路径
print(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))

3-2：路径的拼接

eg1:新建一个Data文件，里面新建一个file文件log，并且log里输入“Hello World！”

在module包里新建“os学习.py"

最终将两者的路径拼接成”D:\test\code\testDev\data\log“形式

import os
print(os.path.dirname(__file__))   #运行结果：D:\test\code\testDev\module
print(os.path.dirname(os.path.dirname(__file__)))   #运行结果：D:\test\code\testDev
base_dir=os.path.dirname(os.path.dirname(__file__))  #转换成文件形式
print(os.path.join(base_dir,"data","log")) #使用.join拼接,,#运行结果：D:\test\code\testDev\data\log
filePath=os.path.join(base_dir,"data","log") #转换成文件形式
with open(file=filePath,mode="r",encoding="UTF-8") as f: #将拼接好的读取出来
     print(f.read())

运行结果如下：

D:\test\code\testDev\module
D:\test\code\testDev
D:\test\code\testDev\data\log
Hello World!

Process finished with exit code 0

eg2:新建一个Data文件，里面新建一个file文件log，并且log里输入“Hello World！

在module包里新建"index包"再在此包里创建"os学习.py"

最终将两者的路径拼接成”D:\test\code\testDev\data\log“形式

import os
print(os.path.dirname(__file__))  #运行结果D:\test\code\testDev\module\index
print(os.path.dirname(os.path.dirname(__file__)))  #运行结果D:\test\code\testDev\module
print(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) #运行结果D:\test\code\testDev
base_dir=os.path.dirname(os.path.dirname(os.path.dirname(__file__))) #转换成文件形式
print(os.path.join(base_dir,"data","log")) #使用.join拼接,,#运行结果：D:\test\code\testDev\data\log
filePath=os.path.join(base_dir,"data","log") #转换成文件形式
with open(file=filePath,mode="r",encoding="UTF-8") as f: #将拼接好的读取出来
    print(f.read())

运行结果如下：

D:\test\code\testDev\module\index
D:\test\code\testDev\module
D:\test\code\testDev
D:\test\code\testDev\data\log
Hello World!

Process finished with exit code 0

3-3

3-3-1：获取操作系统:os.name

import os
print(os.name)

运行结果如下：

nt

Process finished with exit code 0

3-3-2:判断目录是否存在:os.path.exists()

import os
print(os.path.exists("C:\Program Files\Google"))

运行结果如下：

True

Process finished with exit code 0

3-3-3:判断是否是文件:os.listdir()

import os
print(os.path.exists("C:\Program Files\Google"))
for item in os.listdir("C:\Program Files\Google")
    print(item)

运行结果如下：

True
Chrome
GoogleUpdater

Process finished with exit code 0

事实上也确实如此：

3-3-4：”ping“命令来看是否可以访问网址：os.system()

import os
print(os.system("ping www.baidu.com))

运行结果如下：

���� Ping www.baidu.com [14.215.177.39] ���� 32 �ֽڵ�����:
���� 14.215.177.39 �Ļظ�: �ֽ�=32 ʱ��=35ms TTL=54
���� 14.215.177.39 �Ļظ�: �ֽ�=32 ʱ��=33ms TTL=54
���� 14.215.177.39 �Ļظ�: �ֽ�=32 ʱ��=51ms TTL=54
���� 14.215.177.39 �Ļظ�: �ֽ�=32 ʱ��=33ms TTL=54

14.215.177.39 �� Ping ͳ����Ϣ:
    ���ݰ�: �ѷ��� = 4���ѽ��� = 4����ʧ = 0 (0% ��ʧ)��
�����г̵Ĺ���ʱ��(�Ժ���Ϊ��λ):
    ��� = 33ms��� = 51ms��ƽ�� = 38ms
0

Process finished with exit code 0

4、time实战

time模块提供了各种与时间有关系的库，具体time的案例实战如下：

import time as t
#操作时间
#获取时间戳
print("获取当前时间的时间戳:",t.time()) #用的较多
print("返回当前的字符串:",t.ctime())
print("时间戳转为字符串:",t.ctime(t.time()))
print("本地化:",t.localtime(t.time()).tm_year)
print("本地化:",t.localtime(t.time()).tm_mon)
print("本地化:",t.localtime(t.time()).tm_mday)
print("中国人的时间:",t.strftime("%y-%m-%d %H:%M:%S",t.localtime())) #用的较多
t.sleep(10) #休眠10S
print("中国人的时间:",t.strftime("%y-%m-%d %X",t.localtime()))  # %H:%M:%S等价于%X
print("中国人的时间:",t.strftime("%y-%m-%d %x",t.localtime()))

运行结果如下：

获取当前时间的时间戳: 1655806814.1414294 #在每次重新运行的时候，所获取的当前时间戳是不一样的！
返回当前的字符串: Tue Jun 21 18:20:14 2022
时间戳转为字符串: Tue Jun 21 18:20:14 2022
本地化: 2022
本地化: 6
本地化: 21
中国人的时间: 22-06-21 18:20:14
中国人的时间: 22-06-21 18:20:24
中国人的时间: 22-06-21 06/21/22

Process finished with exit code 0

5、hashilb库实战

hashilb里面主要会涉及到md5的加密算法,其中md5是一种加密方式，md5加密后基本破解不了。

实战如下：

需求：接口测试

a:针对字典进行排序

b:把排序后的字典处理成key1=value1&key1=value2

c:进行md5加密，加密后就是密钥

import hashlib
from urllib import parse #urllib是网络爬虫
import time
def sign():
    dict1={"name":"Lucy","age":23,"city":"xi'an","time":time.time()}#加入时间戳可以使我们的项目更具安全性，不易破解！
    #字典排序
    data=dict(sorted(dict1.items(),key=lambda  item:item[0]))
    print(data)
    #把排序后的结果处理成key1=value1&key1=value2，编码：就是把str的数据类型转为bytes的数据类型的过程，使⽤到的关键字是encode.
    data2=parse.urlencode(data)
    print(data2)
    m=hashlib.md5() #进行md5的加密
    m.update(data2.encode("UTF-8"))
    print("加密后的结果信息:\n",m.hexdigest())
sign()

运行结果如下：

{'age': 23, 'city': "xi'an", 'name': 'Lucy', 'time': 1655807662.5053277}
age=23&city=xi%27an&name=Lucy&time=1655807662.5053277
加密后的结果信息:
 03488e7609a6606545acf584f26c6ce7

Process finished with exit code 0

6、Datetime实战

相比于time的模块，datetime也是表示时间的，但是会更加的直观，案例如下：

import datetime
import time
#datetime也是表示时间，是对time的二次封装
#获取当前时间
print(datetime.datetime.now())
#在当前时间基础上增加或者减少
print(datetime.datetime.now()-datetime.timedelta(days=10))
print(datetime.datetime.now()-datetime.timedelta(minutes=10))
print(datetime.datetime.now()-datetime.timedelta(seconds=10))
print(datetime.datetime.now()+datetime.timedelta(days=10))
print(datetime.datetime.now()+datetime.timedelta(minutes=10))
print(datetime.datetime.now()+datetime.timedelta(seconds=10))
#将时间戳转换为时间
print(datetime.datetime.fromtimestamp(time.time()))

运行结果如下：

2022-06-21 18:38:35.734726
2022-06-11 18:38:35.734726
2022-06-21 18:28:35.734726
2022-06-21 18:38:25.734726
2022-07-01 18:38:35.734726
2022-06-21 18:48:35.734726
2022-06-21 18:38:45.734726
2022-06-21 18:38:35.734727

Process finished with exit code 0

7、JSON库实战（很重要）

在接口测试中应用较多

7-1：序列化:【简单地说就是把Python对象(字典，列表，元组)转为字符串的过程。】把内存⾥的数据类型转为字符串的数据类型，使能够存储到硬盘或通过网络传输到远程，因为硬盘或者网络传输时只接受bytes的数据类型。序列化使用函数：json.dumps()

        反序列化:【简单地说就是把把字符串转为Python对象(字典，列表，元组)的过程。】反序列化使用函数：json.loads()

7-1-1：字典的序列化和反序列化

import json
#字典的序列化
dict1={"name":"Lucy","age":23,"city":"xi'an"}
dict1_str=json.dumps(dict1,indent=True,ensure_ascii=False)
dict1_str=json.dumps(dict1,indent=True,ensure_ascii=True)
print(dict1_str)
print(type(dict1_str))
#字典的反序列化
str_dict1=json.loads(dict1_str)
print(str_dict1)
print(type(str_dict1))

运行结果如下：

{
 "name": "Lucy",
 "age": 23,
 "city": "xi'an"
}
<class 'str'>
{'name': 'Lucy', 'age': 23, 'city': "xi'an"}
<class 'dict'>

Process finished with exit code 0

注意：字典的序列化的以下情况：

NO1：

import json
dict1={"name":"Lucy","age":23,"city":"xi'an"}
#无中文，不会出现乱码现象，因此不论"ensure_ascii"是等于"True"还是"False"，都不会影响。
dict1_str=json.dumps(dict1,indent=True,ensure_ascii=False)
dict1_str=json.dumps(dict1,indent=True,ensure_ascii=True)
print(dict1_str)
print(type(dict1_str))

运行结果如下：

{
 "name": "Lucy",
 "age": 23,
 "city": "xi'an"
}
<class 'str'>

Process finished with exit code 0

NO2：字典的序列化-乱码现象（ensure_ascii）

import json
dict1={"name":"黛西","age":23,"city":"xi'an"} #有中文，注意ASCLL码转换
#dict1_str=json.dumps(dict1,indent=True,ensure_ascii=True) #乱码现象
 #Python默认是ASCLL码，“ensure_ascii=False”转换为我们认识的中文
dict1_str=json.dumps(dict1,indent=True,ensure_ascii=False) #正确
print(dict1_str)
print(type(dict1_str))

运行结果如下：

{
 "name": "黛西",
 "age": 23,
 "city": "xi'an"
}
<class 'str'>

Process finished with exit code 0

NO3：字典的序列化-缩进现象（indent）

import json
dict1={"name":"黛西","age":23,"city":"xi'an"} #有中文，注意ASCLL码转换
dict1_str=json.dumps(dict1,indent=True,ensure_ascii=True) #乱码现象
Python默认是ASCLL码，“ensure_ascii=False”转换为我们认识的中文
dict1_str=json.dumps(dict1,indent=False,ensure_ascii=False) #错误的缩进
print(dict1_str)
print(type(dict1_str))

运行结果如下：

{
"name": "黛西",
"age": 23,
"city": "xi'an"
}
<class 'str'>

Process finished with exit code 0

7-1-2:元组的序列化和反序列化

import json
#元组的序列化
tuple1=("Python","Java")
tuple1_str=json.dumps(tuple1)
print(tuple1_str)
print(type(tuple1_str))
#元组的反序列化
str_tuple1=json.loads(tuple1_str)
print(str_tuple1)
print(type(str_tuple1))

运行结果如下：（注意它的运行结果的不同）

["Python", "Java"] #列表
<class 'str'>
['Python', 'Java'] #列表
<class 'list'>

Process finished with exit code 0

7-1-3:列表的序列化和反序列化

import json
#列表的序列化
lists=[x for x in range(5)]
list_str=json.dumps(lists)
print(list_str)
print(type(list_str))
#列表的反序列化
str_list=json.loads(list_str)
print(str_list)
print(type(str_list))

运行结果如下：

[0, 1, 2, 3, 4]
<class 'str'>
[0, 1, 2, 3, 4]
<class 'list'>

Process finished with exit code 0

7-2：针对文件的序列化和反序列化

序列化：把第三方的内容写到文件中 dump()

反序列化:从文件中读取数据 load()

7-2-1：先新建一个空白"json.txt"文本

import json
dict1={"name":"黛西","age":23,"city":"xi'an"} #假设为第三方的内容
json.dump(dict1,open(file="json.txt",mode="w",encoding="UTF-8"),ensure_ascii=False)
#写到文件中dump()
data=(json.load(open(file="json.txt",mode="r",encoding="UTF-8")))
#读取数据load()
print(data)
print(type(data))

运行结果如下：

{'name': '黛西', 'age': 23, 'city': "xi'an"}
<class 'dict'>

Process finished with exit code 0

会发现写的是字典型，对应的也会输出字典型！

打开空白"json.txt"文本，内容如下：

{"name": "黛西", "age": 23, "city": "xi'an"}

7-2-2：进一步优化“通过控制台的模式来交互”

#3、通过控制台的模式来交互
import json
#公共部分，封装思想
def out():
    username=input("What is your name?")
    password=input("Please write your password:")
    return username,password
#注册
def registered():
    username,password=out()
    temp=username+"-"+password
    # with open(file="login.txt",mode="w",encoding="UTF-8") as f:
    #     f.write(temp)
    json.dump(temp,open(file="login.txt",mode="w",encoding="UTF-8"))
# registered()
# 登陆
def login():
    username, password = out()
    # with open(file="login.txt",mode="r",encoding="UTF-8") as f:
    #     lists=f.read().split("-")
    lists=str(json.load(open(file="login.txt",mode="r",encoding="UTF-8"))).split("-")
#写的文件是字符串型，所以json.load()读取出来的也是字符串型的，之所以强转是因为想要变成列表型的，方便读取。
    if username==lists[0] and password==lists[1]:
        return True
    else:
        print ("登陆失败，请重新登录！")
# print(login())
#访问主页面
def profile():
    # with open(file="login.txt",mode="r",encoding="UTF-8") as f:
    #     lists=f.read().split("-")
    lists = str(json.load(open(file="login.txt", mode="r", encoding="UTF-8"))).split("-")
    print("Welcome to {person} page!".format(person=lists[0]))
# profile()
#主函数
def principal():
    while True:
        try:
            f=int(input("1、注册,2、登陆\n"))
            if f==1:
                registered()
            elif f==2:
                if login()==True:
                    profile()
                else:
                    print("Please login again")
            else:
                break
        except:continue
if __name__ == '__main__': #作为程序的入口，执行函数，得到最终的结果
    principal()

运行结果如下：

1、注册,2、登陆
1
What is your name?Lucy
Please write your password:17166230
1、注册,2、登陆
2
What is your name?Rose
Please write your password:20220621
登陆失败，请重新登录！
Please login again
1、注册,2、登陆
2
What is your name?Lucy
Please write your password:17166230
Welcome to Lucy page!
1、注册,2、登陆
3

Process finished with exit code 0