19.7.18

coolections模块：

from coolections import namdtuple

#创建一个有序字典
dic = collections.OrderedDict()
dic['name'] = 'winter'
dic['age'] = 18
dic['gender'] = 'male'

print(dic)                         #结果OrderedDict([('name', 'winter'), ('age', 18), ('gender', 'male')])

#将一个键值对放入最后
dic.move_to_end('name')
print(dic)                         #结果OrderedDict([('age', 18), ('gender', 'male'), ('name', 'winter')])


from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])  # 定义命名元组
p = Point(10, y=20)  # 创建一个对象
p
Point(x=10, y=20)
p.x + p.y
30
p[0] + p[1]  # 像普通元组那样访问元素
30
x, y = p     # 元组拆封
x
10
y
20

"""
namedtuple : 可命名元组，通过名字来访问元组元素
命名元组有助于对元组每个元素赋予意义，这样就可以通过名字来访问元组里的元素，
增强了可读性；尤其对于坐标，html标签的长宽等，使用名字可读性更强；有点类似
于字典了并且让我们的代码有更好的可读性和自文档性。你可以在任何使用元组地方使用命名元组。

"""




# 双端队列:
"""
python 中，队列是线程间最常用的交换数据的形式。queue模块是提供队列操作的模块，
虽然简单易用，但是不小心的话，还是会出现一些意外。queue模块其实是对数据结构中
栈和队列这种数据结构的封装，把抽象的数据结构封装成类的属性和方法
"""
import queue
q = queue.Queue(3)  # 调用构造函数，初始化一个大小为3的队列
print(q.empty())  # 判断队列是否为空，也就是队列中是否有数据
#  入队，在队列尾增加数据， block参数，可以是True和False 意思是如果队列已经满了则阻塞在这里，
# timeout 参数 是指超时时间，如果被阻塞了那最多阻塞的时间，如果时间超过了则报错。
q.put(13, block=True, timeout=5)
print(q.full())  # 判断队列是否满了，这里我们队列初始化的大小为3
print(q.qsize())  # 获取队列当前数据的个数
#  block参数的功能是 如果这个队列为空则阻塞，
#  timeout和上面一样，如果阻塞超过了这个时间就报错，如果想一只等待这就传递None
print(q.get(block=True, timeout=None))

时间模块：

"""
  time 三种表现形式
    1.时间戳  时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
    2.格式化时间  已格式化的结构使时间更具可读(用来展示给人看的) 
    3.结构化时间  时间元组，共有九个元素组。
"""

import time

print(time.time()) # 查看时间戳

print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 查看当前时间

print(time.localtime())
print(time.localtime(time.time()))
print(time.strftime('%Y-%m',time.localtime()))
print(time.strptime(time.strftime('%Y-%m',time.localtime()),'%Y-%m'))


 # 输出结果为:

1563456596.4537
2019-07-18 21:29:56
time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=21, tm_min=29, tm_sec=56, tm_wday=3, tm_yday=199, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=21, tm_min=29, tm_sec=56, tm_wday=3, tm_yday=199, tm_isdst=0)
2019-07
time.struct_time(tm_year=2019, tm_mon=7, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=182, tm_isdst=-1)

# time.sleep()  推迟程序执行秒数

import time
print "Start : %s" % time.ctime()
time.sleep(5)  # 推迟五秒执行
print "End : %s" % time.ctime()

"""
python中时间日期格式化符号：

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
"""

random模块：

也叫随机模块，用于生成随机数。

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

import random  
print(random.randint(1,10))   # 随机生成1-9


# random.uniform(a,b)   用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，
一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。

import random  
print(random.uniform(1,10))  
print(random.uniform(10,1)) 

os模块：

"""
os.getcwd()模块函数

功能：获取当前工作目录，即当前python脚本工作的目录路径【无参】

使用方法：os.getcwd()

格式如：a = os.getcwd()
"""

