在日常工作中我们会处理不同类型（如Excel，CSV，TXT等）的文件，或读或写或读写，文件的操作对我们去处理数据十分的有用。

一、文件夹操作

  为什么要说文件夹呢？因为文件存在于文件夹下，对文件的操作必定离不开对文件夹的操作。

1.工作路径

  在Python开发中，往往会自定义一些包，在导入包的时候，在一些情况下往往会提示 No xxx Moudlue 之类的错误，往往让人匪夷所思。所以必须好好梳理下这块程序执行的思路。【感谢梳理】

  对于目录的操作，Python有三种模块可以处理：

os.path --- 返回的是字符串
pathlib --- 返回的是一个Path对象
shutil --- 更多的是对文件的复制或移动操作

1.1 os.path模块

import os
import datetime

# 返回目录
print("返回当前执行文件的目录：%s" % os.path.dirname(__file__))
print(os.path.dirname("返回当前文件的工作空间目录：%s" % os.path.dirname(__file__)))

# 返回当前工作目录
print("返回当前工作目录：%s" % print(os.getcwd()))

# 判断路径是否存在
pwd1 = os.path.dirname(__file__)
pwd2 = "OperateFile"
print("如果路径存在，返回True：%s" % os.path.exists(pwd1))
print("如果路径存在，返回False：%s" % os.path.exists(pwd2))

# 返回一个绝对路径
print("返回一个绝对路径：%s, 注意它的盘符是当前操作系统的默认盘符" % os.path.abspath(pwd1))

# 返回路径的最后一部分
print("返回路径的最后一部分：%s" % os.path.basename(pwd1))

# 返回文件名
print("返回文件名 %s" % os.path.basename(__file__))

# 将路径切割成头和尾的一个元组
print("将路径切割成头和尾的一个元组：(%s, %s)" % os.path.split(pwd1))

# 拼接一个路径
print("拼接一个路径：%s" % os.path.join("D:\MySpace\Python\BasicPython\OperateFile", r"JoinFile"))

print("返回操作系统：%s" % os.name)
print("显示当前操作系统的详细信息: (%s, %s, %s, %s, %s)" % os.uname())
print("返回当前的操作系统：%s" % sys.platform)
print("返回目录列表的内容：%s" % os.listdir("./"))
print("修改文件的权限：%s" % os.chmod("01_workpath_os_path.py", 777))


# *_*_*_*_*_*_*_*_*_*_*_*_*_*_创建动态日志目录*_*_*_*_*_*_*_*_*_*_*_*_*_*_*
# 如果想要动态创建一个时间戳目录，来动态存放程序日志
# 1.为了避免程序找不到目录尴尬, 首先确定当前程序的工作空间
CURRENT_DIR = os.path.dirname(os.path.dirname(__file__))
print("当前程序的工作目录：%s" % CURRENT_DIR)
# 2.生成时间戳
nowTime = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
print("程序执行的当前时间戳：%s" % nowTime)
# 3.拼接存放日志的目录
LOG_PATH = CURRENT_DIR + "/OperateFile/log/" + nowTime + "/"
print(LOG_PATH)
# 4.判断存放日志的目录LOG_PATH是否存在，不存在的话就就创建该目录
isExists = os.path.exists(LOG_PATH)
if not isExists:
    os.mkdir(LOG_PATH)

1.2 pathlib模块

from pathlib import Path
import os

# 返回当前目录
p = Path()
print("返回当前目录：%s" % p)
print("返回当前目录：%s" % p.cwd())

# 返回当前家目录（当前操作系统的）
print("返回当前家目录：%s" % p.home())

# 判断是否是目录
print("判断是否是目录：%s" % p.is_dir())

# 是否是软链接
print("是否是软链接：%s" % p.is_symlink())

# 是否是块设备
print("是否是块设备：%s" % p.is_block_device())


# 是否是socket文件
print("是否是socket文件：%s" % p.is_socket())

# 是否是绝对路径
print("是否是绝对路径：%s" % p.is_absolute())

