python接口自动化之python

玉兰 • • 杂文

一、python入门

1. python介绍

1.1 python可运用范围

1.1.1 脚本、小工具

import random
import win32api
import time
import win32con

names = ['张三', '李四', '王五', '小六']
name = random.choice(names)
print("抽到谁谁是大帅比！")
print("倒计时开始~")
for num in range(3):
     time.sleep(1)
     print(3-num)
time.sleep(1)
win32api.MessageBox(0, name, "提示", win32con.MB_ICONASTERISK)

1.1.2 单个接口测试

import requests
import json


def config():
    # 拉取配置，获取配置列表
    # url
    url = "http://17620533205.wicp.vip:46685/logout"
    # 请求头
    # headers = {
    #     'Content-Type': 'application/x-www-form-urlencoded'
    # }
    # 请求参数
    data = {
        'account': '111000',
        'password': '123456'
    }
    r1 = requests.post(url, json=data)
    # 以json数据类型接收，传给r2，r2即整个接口测试返回的数据
    r2 = r1.json()
    print(json.dumps(r2, sort_keys=True, indent=4, separators=(',', ':'), ensure_ascii=False))


config()

1.1.3 selenium

from selenium import webdriver
import time

driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)
url = 'https://dev.umaicloud.com/login'
# 访问网页登录页
driver.get(url)
# 点击账号输入框和输入账号
driver.find_element_by_xpath('//*[@id="app"]/div/div[3]/div[1]/div[2]/div[1]/form/div[1]/div/div/input').send_keys(
    'xxxxx')
# 点击密码输入框输入密码
driver.find_element_by_xpath('//*[@id="app"]/div/div[3]/div[1]/div[2]/div[1]/form/div[2]/div/div/input').send_keys(
    'xxxxx')
# 点击登录按钮
driver.find_element_by_xpath('//*[@id="app"]/div/div[3]/div[1]/div[2]/div[1]/form/div[4]/div/button').click()
time.sleep(10)
print("登录成功")
# 关闭浏览器
driver.quit()

# 八大定位元素方法
# find_element_by_name
# find_element_by_id
# find_element_by_xpath
# find_element_by_link_text
# find_element_by_partial_link_text
# find_element_by_tag_name
# find_element_by_class_name
# find_element_by_css_selector

1.1.4 appium

# -*- encoding=utf8 -*-
__author__ = "Administrator"
from airtest.core.api import *
auto_setup(__file__)
from poco.drivers.android.uiautomation import AndroidUiautomationPoco
poco = AndroidUiautomationPoco(use_airtest_input=True, screenshot_each_action=False)

def open_app(start_time):
 stop_app('com.tencent.mm')
 start_app('com.tencent.mm')
 sleep(2)
 items_elements = poco(name='com.tencent.mm:id/b2p').offspring('com.tencent.mm:id/e0n')
 names = list(map(lambda x: x.get_text(), items_elements))
 target = "调试"
 index = names.index(target)
 print([index])
 print(items_elements[index])
 items_elements[index].click()
 while True:
     times = time.strftime("%H:%M:%S")
     sleep(1)
     if times >= start_time:
         while True:
             try:
                 msg_list = poco("com.tencent.mm:id/alz").child("android.widget.RelativeLayout").offspring("com.tencent.mm:id/ak4")
             except Exception:
                 print("暂无红包，继续等待！")
             else:
                 while True:
                     for msg in msg_list:
                         red_package = msg.offspring("com.tencent.mm:id/r6")
                         invalid = msg.offspring("com.tencent.mm:id/aa5").offspring("com.tencent.mm:id/qv")
                         if red_package:
                             print("发现红包")
                             if invalid.exists() and (invalid.get_text() == '已领取' or invalid.get_text() == '已被领完'):
                                 print("无效红包")
                                 continue
                             else:
                                 print("有效红包,正在抢~")
                                 red_package.click()
                                 open_btn = poco("com.tencent.mm:id/dbr")
                                 if open_btn.exists():
                                     open_btn.click()
                                 else:
                                     print("来晚一步，已被抢完~")
                                 keyevent('BACK')

     else:
         print(times)


open_app("10:29:00")

1.1.5 爬虫

import requests
import re
from urllib import parse
from win32com.client import Dispatch
import time
import win32api
import pyperclip
from DownloadMovie import download


