python文件操作

在我们日常工作中我们会处理不同类型（Excel、CSV、TXT等）文件，或读或写或读写。掌握文件操作对我们工作来说十分有用。

文件夹

对文件的操作离不开对文件夹的操作。

在Python开发中会定义很多自动以模块，在导入包时，在一些情况下往往会提示No xxxx Moudle之类的错误，磨刀不误砍柴工嘛，好好梳理下Python的工作路径，《参考博客》

Python中对于文件夹的处理有三大模块：

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

os.path

处理结果返回的是字符串形式

import os
import datetime
 
print("去掉文件名返回工作目录：", os.path.dirname('/home/ubuntu/MySpace/Python/notes/Python文件操作.ipynb'))

去掉文件名返回工作目录： /home/ubuntu/MySpace/Python/notes

print("返回上一层的工作目录全路径：", os.path.dirname(os.path.dirname('/home/ubuntu/MySpace/Python/notes/Python文件操作.ipynb')))

返回上一层的工作目录全路径： /home/ubuntu/MySpace/Python

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

返回当前工作目录： /home/ubuntu/MySpace/Python/notes

pwd_1 = "/home/ubuntu/MySpace/Python/notes/"
pwd_2 = "/home/ubuntu/MySpace/Python/xxx/"
 
path_1 = os.path.exists(pwd_1)
path_2 = os.path.exists(pwd_2)
 
def judge_path(path):
    if path:
        print("path 存在，值为：", path)
    else:
        print("path 不存在，值为：", path)
        
if __name__ == "__main__":
    judge_path(path_1)
    judge_path(path_2)

path 存在，值为： True
path 不存在，值为： False

print("返回绝对路径：", os.path.abspath("/home/ubuntu/MySpace/Python/notes/Python文件操作.ipynb"))

返回绝对路径： /home/ubuntu/MySpace/Python/notes/Python文件操作.ipynb

print("返回路径的最后一部分：", os.path.basename("/home/ubuntu/MySpace/Python/notes/Python文件操作.ipynb"))
print("返回路径的最后一部分：", os.path.basename("/home/ubuntu/MySpace/Python/notes"))

返回路径的最后一部分： Python文件操作.ipynb
返回路径的最后一部分： notes

print("返回文件名：", os.path.basename("/home/ubuntu/MySpace/Python/notes/Python文件操作.ipynb"))

返回文件名： Python文件操作.ipynb

print("将路径切割成头和尾的元组：", os.path.split("/home/ubuntu/MySpace/Python/notes/Python文件操作.ipynb"))
print("将路径切割成头和尾的元组：", os.path.split("/home/ubuntu/MySpace/Python/notes"))

将路径切割成头和尾的元组： ('/home/ubuntu/MySpace/Python/notes', 'Python文件操作.ipynb')
将路径切割成头和尾的元组： ('/home/ubuntu/MySpace/Python', 'notes')

print("路径拼接：", os.path.join("/home/ubuntu/MySpace/Python/notes/", "拼接路径"))

路径拼接： /home/ubuntu/MySpace/Python/notes/拼接路径

print("返回当前目录下的所有内容：", os.listdir('./'))
 
print("\n返回当前目录下的所有内容：", os.listdir('./data/'))

返回当前目录下的所有内容： ['校招生面试.ipynb', 'BasicPythonMind.mmd', 'Python文件操作.ipynb', '.~Python文件操作.ipynb', '.ipynb_checkpoints', 'Python文件.ipynb', '测试开发.mmd', '测试开发面试.ipynb', 'Python基础知识.ipynb', '__init__.py', 'data']
 
返回当前目录下的所有内容： ['read.txt', '.ipynb_checkpoints', 'count.txt', 'dst', 'src', 'write.txt']

# print("修改文件权限：", os.chmod("文件名", 665))

print("返回操作系统名称：", os.name)

返回操作系统名称： posix

print("返回当前操作系统的详细信息：", os.uname())

返回当前操作系统的详细信息： posix.uname_result(sysname='Linux', nodename='VM-0-8-ubuntu', release='4.15.0-54-generic', version='#58-Ubuntu SMP Mon Jun 24 10:55:24 UTC 2019', machine='x86_64')

pathlib

from pathlib import Path
import os
 
p = Path()

print("返回当前目录相对路径：%s" % p)

返回当前目录相对路径：.

print("返回当前目录绝对路径：%s" % p.cwd())

返回当前目录绝对路径：/home/ubuntu/MySpace/Python/notes

print("返回当前家目录：%s" % p.home())

返回当前家目录：/home/ubuntu

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

是否是软链接：False

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

是否是块设备：False

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

是否是socket文件：False

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

是否是绝对路径：False

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

返回一个新的路径，该路径是当前Path的绝对路径，如果是软连接则被解析：False

print("获取绝对路径：%s" % p.absolute())

获取绝对路径：/home/ubuntu/MySpace/Python/notes

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