import os
a = os.getcwd()     #获取当前工作目录，即当前python脚本工作的目录路径【无参】
print(a)
#输出
#H:\py

"""
os.chdir()模块函数

功能：改变当前脚本工作目录；相当于shell下cd【有参】

使用方法：os.chdir("字符串格式要更改的路径")

格式如：os.chdir("D:")
"""
import os
retval = os.getcwd()    # 查看当前工作目录
print("当前工作目录为 %s" % retval)
os.chdir("D:")    # 修改当前工作目录
retval = os.getcwd()    # 查看修改后的工作目录
print("目录修改成功 %s" % retval)
#输出
# 当前工作目录为 H:\py
# 目录修改成功 D:\

sys模块：

sys块提供对解释器使用或维护的一些变量的访问，以及与解释器强烈交互的函数。它始终可用。

import sys
sys.path.append()  # 将某个路径添加到系统的环境变量中
print(sys.platform)
print(sys.version)  # python解释器的版本

print(sys.argv)  # 命令行启动文件 可以做身份的验证
if len(sys.argv) <= 1:
    print('请输入用户名和密码')
else:
    username = sys.argv[1]
    password = sys.argv[2]
    if username == 'jason' and password == '123':
        print('欢迎使用')
        # 当前这个py文件逻辑代码
    else:
        print('用户不存在 无法执行当前文件')

序列化模块：

jason模块和pickle模块

"""
jason提供四个功能：jason.loads 　jason.dumps    jason.load    jason.dump。loads跟dumps是用来处理字符串的，load跟dump是用来处理文件的。

loads：把json转换成其他格式，字符串或文件相关的
dumps：把其他对象或格式转换为json格式
load：将文件的内容转换成为json数据
dump：把json数据写入到文件中
"""
# 1.把dict格式转换为json字符串格式
import json

a = dict(name='huangdongju', age=25,message='something')
print (a)
print (type(a))
b = json.dumps(a)
print (b)
print (type(b))

#  结果：
{'name': 'huangdongju', 'age': 25, 'message': 'something'}
<class 'dict'>
{"name": "huangdongju", "age": 25, "message": "something"}
<class 'str'>

#  2.把json格式转换成为dict

d = {"name":"jason"}
print(d)
res = json.dumps(d)  
print(res,type(res))
res1 = json.loads(res)
print(res1,type(res1))

# 结果：
{'name': 'jason'}
{"name": "jason"} <class 'str'>
{'name': 'jason'} <class 'dict'>

# 3.把json写入文件中

jsondata = '''{"a":1,"b":2,"c":3}'''
with open('a.txt','w') as f:
    json.dump(jsondata,f)

# 结果
"{\"a\":1,\"b\":2,\"c\":3}"

# 4.从文件中读取内容转换成json格式

with open('a.txt','r') as fr:
    m = json.load(fr)
    print (m)
    print (type(m))

# 结果
{"a":1,"b":2,"c":3}
<class 'str'>



# pickle模块  跟jason模块用法一样，但是它只能在python里面使用
import pickle
d = {'name':'jason'}
res = pickle.dumps(d)  # 将对象直接转成二进制
print(pickle.dumps(d))
res1 = pickle.loads(res)
print(res1,type(res1))


with open('userinfo_1','wb') as f:
   pickle.dump(d,f)

with open('userinfo_1','rb') as f:
    res = pickle.load(f)
    print(res,type(res))


"""
序列化
    序列:字符串
    序列化:其他数据类型转换成字符串的过程

写入文件的数据必须是字符串
基于网络传输的数据必须是二进制

   
    序列化:其他数据类型转成字符串的过程
    反序列化:字符串转成其他数据类型

    json模块
        所有的语言都支持json格式
        支持的数据类型很少  字符串 列表 字典 整型 元组(转成列表)  布尔值


    pickle模块
        只支持python
        python所有的数据类型都支持
        用pickle操作文件的时候 文件的打开模式必须是b模式
"""