import sys, os

# 程序主目录

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

# 添加主目录至环境变量,通常写于文件首部位置

sys.path.append(BASE_DIR)

print(sys.path[0], type(sys.path[0]))

#out:

E:\学习经历\python勃起\SVN目录\S13-Day05\class <class 'str'>

 os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径

 os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd

 os.makedirs('dir1/dir2')    可生成多层递归目录，相当于linux中的mkdir -p

 os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

 os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirname

 os.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

 os.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

 os.remove()                 删除一个文件

 os.rename("oldname","new")  重命名文件/目录

 os.stat('path/filename')    获取文件/目录信息

 os.sep                      操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

 os.linesep                  当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

 os.pathsep                  用于分割文件路径的字符串,windows下为";"，Linux下为"："

 os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'

 os.system("bash command")   运行shell命令，并输出对应结果

 os.environ                  获取系统环境变量

 os.path.abspath(path)       返回path规范化的绝对路径

 os.path.split(path)         将path分割成目录和文件名二元组返回

 os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素

 os.path.basename(path)      返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

 os.path.exists(path)        如果path存在，返回True；如果path不存在，返回False

 os.path.isabs(path)         如果path是绝对路径，返回True

 os.path.isfile(path)        如果path是一个存在的文件，返回True。否则返回False

 os.path.isdir(path)         如果path是一个存在的目录，则返回True。否则返回False

 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

 os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间

 os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间

 random.random()       用于生成一个0到1的随机浮点数: 0 <= n < 1.0

 random.uniform(a,b)  用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限

 random.randint(a, b)    用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

 random.randrange([start], stop[, step])  从指定范围内，按指定基数递增的集合中 获取一个随机数

 random.choice   从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型

 random.sample(sequence, k)     从指定序列中随机获取指定长度的片断

 import time

 import datetime

 print(time.time()) #返回当前系统时间戳

 print(time.ctime()) #输出Tue Jan 26 18:23:48 2016 ,当前系统时间

 print(time.ctime(time.time()-86640)) #将时间戳转为字符串格式

 print(time.gmtime(time.time()-86640)) #将时间戳转换成struct_time格式

 print(time.localtime(time.time()-86640)) #将时间戳转换成struct_time格式,但返回 的本地时间

 print(time.mktime(time.localtime())) #与time.localtime()功能相反,将struct_time格式转回成时间戳格式

 #time.sleep(4) #sleep

 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将struct_time格式转成指定的字符串格式

 print(time.strptime("2016-01-28","%Y-%m-%d") ) #将字符串格式转换成struct_time格式

 #datetime module

 print(datetime.date.today()) #输出格式 2016-01-26

 print(datetime.date.fromtimestamp(time.time()-864400) ) #2016-01-16 将时间戳转成日期格式

 current_time = datetime.datetime.now() #

 print(current_time) #输出2016-01-26 19:04:30.335935

 print(current_time.timetuple()) #返回struct_time格式

 #datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])

 print(current_time.replace(2014,9,12)) #输出2014-09-12 19:06:24.074900,返回当前时间,但指定的值将被替换

 str_to_date = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M") #将字符串转换成日期格式

 new_date = datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天

 new_date = datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天

 new_date = datetime.datetime.now() + datetime.timedelta(hours=-10) #比现在减10小时

 new_date = datetime.datetime.now() + datetime.timedelta(seconds=120) #比现在+120s

 print(new_date)

 import json

 dic = '{"k1":1, "k2":2}'

 print(json.loads(dic), type(json.loads(dic)))

 out: {'k1': 1, 'k2': 2} <class 'dict'>

 dic = {'k1':1}

 s = json.dumps(dic)

 print(s, type(s))

 out: {"k1": 1} <class 'str'>

 import json, os

 li = [11, 22, 33]

 json.dump(li, open('write.txt', 'w'))

 os.system("type write.txt")

 out: [11, 22, 33]

 LI = json.load(open('write.txt', 'r'))

 print(LI, type(LI))

 out: [11, 22, 33] <class 'list'>

 import pickle

 li = [11,22,33]

 r = pickle.dumps(li)

 print(r, type(r))

 out: b'\x80\x03]q\x00(K\x0bK\x16K!e.' <class 'bytes'>

 s = pickle.loads(r)

 print(s, type(s))

 out: [11, 22, 33] <class 'list'>

 import pickle

 li = [11,22,33]

 r = pickle.dump(li,open("write.txt",'wb'))

 print(r, type(r))

 out: None <class 'NoneType'>

 s = pickle.load(open("write.txt",'rb'), encoding='utf-8')

 print(s, type(s))

 out: [11, 22, 33] <class 'list'>

 import logging, os

 logging.basicConfig(filename='example.log',level=logging.INFO)

 logging.debug('This message should go to the log file')

 logging.info('So should this')

 logging.warning('And this, too')

 os.system("type example.log")

 out:

 INFO:root:So should this

 WARNING:root:And this, too

