import time
import datetime


def main():
    date1_string = "2017/6/8 15:0:0"
    # date1_string转换为时间戳
	# strptime -> mktime -> fromtimestamp ==> datetime.datetime
    date1 = datetime.datetime.fromtimestamp(time.mktime(
        time.strptime(date1_string, '%Y/%m/%d %H:%M:%S')))

    date2 = datetime.datetime.now()		# 获取当前时间

    # 使用datetime.datetime对象之间 进行操作，结果为datetime.timedelta对象
    result1 = date2 - date1		# 两个时间过了多久了
    print(result1.days, result1.seconds)

    # datetime.datetime与datetime.timedelta之间的操作, 结果是datetime.datetime对象
    year = datetime.timedelta(days=365)     # 一年时间

    result2 = date2 + 2 * year		# 当前时间的两年后
    print(result2.year, result2.month, result2.day)


if __name__ == '__main__':
    main()

import random


def make_code(n):
    res = ''
    for i in range(n):
        letter = chr(random.randint(65, 90))		# 生成A-Z的任意一个字母
        number = str(random.randint(0, 9))			# 生成0-9的任意一个数
        res += random.choice([letter, number])
    return res

print(make_code(9))

import json


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

    def data_dict(self):
        # 返回的是基本数据类型
        return {"name": self.name, "age": self.age}


class JsonCustomEncoder(json.JSONEncoder):
    # 重写default方法
    def default(self, field):
        if isinstance(field, Foo):
            return field.data_dict()    # 调用自定义的方法
        else:
            return json.JSONEncoder.default(self, field)


f = Foo("lczmx", 21)

# 使用时要指定自定义的编码器
res = json.dumps(f, cls=JsonCustomEncoder)
print(res)
# {"name": "lczmx", "age": 21}

import pickle

dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}

print(type(dic))  # <class 'dict'>

j = pickle.dumps(dic)
print(type(j))  # <class 'bytes'>


f = open('序列化对象_pickle', 'wb')  # 注意是w是写入str,wb是写入bytes,j是'bytes'
f.write(j)  # -------------------等价于pickle.dump(dic,f)

f.close()
# -------------------------反序列化
f = open('序列化对象_pickle', 'rb')

data = pickle.loads(f.read())  # 等价于data=pickle.load(f)


print(data['age'])

import shelve

d = shelve.open("持久化文件.txt")


# 以 d[key] = data 的形式存储
d["name"] = "lczmx"
d["age"] = 22
d["addr"] = "guangzhou"
d["data"] = [1, 2, 3]


# 使用中括号取值
name = d["name"]
print(name)         # lczmx

# 使用del删除某个键对应的值

del d["age"]

# 可以使用 in 判断某个键是否存在
flag = "age" in d
print(flag)         # False

# .keys()方法 可以列出所有的键 (速度较慢!)
klist = list(d.keys())
print(klist)        # ['name', 'addr', 'data']


# 值即使是引用对象，假如要保存修改后的值，要重新赋值
temp = d['data']
temp.append(4)
print(d["data"])    # [1, 2, 3]
d['data'] = temp
print(d["data"])    # [1, 2, 3, 4]

# close掉，可以使用上下文管理协议
d.close()

import xml.etree.ElementTree as ET

# 创建根节点
new_xml = ET.Element("namelist")

# 为跟节点创建字节点
name1 = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"})
age1 = ET.SubElement(name1, "age", attrib={"checked": "no"})

# 添加内容
name1.text = '老王'
age1.text = "30"

# 同上
name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
age2 = ET.SubElement(name2, "age")
name2.text = "隔壁"
age2.text = '33'

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

# 写入文件中
et.write("test.xml", encoding="utf-8", xml_declaration=True)

# 打印生成的格式
ET.dump(new_xml)

<?xml version='1.0' encoding='utf-8'?>
<namelist>
    <name enrolled="yes">老王<age checked="no">30</age></name>
    <name enrolled="no">隔壁<age>33</age></name>
</namelist>

import xml.etree.ElementTree as ET


tree = ET.parse("./test.xml")
root = tree.getroot()

import struct


# 数据 -> bytes
pi = 3.14159265358
res = struct.pack("f", pi)
print(res, type(res))  # b'\xdb\x0fI@' <class 'bytes'> # 已经转化为字节类型


# bytes -> 原数据
data = struct.unpack("f", res)
print(data, type(data))  # (3.1415927410125732,) <class 'tuple'>

import re


res = re.findall(r"(abc)+", "abcabcabc")
print(res)      # ['abc']

import re


res = re.findall(r"(?:abc)+", "abcabcabc")
print(res)      # ['abcabcabc']

import logging


logging.basicConfig()

logging.debug("debug messages")
logging.info("info messages")
logging.warning("warning messages")
logging.error("error messages")
logging.critical("critical messages")

import logging


logging.basicConfig(filename="test.log")

logging.debug("debug messages")
logging.info("info messages")
logging.warning("warning messages")
logging.error("error messages")
logging.critical("critical messages")

import logging
import mylib


def main():

    logging.basicConfig()
    logging.warning("start function")
    mylib.my_func()
    logging.warning("end function")
    print(id(logging))	# 2248755624272


if __name__ == '__main__':
    main()

# ./mylib.py
import logging


def my_func():
    logging.error("error massage")
    print(id(logging))	# 2248755624272

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

import logging


logging.basicConfig(level=logging.INFO)
logging.warning("start function")

import logging
import argparse

# log选项的值只能是level_list的元素
level_list = ["debug", "info", "warning", "warn", "error", "fatal", "critical"]
level_list.extend(list(map(lambda x: x.upper(), level_list)))	# 全大写再加入

