Python学习笔记：Python基础使用

# # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#												        #
#				人生苦短	我学PYTHON				        #
#												        #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # #

类、

# 带参构造方法
# 类中的构造方法，可以定义形式参数，目的是在创建对象的同时，为对象的实例属性赋值


class Dog:
    def __init__(self, name, age):
        self.age = age
        self.name = name


# self关键字：类中定义的普通方法，默认第一个参数就是self，self表示的是当前的对象
# shout方法中调用了self.name和self.age，那么这个self表示的是当前调用shout()方法的对象
class Dog1:
    def __init__(self, name, age):
        self.age = age
        self.name = name

    def shout(self):
        print(self.name, self.age)


# 换一个思路理解
# 在下面，创建的dog这个对象调用了shout()方法，那么此时self指代的就是dog这个对象
dog = Dog1("阿黄", 9)
print(dog.age)
print(dog.name)
dog.shout()


# 类属性可以通过【类.属性=新的值】去修改类属性值，但是对象属性只能使用，不能修改
class Chinese:
    country = "中国"

    def __init__(self):
        pass


chi = Chinese()
chi.country = "韩国"
print(chi.country)  # 输出【韩国】
print(Chinese.country)  # 输出【中国】

Chinese.country = "日本"
print(Chinese.country)  # 输出【日本】


# 实例属性、实例方法
class Dog2:
    def __init__(self, name, age):
        self.age = age
        self.name = name

    def shout(self):
        # 实例方法中，可以通过self调用实例属性
        print(self.name, self.age)

    def talk_lif(self):
        # 实例方法中，也可以通过self调用实例方法
        self.shout()


# 类方法：如果方法中，不需要调用任何的实例属性或实例方法，但是需要调用类属性，这时可以将这个方法定义成类方法。
# 定义类方法，需要在方法名上加上装饰器@classmethod
# 调用类方法时，应该通过类名或者对象直接调用
# 静态方法：如果方法中既不调用实例属性或方法，也不调用类属性或方法，那么这个方法应该定义成静态方法。
# @staticmethod静态方法可以直接通过类名或者对象调用

封装、

# 面向对象的三大特征：封装、继承、多态
# 封装有两层含义：
# (1) 将代码都写在类中，用类包装了代码。
# (2) 将类中的内容通过一些手段隐藏起来，从而保护代码的安全性。
# 注意：
# 1) 在类中双下划线开头的变量是私有变量
# 2) 在类中双下划线开头的方法是私有方法
# 3) 私有方法和私有变量只能在当前类调用，原则上不能再类外直接调用
# 4) 一旦我们把某个变量私有化，通常会为这个变量定义两个方法，一个是set_变量名（）用来为这个变量赋值，一个get_变量名（）用来获取变量的值。

class Dog:
    def __init__(self,name,age):
        #用双下划线定义的实例属性属于私有属性，原则上只能在当前类中直接调用。
        self.__name = name
        self.__age = age

    def shout(self):
        print("狗的年龄是%d，狗的名字是%s"%(self.__age,self.__name))
    #__age是私有属性，所有要为age写一个set_age（）方法，用来为age赋值
    def set_age(self,age):
        if age>0:
            self.__age = age
        else:
            print("输入的年龄有误，没有修改对象age的值")
    #也要为age写一个get_age（）方法，用来获取age的值
    def get_age(self):
        return self.__age
    def set_name(self,name):
        self.__name = name
    def get_name(self):
        return self.__name

    def __eat(self):
        print("我家的狗吃肉！")
    def dog_eat(self):
        self.__eat()

dog = Dog("旺财",10)
print(dog.get_age())
dog.dog_eat()
#错误的演示，类外不能直接调用类的私有方法
dog.__eat()
#错误的演示，类外不能直接调用类的私有变量
print(dog.__age)
#当我们在类中把age私有化后，在类外直接对私有的内容访问，是不能访问的。
dog.__age = -10
dog.shout()

继承、