# 返回一个新的路径，该路径是当前Path的绝对路径，如果是软连接则被解析
print("返回一个新的路径，该路径是当前Path的绝对路径，如果是软连接则被解析：%s" % p.is_absolute())

# 获取绝对路径，推荐使用resolve()
print("获取绝对路径：%s" % p.absolute())

# 返回一个新的路径，该路径是当前Path的绝对路径，如果是软连接则被解析
print("获取绝对路径：%s" % p.resolve())

# 判断目录或者文件是否存在
print("判断目录或者文件是否存在：%s" % p.exists())

# 删除空目录
# print("删除空目录", p.rmdir())

# 创建一个文件
print("创建一个文件：%s" % p.touch("test.txt"))

# 将路径解析成url
p_u = Path("../usr/local/sbin")
# print("将路径解析成url：%s" % p_u.as_uri())

# 返回 p1 下目录的相关信息
p1 = Path("/usr/local/httpd/httpd.conf")
print("目录的最后一个部分，没有后缀p1.name：%s" % p1.name)
print("连接多个字符串到Path对象中-p1.joinpath：%s" % p1.joinpath('test'))
print("目录的逻辑父目录-p1.parent：%s" % p1.parent)
print("父目录序列，索引0是直接的父-p1.parents：%s" % p1.parents[0])
print("父目录序列，索引0是直接的父-p1.parents：%s" % p1.parents[1])
print("父目录序列，索引0是直接的父-p1.parents：%s" % p1.parents[2])
print("父目录序列，索引0是直接的父-p1.parents：%s" % p1.parents[3])
print("目录中的最后一部分-p1.stem：%s" % p1.stem)
print("目录中的最后一部分的扩展名-p1.suffix：%s" % p1.suffix)
print("返回多个扩展名列表-p1.suffixes：%s" % p1.suffixes)
print("返回路径中的每一个部分-p1.parts：(%s, %s, %s, %s, %s)" % p1.parts)
print("补充扩展名到路径的尾部，返回新的路径，扩展名存在则无效-p1.with_suffix(suffix)：%s" % p1.with_suffix('.txt'))
print("替换目录最后一个部分并返回一个新的路径-p1.with_name(name)：%s" % p1.with_name("httpd.txt"))

1.3 shutil模块

import shutil

src = ""
dst = ""
olddir = ""
newdir = ""
# 从源src复制到dst中去。 如果当前的dst已存在的话就会被覆盖掉
shutil.copyfile(src, dst)
# 移动文件或重命名
shutil.move(src, dst)
# 只是会复制其权限其他的东西是不会被复制的
shutil.copymode(src, dst)
# 复制权限、最后访问时间、最后修改时间
shutil.copystat(src, dst)
# 复制一个文件到一个文件或一个目录
shutil.copy(src, dst)
# 在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西
shutil.copy2(src, dst)
# 如果两个位置的文件系统是一样的话相当于是rename操作，只是改名；如果是不在相同的文件系统的话就是做move操作
shutil.copy2(src, dst)
# 把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接
shutil.copytree(olddir, newdir, True)
# 递归删除一个目录以及目录内的所有内容
shutil.rmtree(src)

二、文件操作

1.Excel文件操作

  这里读取 Excel 用到 xlrd 模块，写入 Excel 的时候会用到文件复制，这里用到 xlutils 模块

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   21_file_excel.py
@Time    :   2019/12/21下午2:46
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

import os
import sys
import xlrd
from xlutils.copy import copy

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
print("BASE_DIR: %s" % BASE_DIR)