获取绝对路径：/home/ubuntu/MySpace/Python/notes

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

判断目录或者文件是否存在：True

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

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"))

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

shutil

shutil --- 更多的是对文件的复制或移动操作

文件操作

Excel文件

# !pip3 install xlrd
# !pip3 install xlutils

Collecting xlrd
  Downloading http://mirrors.tencentyun.com/pypi/packages/b0/16/63576a1a001752e34bf8ea62e367997530dc553b689356b9879339cf45a4/xlrd-1.2.0-py2.py3-none-any.whl (103kB)
    100% |████████████████████████████████| 112kB 577kB/s ta 0:00:01
[?25hInstalling collected packages: xlrd
Successfully installed xlrd-1.2.0
Collecting xlutils
  Downloading http://mirrors.tencentyun.com/pypi/packages/c7/55/e22ac73dbb316cabb5db28bef6c87044a95914f713a6e81b593f8a0d2f79/xlutils-2.0.0-py2.py3-none-any.whl (55kB)
    100% |████████████████████████████████| 61kB 589kB/s ta 0:00:011
[?25hCollecting xlrd>=0.7.2 (from xlutils)
  Downloading http://mirrors.tencentyun.com/pypi/packages/b0/16/63576a1a001752e34bf8ea62e367997530dc553b689356b9879339cf45a4/xlrd-1.2.0-py2.py3-none-any.whl (103kB)
    100% |████████████████████████████████| 112kB 982kB/s ta 0:00:01
[?25hCollecting xlwt>=0.7.4 (from xlutils)
  Downloading http://mirrors.tencentyun.com/pypi/packages/44/48/def306413b25c3d01753603b1a222a011b8621aed27cd7f89cbc27e6b0f4/xlwt-1.3.0-py2.py3-none-any.whl (99kB)
    100% |████████████████████████████████| 102kB 1.5MB/s a 0:00:011
[?25hInstalling collected packages: xlrd, xlwt, xlutils
Successfully installed xlrd-1.2.0 xlutils-2.0.0 xlwt-1.3.0

import xlrd
from xlutils.copy import copy
import os
import sys
 
BASE_DIR = os.path.dirname(os.path.dirname("./data/excel.xls"))
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 = "./data/excel.xls"
 
        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")

BASE_DIR: .
获取Excel对象：<xlrd.sheet.Sheet object at 0x7f1f9c19a588>
Excel有：(12, 6)
Excel有：12 行
Excel有：6 列
Excel的第 2 行 2 列的值为： B 

CSV文件

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

# !pip3 install numpy
# !pip3 install pandas

Collecting numpy
  Downloading http://mirrors.tencentyun.com/pypi/packages/07/08/a549ba8b061005bb629b76adc000f3caaaf881028b963c2e18f811c6edc1/numpy-1.18.2-cp36-cp36m-manylinux1_x86_64.whl (20.2MB)
    100% |████████████████████████████████| 20.2MB 6.6MB/s ta 0:00:011   12% |████                            | 2.5MB 3.9MB/s eta 0:00:05    23% |███████▋                        | 4.8MB 7.6MB/s eta 0:00:03    41% |█████████████▎                  | 8.4MB 26.8MB/s eta 0:00:01    95% |██████████████████████████████▋ | 19.3MB 11.3MB/s eta 0:00:01
[?25hInstalling collected packages: numpy
Successfully installed numpy-1.18.2
Collecting pandas
  Downloading http://mirrors.tencentyun.com/pypi/packages/bb/71/8f53bdbcbc67c912b888b40def255767e475402e9df64050019149b1a943/pandas-1.0.3-cp36-cp36m-manylinux1_x86_64.whl (10.0MB)
    100% |████████████████████████████████| 10.0MB 4.1MB/s ta 0:00:011
[?25hCollecting python-dateutil>=2.6.1 (from pandas)
  Downloading http://mirrors.tencentyun.com/pypi/packages/d4/70/d60450c3dd48ef87586924207ae8907090de0b306af2bce5d134d78615cb/python_dateutil-2.8.1-py2.py3-none-any.whl (227kB)
    100% |████████████████████████████████| 235kB 32.6MB/s ta 0:00:01
[?25hCollecting numpy>=1.13.3 (from pandas)
  Downloading http://mirrors.tencentyun.com/pypi/packages/07/08/a549ba8b061005bb629b76adc000f3caaaf881028b963c2e18f811c6edc1/numpy-1.18.2-cp36-cp36m-manylinux1_x86_64.whl (20.2MB)
    100% |████████████████████████████████| 20.2MB 3.1MB/s ta 0:00:01    12% |████▏                           | 2.6MB 3.7MB/s eta 0:00:05    46% |███████████████                 | 9.4MB 2.9MB/s eta 0:00:04    47% |███████████████▏                | 9.6MB 3.2MB/s eta 0:00:04    77% |█████████████████████████       | 15.7MB 3.3MB/s eta 0:00:02
[?25hCollecting pytz>=2017.2 (from pandas)
  Downloading http://mirrors.tencentyun.com/pypi/packages/e7/f9/f0b53f88060247251bf481fa6ea62cd0d25bf1b11a87888e53ce5b7c8ad2/pytz-2019.3-py2.py3-none-any.whl (509kB)
    100% |████████████████████████████████| 512kB 2.9MB/s ta 0:00:01
[?25hCollecting six>=1.5 (from python-dateutil>=2.6.1->pandas)
  Downloading http://mirrors.tencentyun.com/pypi/packages/65/eb/1f97cb97bfc2390a276969c6fae16075da282f5058082d4cb10c6c5c1dba/six-1.14.0-py2.py3-none-any.whl
Installing collected packages: six, python-dateutil, numpy, pytz, pandas
Successfully installed numpy-1.18.2 pandas-1.0.3 python-dateutil-2.8.1 pytz-2019.3 six-1.14.0

import os
import sys
import numpy as np
import pandas as pd
 
BASE_DIR = os.path.dirname(os.path.dirname("./data/csv.csv"))
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 = "./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']))
 

BASE_DIR: .
获取csv的所有数据：     0       1     2                  3                  4
0   id  is_run  name         start_time           end_time
1    1    TRUE    A   2020/4/12 0:00:00  2020/5/12 0:00:00
2    2    TRUE    B   2020/4/12 0:00:00  2020/5/12 0:00:00
3    3    TRUE     C  2020/4/12 0:00:00  2020/5/12 0:00:00
4    4    TRUE    D   2020/4/12 0:00:00  2020/5/12 0:00:00
5    5    TRUE     E  2020/4/12 0:00:00  2020/5/12 0:00:00
6    6    TRUE     F  2020/4/12 0:00:00  2020/5/12 0:00:00
7    7    TRUE     G  2020/4/12 0:00:00  2020/5/12 0:00:00
8    8    TRUE     H  2020/4/12 0:00:00  2020/5/12 0:00:00
9    9    TRUE     I  2020/4/12 0:00:00  2020/5/12 0:00:00
10  10    TRUE     J  2020/4/12 0:00:00  2020/5/12 0:00:00

json文件

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

"""
    json.loads针对内存对象，即将Python内置数据序列化为字串
    json.load针对文件句柄，主要是针对读取文件
 
"""
 
import os
import sys
import json
 
file_name = "./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)

将字符串转换为json："\"foo\bar"
数据类型为：<class 'str'>
将列表转换为json：[
    "foo",
    {
        "bar": [
            "baz",
            null,
            1.0,
            2
        ]
    }
]
数据类型为：<class 'str'>
将字段转换为json：[
    "foo",
    {
        "bar": [
            "baz",
            null,
            1.0,
            2
        ]
    }
]
数据类型为：<class 'str'>

log文件

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

import os
import sys
import logging
import datetime
 
BASE_DIR = os.path.dirname(os.path.dirname("./data/"))
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 = "./data/"
            
    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 = "./data/%s_log.log" % log_times
    # ol.write_log1(file_name_1)
    
    file_name_2 = "./data/%s_log.log" % log_times
    # ol.write_log2(file_name_2, message="[test......]")
 

ini文件

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

import os
import sys
import configparser
 
BASE_DIR = os.path.dirname(os.path.dirname("./data/ini.ini"))
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 = "./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')))
 

id 2
获取节点 Second 的 second_id 参数的值为：id>2

xml文件

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

#!/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("./data/xml.xml"))
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 = "./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()

获取xml文件对象：<xml.dom.minidom.Document object at 0x7f1f84ab9b88>
获取文档根元素: Poeple
请检查你的节点是否存在
请检查你的节点是否存在
请检查你的节点是否存在
请检查你的节点是否存在
请检查你的节点是否存在

txt文件

import os
import sys
 
BASE_DIR = os.path.dirname(os.path.dirname("./data/txt.txt"))
sys.path.append(BASE_DIR)
 
file_name = "./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/txt.txt'
    # write_txt("sjkjk")
    text_lists = "[1, 2, 3]"
    write_lines(text_lists)
    # print(ot.close_txt())
 

None

实用模板

创建动态日志目录

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

当前程序的工作目录：.
程序执行的当前时间戳：2020-04-12_14-17-41
../data/2020-04-12_14-17-41/
 
 
 
---------------------------------------------------------------------------
 
FileNotFoundError                         Traceback (most recent call last)
 
<ipython-input-36-3bbe55d41cd3> in <module>
     12 isExists = os.path.exists(LOG_PATH)
     13 if not isExists:
---> 14     os.mkdir(LOG_PATH)
 
 
FileNotFoundError: [Errno 2] No such file or directory: '../data/2020-04-12_14-17-41/'