第十六天

Posted 2020-11-27 xueba

time模块

import time

1.获取时间戳

time.time() 1970.1.1 00.00.00 到现在经过的秒数

2.获取格式化的时间对象 9个字段组成

time.gmtime() #GMT 格林尼治时间

time.struct_time(tm_year=2020, tm_mon=3, tm_mday=2, tm_hour=13, tm_min=42, tm_sec=15, tm_wday=0, tm_yday=62, tm_isdst=0)

time.localtime() 当地时间

time.gmtime(1) 过一秒后的时间

3.格式化时间对象和字符串之间的互化

time.strftime()

import time
# print(time.gmtime())
print(time.strftime("year:%Y %m %d %H:%M:%S"))


year:2020 03 02 22:04:33

print(time.strftime("year:%Y"))
year:2020

4.把字符串转化为 时间对象

time_obj=time.srtptime("2010 10",‘%Y %m‘)

把一个字符串解析成时间的格式

time_obj=time.strptime("2010 10",'%Y %m')
print(time_obj)

# 指定的 改变了   其他的默认

# time.struct_time(tm_year=2010, tm_mon=10, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=274, tm_isdst=-1)

5.时间对象-->时间戳

t1=time.localtime()
t2=time.mktime(t1)

print(t2)
print(time.time())     几乎一样  因为有延迟

6.time.sleep(3) 暂停当前程序 休眠

延迟3秒

datetime 日期时间模块

import datetime

date类: 年月日

d=datetime.date(2010,10,10)      2010-10-10
    
print(d)

获取date的属性

print(d.year)       2010
print(d.month)      10
print(d.day)        10

time类:时分秒

t=timedate.time(11:12:13)

t=datetime.time(11,12,13)
print(t)        #11:12:13
print(t.hour)      11
print(t.minute)   12
print(t.second)   13

datetime 两者的结合

dt=datetime.datetime(2010,10,10,11,12,13)

print(dt)

datetime中的类,主要用于数学计算

timedelta 时间的变化量

td=datetime.datetime(days=1)

print(td)

1.参与事件运算

2.创建时间对象

date,datetime timedelta 只有这三个可以运算

t=datetime.datetime(2010,10,10,11,12,13)

td=datetime.timedetla(seconds=3)

res=t-td

print(res)

2010-10-10 11:12:10

根据年份查看二月份有几天

year=int(input("请输入年份:"))
d=datetime.date(year,3,1)

td=datetime.timedelta(days=1)

res=d-td

print(res.day)

##########再测 是不是闰年


if (d.year %4==0 and d.year%100!=0 ) or d.year %400==0 :
    print(f"{d.year}年是闰年")
    
else:
    print("不是闰年")

os 操作系统

import os

和文件操作相关

重命名

os.rename("a.txt",‘b.txt‘) 先 原名, 更改后的名

删除

os.remove(‘a.txt‘)

删除目录 必须是空目录

os.removedirs("aa") 有文件删不了

python 删除之后 不走回收站 直接就删完了

使用shutil 模块可以删除带内容的目录

import shutil

shutil.rmtree("aa")

和路径相关的操作,被封装到另一个子模块中:os.path

#只获取路径

res=os.path.dirname(r‘d:/aaa/bbb/ccc/a.txt‘)

print(res) ///// d:/aaa/bbb/ccc

#只获取文件名

res=os.path.basename(r‘d:/aaa/bbb/ccc/a.txt‘)

print(res) ///// a.txt

#(‘路径‘,‘文件名‘ ) 路径名和文件名分开 结果是元组

res=os.path.split(r‘d:/aaa/bbb/ccc/a.txt‘)

(‘ d:/aaa/bbb/ccc‘, ‘a.txt‘ )

#拼接路径

import os

path=os.path.join("d:\","a.txt")
print(path)

#绝对路径

如果是/开头,默认是在当前盘符下

res=os.path.abspath(r‘/a/b/c‘)

///// d:/a/b/c

如果是不是/开头,默认当前路径

res=os.path.abspath(r‘a/b/c‘)

//// d:/python3/a/b/c

判断 是不是绝对路径

os.path.isabs("a.txt")

判断是不是目录

os.path.isdir("d:/a.txt") 是目录 True 不是 False

判断是否存在

os.path.exists("d:/a.txt")

判断是不是文件

os.path.isfile("d:/a.txt")

和python解释器相关的操作

获取命令行方式运行的脚本后面的参数

import sys

sys.argv[0] 函数名

sys.argv[1] 第一个参数

sys.argv[2] 第二个参数

sys.argv[3] ........

C:UsersAdministratorDesktop小丁变优秀的代码day16

import sys

print("第一个参数是"+sys.argv[0])

a=int(sys.argv[1])+int(sys.argv[2])
print(a)

cmd 里面

---

先切换到那个目录 然后 python oss.py 1 2

/// 第一个参数是oss.py
3

解释器寻找模块的路径

josn:将数据转换成字符串,用于存储或网络传输

已经加载的模块

print(sys.modules) 打印出来

json模块

结构化:

线性数据 : 数据之间没有关系

序列化过程: 拆分 serialization

s=json.dumps()

||||

传-->网线

||||

再转化为原来的数据类型

反序列化: 组装 deserialization

json.loads() 字符串----> 列表

序列化:将内存中的数据转换成字节串,用以保存在文件或者通过网络传输, 称为为序列化过程

反序列化:从文件中,网络中获取的数据,转化为内存中原来的数据类型,称为反序列化过程

列表

import  json
s=json.dumps([1,2,3])

print(type(s))
print(s)      

#<class 'str'>
'[1, 2, 3]'   # 变成字符串

元组 ---序列化后变成列表

数字---字符串

字典----字符串 ‘{"a":"a"}‘

**集合不能序列化

作用:将json写到文件中

with open("a.txt",mode="at",encoding="utf-8") as f
    json.dump([1,2,3],f)
    
    
    
   *********** json.dump([1,2,3],f)   *********

反序列化

元组 先序列化 再 反序列化之后 是列表

res=json.dumps((1,2,3))

lst=json.loads(res)

print(lst)

从文件中反序列化

with open("a.txt",encoding="utf-8")as f:
    res=json.load(f)
    print(type(res))
    print(res)

#json 涉及文件不加s

json.dumps()

json.loads()

json.dump()

json.load()

json文件通常是一次性写,一次性读

使用另一种方式,可以实现多次写,多次读

将需要序列化的对象,通过多次序列化的方式,用文件write的方法 把多次序列化后的json字符串 写到文件中

///先写

with open("a.txt",mode="at",encoding="utf-8")as f:
    d.write(json.dumps([1,2,3])+'
')
    d.write(json.dumps([1,2,3])+'
')
    d.write(json.dumps([1,2,3])+'
')

将分次序列化的json字符串 反序列化回来

////先读

with open("a.txt",mode="rt",encoding="utf-8")as f:
    for x in f:
        print(json.load(x.strip()))
        

pickle

hashlib

collection