class OperateExcel(object):

    def __init__(self, file_name=None, sheet_id=None):
        """
        获取要读取的excel文件
        :param file_name: 文件名称
        :param sheet_id: 文件的sheet页
        """
        if file_name:
            self.file_name = file_name
        else:
            self.file_name = "../OperateFile/data/excel.xlsx"

        if sheet_id:
            self.sheet_id = sheet_id
        else:
            self.sheet_id = 0

        self.sheet_table = self.get_sheet()

    # 获取 sheet 页的操作对象
    def get_sheet(self):
        data = xlrd.open_workbook(self.file_name)
        sheet_table = data.sheets()[self.sheet_id]
        return sheet_table

    # 获取 sheet 页的行数和列数，返回的是一个元祖
    def get_sheet_nrows_ncols(self):
        return self.sheet_table.nrows, self.sheet_table.ncols

    # 获取 sheet 页的行数（Excel中常用到）
    def get_sheet_nrows(self):
        return self.sheet_table.nrows

    # 获取 sheet 页的列数
    def get_sheet_ncols(self):
        return self.sheet_table.ncols

    # 获取单元格中的数据
    def get_sheet_cell(self, row, col):
        """
        :param row: 单元格的第几行
        :param col: 单元格的第几列
        :return: 单元格的值
        """
        cell_data = self.sheet_table.cell_value(row, col)
        return cell_data

    # 写数据到 Excel 文件中
    def write_to_excel(self, row, col, value):
        # 获取操作Excel的操作句柄
        data = xlrd.open_workbook(self.file_name)
        # 拷贝数据
        copy_data = copy(data)
        # 选择要写入的Excel sheet页
        copy_data_sheet = copy_data.get_sheet(self.sheet_id)
        # 写入数据
        copy_data_sheet.write(row, col, value)
        # 保存数据到excel
        copy_data.save(self.file_name)


if __name__ == "__main__":
    oe = OperateExcel()
    print("获取Excel对象：%s" % oe.get_sheet())
    print("Excel有：(%s, %s)" % oe.get_sheet_nrows_ncols())
    print("Excel有：%s 行" % oe.get_sheet_nrows())
    print("Excel有：%s 列" % oe.get_sheet_ncols())
    print("Excel的第 %s 行 %s 列的值为： %s" % (2, 2, oe.get_sheet_cell(2, 2)))
    oe.write_to_excel(11, 5, "Values")

2.CSV文件操作

  什么是 CSV 文件呢：CSV（Comma-Separated Values）格式的文件是指以纯文本形式存储的表格数据。会用到 pandas 模块来处理 csv 文件，Pandas 是一个强大的分析结构化数据的工具集；它的使用基础是Numpy（提供高性能的矩阵运算）；用于数据挖掘和数据分析，同时也提供数据清洗功能。

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   22_file_csv.py
@Time    :   2019/12/2210:42
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

import os
import sys
import numpy as np
import pandas as pd

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
print("BASE_DIR: %s" % BASE_DIR)
sys.path.append(BASE_DIR)


class OperateCsv(object):
    
    def __init__(self, file_name=None):
        if file_name:
            self.file_name = file_name
        else:
            self.file_name = "../OperateFile/data/csv.csv"
            
        self.df = self.read_csv()
        
    def read_csv(self):
        """
        filename可以直接从盘符开始，标明每一级的文件夹直到csv文件，
        header=None表示头部为空，
        sep=' '表示数据间使用空格作为分隔符，如果分隔符是逗号，只需换成 ‘，’即可
        @return: 返回CSV中的所有数据
        """
        df = pd.read_csv(
            self.file_name,
            header=None
        )
        return df
        
    def read_front_rows(self, n):
        """
        会包含表头的返回前n行的CSV数据
        @param n: 要返回的行数
        @return: 返回的 n 行数据
        """
        return self.df.head(n)
    
    def read_tail_rows(self, n):
        """
        返回CSV文件的最后 n 行数据
        @param n: 要返回的行数
        @return: 返回的后 n 行数据
        """
        return self.df.tail(n)
    
    def read_skiprows(self, *args):
        return pd.read_table(self.file_name, header=None, skiprows=args)
    
    def read_rows_cols(self, *args):
        drc = pd.read_csv(
            self.file_name,
            header=None,
            names=args
        )
        return drc
    
    def drop_col(self, *args):
        return self.df.drop(args)