# 	类与类之间为了代码的复用，可以把重复的内容放到父类（基类，超类）中去，然后用子类继承它。
# 
# 		Class 子类(父类,父类1,父类2………)
# 			属性
# 			方法
# 
# 	继承的特点：
# 		(1) 子类继承父类所有的非私有的内容
# 		(2) 子类可以扩展自己独有的内容
# 子类可以重写父类的方法，子类可以覆盖父类中同名的属性或方法，也就是子类的对象调用方法时，优先调用自己类中的内容。
class Student:
    def study(self):
        print("好好学习，天天向上！")
        
class Little_student(Student):
    def play(self):
        print("小学生玩王者荣耀！")
    def study(self):
        print("学习思想品德！")

# 子类中如果要调用父类的方法，可以通过super()来实现
class Student:
    def study(self):
        print("好好学习，天天向上！")
        
class Little_student(Student):
    def play(self):
        print("小学生玩王者荣耀！")
    def study(self):
        # 在子类中可以通过super()来调用父类的方法
        super().study()
        print("学习思想品德！")        

多态、

# 如果子类重写了父类的方法，那么调用重写后的方法具体执行什么内容，取决于当前调用方法的那个对象是谁。
# 多态的前提：类的继承、要有方法的重写
class Animal:
    def eat(self):
        print("动物吃")

class Tiger(Animal):
    def eat(self):
        print("老虎吃肉！")
class Panda(Animal):
    def eat(self):
        print("熊猫吃竹子")
class Pig(Animal):
    def eat(self):
        print("猪吃草！")

#定义一个形参，为了接收一个可以调用eat()方法的对象
def test_eat(x):
    x.eat()

panda = Panda()
tiger2 = Tiger()
animal2 = Animal()
#根据传进来的对象不同，执行的方法也不同，这就是多态。
test_eat(panda)
test_eat(tiger2)
test_eat(animal2)

print("---------------------------------")
amimal = Animal()
tiger = Tiger()
amimal.eat()
tiger.eat()

异常处理、

try:
    # 这里面写需要执行的代码
    a = 2
    b = "3"
    c = a + b
except TypeError: # 选写一个except就行了
    print("报错了会打印这条TypeError语句！")
except IndexError: # 选写一个except就行了
    print("报错了会打印这条IndexError语句！")
except: # 选写一个except就行了
    print("报错了会打印这条语句！")
else: # 可以省略这个模块
    print("如果没报错，会执行这条语句！")
finally: # 可以省略这个模块
    print("不管有没有报错，都会执行这条语句！")

FILE IO

IO表示input和output 是编程时对数据传输的一种描述，input表示输入数据，output表示输出数据。
	file = open("d:/file_io.txt","w") # w只写，r只读，a追加。
	file.write("hello 你好！\n")	
	file.write(r"hello world!\n") # 如果在字符串前面加r，则表示后续的字符串所有内容都直接作为字符来处理，不再具备特殊含义。    
	file = open("./file_io.txt", "a")
	file.write("这是追加的内容！")
    
	file = open("./file_io.txt", "r") # 相对路径以当前代码文件为参考确认的路径。    
	content = file.read() # read()方法：从文件中将整个文件的所有数据都读出来。
	content = file.read(5) # 从文件中读取5个字符
	print(content, end="") # 如果不想换行打印，就可以在print()函数中指定end的值为空字符   
	content = file.readline() # 读取文件中的一行数据
	if len(content) == 0:
		break
	print(content, end="")
	file.close()

FILE IO_CSV

import csv

class CSV_write:
    def csv_write(self):
        # csv 的write
        # 打开/创建csv文件，可写模式，newline=""代表不跳过下一行
        file = open("csv_data_01.csv", "w", newline="")
        # 创建对象write
        write = csv.writer(file)
        # 写入csv表头，按照列表中的顺序，依次填入excel表格的第一行
        write.writerow(['序号', '标题', '公司', '薪资', '地点'])
        file.close()

class CSV_read:
    def csv_read(self):
        with open('csv_data_01.csv', 'r') as f:
            reader = csv.reader(f)
            for row in reader:
                print(row)

                