import logging

logging.debug('This is debug message')

logging.info('This is info message')

logging.warning('This is warning message')

logging.critical('This is critical message')

logging.error('This is error message')

out:

WARNING:root:This is warning message

CRITICAL:root:This is critical message

ERROR:root:This is error message

import logging

#define logfile/logformat/loglevel for file log

logging.basicConfig(level=logging.DEBUG,

                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',

                datefmt='%a, %d %b %Y %H:%M:%S',

                filename='example.log',

                filemode='w')

#create logger obj

logger = logging.getLogger('CURRENT-USER')

logger.setLevel(logging.DEBUG)

#create console handler and set level to INFO

ch = logging.StreamHandler()

ch.setLevel(logging.INFO)

# define log format for console log

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

ch.setFormatter(formatter)

# add console handle to logger obj

logger.addHandler(ch)

logger.debug('This is debug message')

logger.info('This is info message')

logger.warning('This is warning message')

logger.critical('This is critical message')

logger.error('This is error message')

from xml.etree import ElementTree as ET

# 直接解析XML

# ElementTree 类型具有将内存中xml数据写入文件的属性，而Element不具备

tree = ET.parse("example.xml")

root = tree.getroot()

print(root)

out: <Element 'data' at 0x0000000000A56138>

from xml.etree import ElementTree as ET

str_xml = open('example.xml', 'r').read()

root = ET.XML(str_xml)

print(root) 

out: <Element 'data' at 0x0000000000C37818>

from xml.etree import ElementTree as ET

tree = ET.parse("example.xml")

root = tree.getroot()

for child in root:

    print(child, child.tag, child.attrib)

    for gradechild in child:

        print(gradechild, gradechild.tag, gradechild.text, gradechild.attrib, )

out: <Element 'country' at 0x0000000000E03AE8> country {'name': 'Liechtenstein'}

<Element 'rank' at 0x0000000000E18318> rank 2 {'updated': 'yes'}

<Element 'year' at 0x0000000000E18368> year 2023 {}

<Element 'gdppc' at 0x0000000000E183B8> gdppc 141100 {}

<Element 'neighbor' at 0x0000000000E18408> neighbor None {'direction': 'E', 'name': 'Austria'}

<Element 'neighbor' at 0x0000000000E18458> neighbor None {'direction': 'W', 'name': 'Switzerland'}

<Element 'country' at 0x0000000000E184A8> country {'name': 'Singapore'}

<Element 'rank' at 0x0000000000E184F8> rank 5 {'updated': 'yes'}

<Element 'year' at 0x0000000000E18548> year 2026 {}

<Element 'gdppc' at 0x0000000000E18598> gdppc 59900 {}

<Element 'neighbor' at 0x0000000000E185E8> neighbor None {'direction': 'N', 'name': 'Malaysia'}

<Element 'country' at 0x0000000000E18638> country {'name': 'Panama'}

<Element 'rank' at 0x0000000000E18688> rank 69 {'updated': 'yes'}