if __name__ == "__main__":
    oc = OperateCsv()
    # print("获取csv的所有数据：%s" % oc.read_csv())
    # print("获取前 %s 的数据: %s" % (4, oc.read_front_rows(4)))
    # print("获取后 %s 的数据: %s" % (3, oc.read_tail_rows(3)))
    # print("获取数据跳过某些行: %s" % (oc.read_skiprows(0, 1, 2)))
    # print("获取指定列" % oc.read_rows_cols('start_time', 'id'))
    print("删除指定列", oc.drop_col(['id']))

三、文本操作

1.txt文本操作

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   31_text_txt.py
@Time    :   2019/12/2217:20
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

import os
import sys

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)

file_name = "../OperateFile/data/txt.txt"
fr = open(file_name, 'r', encoding="utf-8")
fw = open(file_name, 'w', encoding="utf-8")
fa = open(file_name, 'a', encoding="utf-8")


def load_txt():
    print(fr.read())


def read_txt_byte(n):
    print(fr.read(n))


def read_line():
    print(fr.readline())

def read_lines():
    print(fr.readlines())
    
def write_txt(message):
    """
    :param message: 写入的数据
    :return: 返回写入的字符的长度
    """
    print(fw.write(message))
    
def write_lines(*args):
    print(fa.writelines(args))


def close_txt(self):
    fr.close()
    print("关闭读取文件句柄")

if __name__ == "__main__":
    file_name_1 = './data/txt1.txt'
    # write_txt("sjkjk")
    text_lists = "[1, 2, 3]"
    write_lines(text_lists)
    # print(ot.close_txt())

2.xml文本操作

  可扩展标记语言，标准通用标记语言的子集，简称XML。是一种用于标记电子文件使其具有结构性的标记语言。《百度百科》

<?xml version="1.0" encoding="utf-8"?><!-- This is template xml --><Poeple>     
    <person ID="p001">            
        <id>1</id>            
        <name>A11</name>
        <age>9999</age>            
        <sex>male</sex>            
        <comments>                  
            <![CDATA[This is not jie xi]]>                  
        </comments>            
    </person>      

  <person ID="p002">            
        <id>2</id>            
        <name>&quot;B&quot;</name>            
        <age>21</age>            
        <sex>female</sex>            
        <comments>                  
            <![CDATA[This is not jie xi]]>                  
        </comments>            
  </person>      

  <person>            
        <id>3</id>            
        <name>&quot;C&quot;</name>            
        <age>22</age>            
        <sex>female</sex>            
        <comments>                  
            <![CDATA[This is not jie xi]]>                  
        </comments>            
  </person>  

  <person ID="p004">    
        <id>4</id>    
        <name>D</name>    
        <age>23</age>    
        <sex>male</sex>    
        <comments><![CDATA[create success]]></comments>  
    </person>
    
    <person ID="p004"><id>4</id><name>D</name><age>23</age><sex>male</sex><comments><![CDATA[create success]]></comments></person>
</Poeple>

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   32_text_xml.py
@Time    :   2019/12/2214:07
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

import os
import sys
from xml.etree.ElementTree import ElementTree, Element
from xml.dom.minidom import parse

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)