# 设计函数专门读取 csv文件
# 参数1 文件名 参数2： 读取第几行
def get_csv_data(csv_file,line):
        jw_csv_file= open(csv_file, 'r', encoding='utf-8-sig')# 打开文件
        reader = csv.reader(jw_csv_file) # 加载数据
        # 参数2 :决定了下标位置的开始计数方式，默认从0开始，可设置为从1开始
        for index, row in enumerate(reader, 1): # 枚举
            if index == line:
                print(row)
                return row
if __name__=="__main__":# 自测
    #参数１　　当前的ｃｓｖ文件
    #　参数２　　　行数
    get_csv_data("./jwaccount.csv",2)                

FILE IO_EXCEL

# # # # # # # # # # # # # # # # # # # # # # # # # # # #
#                                                      
# 能够操作Excel的模块：xlrd openpyxl pandas             
# openpyxl三大对象：工作簿、工作表、单元格               
#                                                     
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
import openpyxl
import os


class ExcelRead:
    def excel_read(self):
        # 工作簿EXCEL所在目录
        # os.path.dirname()：得到上一级目录，os.getcwd()：得到当前脚本的目录
        path = os.path.dirname(os.getcwd()) + "\\data_control\\" + "excel_data_01.xlsx"
        # 读取工作簿
        wk = openpyxl.load_workbook(path)
        # 读取工作表
        sheet = wk["Sheet1"]
        # 读取单元格的内容,存储至变量value中
        # value = sheet.cell(row=1, column=1).value
        # 获取单元格行数、列数
        rows = sheet.max_row
        cols = sheet.max_column

        # 这里演示比较复杂的数据嵌套结构：通过字典、列表嵌套的方式保存数据        
        '''
        [{'username': 'test01', 'passwd': 10001},
         {'username': 'test02', 'passwd': 10002},
         {'username': 'test03', 'passwd': 10003},
         {'username': 'test04', 'passwd': 10004},
         {'username': 'test05', 'passwd': 10005},
         {'username': 'test06', 'passwd': 10006},
         {'username': 'test07', 'passwd': 10007},
         {'username': 'test08', 'passwd': 10008},
         {'username': 'test09', 'passwd': 10009},
         {'username': 'test10', 'passwd': 10010}]
		'''
        a=[]
        for x in range(2, rows + 1):
            dic = {}
            for y in range(1, cols + 1):
                dic[sheet.cell(row=1, column=y).value] = sheet.cell(row=x, column=y).value
            a.append(dic)
        return a


# qq = ExcelRead().excel_read()
# print(qq)

FILE IO_TXT

# 读取数据到列表b
file_path = "./txt_data_01.txt"
b = []
file = open(file_path, 'r', encoding='UTF-8')
while True:
    content = file.readline()
    b.append(content)
    if len(content) == 0:
        break
file.close()

# 记录行数
lines = 0
filename = open(file_path, 'r', encoding='UTF-8')  # 以只读方式打开文件
file_contents = filename.read()  # 读取文档内容到file_contents
for file_content in file_contents:  # 统计文件内容中换行符的数目
    if file_content == '\n':
        lines += 1
if file_contents[-1] != '\n':  # 当文件最后一个字符不为换行符时，行数+1
    lines += 1
file.close()


# 写入b列表数据
output_path = "./output_txt.txt"
file_02 = open(output_path, "w", encoding='UTF-8')
file_02.writelines(b)
file_02.close()

FILE IO_YAML