<Element 'year' at 0x0000000000E186D8> year 2026 {}

<Element 'gdppc' at 0x0000000000E18728> gdppc 13600 {}

<Element 'neighbor' at 0x0000000000E18778> neighbor None {'direction': 'W', 'name': 'Costa Rica'}

<Element 'neighbor' at 0x0000000000E187C8> neighbor None {'direction': 'E', 'name': 'Colombia'}

from xml.etree import ElementTree as ET

str_xml = open('example.xml', 'r').read()

root = ET.XML(str_xml)

for node in root.iter('year'): # 去所有子和子孙节点中，找寻year节点

    print(node.tag, node.text)

out:

year 2023

year 2026

year 2026

from xml.etree import ElementTree as ET

# 打开文件，读取XML内容

str_xml = open('example.xml', 'r').read()

# 将字符串解析成xml特殊对象，root代指xml文件的根节点

root = ET.XML(str_xml)

############ 操作 ############

# 顶层标签

print(root.tag)

# 循环所有的year节点

for node in root.iter('year'):

    # 将year节点中的内容自增一

    new_year = int(node.text) + 1

    node.text = str(new_year)

    # 设置属性

    node.set('name', 'alex')

    node.set('age', '')

    # 删除属性

    del node.attrib['name']

############ 保存文件 ############

tree = ET.ElementTree(root)

tree.write("test3.xml", encoding='utf-8')

# 直接解析xml文件

tree = ET.parse("example.xml")

# 获取xml文件的根节点

root = tree.getroot()

############ 操作 ############

# 顶层标签

print(root.tag)

# 遍历data下的所有country节点

for country in root.findall('country'):

    # 获取每一个country节点下rank节点的内容

    rank = int(country.find('rank').text)

    if rank > 50:

        # 删除指定country节点

        root.remove(country)

############ 保存文件 ############

tree.write("test-delnode.xml", encoding='utf-8')

from xml.etree import ElementTree as ET

tree = ET.parse("example.xml")

root = tree.getroot()

# ele = ET.Element()

ele = ET.Element('test', {'k1': 'v1'})

ele.text = "内容"

# 在无text内容的时候，采用自闭合标签，即<test k1='v1' />

# def __init__(self, tag, attrib={}, **extra):

root.append(ele)

tree.write('createxml.xml', encoding='utf-8')

from xml.etree import ElementTree as ET

# 创建根节点

root = ET.Element("family")

# 创建节点大儿子

son1 = ET.Element('son', {'name': 'lisi'})

# 创建节点小儿子

son2 = ET.Element('son', {'name': 'zhangsan'})

# 在大儿子中创建两个孙子

grandson1 = ET.Element('grandson', {'name': 'wangwu'})

grandson2 = ET.Element('grandson', {'name': 'maliu'})

# 把孙子添加到父亲节点中

son1.append(grandson1)

son2.append(grandson2)

# 把父亲添加到爷爷节点中

root.append(son1)

root.append(son2)

# 将爷爷节点转换为Etree类型

tree = ET.ElementTree(root)

# 默认情况下write，会保存为一行，没有缩进

# tree.write("create_new_xml.xml", encoding='utf-8')

tree.write("create_new_xml.xml", encoding='GBK', xml_declaration=True, short_empty_elements=False)

# short_empty_elements = True表示开启自封闭标签，False表示关闭自封闭标签

# xml_declaration = None时，如果为US-ASCII 或者UTF-8则不添加声明，其他编码格式添加声明。如果为True则永远添加声明.False关闭添加声明

def prettify(elem):

    """将节点转换成字符串，并添加缩进。

    """

    rough_string = ET.tostring(elem, 'utf-8')

    reparsed = minidom.parseString(rough_string)

    return reparsed.toprettyxml(indent="\t")

from xml.dom import minidom

from xml.etree import ElementTree as ET

# 创建根节点

root = ET.Element("family")

# 创建节点大儿子

son1 = ET.Element('son', {'name': 'lisi'})