class OperateXml(object):
    
    def __init__(self, file_name=None):
        if file_name:
            self.file_name = file_name
        else:
            self.file_name = "../OperateFile/data/xml.xml"
            
        self.dom = self.read_xml()
        
    def read_xml(self):
        """
        :return: 获取xml文件对象
        """
        dom = parse(self.file_name)
        return dom
    
    def get_document_element(self):
        """
        :return: rootNode---获取跟元素对象
        :return: 获取文档根元素
        """
        rootNode = self.dom.documentElement
        return rootNode.nodeName
    
    def get_root_next_info(self):
        """
        :return:
        """
        rootNode = self.dom.documentElement
        persons = rootNode.getElementsByTagName("person")
        for person in persons:
            if person.hasAttribute("ID"):
                print("ID: %s" % person.getAttribute("ID"))
                # id 参数
                id = person.getElementsByTagName("id")[0]
                print(id.nodeName, ":", id.childNodes[0].data)
                # name 参数
                name = person.getElementsByTagName("name")[0]
                print(name.nodeName, ":", name.childNodes[0].data)
                # sex 参数
                sex = person.getElementsByTagName("sex")[0]
                print(sex.nodeName, ":", sex.childNodes[0].data)
                # comments 参数---xml不解析
                comments = person.getElementsByTagName("comments")[0]
                print(comments.nodeName, ":", comments.childNodes[0].data)
            else:
                print("......")
    
    def write_xml(self):
        # 获取文档根元素
        rootNode = self.dom.documentElement
        
        # 新建一个person节点
        person_node = self.dom.createElement("person")
        person_node.setAttribute("ID", "p004")
        
        # 创建id节点，并设置textValue
        id_node = self.dom.createElement("id")
        id_text_value = self.dom.createTextNode("4")
        # 把文本节点挂到id_node节点上，即赋予值
        id_node.appendChild(id_text_value)
        # 把id_node挂在到person节点上，认亲
        person_node.appendChild(id_node)

        # 创建name节点，并设置textValue
        name_node = self.dom.createElement("name")
        name_text_value = self.dom.createTextNode("D")
        # 把文本节点挂到name_node节点上，即赋予值
        name_node.appendChild(name_text_value)
        # 把name_node挂在到person节点上，认亲
        person_node.appendChild(name_node)

        # 创建age节点，并设置textValue
        age_node = self.dom.createElement("age")
        age_text_value = self.dom.createTextNode("23")
        # 把文本节点挂到age_node节点上，即赋予值
        age_node.appendChild(age_text_value)
        # 把age_node挂在到person节点上，认亲
        person_node.appendChild(age_node)

        # 创建sex节点，并设置textValue
        sex_node = self.dom.createElement("sex")
        sex_text_value = self.dom.createTextNode("male")
        # 把文本节点挂到sex_node节点上，即赋予值
        sex_node.appendChild(sex_text_value)
        # 把sex_node挂在到person节点上，认亲
        person_node.appendChild(sex_node)

        # 创建comments节点，并设置textValue
        comments_node = self.dom.createElement("comments")
        comments_text_value = self.dom.createCDATASection("create success")
        # 把文本节点挂到comments_node节点上，即赋予值
        comments_node.appendChild(comments_text_value)
        # 把comments_node挂在到person节点上，认亲
        person_node.appendChild(comments_node)
        
        # 将上面创建的子节点挂在到根节点
        rootNode.appendChild(person_node)
        
        # 调整格式
        with open(self.file_name, 'w') as f:
            self.dom.writexml(f, addindent="", encoding="utf-8")
            
    def update_xml(self):
        # 文档根元素
        rootNode = self.dom.documentElement
        
        # 找到自己要更新的节点
        persons = rootNode.getElementsByTagName("person")
        for person in persons:
            name = person.getElementsByTagName("name")[0]
            # print(name.childNodes[0].data)
            if name.childNodes[0].data == "A1":
                # 获取到name节点的父节点
                pn = name.parentNode
                print("pn: %s" % pn)
                # 父节点的age节点，就是name的兄弟节点
                age = pn.getElementsByTagName("age")[0]
                print("age: %s" % age)
                # 更新想要更新节点的值
                name.childNodes[0].data = "A11"
                age.childNodes[0].data = "9999"
            else:
                print("请检查你的节点是否存在")

        with open(self.file_name, 'w') as f:
            self.dom.writexml(f, addindent='', encoding="utf-8")
        

if __name__ == "__main__":
    ox = OperateXml()
    print("获取xml文件对象：%s" % ox.read_xml())
    print("获取文档根元素: %s" % ox.get_document_element())
    # 获取xml各个节点信息
    # ox.get_root_next_info()
    # 向xml文件中写数据
    # ox.write_xml()
    # 更新xml文件数据
    ox.update_xml()
    