class dytt(object):
 def __init__(self):
     pass

 @staticmethod
 def get_id():
     name = parse.quote(input("请输入你要下载的电影名称："), encoding='gbk')
     url = "http://s.ygdy8.com/plus/so1.php?typeid=1&keyword=" + name
     headers = {
         "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
         "Accept-Encoding": "gzip, deflate",
         "Accept-Language": "zh-CN,zh;q=0.9",
         "Connection": "keep-alive",
         "Cookie": "UM_distinctid=16f9ecd77256b4-07ee71ccac26da-376b4502-1fa400-16f9ecd77262a1",
         "Host": "s.ygdy8.com",
         "Upgrade-Insecure-Requests": "1",
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36",
     }
     r = requests.get(url, headers=headers, verify=False)
     r.encoding = 'gbk'
     # print(r.text)
     result1 = re.findall(""))
             i += 1
         num = int(input("请输入你要下载的电影序号："))
         result2 = str(re.findall("html/gndy/.+?.html", result1[num - 1], re.S)).strip('[""]').strip("'")
         # print(result2)
         return result2

 @staticmethod
 def get_download_url():
     movie_id = dytt.get_id()
     requests.packages.urllib3.disable_warnings()
     url = "https://www.ygdy8.com/" + movie_id
     # print(url)
     r = requests.get(url, verify=False)
     r.encoding = 'gbk'
     # print(r.text)
     result = re.findall('>magnet:.+?<', r.text, re.S)
     # print(len(result))
     if len(result) == 0:
         result1 = re.findall('', r.text, re.S)
         if len(result1) == 0:
             result3 = re.findall('thunder.+?<', r.text, re.S)
             if len(result3) == 0:
                 print("暂未找到下载链接或下载链接失效！")
             elif len(result3) == 1:
                 print("正在打开迅雷，可能需要几秒钟~")
                 win32api.ShellExecute(0, 'open', 'C://Program Files//Thunder//Program//ThunderStart.exe', '', '', 3)
                 time.sleep(5)
                 pyperclip.copy(result3)
             else:
                 for j in range(len(result3)):
                     print(f"{j + 1}、", result3[j])
                     j += 1
                 num = int(input("请选择："))
                 pyperclip.copy(result3[num - 1])
         else:
             if len(result1) == 1:
                 result2 = str(result1).strip("['']").strip('"')
                 # print(result2)
                 dytt.open_thunder(result2)
             else:
                 for m in range(len(result1)):
                     print(f"{m + 1}、", result1[m])
                     m += 1
                 num = int(input("请选择："))
                 result2 = str(result1[num - 1]).strip("['']").strip('"')
                 # print(result2)
                 dytt.open_thunder(result2)
     else:
         for n in range(len(result)):
             print(f"{n + 1}、", result[n].strip('><'))
             n += 1
         num = int(input("请输入你要下载的电影序号："))
         result3 = result[num - 1].strip('><')
         dytt.open_thunder(result3)

 def open_thunder(downloadurl):
     print("正在打开迅雷，可能需要几秒钟~")
     win32api.ShellExecute(0, 'open', 'C://Program Files//Thunder//Program//ThunderStart.exe', '', '', 3)
     time.sleep(5)
     thunder = Dispatch('ThunderAgent.Agent64.1')
     thunder.AddTask(downloadurl)
     thunder.CommitTasks()


dytt.get_download_url()

1.1.6 面向对象与面向过程

  • 区别

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
举个栗子：用面向过程的方法写出来的程序是一份蛋炒饭，而用面向对象写出来的程序是一份盖浇饭。盖浇饭，就是菜饭分离，在一碗白米饭上面浇上一份盖菜，喜欢什么菜，你就浇上什么菜。

  • 面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展。

  • 面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护。
缺点：性能比面向过程低。

1.2 环境搭建（python+pycharm）

1.2.1 python下载

Python官网：https://www.python.org/

Python文档下载地址：https://www.python.org/doc/

/172.18.1.125/download添加到映射，长期共享学习软件。

1.2.2 python安装

https://www.runoob.com/python3/python3-install.html

1.2.3 python安装路径添加至path

如：D:/python;复制到系统变量中的path中。

1.2.4 检验安装

cmd中输入python，能进入python则安装成功，不能则环境有误或者安装不成功。

1.2.5 修改pip下载路径为国内源

在C:/Users/Administrator路径下新建pip文件夹，再进入pip文件夹中新建pip.ini文件，将下面三行复制保存即可。

[global]
trusted-host =  mirrors.aliyun.com
index-url = https://mirrors.aliyun.com/pypi/simple

1.2.6 升级pip版本到20版本+

python -m pip install --upgrade pip

1.2.7 查看安装的所有模块

pip list

1.2.8 设置pycharm运行Python的路径

打开pycharm——点击左上角文件-设置——搜索框中输入project——点击project interpreter右侧的下拉箭头——确认是否是你的Python的安装路径——如果找不到或路径不对，点击show all——再点击+添加——进入到new environment中——设置location（py文件的路径）——设置base interpreter（Python安装路径）——勾选下面inherit global···和make available

1.2.9 修改字体大小及主题

设置——搜索框搜索font——修改font、color scheme font、console font中的字体（推荐source code pro）、大小（16）、行距（1.0）

1.3 解释器及编码

1.3.1 解释器

未指定解释器时，在linux中运行代码可能会报错，需将下面一行复制在代码第一行

#!/usr/bin/python

1.3.2 编码

Python 文件中如果未指定编码，在执行过程可能会出现报错，Python3正常

#!/usr/bin/python

print ("你好，世界")

解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 # coding=utf-8 就行了，# coding=utf-8的=号两边不要空格

2.python基础（针对性讲解）