from appium import webdriver
import yaml
import os
#日志准备
def appium_desired():
    # 获取当前路径---就算被别的文件调用 获取当前位置
    base_dir = os.path.dirname(__file__)
    # os.path.dirname(__file__)  获取当前的配置文件
    # 拼接路径
    yaml_path = os.path.join(base_dir, 'jw_kyb_caps.yaml')
    print(yaml_path)
    jwfile=open(yaml_path,'r',encoding='utf-8')# 打开配置文件
    data=yaml.load(jwfile)# 加载配置文件内容
    desired_caps={}
    # 利用data读取每个键对应的值
    desired_caps['platformName']=data['platformName']
    desired_caps['platformVersion']=data['platformVersion']
    desired_caps['deviceName']=data['deviceName']
    #os.path.dirname代表获取当前路径  比如  c：/a/b/c.txt ====>c：/a/b/
    # 两层的话再获取上一层路径
    base_dir = os.path.dirname(os.path.dirname(__file__))
    print("项目路径",base_dir)
    # 读取到了 被测试app的路径和软件名称
    # join拼接路径
    app_path = os.path.join(base_dir,'app', data['appname'])
    desired_caps['app']=app_path
    desired_caps['appPackage']=data['appPackage']
    desired_caps['appActivity']=data['appActivity']
    desired_caps['noReset']=data['noReset']
    driver=webdriver.Remote('http://'+str(data['ip'])+':'+str(data['port'])+'/wd/hub',desired_caps)
    driver.implicitly_wait(4)
    return driver # 根据配置文件的出需要控制的手机和app
# 单元测试===》自测一下
if __name__ == '__main__':
    appium_desired()

数据驱动_DDT

import unittest
from ddt import ddt, data, unpack

# 定义一个列表，列表数据为多个字典，字典数据为键值对存储具体数据。
dic = [{"name":"zhangsan", "age":25},{"name":"lisi", "age":24}, {"name":"wangwu", "age":18}]


@ddt
class MyTestCase(unittest.TestCase):

    def setUp(self) -> None:
        print("开始测试~~~")

    @data(*dic)
    @unpack
    def test_01(self, name, age):
        print(name, age)

    def tearDown(self) -> None:
        print("结束测试~~~")


if __name__ == '__main__':
    unittest.main()

数据驱动案例_EXCEL+DDT

# # # # # # # # # # # # # # # # # # # # # # # # # # # #
#                                                     
# 能够操作Excel的模块：xlrd openpyxl pandas           
# openpyxl三大对象：工作簿、工作表、单元格            
#                                                     
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
import openpyxl
import os
from prettytable import PrettyTable


class ExcelRead:

    def excel_read(self):
        # Excel路径
        # path = os.path.dirname(os.getcwd()) + "\\demo\\" + "price.xlsx"
        path = "./price.xlsx"
        # 读取工作簿
        wk = openpyxl.load_workbook(path)
        # 读取工作表
        sheet = wk["Sheet1"]
        # 读取单元格的内容,存储至变量value中
        # value = sheet.cell(row=1, column=1).value
        # 获取单元格行数、列数
        global rows
        global cols
        rows = sheet.max_row
        cols = sheet.max_column

        # 记录表头信息到列表head
        global head
        head = []
        for h in range(1, cols + 1):
            header = sheet.cell(row=1, column=h).value
            head.append(header)

        # 记录表内容到content
        global content
        content = []
        for x in range(2, rows + 1):
            dic = {}
            for y in range(1, cols + 1):
                dic[head[y-1]] = sheet.cell(row=x, column=y).value
            content.append(dic)
        return content


ExcelRead().excel_read()
while True:
    find = input("请输入要查询的商品：")
    # 写入表头内容，表头为列表head
    x = PrettyTable(head)
    # nn指向字典中的第二个数据的【键】，即"存货名称"
    nn = head[1]
    # content为一个列表，里面嵌套很多字典，字典里面为数据
    # 从content的第一行开始遍历
    for i in range(1, rows-1):
        # p指向列表的第i个字典
        p = content[i]
        # p[nn] 代表取nn键对应的值，（键值对的值，nn为【键】），输入的数据find用来匹配nn键对应的值，这里直接用p["存货名称"]
        if find in p["存货名称"]:
            m = []
            for o in range(0, cols):
                q = head[o]
                n = p[q]
                m.append(n)
            x.add_row(m)
    # 全体左对齐 x.align[] = "l"
    for g in range(0,cols):
        aa = head[g]
        x.align[aa] = "l"
    print(x)