parser = argparse.ArgumentParser(description="test file")

parser.add_argument("--log", default="debug", choices=level_list)

args = parser.parse_args()

# 拿到级别字符串后要大写

level = getattr(logging, args.log.upper())
logging.basicConfig(level=level)

logging.debug("debug messages")
logging.info("info messages")
logging.warning("warning messages")
logging.error("error messages")
logging.critical("critical messages")

$ python test.py --log error
ERROR:root:error messages
CRITICAL:root:critical messages

$ python test.py --log info 
INFO:root:info messages
WARNING:root:warning messages
ERROR:root:error messages
CRITICAL:root:critical messages

import configparser

# 1 创建parser对象
config = configparser.ConfigParser()

# 2 添加数据
# 方法一
config["DEFAULT"] = {"HOST": "localhost", "PORT": "3306"}

# 方法二
config["CUSTOM"] = {}
config["CUSTOM"]["HOST"] = "192.168.0.1"
# 或
custom_config = config["CUSTOM"]
custom_config["PORT"] = "3333"

# 3 写入文件

with open("config.ini", "w") as f:
    config.write(f)

[DEFAULT]
host = localhost
port = 3306

[CUSTOM]
host = 192.168.0.1
port = 3333

 parser = argparse.ArgumentParser(description="计算两个数的和", prog="SUM")

parser.add_argument("x", type=float, help="一个数x")        # 添加位置参数x
parser.add_argument("y", type=float, help="一个数y")        # 添加位置参数y
# 添加选项-a， 把值存储为True
parser.add_argument("-a", action="store_true", help="显示详细过程")

# 添加选项-f，它的值知道能是[1, 2, 3]中的元素
parser.add_argument("-f", default=1, choices=[1, 2, 3],
                    type=int, help="保留小数点位数")

# 添加选项-v 或 --version
# 使用来自argparse.ArgumentParser的prog参数
parser.add_argument("-v", "--version", action="version",
                    version="%(prog)s 0.1", help="显示版本")

# 解析
args = parser.parse_args()
print(args.x)
print(args.a)
print(args.f)

import argparse

parser = argparse.ArgumentParser(description="计算两个数的和", prog="SUM")

parser.add_argument("x", type=float, help="一个数x")        # 添加位置参数x
parser.add_argument("y", type=float, help="一个数y")        # 添加位置参数y
# 添加选项-a， 把值存储为True
parser.add_argument("-a", action="store_true", help="显示详细过程")

# 添加选项-f，它的值知道能是[1, 2, 3]中的元素
parser.add_argument("-f", default=1, choices=[1, 2, 3],
                    type=int, help="保留小数点位数")

# 添加选项-v 或 --version
# 使用来自argparse.ArgumentParser的prog参数
parser.add_argument("-v", "--version", action="version",
                    version="%(prog)s 0.1", help="显示版本")

# 解析
args = parser.parse_args()

# 计算并保留小数
res = round(args.x + args.y, args.f)

if args.a:
    print("{x} + {y} = {res}".format(x=args.x, y=args.y, res=res))
else:
    print(res)

$ python get_sum.py -h
usage: SUM [-h] [-a] [-f {1,2,3}] [-v] x y

计算两个数的和

positional arguments:
  x              一个数x
  y              一个数y

optional arguments:
  -h, --help     show this help message and exit
  -a             显示详细过程
  -f {1,2,3}     保留小数点位数
  -v, --version  显示版本


$ python get_sum.py -v
SUM 0.1


$ python get_sum.py 3.14 5.96
9.1

$ python get_sum.py 3.14 5.96 -a
3.14 + 5.96 = 9.1

$ python get_sum.py 3.14159 3.335 -f 3 -a 
3.14159 + 3.335 = 6.477

$ python get_sum.py 
usage: SUM [-h] [-a] [-f {1,2,3}] [-v] x y
SUM: error: the following arguments are required: x, y

import hashlib


md5 = hashlib.md5()
# 输入的是字节串
md5.update("test message".encode("utf-8"))

res = md5.hexdigest()
print(res)
# c72b9698fa1927e1dd12d3cf26ed84b2

import hashlib


md5 = hashlib.md5()
# 输入的是字节
md5.update("加盐".encode("utf-8"))
md5.update("test message".encode("utf-8"))

res = md5.hexdigest()
print(res)
# 3f5a030db81d9e5e83d2c8e7eba1965c

import uuid

print(uuid.uuid4())
# f1d50cdd-2f36-4db2-b788-ec4f2f08ce52

import subprocess


# 执行没有参数的
subprocess.Popen(["dir"], shell=True, stdout=open("dir_res.txt", "w"))


# 有参数
# get_sum.py为argparse模块最后的例子
command = "python get_sum.py 3.47 2.48 -a -f 2"

res2 = subprocess.Popen(command.split(" "), shell=True, stdout=subprocess.PIPE)
print(res2.stdout.read().decode("gbk"))  # 3.47 + 2.48 = 5.95


# stdout作为stdin

res3 = subprocess.Popen(["echo", "www.baidu.com"],
                        shell=True, stdout=subprocess.PIPE)

res4 = subprocess.Popen(["nslookup"], shell=True,
                        stdin=res3.stdout, stdout=subprocess.PIPE)

print(res4.stdout.read().decode("gbk"))
"""
默认服务器:  UnKnown
Address:  192.168.0.1

> 服务器:  UnKnown
Address:  192.168.0.1

名称:    www.baidu.com
Address:  182.61.200.7

>
"""