3.log文本操作

  所谓日志（Log）是指系统所指定对象的某些操作和其操作结果按时间有序的集合。log文件就是日志文件，log文件记录了系统和系统的用户之间交互的信息，是自动捕获人与系统终端之间交互的类型、内容或时间的数据收集方法；对网络搜索而言，日志是利用网络搜索引擎搜索信息的用户在搜索信息期间与该网络搜索引擎发生互动的电子记录。《百度百科》

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   33_text_log.xml
@Time    :   2019/12/2216:18
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

import os
import sys
import logging
import datetime

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
LOG_FORMAT = "%(asctime)s=====%(levelname)s+++++%(message)s"

class OperateLog():
    def __int__(self, file_name=None):
        if file_name:
            self.file_name = file_name
        else:
            self.file_name = "../OperateFile/logs/"
            
    def write_log1(self, file_name=None, message=None):
        logging.basicConfig(
            filename=file_name,
            level=logging.DEBUG,
            format=LOG_FORMAT
        )
        logging.debug(message)
        logging.info(message)
        logging.warning(message)
        logging.error(message)
        logging.critical(message)
        
    def write_log2(self, file_name=None, message=None):
        """
        :param file_name: 日志路径
        :param message: 要写入的日志信息
        :return:
        """
        logging.basicConfig(
            filename=file_name,
            level=logging.DEBUG,
            format=LOG_FORMAT
        )
        logging.log(logging.DEBUG, message)
        logging.log(logging.INFO, message)
        logging.log(logging.WARNING, message)
        logging.log(logging.ERROR, message)
        logging.log(logging.CRITICAL, message)
        
        
if __name__ == "__main__":
    ol = OperateLog()
    log_times = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    
    file_name_1 = "./logs/%s_log.log" % log_times
    # ol.write_log1(file_name_1)
    
    file_name_2 = "./logs/%s_log.log" % log_times
    # ol.write_log2(file_name_2, message="[test......]")

4.ini文本操作

  *.ini文件是Initialization file的缩写，即为初始化文件，是Windows系统配置文件所采用的存储格式，统管Windows的各项配置《百度百科》。ini配置文件由节、键、值组成。

[First]
first_id = id>1
first_name = name>"A"
first_sex = sex>"male"
first_high = high>"170"
[Second]
second_id = id>2
second_name = name>"B"
second_sex = sex>"fame"
second_high = hig >"160"

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   34_text_ini.py
@Time    :   2019/12/2213:24
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

import os
import sys
import configparser

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)


class OperateIni(object):
    
    def __init__(self, file_name=None, node=None):
        if file_name:
            self.file_name = file_name
        else:
            self.file_name = "../OperateFile/data/ini.ini"
        
        if node:
            self.node = node
        else:
            self.node = "First"
            
        self.cf = self.read_ini()
        
    def read_ini(self):
        cf = configparser.ConfigParser()
        cf.read(self.file_name)
        return cf
    
    def get_value(self, node, key):
        value = self.cf.get(node, key)
        return value
    

if __name__ == "__main__":
    oi = OperateIni()
    data = oi.get_value(node="Second", key='second_id')
    key = data.split(">")[0]
    value = data.split(">")[1]
    print(key, value)
    print("获取节点 %s 的 %s 参数的值为：%s" % ("Second", "second_id", oi.get_value(node="Second", key='second_id')))

5.json文本操作

  JSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。它基于 ECMAScript 的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

json文本示例：下面就是我们经常在接口中常用的数据传输方式，大部分获取到的数据要通过一定的解析来获得我们需要的关键信息。

