菜鸟教程

#!/usr/bin/python3
# 一个简单的类实例
class Complex:
    i = '12345'
    def f(self):
        return 'hello world'
    # 类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。对应的 __init__() 方法就会被调用
    # __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上

    def __init__(self, realpart, imagpart):
        # 声明两个局部变量,只作用于__init__()方法,两个变量相加做运算
        self.r = realpart + imagpart


# 创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。 传入参数123和124
x = Complex(123,124)
# 访问类的属性和方法
print("访问x类的属性:" + x.i)  # 访问属性
print("访问x的f方法" + x.f())  # 访问方法
# 打印x类中的r属性
print("realpart + imagpart" + "=" + str(x.r))

# 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
class Test:
    def prt(self):
        # 打印self,self 代表的是类的实例，代表当前对象的地址
        print(self)
        #  self.class 则指向类
        print(self.__class__)
    # self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的
    def prt2(runoob):
        print(runoob)
        print(runoob.__class__)

# 创建了一个新的类实例并将该对象赋给局部变量 a，a 为空的对象


# 实例化类
a = Test()
a.prt()
a.prt2()

# 类的方法
class people:
    # 定义人的基本属性,比如说名字,年龄,性别
    name = ''
    age = 0
    sex = ''

    # 定义构造的方法,比如一个人的行为举止,动作,说话,吃饭,睡觉,写代码
    # __init__() 方法传入参数，参数通过 __init__() 传递到类的实例化操作上
    def __init__(self, n, a, s):
        self.name = n
        self.age = a
        self.sex = s

    # 定义一个方法,动作行为:说话
    def speak(self):
        print("%s 说:我今年%d岁,性别为%s" % (self.name, self.age, self.sex))

    # 定义一个方法,动作行为:吃饭
    def eat(self):
        print("%s现在正在吃饭" % (self.name))

    # 定义一个方法,动作行为:睡觉
    def sleep(self):
        print("%s吃完了饭,正在睡觉" % (self.name))


# 实例化类
p = people('雷阳洪', 23, '男')
p.speak()
p.eat()
p.sleep()

果芽学习

# 面向过程编程
name = '张三'
age = 16
nickname = ''
if age < 18:
    nickname = '小鲜肉'
elif age in range(18, 30):
    nickname = '男神'
else:
    nickname = '油腻大叔'


name1 = '李四'
age1 = 26
nickname1 = ''
if age1 < 18:
    nickname1 = '小鲜肉'
elif age1 in range(18, 30):
    nickname1 = '男神'
else:
    nickname1 = '油腻大叔'


name2 = '王二麻子'
age2 = 31
nickname2 = ''
if age2 < 18:
    nickname2 = '小鲜肉'
elif age2 in range(18, 30):
    nickname2 = '男神'
else:
    nickname2 = '油腻大叔'
print(name2 + ',' + str(age2) + ',' + nickname2)


# 面向函数编程
'''
面向函数编程,将运算过程封装成一个函数,用来判断age的昵称.
函数本身不会执行,必须调用才能执行
以下代码才是执行步骤,根据执行步骤执行:1234
'''
# 4.执行函数,处理age的昵称 ,返回给nickname变量存起来
def get_nickname(age):
    if age < 18:
        nickname = '小鲜肉'
    elif age2 in range(18, 30):
        nickname = '男神'
    else:
        nickname = '油腻大叔'
    return nickname


# 1.name 变量 赋值 '张三'
name = '张三'
# 2.age 变量赋值 18
age3 = 18
# 3.调用get_nickname函数,传入age变量
nickname = get_nickname(age3)
# 5.打印处理后的name+age+nickname
print(name + ',' + str(age3) + ',' + nickname)

面向对象编程

class People:
    # 2.定义People类的初始变量
    name = ''
    age = 0
    nick_name = ''

    # 3.初始化方法,默认调用init方法,调用类 People('张三', 17) 括号里的参数进行赋值
    def __init__(self, n, a):
        self.name = n # self.name = '张三'
        self.age = a # self.age = '17'
        # 4.调用nick_name函数,判断nick_name变量的昵称之后,返回给p变量
        self.nick_name()
    # 5.判断p变量传入的age,得出nick_name 的昵称(self代表的是p变量的地址,self.age=17)
    # 如果p的内存里面没有nick_name变量,python自动新建nick_name变量并赋值.
    # 此时nick_name = 小鲜肉 
    def nick_name(self):
        if self.age < 18:
            self.nick_name = '小鲜肉'
        elif self.age in range(18, 30):
            self.nick_name = '男神'
        else: self.nick_name = '老男人'
        return self.nick_name


# 1.引用People类,传入参数'张三',17  赋值给p变量
p = People('张三', 17)

# 6.最后打印p的name  age  nick_name
print(p.name + str(p.age) + p.nick_name)

动态获取ini配置文件里面的url和mysql的配置信息做接口自动化

文件名:config_dev.ini

#果芽url
[API_GY_DEV]
host = dev.guoyasoft.com
port = 8080
protocal = http
#果芽mysql配置
[DB_GY_DEV]
host = qa.guoyasoft.com
port = 3306
db = guoya_virtual_mall_1811
user = root
passwd = Guoya006
charset = utf8

工具类

文件名:config_tool