# 创建节点小儿子

son2 = ET.Element('son', {'name': 'zhangsan'})

# 在大儿子中创建两个孙子

grandson1 = ET.Element('grandson', {'name': 'wangwu'})

grandson2 = ET.Element('grandson', {'name': 'maliu'})

# 把孙子添加到父亲节点中

son1.append(grandson1)

son2.append(grandson2)

# 把父亲添加到爷爷节点中

root.append(son1)

root.append(son2)

raw_str = prettify(root)

f = open("create_new_xml.xml",'w',encoding='utf-8')

f.write(raw_str)

f.close()

from xml.etree import ElementTree as ET

# 创建根节点

root = ET.Element("famliy")

# 创建大儿子

# son1 = ET.Element('son', {'name': '儿1'})

son1 = root.makeelement('son', {'name': '儿1'})

# 创建小儿子

# son2 = ET.Element('son', {"name": '儿2'})

son2 = root.makeelement('son', {"name": '儿2'})

# 在大儿子中创建两个孙子

# grandson1 = ET.Element('grandson', {'name': '儿11'})

grandson1 = son1.makeelement('grandson', {'name': '儿11'})

# grandson2 = ET.Element('grandson', {'name': '儿12'})

grandson2 = son1.makeelement('grandson', {'name': '儿12'})

son1.append(grandson1)

son1.append(grandson2)

# 把儿子添加到根节点中

root.append(son1)

root.append(son1)

tree = ET.ElementTree(root)

tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

from xml.etree import ElementTree as ET

# 创建根节点

root = ET.Element("famliy")

# 创建节点大儿子

son1 = ET.SubElement(root, "son", attrib={'name': '儿1'})

# 创建小儿子

son2 = ET.SubElement(root, "son", attrib={"name": "儿2"})

# 在大儿子中创建一个孙子

grandson1 = ET.SubElement(son1, "age", attrib={'name': '儿11'})

grandson1.text = '孙子'

et = ET.ElementTree(root)  #生成文档对象

et.write("test.xml", encoding="utf-8", xml_declaration=True, short_empty_elements=False)

import zipfile

# 压缩。 压缩之后源文件不消失

z = zipfile.ZipFile('test.zip', 'w')

# w表示创建新的，a表示追加

z.write('file_1.log') # file必须存在，否则会报错FileNotFoundError

z.write('file_2.txt')

z.close()

# 解压

z = zipfile.ZipFile('test.zip', 'r')

# 查看压缩包中文件名列表

print(z.namelist())

# 解压单个文件

z.extract('file_1.log')

# 解压全部文件

z.extractall()

z.close()

# 压缩

tar = tarfile.open('test.tar','w')

tar.add('file_1.log', arcname='bbs2.log') # 压缩后可改变压缩名

tar.add('file_2.txt') # 不写arcname的话，文件名保持不变

tar.close()

# 解压

tar = tarfile.open('test.tar','r')

# 获取压缩文件的文件名列表

print(tar.getnames())

# 解压单个文件

tar.extract("file_2.txt")

# 解压全部文件

tar.extractall()  # 可设置解压地址,默认为当前目录

tar.close()

import subprocess

obj = subprocess.Popen(["python3"],

                        stdin=subprocess.PIPE,

                        stdout=subprocess.PIPE,

                        stderr=subprocess.PIPE,

                        universal_newlines=True)

obj.stdin.write("print(1)\n")

obj.stdin.write("print(2)")

obj.stdin.close()

cmd_out = obj.stdout.read()

obj.stdout.close()

cmd_error = obj.stderr.read()

obj.stderr.close()

print(cmd_out)

print(cmd_error)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)

obj.stdin.write("print(1)\n")

obj.stdin.write("print(2)")

out_error_list = obj.communicate()

print(out_error_list)

# out_error_list = (stdout, stderr)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)

out_error_list = obj.communicate('print("hello")')

print(out_error_list)

# if self.universal_newlines is True, this should be a string; if it is False, "input" should be bytes.