2.1 语法要求

  • python标识符

    在 Python 中，所有标识符可以包括英文、数字以及下划线，但不能以数字开头。

    包含：项目名称、包名、模块名、变量名、函数名、类名。

    最好见名知意，如test_goods，不建议test01等模糊命名方式，也尽量不要中文。

    Python标识符（除类名）命名规范建议都使用_隔开，如test_goods，不建议testgoods，testGoods。

    Python类名按照规范应该使用驼峰式命名法，如TestGoods，即首字母、后面每个单词的首字母大写。

    Python 可以同一行显示多条语句，方法是用分号 ; 分开，也可以使用/将一行语句分为多行，如：

    为了阅读舒适性，Python每行尽量不要超过80个字符，Pycharm也会有辅助线。

    print ('hello');print ('world');
hello
world
print('hello /
      world')
Hello,      World!

  • python保留字符

    下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

    所有 Python 的关键字只包含小写字母

    and exec not
    assert finally or
    break for pass
    class from print
    continue global raise
    def if return
    del import try
    elif in while
    else is with
    except lambda yield

  • 行和缩进

    学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

    缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

    正确的缩进：

    if True:
    print ("True")
else:
    print ("False")

    错误的缩进：

    if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
    # 没有严格缩进，在执行时会报错
  print ("False")

    执行以上代码，会出现如下错误提醒：

    File "test.py", line 11
    print ("False")
                  ^
IndentationError: unindent does not match any outer indentation level

    因此，在 Python 的代码块中必须使用相同数目的行首缩进空格数。

    建议你在每个缩进层次使用单个制表符或两个空格或四个空格

  • 注释

    python中单行注释采用 # 开头，多行注释也可以全选要注释的内容，按住ctrl+/

    # 第一个注释
print ("Hello, Python!")  # 第二个注释

    python 中多行注释使用三个单引号(''')或三个双引号(""")

    '''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''
"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

  • 输入和输出

    print("我叫王智景")

    input("请输入内容：")，input是读取用户输入在控制台的内容，类型为str，可使用type()查看输入或输出类型。

2.2 常用运算符

  • 算数运算符

    a = 1
b = 2
w = a + b
x = b - a
y = a * b
z = int(b / a)
print(w, x, y, z)

  • 比较（关系）运算符

    运算符 描述 实例
    == 等于 - 比较对象是否相等 (a == b) 返回 False
    != 不等于 - 比较两个对象是否不相等 (a != b) 返回 true
    <> 不等于 - 比较两个对象是否不相等 (a <> b) 返回 true。这个运算符类似 !=
    > 大于 - 返回x是否大于y (a > b) 返回 False
    < 小于 - 返回x是否小于y (a < b) 返回 true
    >= 大于等于 - 返回x是否大于等于y (a >= b) 返回 False
    <= 小于等于 - 返回x是否小于等于y (a <= b) 返回 true

  • 赋值运算符

    运算符 描述 实例
    = 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
    += 加法赋值运算符 c += a 等效于 c = c + a
    -= 减法赋值运算符 c -= a 等效于 c = c - a
    *= 乘法赋值运算符 c *= a 等效于 c = c * a
    /= 除法赋值运算符 c /= a 等效于 c = c / a
    %= 取模赋值运算符 c %= a 等效于 c = c % a
    **= 幂赋值运算符 c **= a 等效于 c = c ** a
    //= 取整除赋值运算符 c //= a 等效于 c = c // a

  • 逻辑运算符

    运算符 逻辑表达式 描述
    and x and y "与"
    or x or y "或"
    not not x "非"

  • 成员运算符

    运算符 描述 实例
    in 找到返回True，否则False x 在 y 序列中 , 如果 x 在 y 序列中返回 True
    not in 没有找到返回True，否则False x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

2.3 条件语句

常规语句表达：

if 判断条件：
    执行语句……
else：
    执行语句……

多个条件判断表达：

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

2.4 循环语句

2.4.1 for

for num in range(10):
    print(num) # num会从0开始遍历，至10结束（不包含10），打印出来

0
1
2
3
4
5
6
7
8
9

for num in range(1, 10):
    print(num) # num从1开始遍历，至10结束（不包含10），打印出来

1
2
3
4
5
6
7
8
9

names = ['张三', '李四', '王五', '小六']
for name in names:
    print(name) # 遍历列表names，打印names所有元素

张三
李四
王五
小六

names = ['张三', '李四', '王五', '小六']
print(len(names))  # 获取列表长度 结果为4
for num in range(len(names)):  # 将长度作为一个范围，num会从0遍历，再把num作为序号加入到列表索引中
    print(names[num])

4
张三
李四
王五
小六

2.4.2 while

执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。

当判断条件假 false 时，循环结束。

while 判断条件：
    执行语句……

age = 0
while age > 0:  # 条件不成立，所以不会执行该while语句
    print("条件不成立")
while age == 0:  # 因为age永远是0，所以陷入无限循环
    print("条件为真")

2.4.3 循环控制语句

age = 0
while True:  # 判断该条件是否为真，真就会一直循环往下执行代码，也可以表示为while age >= 0:
    age += 1  # 每过一年，我大一岁
    if age > 18:  # 如果我长大到了18岁，则跳出循环
        print("我超过18岁了")
        break  # 开始跳出
    elif age == 18:  # 当age=18岁时，会走到这，因为加了pass语句，执行了空语句，所以不会报错
        # print("我刚好18岁了")
        pass
    else:
        print("我还没到18岁呢")  # 判断我还没到18岁，会一直循环下去，知道18岁才跳出循环
        continue
        print("加了continue就不会走到这条语句，没加的话会执行完else里的语句再进行下一次循环")

  • break

    Python break语句，就像在C语言中，打破了最小封闭for或while循环。

    break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

    break语句用在while和for循环中。如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

  • continue

    Python continue 语句跳出本次循环，continue后的语句不执行，未加continue会执行该次循环中所有符合条件的语句，执行完毕后再进入循环，而break跳出整个循环。

    continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

    continue语句用在while和for循环中。

  • pass

    Python pass 是空语句，是为了保持程序结构的完整性。

    pass不做任何事情，一般用做占位语句。

2.5 变量类型

  • 整型

    a = 10

  • 浮点型

    a = 10.0

  • 字符串

    a = "name" or a = 'name'

  • 字典

    字典的每个键值 key=>value对用冒号 : 分割，每个键值对之间用逗号 , 分割整个字典包括在花括号 {} 中 。

    键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

    dict = {'a': 1, 'b': 2, 'b': '3'}

  • 列表

    list1 = ['physics', 'chemistry', 1997, 2000]

    list2 = [1, 2, 3, 4, 5 ]

    list3 = ["a", "b", "c", "d"]

  • 元组

    Python的元组与列表类似，不同之处在于元组的元素不能修改。

    元组使用小括号，列表使用方括号。

    tup1 = ('physics', 'chemistry', 1997, 2000)

    tup2 = (1, 2, 3, 4, 5 )

    tup3 = "a", "b", "c", "d"

2.6 字符串

  • 索引

    strings = 'hello world' # 空格也属于一个字符
print(strings[0]) # 取第一个字符
print(strings[1:5]) # 截取第二个字符到第五个(不包含5即第6个字符)

    h
ello

  • 运算

    操作符 描述 实例
    + 字符串连接 >>>a + b 'HelloPython'
    * 重复输出字符串 >>>a * 2 'HelloHello'
    [] 通过索引获取字符串中字符 >>>a[1] 'e'
    [ : ] 截取字符串中的一部分 >>>a[1:4] 'ell'
    in 成员运算符 - 如果字符串中包含给定的字符返回 True >>>"H" in a True
    not in 成员运算符 - 如果字符串中不包含给定的字符返回 True >>>"M" not in a True
    % 格式字符串 请看下一章节 
    var = 'Hello World!'

print("输出：", var[:6] + 'Python!')

    输出： Hello Python!

  • 格式化

    符 号 描述
    %c 格式化字符及其ASCII码
    %s 格式化字符串
    %d 格式化整数
    %u 格式化无符号整型
    %o 格式化无符号八进制数
    %x 格式化无符号十六进制数
    %X 格式化无符号十六进制数（大写）
    %f 格式化浮点数字，可指定小数点后的精度
    %e 用科学计数法格式化浮点数
    %E 作用同%e，用科学计数法格式化浮点数
    %g %f和%e的简写
    %G %F 和 %E 的简写
    %p 用十六进制数格式化变量的地址

    Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

    #!/usr/bin/python

print("My name is %s and I am %d years old!" % ('python', 29))

    My name is python and I am 29 years old!

2.7 列表

  • 访问列表中的值及截取

    Python 表达式 结果 描述
    L[2] 'Taobao' 读取列表中第三个元素
    L[-2] 'Runoob' 读取列表中倒数第二个元素
    L[1:] ['Runoob', 'Taobao'] 从第二个元素开始截取列表 
    list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7]

print(list1[0])
print(list2[1:5])

    physics
[2, 3, 4, 5]

  • 增加值

    list = []  # 空列表
list.append('hello')  # 使用 append() 添加元素
list.append('python')
print(list)

    ['hello', 'python']

  • 删除值

    list = []  # 空列表
list.append('hello')  # 使用 append() 添加元素
list.append('python')
print(list)

del list[1]  # 删除list中第二个元素，即python
print(list)

  • 列表函数&方法

    序号 函数
    1 cmp(list1, list2) 比较两个列表的元素
    2 len(list) 列表元素个数
    3 max(list) 返回列表元素最大值
    4 min(list) 返回列表元素最小值
    5 list(seq) 将元组转换为列表
    序号 方法
    1 list.append(obj) 在列表末尾添加新的对象
    2 list.count(obj) 统计某个元素在列表中出现的次数
    3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
    4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
    5 list.insert(index, obj) 将对象插入列表
    6 [list.pop(index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
    7 list.remove(obj) 移除列表中某个值的第一个匹配项
    8 list.reverse() 反向列表中元素
    9 list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

2.8 字典

  • 查（访问字典的值，同json取值）

    dicts = {'Name': 'python', 'Age': 29, 'sex': 'other'}

print(dicts['Name'])
print(dicts['Age'])

    python
29

    如果字典中没有的键访问数据，会报KeyError: 'xxx'错误，解析json时遇到这种情况也会报错

    dicts = {'Name': 'python', 'Age': 29, 'Sex': 'other'}

print(dicts['email'])

  • 增/改（增加/修改字典）

    dicts = {'Name': 'python', 'Age': 29, 'Sex': 'other'}
dicts['Sex'] = '男'
dicts['Age'] = 30
print(dicts)

    {'Name': 'python', 'Age': 30, 'Sex': '男'}

    如果修改字典时取键时不在字典中，会在字典中新增键与值

    dicts = {'Name': 'python', 'Age': 29, 'Sex': 'other'}
dicts['name'] = 'java'
dicts['age'] = 30
dicts['sex'] = '男'
print(dicts)

    {'Name': 'python', 'Age': 29, 'Sex': 'other', 'name': 'java', 'age': 30, 'sex': '男'}

  • 删（删除字典元素）

    dicts = {'Name': 'python', 'Age': 29, 'Sex': 'other'}
del dicts['Sex']
print(dicts)  # 删除了Sex及值，打印时就不会被打印出来
dicts.clear()  # 清空了字典元素，打印时会打印空的字典
print(dicts)
del dicts  # 删除了整个字典，所以打印时会提示未定义dicts
print(dicts)

    {'Name': 'python', 'Age': 29}
{}
NameError: name 'dicts' is not defined

2.9 类型转换

2.9.1 各数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

函数 描述
[int(x ,base]) 将x转换为一个整数
[long(x ,base] ) 将x转换为一个长整数
float(x) 将x转换到一个浮点数
[complex(real ,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

2.9.2 字符串与字典

json.dumps()和json.loads()是json格式处理函数（可以这么理解，json是字符串）
(1)json.dumps()函数是将一个Python数据类型列表进行json格式的编码（可以这么理解，json.dumps()函数是将json丢掉，不要json，那就是将字典转化为字符串）
(2)json.loads()函数是将json格式数据转换为字典（可以这么理解，json.loads()函数是加载json，意味着要json，那就是将字符串转化为字典）

  • json.dumps()

    data参数支持字典格式也支持字符串格式，如果是字典格式，requests方法会将其按照默认表单urlencoded格式转换为字符串，如果是字符串则不转化
    如果data以字符串格式传输需要遵循以下几点：

    • 必须是严格的JSON格式字符串，里面必须用双引号，k-v之间必须有逗号，布尔值必须是小写的true/false等等
    • 不能有中文，直接传字符串不会自动编码

    一般来说，建议将data声明为字典格式（方便数据添加修改），然后再用json.dumps()方法把data转换为合法的JSON字符串格式

    import json  # 需要导入JSON包

data = {'name': '张三', 'password': '123456', "male": True, "money": None}  # 字典格式
str_data = json.dumps(data)  # 序列化，转化为合法的JSON文本（方便HTTP传输）
print(str_data)

    {"name": "/u5f20/u4e09", "password": "123456", "male": true, "money": null}

    indent: 缩进空格数，indent=0输出为一行

    sork_keys=True: 将json结果的key按ascii码排序

    ensure_ascii=Fasle: 不确保ascii码，如果返回格式为utf-8包含中文，不转化为/u...

    import json  # 需要导入JSON包

data = {'name': '张三', 'password': '123456', "male": True, "money": None}  # 字典格式
str_data = json.dumps(data, indent=4, sort_keys=True, ensure_ascii=False)  # 序列化，转化为合法的JSON文本（方便HTTP传输）
print(str_data)

    {
    "male": true,
    "money": null,
    "name": "张三",
    "password": "123456"
}

  • json.loads()

    将合法的JSON字符串转换字典

    import json  # 需要导入JSON包

data = {'name': '张三', 'password': '123456', "male": True, "money": None}  # 字典格式
str_data1 = json.dumps(data, indent=4, sort_keys=True, ensure_ascii=False)  # 序列化，转化为合法的JSON文本（方便HTTP传输）
print(str_data1)
print(type(str_data1))
str_data2 = json.loads(str_data1)
print(str_data2)
print(type(str_data2))

    {
    "male": true,
    "money": null,
    "name": "张三",
    "password": "123456"
}

{'male': True, 'money': None, 'name': '张三', 'password': '123456'}

3. 脚本实例编写

  • 打印1~100中所有奇数/偶数
  • 计算1~100之间所有奇数的和
  • 计算1~100之间所有偶数的和

二、接口测试

1. 内置模块

1.1 time

序号 函数及描述
1 time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
2 [time.asctime(tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
3 time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
4 [time.ctime(secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime()
5 [time.gmtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
6 [time.localtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
7 time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。
8 time.sleep(secs) 推迟调用线程的运行，secs指秒数。
9 [time.strftime(fmt,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
10 time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据fmt的格式把一个时间字符串解析为时间元组。
11 time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
12 time.tzset() 根据环境变量TZ重新初始化时间相关设置。

  • time.time()——获取时间戳

    import time

print(time.time())

    1588929714.3305402

  • 获取当前时间（格式化时间）

    python中时间日期格式化符号

    • y 两位数的年份表示（00-99）
    • %Y 四位数的年份表示（000-9999）
    • %m 月份（01-12）
    • %d 月内中的一天（0-31）
    • %H 24小时制小时数（0-23）
    • %I 12小时制小时数（01-12）
    • %M 分钟数（00=59）
    • %S 秒（00-59）
    • %a 本地简化星期名称
    • %A 本地完整星期名称
    • %b 本地简化的月份名称
    • %B 本地完整的月份名称
    • %c 本地相应的日期表示和时间表示
    • %j 年内的一天（001-366）
    • %p 本地A.M.或P.M.的等价符
    • %U 一年中的星期数（00-53）星期天为星期的开始
    • %w 星期（0-6），星期天为星期的开始
    • %W 一年中的星期数（00-53）星期一为星期的开始
    • %x 本地相应的日期表示
    • %X 本地相应的时间表示
    • %Z 当前时区的名称
    • %% %号本身
    import time

localtime = time.strftime('%Y-%m-%d %H:%M:%S')
print(localtime)

    20-05-08 17:26:05

  • round()

    语法

    round(number,digits)

    参数

    number

    要四舍五入的数，digits是要小数点后保留的位数。

    如果 digits 大于 0，则四舍五入到指定的小数位。

    如果 digits 等于 0，则四舍五入到最接近的整数。

    如果 digits 小于 0，则在小数点左侧进行四舍五入。

    如果round函数只有参数number,等同于digits 等于 0。

    返回值

    四舍五入后的值

print(round(3.1415926, 2))


```python
3.14

import time

print(time.time())  # 打印当前时间戳
print(round(time.time()))  # 打印无小数点的时间戳
print(round(time.time()*100))  # 等于1588932416.278496四舍五入后的值*100，即12位时间戳

1588932416.278496
1588932416
158893241628

1.2 calendar

序号 函数及描述
1 calendar.calendar(year,w=2,l=1,c=6) 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
2 calendar.firstweekday( ) 返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一。
3 calendar.isleap(year) 是闰年返回 True，否则为 False。>>> import calendar >>> print(calendar.isleap(2000)) True >>> print(calendar.isleap(1900)) False
4 calendar.leapdays(y1,y2) 返回在Y1，Y2两年之间的闰年总数。
5 calendar.month(year,month,w=2,l=1) 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
6 calendar.monthcalendar(year,month) 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
7 calendar.monthrange(year,month) 返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
8 calendar.prcal(year,w=2,l=1,c=6) 相当于 print calendar.calendar(year,w=2,l=1,c=6)。
9 calendar.prmonth(year,month,w=2,l=1) 相当于 print calendar.month(year,month,w=2,l=1) 。
10 calendar.setfirstweekday(weekday) 设置每周的起始日期码。0（星期一）到6（星期日）。
11 calendar.timegm(tupletime) 和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。
12 calendar.weekday(year,month,day) 返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。

  • 获取某月日历

    import calendar

cal = calendar.month(2020, 5)
print(cal)

          May 2020
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

  • 格式化日期

    import time

# 格式化成2016-03-20 11:45:39形式
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

# 格式化成Sat Mar 28 22:24:24 2016形式
print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))

# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))

    2020-05-08 17:32:39
Fri May 08 17:32:39 2020
1459175064.0

1.3 json

类型转换已经提到过，可以翻阅类型转换查看，下面也截取了一部分关键内容，可以多了解一点

函数 描述
json.dumps 将 Python 对象编码成 JSON 字符串
json.loads 将已编码的 JSON 字符串解码为 Python 对象
  • python 原始类型向 json 类型的转化对照表
Python JSON
dict object
list, tuple array
str, unicode string
int, long, float number
True true
False false
None null
  • json 类型转换到 python 的类型对照表
JSON Python
object dict
array list
string unicode
number (int) int, long
number (real) float
true True
false False
null None

1.4 random

  • 返回值

    返回随机生成的一个实数，它在[0,1)范围内。

    import random

# 生成第一个随机数
print(random.random())

# 生成第二个随机数
print(random.random())

    0.9516361757935445
0.3494738700183079

  • 常用方法

    import random

list = [1, 2, 3, 4, 5]
print(random.randint(1, 10))  # 产生 1 到 10 的一个整数型随机数
print(random.random())  # 产生 0 到 1 之间的随机浮点数
print(random.uniform(1.1, 5.4))  # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print(random.choice(list))  # 从序列中随机选取一个元素
print(random.randrange(1, 100, 2))  # 生成从1到100的间隔为2的随机整数
random.shuffle(list)  # 将序列list中的元素顺序打乱
print(list)

    7
0.04950387613677654
3.5018207607321745
5
65
[3, 4, 5, 1, 2]

1.5 os常用方法

  • os.open()

    import os

# 打开文件
fd = os.open("foo.txt", os.O_RDWR | os.O_CREAT)

# 关闭文件
os.close(fd)

print("关闭文件成功!!")

    os.open(files, flags[, mode])打开一个文件，并且设置需要的打开选项，mode参数是可选的。

    • file -- 要打开的文件
    • flags -- 该参数可以是以下选项，多个使用 "|" 隔开：

      • os.O_RDONLY: 以只读的方式打开
      • os.O_WRONLY: 以只写的方式打开
      • os.O_RDWR : 以读写的方式打开
      • os.O_NONBLOCK: 打开时不阻塞
      • os.O_APPEND: 以追加的方式打开
      • os.O_CREAT: 创建并打开一个新文件
      • os.O_TRUNC: 打开一个文件并截断它的长度为零（必须有写权限）
      • os.O_EXCL: 如果指定的文件存在，返回错误
      • os.O_SHLOCK: 自动获取共享锁
      • os.O_EXLOCK: 自动获取独立锁
      • os.O_DIRECT: 消除或减少缓存效果
      • os.O_FSYNC : 同步写入
      • os.O_NOFOLLOW: 不追踪软链接
    • mode -- 类似 chmod()。

  • os.system()

    system函数可以将字符串转化成命令在服务器上运行。

    import os

os.system('shutdown /s /t 300 /c "5分钟后自动关机"')

1.6 hashlib

hashlib是一个提供字符加密功能的模块，包含MD5和SHA的加密算法，具体支持md5,sha1, sha224, sha256, sha384, sha512等算法。 该模块在用户登录认证方面应用广泛，对文本加密也很常见。

简单来说。就是三步：

1，建立加密对象。2，对字符串进行算法加密。3，获得16进制显示。

import hashlib

md5 = hashlib.md5()  # 创建hashlib的md5对象
md5.update('字符串'.encode('utf-8'))  # 将字符串载入到md5对象中，获得md5算法加密
new_md5 = md5.hexdigest()  # 通过hexdigest()方法，获得new_md5对象的16进制md5显示
print(new_md5)

cc4dd1da7e1a754534215f02fb9ba85d

注意：向对象中传入字符串时，在python3中需要对字符串进行 encode 操作必须为编码类型。使用.encode('UTF-8')的方法，使字符串变为bytes类型。

可以创建的加密算法有：md5,sha1, sha224, sha256, sha384, sha512。

import hashlib
new_md5 = hashlib.md5()
new_sha1 = hashlib.sha1()
new_sha256 = hashlib.sha256()

2. 第三方模块

2.1 requests

  • 安装库

    pip install requests

  • 导入库

    import requests

3. 组成

3.1 url

3.2 params的用法

  • 参数类型

    字典，字典中键值对作为查询参数。

  • 特点

    url为基准的url地址，不包含查询参数。

    该方法会自动对params字典编码，然后和url拼接。

    import requests

url = 'http://httpbin.org/get'
data = {
    "name": "张三",
    "age": 22
}
response = requests.get(url, params=data)  # 自动对params中的内容进行编码，然后和url进行拼接，再发出请求，查看打印的name已经被编码了，如需解码可以用urllib.parse.unquote
print(response.url)

    http://httpbin.org/get?name=%E5%BC%A0%E4%B8%89&age=22

  • 参数包含在url中

    import requests
response = requests.get("http://httpbin.org/get?name=zhangsan&age=22")
print(response.text)

  • 通过get方法传送参数

    import requests

url = 'http://httpbin.org/get?name=zhangsan&age=22'
data = {
    "name": "zhangsan",
    "age": 22
}
response = requests.get("http://httpbin.org/get", params=data)
# print(response.text)
print(response.url)
if url == response.url:
    print("两个url是一致的")
else:
    print("两个url不一致")

3.3 data

  • 用于post请求

    通常，想要发送一些编码为表单形式的数据（像HTML表单），只需传递一个字典给data参数，然后数据字典在发出请求时会自动编码为表单形式。

    response = requests.post(url, data = data, headers=headers)

3.4 headers

  • 模拟发送请求头（传送headers参数）

    有些网站为了避免被爬虫攻击，会用请求头中的User-Agent来判断是否是浏览器请求，提交数据类型也可以在请求头中声明。

    import requests
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36",
    "Content-Type": "application/x-www-form-urlencoded"
}
response = requests.get("http://httpbin.org/get", headers=headers)
print(response.text)

3.5 cookies和session

  • cookies和session的用处

    使用的cookie和session好处：很多网站必须登录后(或者获取某种权限后)才能够请求到相关数据。

    使用的cookie和session的弊端：一套cookie和session往往和一个用户对应.请求太快，请求次数太多，容易被服务器识别为爬虫，从而使账号收到损害。

    • 不需要cookie的时候尽量不去使用cookie。
    • 为了获取登录之后的页面，我们必须发送带有cookies的请求，此时为了确保账号安全应该尽量降低数据采集速度。

  • 获取cookies信息

    response.cookies

  • cookies在首次登录后获取到，后面可以放在requests提交时用

    import requests

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36",
    "Content-Type": "application/x-www-form-urlencoded"
}
response = requests.get("http://httpbin.org/get", headers=headers, cookies=response.cookies)
print(response.text)

  • 构造session回话对象

    requests库的session会话对象可以跨请求保持某些参数，说白了，就是比如你使用session成功的登录了某个网站，则在再次使用该session对象求求该网站的其他网页都会默认使用该session之前使用的cookie等参数。

    session = requests.session()

4. get请求

  • 无参数

    常用于访问网址或无参数的请求url

    import requests
response = requests.get("www.baidu.com")
print(response.headers)  # 可查看响应头headers中Content-Type中的类型，从而决定以什么方法接收
print(response.text)

  • 有参数

    import requests

url = 'http://httpbin.org/get'
data = {
    "name": "张三",
    "age": 22
}
response = requests.get(url, params=data)  # 自动对params中的内容进行编码，然后和url进行拼接，再发出请求，查看打印的name已经被编码了，如需解码可以用urllib.parse.unquote
print(response.url)
print(response.headers)  # 返回的是application/json，尽量用response.json()
print(response.text)  # 可能也不会报错，但是数据类型不是字典，是字符串
print(type(response.text))
print(response.json())  # 返回的是json，以json去接收，数据类型是字典，方便后续字典取值
print(type(response.json()))

    {'Date': 'Sat, 09 May 2020 03:39:03 GMT', 'Content-Type': 'application/json', 'Content-Length': '378', 'Connection': 'keep-alive', 'Server': 'gunicorn/19.9.0', 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': 'true'}
{
  "args": {
    "age": "22", 
    "name": "/u5f20/u4e09"
  }, 
  "headers": {
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Host": "httpbin.org", 
    "User-Agent": "python-requests/2.22.0", 
    "X-Amzn-Trace-Id": "Root=1-5eb625d7-7528eeb39efb718f94feac7e"
  }, 
  "origin": "183.15.91.21", 
  "url": "http://httpbin.org/get?name=/u5f20/u4e09&age=22"
}


{'args': {'age': '22', 'name': '张三'}, 'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.22.0', 'X-Amzn-Trace-Id': 'Root=1-5eb625d7-7528eeb39efb718f94feac7e'}, 'origin': '183.15.91.21', 'url': 'http://httpbin.org/get?name=张三&age=22'}

  • urllib.parse.quote编码（需要导入urllib.parse）

    此处name=张三已经被编码了，用这个urllib.parse.quote可实现一样的效果。

    from urllib import parse  # 或者import urllib.parse
name = '张三'
age = '22'
url1 = 'http://httpbin.org/get?name=%E5%BC%A0%E4%B8%89&age=22'
new_name = urllib.parse.quote(name)
print(new_name)
url2 = "http://httpbin.org/get?name=" + new_name + '&age=' + age
print(url2)
if url1 == url2:
    print("两个url是一致的")
else:
    print("两个url不一致")

    %E5%BC%A0%E4%B8%89
http://httpbin.org/get?name=%E5%BC%A0%E4%B8%89&age=22
两个url是一致的

  • urllib.parse.unquote解码

    from urllib import parse  # 或者import urllib.parse
name = '%E5%BC%A0%E4%B8%89'  # %E5%BC%A0%E4%B8%89即张三
print(urllib.parse.unquote(name))

    张三

5. post请求

  • x-www-form-urlencoded

    浏览器原生form表单默认的数据格式。

    name=value&name2=value2=name3=value3

  • application/json

    具体表述请求数据为json格式，如果不设置 enctype 属性，那么最终就会以 application/x-www-form-urlencoded 方式提交数据（ enctype 的 POST 默认方式）。

    {"name1":"value1","name2":"value2"}

  • text/html

    以xml的形式进行传参。

    

examples.getStateName


41

6. 代理

  • 代理的用法

    proxies = {
    "http": "https://175.44.148.176:9000",
    "https": "https://183.129.207.86:14002"
}
response = requests.get("https://www.baidu.com/", proxies=proxies)

7. response属性

属性 描述
response.text 获取str类型（Unicode编码）的响应，即：url对应的页面内容
response.content 获取bytes类型的响应
response.status_code 获取响应状态码
response.headers 获取响应头
response.request 获取响应对应的请求
response.url 获取请求url
response.encoding 从HTTP header中猜测的响应内容编码方式

  • response.encoding

    当用response.text获取了html内容出现unicode码时，可以通过设置字符编码response.encoding 来匹配指定的编码，这样就不会乱码了。

    import requests
r = requests.get("http://www.baidu.com")
print(r.text)  # 未指定编码，打印中文时出现乱码

    
 ç�¾åº¦ä¸�ä¸�ï¼�ä½ å°±ç�¥é��

³äº�ç�¾åº¦ About Baidu

©2017 Baidu ä½¿ç�¨ç�¾åº¦å��å¿
读  æ��è§�å��é¦� äº¬ICPè¯�030173å�·