# 这是一个获取本地config_dev.ini文件中的url的配置信息的工具类
import configparser
import os


class ConfigTool:
    def __init__(self):
        # 返回脚本的路径
        cur_path = os.path.dirname(__file__).replace('\\','/')
        # find() 方法检测字符串中是否包含子字符串 str  查看当前路径是否有's04-leiyh'文件夹
        # 获取该文件夹的总长个数.9个
        # 获取's04-leiyh'项目的绝对路径 先查找's04-leiyh'项目之前的路径的个数
        # 再获取's04-leiyh'项目的长度,最后索引获取展示's04-leiyh'项目的绝对路径
        root_path = cur_path[:cur_path.find('s04-leiyh') + len('s04-leiyh')]
        # 拿到config_dev.ini配置文件的路径 赋值给file_path变量
        file_path = '/week3/config/config_dev.ini'
        # 字符串拼接,拿到config_dev.ini配置文件的绝对路径
        file_name = root_path + file_path
        print(file_name)
        # 初始化实例,configparser模块的ConfigParser()类 赋值给config
        self.config = configparser.ConfigParser()
        # 读取配置文件,file_name 是配置文件的绝对路径
        self.config.read(file_name)

    # 定义一个用来获取配置文件中的命名部分(section)的选项值(option)的方法
    def get_conf(self, section, option):
        # 返回配置文件中获取section和option的值
        return self.config.get(section, option)

# 这是读取本地config_dev.ini文件中的mysql的配置信息的工具类
import pymysql
import week3.tools.config_tool as config_tool


class DBTool:
    # 读取数据库
    def __init__(self):
        # 调用config_tool.ConfigTool()类,赋值给conf变量 读取数据库的配置信息
        conf = config_tool.ConfigTool()
        self.host = conf.get_conf('DB_GY_DEV', 'host')
        self.port = int(conf.get_conf('DB_GY_DEV', 'port'))
        self.db = conf.get_conf('DB_GY_DEV', 'db')
        self.user = conf.get_conf('DB_GY_DEV', 'user')
        self.passwd = conf.get_conf('DB_GY_DEV', 'passwd')
        self.charset = conf.get_conf('DB_GY_DEV', 'charset')

    # 配置数据的连接信息,建立连接
    def get_connect(self):
        conn = pymysql.connect(
            host=self.host,
            port=self.port,
            db=self.db,
            user=self.user,
            passwd=self.passwd,
            charset=self.charset
        )

        self.conn = conn

    # 执行一条sql命令
    def query_one(self, sql):
        self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)
        self.cursor.execute(sql)
        # 获取一条数据
        row = self.cursor.fetchone()
        # 返回获取的数据
        return row
    # 断开
    def close(self):
        self.cursor.close()
        self.conn.close()

登陆自动化接口代码

#这个脚本实现的功能是利用python的requests类动态获取url和动态获取请求参数发送post请求的一个脚本
import pymysql
import week3.tools.config_tool as config_tool
import week3.tools.mydb_tool as mydb_tool
import requests

# 1. swagger查看登录接口
# 2. 新增test_case包,写test_login.py模块,使用requests模块实现接口调用
# 3. 新增config包,添加config.ini配置文件,配置api和db配置
# 4. 新增tools包,添加config_tool.py和db_tool.py
# 5. 使用config_tool工具实现url读配置文件
# 6. 使用db_tool工具,实现数据库连接信息从配置文件读取,登录用户数据从db读取
'''
思路:
    1.使用config_tool工具,动态获取config_dev.ini文件中的配置信息,url组成分别有协议+主机+端口
    2.使用db_tool工具,实现数据库连接信息从配置文件读取,登录用户数据从db读取
    3.获取数据库连接信息,建立连接,执行一条sql命令
    4.动态获取数据库中的username和pwd
    5.最后发送请求的url和json类型的data
'''


def test_login():
    # 实例化调用config_tool.ConfigTool()的工具类,赋值给conf变量
    conf = config_tool.ConfigTool()
    # 取值,取出协议名
    protocal = conf.get_conf('API_GY_DEV', 'protocal')
    # 取值,取出主机
    host = conf.get_conf('API_GY_DEV', 'host')
    # 取值,取出端口号
    port = conf.get_conf('API_GY_DEV', 'port')
    # 动态获取url 字符串拼接url
    url = protocal + '://' + host + ':' + port + '/login'
    print(url)
    # 动态调用数据库表里的数据
    # 实例化DB类,读取用户数据
    mydb = mydb_tool.DBTool()
    # 建立连接
    mydb.get_connect()
    # 执行一条sql
    row = mydb.query_one('SELECT * FROM `t_user_user`')
    print(row)
    # 取出row的字典中含有user_name的值
    user_name = row['user_name']
    print(user_name)
    # 取出row的字典中含有pwd的值
    pwd = row['pwd']
    print(pwd)
    # 动态获取数据库中的userName和pwd
    data = {
        "pwd": "%s" % (pwd),
        "userName": "%s" % (user_name)
    }
    print(data)
    # 往这个地址发送post的请求
    response = requests.post(url, json=data)
    print(response.text)
    # 获取的json转换成dict格式
    dict_token = dict(response.json())
    print(dict_token['data']['token'])
    # 获取响应数据中的token
    return dict_token['data']['token']