{
    "code": "0000",
    "data": [
        {
            "company_name": "C1",
            "detail": "C1-detail",
            "host": "detail1.com",
            "level": "2",
            "title": "C1的标题",
            "type": "1",
            "update_time": "2019-01-01 15:18:13",
            "url": ["http://www.5itest2.cn"],
            "id": "Q1"
        },
        {
            "company_name": "C2",
            "detail": "C2detail",
            "host": "detail2.com",
            "level": "2",
            "title": "C2的标题",
            "type": "2",
            "update_time": "2019-01-02 15:18:13",
            "url": ["http://www.5itest2.cn"],
            "id": "Q2"
        },
        {
            "company_name": "C3",
            "detail": "C3-detail",
            "host": "detail3.com",
            "level": "2",
            "title": "C3的标题",
            "type": "3",
            "update_time": "2019-01-03 15:18:13",
            "url": ["http://www.5itest3.cn"],
            "id": "Q3"
        }
    ],
    "msg": "请求成功"
}

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   35_text_json.py
@Time    :   2019/12/239:55
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :
-----------
    json.loads针对内存对象，即将Python内置数据序列化为字串
    json.load针对文件句柄，主要是针对读取文件
-----------

"""

import os
import sys
import json

file_name = "../OperateFile/data/json.json"

json_list = '["foo", {"bar":["baz", null, 1.0, 2]}]'
json_dict = '{"a": 0, "b": 0, "c": 0}'

def loads_json(args):
    """
    :param args: 要解析的的数据，可以是
    :return:
    """
    result = json.loads(args)
    return result
    

def load_json(file_path=None):
    """
    :param file_path: 要加载解析的文件
    :return: 解析后的数据
    """
    my_json = open(file_path, 'r', encoding="utf-8")
    result = json.load(my_json)
    return result

def dumps_file_json(file_path=None):
    """
    现将文件中的数据读取到内存中，再从内存中读取，输出到控制台显示
    :param file_path: 要加载解析的文件
    :return: 解析后的格式化数据
    """
    my_json = open(file_path, 'r', encoding="utf-8")
    result = json.load(my_json)
    format_result = json.dumps(result, indent=4, ensure_ascii=False)
    return format_result

def dumps_args_json(args=None):
    """
    将内存中的数据转换为json格式，并排序
    :param args: 内存中的数据，数据类型可以是字符串、列表、字典
    :return: json数据
    """
    format_result = json.dumps(args, indent=4, ensure_ascii=False, sort_keys=True)
    return format_result

def dump_json(args_info=None, file_path=None):
    """
    将内存中的数据解析成json输出到文件中去
    :param args_info: 内存的数据，可以是字符串、列表、字典
    :param file_path: json要输出到的文件名称
    :return: 输出json数据文件
    """
    my_file = open(file_path, 'w')
    json.dump(args_info, my_file, indent=4)
 
 
    
if __name__ == "__main__":
    
    # 从内存中读取将json解析
    # print("将json解析成列表：%s" % loads_json(json_list))
    # print("数据类型为：%s" % type(loads_json(json_list)))
    # print("将json解析成字典：%s" % loads_json(json_dict))
    # print("数据类型为：%s" % type(loads_json(json_dict)))
    #
    # 从文件中读取解析json
    # print("读取文件中的json数据：%s" % load_json(file_path=file_name))
    # print("读取文件中的json数据的数据类型为：%s" % type(load_json(file_path=file_name)))

    # 将数据格式化成json数据格式
    # print("读取文件中的json数据：%s" % dumps_file_json(file_path=file_name))
    # print("数据类型为：%s" % type(dumps_file_json(file_path=file_name)))
    data_str = "\"foo\bar"
    data_list = ['foo', {'bar': ('baz', None, 1.0, 2)}]
    data_dict = {"c": 0, "b": 0, "a": 0}
    print("将字符串转换为json：%s" % dumps_args_json(data_str))
    print("数据类型为：%s" % type(dumps_args_json(data_str)))
    print("将列表转换为json：%s" % dumps_args_json(data_list))
    print("数据类型为：%s" % type(dumps_args_json(data_list)))
    print("将字段转换为json：%s" % dumps_args_json(data_list))
    print("数据类型为：%s" % type(dumps_args_json(data_list)))
    
    
    # args = [1, 2, 3, {'4': 5, '6': 7}]
    # file_name = "../OperateFile/data/dump_json.json"
    # dump_json(args, file_name)