Python【day5】：Python学习(算法-冒泡、模块（模块介绍和导入架构、time & datetime、random模块、OS、sys、json & pickle 模块）等介绍
冒泡算法
__author__ = 'Administrator'
#-*- coding:utf-8 -*-
# 将一个不规则的数组按从小到大的顺序进行排序
# data = [10,4,33,21,54,3,8,11,5,22,2,1,17,13,6]
data = [4,3,2,1]
#方法1：迭代循环次数4*3=12次 这里虽然结果正确，但是存在多余的循环
print("before sort:",data) #before sort: [10, 4, 33, 21, 54, 3, 8, 11, 5, 22, 2, 1, 17, 13, 6]
# previous = data[0]
count = 0
for j in range(len(data)): #将内循环迭代len(data)次，
# 第一次内循环先把最大的放在最后，第二次内循环先把第二大的放在倒数第二，。。。。依次类推
tmp = 0
for i in range(len(data)-1): #将第1个和第2个比较，第2个和第3个比较，依次类推（相邻的2个数比大小） 先把最大的放在最后 len(data)-1
if data[i] > data[i+1]:
# tmp=data[i]
data[i],data[i+1] = data[i+1],data[i] #直接互换
# data[i+1] = tmp
# count+=1 这里count没有交换的话,循环也会加1
count+=1 ##不管是否交换，循环次数都会加1
# print("内",data)
# print("外",data)
print("after sort:",data) #after sort: [1, 2, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
#思路：假设len(data)=3，假设只有3个数，j=0 i=0,1；j=1 i=0,1；j=2 i=0,1； data = [10,4,33]
#i是相邻的2个数对比大小
print("循环的总次数",count) # 15*14=210次
#方法2：优化后，不存在多余的循环，循环的总次数 6
# data = [10,4,33,21,54,3,8,11,5,22,2,1,17,13,6]
data = [4,3,2,1]
count = 0
for j in range(1,len(data)): #这里的j必须从1开始，从0开始不对 j=0 1 2 3 j是从0开始，所以外循环从1开始即可
#优化的情况：第一次内循环，54已经在最右边，第二次内循环，就不必将54排序了，
for i in range(len(data)-j): #内循环的目标是对比第一个和第二个，第二个和第三个。。最后把最大的放在最右边
if data[i] > data[i+1]: #如果第一个数大于第二个数，就互换
# tmp = data[i] #第一个数放临时
data[i],data[i+1] =data[i+1],data[i] #同时互换
# data[i+1] = tmp #临时tmp放第二个
# count+=1 这里count没有交换的话,循环也会加1
count+=1 # #不管是否交换，循环次数都会加1
# print(data)
# print(data)
print(data) #[1, 2, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
print("循环的总次数",count) #循环的总次数 105
# 冒泡的算法（2层嵌套循环）是指数型增长，随着列表的元素增长，执行时间呈指数型增长
# 并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
# 一个算法中的语句执行次数称为语句频度或时间频度。
#方法3，互换的时候用到中间变量tmp
data = [10,4,33,21,54,3,8,11,5,22,2,1,17,13,6]
for j in range(1,len(data)): #这里的j必须从1开始，从0开始不对
for i in range(len(data)-j): #内循环的目标是对比第一个和第二个，第二个和第三个。。最后把最大的放在最右边
if data[i] > data[i+1]:
tmp = data[i] #第一个数放临时
data[i] =data[i+1] #第二个数放第一个数处 4放在10
data[i+1] = tmp #临时tmp放第二个 10放在4
# print(data)
# print(data)
print(data) #[1, 2, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
模块
time模块
import time
import datetime
print(dir(time))#打印内置模块time下的方法
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone',
'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime',
'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time',
'time', 'timezone', 'tzname']
# 时间相关的操作，时间有三种表示方式：#
# 时间戳 1970年1月1日之后的秒，即：time.time()
# 格式化的字符串 2014-11-11 11:11， 即：time.strftime('%Y-%m-%d')
# 结构化时间 元组包含了：年、日、星期等... time.struct_time 即：time.localtime()
#1时间戳
print(time.time()) #1454309989.138591 返回当前系统时间戳-单位：秒 1970年1月1日之后到当前经过的秒
print(time.mktime(time.localtime())) #1454315516.0 返回当前系统时间戳-单位：秒
#2格式化时间字符串
print(time.strftime('%Y-%m-%d-%H-%M-%S'))#默认当前时间) #2016-02-01-15-13-58
# %Y Year with century as a decimal number.
# %m Month as a decimal number [01,12].
# %d Day of the month as a decimal number [01,31].
# %H Hour (24-hour clock) as a decimal number [00,23].
# %M Minute as a decimal number [00,59].
# %S Second as a decimal number [00,61].
print(time.strftime('%Y-%m-%d',time.localtime()))#默认当前时间 #2016-02-01
print(time.asctime())
print(time.asctime(time.localtime()))
print(time.ctime(time.time()))
#3结构化时间-struct
print(time.gmtime()) #可加时间戳参数
print(time.gmtime(time.time()-86640)) #将时间戳转换成struct_time格式
print(time.localtime()) #可加时间戳参数
print(time.localtime(time.time()-86640)) #将时间戳转换成struct_time格式,但返回 的本地时间
#time.struct_time(tm_year=2016, tm_mon=2, tm_mday=1, tm_hour=15, tm_min=13, tm_sec=58, tm_wday=0, tm_yday=32, tm_isdst=0)
# tm_wday=0, 0-6 0代表周日
# tm_yday=32 1-366 一年中的第几天
# tm_isdst=0 是否是夏令时 默认-1
print(time.strptime('2014-11-11', '%Y-%m-%d'))
#3-1通过结构化时间，单独取出年月日时分秒
ll = time.localtime()
print(ll[0]) #2016 输出年份
print(ll[1]) #2 输出月份
print(ll[2]) #1 输出日期
print(ll[3]) #15 输出小时
print(ll[4]) #58 输出分钟
print(ll[5]) #25 输出秒
#二、转换（时间戳、结构化时间、格式化时间相互转换）
#001 时间戳和结构化时间转换
#4时间戳转换成结构化时间gmtime localtime
print(time.gmtime()) #可加时间戳参数 #将时间戳（默认是当前时间戳）转换成struct_time格式，返回的是格林威治时间
print(time.gmtime(time.time()-86640)) #将时间戳（当前时间戳的前一天）转换成struct_time格式，返回的是格林威治时间
#time.struct_time(tm_year=2016, tm_mon=1, tm_mday=31, tm_hour=7, tm_min=40, tm_sec=20, tm_wday=6, tm_yday=31, tm_isdst=0)
print(time.localtime()) #可加时间戳参数 将时间戳（默认是当前时间戳）转换成struct_time格式，返回的本地时间
print(time.localtime(time.time()-86640)) #将时间戳（当前时间戳的前一天）转换成struct_time格式,但返回 的本地时间
#time.struct_time(tm_year=2016, tm_mon=1, tm_mday=31, tm_hour=15, tm_min=40, tm_sec=20, tm_wday=6, tm_yday=31, tm_isdst=0)
#5结构化时间转换成时间戳 mktime
print(time.mktime(time.localtime())) #与time.localtime()功能相反,将struct_time格式转回成时间戳格式
#1454314075.0 输出当前时间戳
#002 字符串时间和结构化时间转换
#6字符串时间转换成结构化时间 strptime
print(time.strptime("2016-01-28","%Y-%m-%d") ) #将字符串格式转换成struct_time格式
#time.struct_time(tm_year=2016, tm_mon=1, tm_mday=28, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=28, tm_isdst=-1)
#7结构化时间转换成字符串时间 strftime
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将struct_time格式转成自定义的字符串格式
#2016-02-01 08:18:46 先将时间戳转换成结构化时间，在将结构化时间转换成字符串时间
print(time.asctime()) #Mon Feb 1 16:29:11 2016 #将struct_time格式转成固定的字符串格式
print(time.asctime(time.localtime())) #Mon Feb 1 16:29:11 2016 #将struct_time格式转成固定的字符串格式
#003 时间戳和字符串时间转换
#8时间戳转换成字符串格式
print(time.ctime()) #输出Tue Jan 26 18:23:48 2016 ,当前系统时间
#Mon Feb 1 16:24:36 2016 将当前时间戳（默认是当前时间戳）转换成字符串格式
print(time.ctime(time.time()-86640)) #将时间戳转为字符串格式
#Sun Jan 31 16:20:36 2016 将当前时间戳的前一天转换成字符串格式
#9其他
print("==",time.sleep(1)) #None 代表睡眠1秒
#alex
print(time.clock()) #返回处理器时间,3.3开始已废弃
print(time.process_time()) #返回处理器时间,3.3开始已废弃
print(time.time()) #返回当前系统时间戳 #1454315703.8568118
print(time.ctime()) #输出Tue Jan 26 18:23:48 2016 ,当前系统时间
print(time.ctime(time.time()-86640)) #将时间戳转为字符串格式 #Sun Jan 31 16:31:03 2016
print(time.gmtime(time.time()-86640)) #将时间戳转换成struct_time格式 #time.struct_time(tm_year=2016, tm_mon=1, tm_mday=31, tm_hour=8, tm_min=31, tm_sec=3, tm_wday=6, tm_yday=31, tm_isdst=0) gm代表格林威治
print(time.localtime(time.time()-86640)) #将时间戳转换成struct_time格式,但返回 的本地时间 time.struct_time(tm_year=2016, tm_mon=1, tm_mday=31, tm_hour=16, tm_min=31, tm_sec=3, tm_wday=6, tm_yday=31, tm_isdst=0) local代表北京时间
print(time.mktime(time.localtime())) #与time.localtime()功能相反,将struct_time格式转回成时间戳格式 #1454315703.0
#time.sleep(4) #sleep
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将struct_time格式转成指定的字符串格式 2016-02-01 08:35:03 gm代表格林威治
print(time.strptime("2016-01-28","%Y-%m-%d") ) #将字符串格式转换成struct_time格式 #time.struct_time(tm_year=2016, tm_mon=1, tm_mday=28, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=28, tm_isdst=-1)
datetime模块
import datetime
import time
'''
datetime.date：表示日期的类。常用的属性有year, month, day
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
'''
print(datetime.datetime.now()) #2016-02-01 16:42:58.946039 显示当前日期时间
print(datetime.datetime.now() - datetime.timedelta(days=5)) #显示当前日期时间之前5天的日期时间
#2016-01-27 16:42:58.946039
print(datetime.date.today()) #输出格式 2016-02-01 显示当天日期
print(datetime.date.fromtimestamp(time.time()-864400) ) #2016-01-22 将时间戳（当前时间戳10天前）转成日期格式
current_time = datetime.datetime.now() #
print(current_time) #输出2016-01-26 19:04:30.335935
print(current_time.timetuple()) #返回struct_time格式
#time.struct_time(tm_year=2016, tm_mon=2, tm_mday=1, tm_hour=16, tm_min=45, tm_sec=28, tm_wday=0, tm_yday=32, tm_isdst=-1)
#datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
print(current_time.replace(2014,9,12)) #输出2014-09-12 16:45:28.639557,返回当前时间,但指定的值将被替换
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) #2016-02-01 16:47:28.659558 比现在+120s
random模块
import random
print(random.random()) #0.5185400135782381 输出0-1之间的小数
print(random.randint(1,2)) #1 #随机输出整数，整数的范围1<=x<=2(左闭右闭)
print(random.randrange(1,3)) # 2 #随机输出整数，整数的范围1<=x<3(左闭右开)
#输出4位验证码，验证码包含大写字母或者数字
import random
checkcode= ""
for i in range(4):
pass
current = random.randint(0,3)
if current == i:#如果随机数字和迭代数相等，几率比较小
current = i #验证码是0-3的整数
else:#如果随机数字和迭代数不相等，几率比较大，大部分是这个情况
current = chr(random.randint(65,90)) #验证码是A-Z的大写字母
checkcode+=str(current) #如果不转换成str，如果验证码含有数字会报错 （依次将验证码拼接成4位）
# checkcode+=current #如果验证码不含有数字，就可以不转换成str
#TypeError: Can't convert 'int' object to str implicitly
print(checkcode) #DBUL
os模块
import os
# os--文件的目录和文件夹操作
# 提供对操作系统进行调用的接口
print(dir(os))
#一、目录文件夹、文件操作（类似linux基本命令）
print(os.getcwd()) #获取当前工作目录，即当前python脚本工作的目录路径
#D:\PycharmProjects\s12\day5_0130\xiaojie
# os.chdir("dirname") # 改变当前脚本工作目录；相当于shell下cd
print(os.chdir("D:\PycharmProjects\s12\day5_0130")) #None 改变当前脚本工作目录；相当于shell下cd
print(os.getcwd())
#D:\PycharmProjects\s12\day5_0130
os.chdir("xiaojie")
os.curdir #返回当前目录: ('.')
print(os.getcwd())
#D:\PycharmProjects\s12\day5_0130\xiaojie
print(os.pardir) #获取当前目录的父目录字符串名：('..')
# os.makedirs('dirname1/dirname2') #可生成多层递归目录
# os.makedirs('D:\\PycharmProjects\\s12\\day5_0130\\xiaojie1\\001\\002\\003') #这里需要转义\\
#如果文件已经存在，会报错 FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件。
# os.removedirs('dirname1') #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
# os.removedirs('D:\\PycharmProjects\\s12\\day5_0130\\xiaojie1\\001\\002\\003')
# os.mkdir('003') #生成单级目录；相当于shell中mkdir dirname （在当前路径新建文件夹003）
# os.rmdir('003') #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
#（在当前路径删除文件夹003）
print(os.listdir('D:\\PycharmProjects\\s12\\day5_0130\\xiaojie') )
#列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
['003', '01冒泡排序.py', '02time模块.py', '03datetime模块.py', '04random模块_验证码.py', '04验证码1.py', '05os模块.py', '__init__.py']
print(os.listdir() ) ##列出当前目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
#['003', '01冒泡排序.py', '02time模块.py', '03datetime模块.py', '04random模块_验证码.py', '04验证码1.py', '05os模块.py', '__init__.py']
####22 os.remove('D:\\PycharmProjects\\s12\\day5_0130\\02\\__init__.py') #删除一个文件
# os.rename("oldname","newname") #重命名文件/目录
# os.rename("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\01.py","D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py")
# #重命名文件
# os.rename("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004","D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\003")
# #重命名目录
# os.stat('path/filename') #获取文件/目录信息
print(os.stat("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004")) #绝对路径
print(os.stat("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py"))
print(os.stat("004")) #相对路径 当前目录下
print(os.stat("004\\001.py"))
#二、分隔符信息相关
# os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
print(os.sep) #\ win下为"\\" 这里sep后面没有小括号
# os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
print(os.linesep)
# os.pathsep 输出用于分割文件路径的字符串
print(os.pathsep) #;
# os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
print(os.name) #nt win->'nt'
# os.system("bash command") 运行shell命令，直接显示
os.system("whoami") #2013-20160114zu\administrator
# print(os.system("dir")) #显示目录
# os.environ 获取系统环境变量
print(os.environ)
#三、路径相关
# os.path.abspath(path) 返回path规范化的绝对路径
print(os.path.abspath("004")) #D:\PycharmProjects\s12\day5_0130\xiaojie\004
#把相对路径转换成绝对路径
# os.path.split(path) 将path分割成目录和文件名二元组返回
print(os.path.split("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py"))
#('D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004', '001.py')
tu1 = os.path.split("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py")
print(tu1[0])
#D:\PycharmProjects\s12\day5_0130\xiaojie\004
# os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
print(os.path.dirname("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py"))
#D:\PycharmProjects\s12\day5_0130\xiaojie\004
# os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
# 即os.path.split(path)的第二个元素
print(os.path.basename("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py"))
#001.py
# os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
print(os.path.exists("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py")) #True
print(os.path.exists("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004")) #True
print(os.path.exists("004")) #True 相对路径 必须是当前目录
print(os.path.exists("004\\001.py")) #True 相对路径
print(os.path.exists("xiaojie\\004")) #False 必须是当前目录
# os.path.isabs(path) 如果path是绝对路径，返回True
print(os.path.isabs("004")) #False 相对路径
print(os.path.isabs("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004")) #True 绝对路径
# os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
print(os.path.isfile("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py")) #True 绝对路径
print(os.path.isfile("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\002.py")) #False
print(os.path.isfile("004\\001.py")) #True 相对路径 必须当前目录
print(os.path.isfile("001.py")) #False 不是当前目录报错
# os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
print(os.path.isdir("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py")) #False 不能到文件
print(os.path.isdir("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\")) #True 只能到文件夹
# os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
print(os.path.join("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004","001.py","test"))
# D:\PycharmProjects\s12\day5_0130\xiaojie\004\001.py\test
print(os.path.join("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004","001.py"))
# D:\PycharmProjects\s12\day5_0130\xiaojie\004\001.py 拼接路径
# os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
print(os.path.getatime("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004"))
#1454383820.87736 时间戳形式
print(os.path.getatime("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py"))
#1454383582.8806882 时间戳形式
# os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
print(os.path.getmtime("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004")) #1454383820.87736
print(os.path.getmtime("004")) #1454383820.87736 时间戳形式
print(os.path.getmtime("D:\\PycharmProjects\\s12\\day5_0130\\xiaojie\\004\\001.py")) #1454383582.8806882
# OS模块
# 提供对操作系统进行调用的接口
#
# os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
# os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
# os.curdir 返回当前目录: ('.')
# os.pardir 获取当前目录的父目录字符串名：('..')
# os.makedirs('dirname1/dirname2') 可生成多层递归目录
# os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
# os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
# os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
# os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
# os.remove() 删除一个文件
# os.rename("oldname","newname") 重命名文件/目录
# os.stat('path/filename') 获取文件/目录信息
# os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
# os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
# os.pathsep 输出用于分割文件路径的字符串
# 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所指向的文件或者目录的最后修改时间
sys模块
import sys
import time
import random
print(dir(sys))
# sys.version 获取Python解释程序的版本信息
print(sys.version) #3.5.1 (v3.5.1:37a07cee5969, Dec 6 2015, 01:54:25) [MSC v.1900 64 bit (AMD64)]
# sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
print(sys.path)
#['D:\\PycharmProjects\\s12\\day5_0130\\xiaojie',
# 'D:\\PycharmProjects',
# 'C:\\Python35\\python35.zip',
# 'C:\\Python35\\DLLs',
# 'C:\\Python35\\lib',
# 'C:\\Python35',
# 'C:\\Python35\\lib\\site-packages']
#sys.platform 返回操作系统平台名称
print(sys.platform) #win32
# sys.stdout.write('please:')
#需求：打印进度条,间隔时间在0-1秒间随机取
for i in range(10): #打印进度条的>> 10次
sys.stdout.write(">>")
sys.stdout.flush() #每写一次，就刷新，而不要等到全部写完，一次性全部刷新出来
time.sleep(random.random()) #定义间隔时间是0-1秒之间随机的
# sys模块
# sys.argv 命令行参数List，第一个元素是程序本身路径
# sys.exit(n) 退出程序，正常退出时exit(0)
# sys.version 获取Python解释程序的版本信息
# sys.maxint 最大的Int值
# sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
# sys.platform 返回操作系统平台名称
# sys.stdout.write('please:')
# val = sys.stdin.readline()[:-1]
json模块
# json & pickle 模块
# 用于序列化的两个模块
#
# json，用于字符串 和 python数据类型间进行转换
# pickle，用于python特有的类型 和 python的数据类型间进行转换
# Json模块提供了四个功能：dumps、dump、loads、load#
# pickle模块提供了四个功能：dumps、dump、loads、load
import json
data= {"k1":"v1","k2":"v2"}
print(data) #{'k2': 'v2', 'k1': 'v1'}
print(type(data)) #<class 'dict'> 字典只能放在内存，不能写入文件（字典也不能传给java）
#将内存中的字典、列表、元组等转换成字符串，需要用json.dumps方法，写入文件，需要用到json.dump方法
#dumps方法：将数据通过特殊形式转换成所有程序都认识的字符串
#需求：将字典写入到文件中：1将字典dumps成字符串，2将字符串写入到文件
j_str = json.dumps(data)
print(j_str) #{"k2": "v2", "k1": "v1"}
print(type(j_str)) #<class 'str'> 字符串就可以写入文件（字符串也可以传给别的程序-例如java）
f = open("json.txt","w")
f.write(j_str)
# f.write(data) #直接写入字典，报错 TypeError: write() argument must be str, not dict
f.close()
#dump方法：将数据通过特殊形式转换成所有程序都认识的字符串，并写入文件
data= {"k1":"v1","k2":"v2"} #定义字典
f = open("json2.txt","w") #新建空文件
json.dump(data,f) #将字典dump成字符串，并且写入到文件（相当于dump一次完成了dumps的2步操作，省去了write）
f.close() #关闭文件
#需求2：将用户输入的字符串，转换成字典（由于用户输入的字典是字符串形式的，所有需要json.loads转换）
#将字符串转换成内存中的字典、列表、元组等数据形式，需要用到json.loads方法
#字符串的形式：1 用户输入的 2 文件读取的
#1用户输入的（要想操作用户输入的字符串，需要json.loads成字典来操作）
# my_input = input("请输入字典：") #{"k1":"v1","k2":"v2"}用户输入的是字典，但是格式是字符串
# print(my_input) #{"k1":"v1","k2":"v2"}
# print(type(my_input)) #<class 'str'>
#
# my_dic1 = json.loads(my_input)
# print(my_dic1) #{'k2': 'v2', 'k1': 'v1'}
# print(type(my_dic1)) #<class 'dict'>
#需求2：将用户输入的字符串，转换成字典（由于用户输入的字典是字符串形式的，所有需要json.loads转换）
#将字符串转换成内存中的字典、列表、元组等数据形式，需要用到json.loads方法
#字符串的形式：1 用户输入的 2 文件读取的
#2从文件读取的（要想操作文件读取的字符串，需要json.loads成字典来操作）
# f = open("json.txt","r")
# for i in f:
# print(i) #{"k1": "v1", "k2": "v2"}
# print(type(i)) #<class 'str'> #不经过json.loads转换，读取的是字符串
f = open("json.txt","r")
for i in f:
my_dic1 = json.loads(i) #经过json.loads转换后，读取的字符串转换成了字典
print(my_dic1) #{"k1": "v1", "k2": "v2"}
print(type(my_dic1)) #<class 'dict'>
#文件中存放的是字符串 内存中存放的是字典、列表、元组等
#1从文件读取出来后的字符串需要json.loads转换成字典等数据类型,用于程序处理
#2用户输入的字符串也需呀json.loads转换成字典等数据类型,用于程序处理
#要把字典写入到文件
#1通过json。dumps把字典转换成字符串，再创建空白文件，用write将字符串写入字典
#2通过json.dump直接把字典转换成字符串后，直接写到文件（不需要write方法）
#内存（字典、列表、元组）--文件（字符串） dumps dump（序列化）
#文件（字符串）--内存（字典、列表、元组 loads（反序列化）
#pickle的优点：除了可以支持字典、列表外，但是还可以支持函数的序列化（只是可以存储，无法反序列化） 加b
#json：只能支持字典 列表 元组，但是json可以在多语言通用
#pickle保存自己的游戏状态--多少血（只能存在文件或者缓存，不能存到数据库，序列化后，把函数序列化到文件）
#pickle只能在python中使用
#字典转换成字符串 --叫序列化
#字符串转换成字典 --叫反序列化
pickle模块
import pickle
#内存（字典、列表、元组）--文件（字符串） dumps dump（序列化）
#文件（字符串）--内存（字典、列表、元组 loads（反序列化）
#pickle的优点：除了可以支持字典、列表外，但是还可以支持函数的序列化（只是可以存储，无法反序列化） 加b
#json：只能支持字典 列表 元组，但是json可以在多语言通用
#pickle保存自己的游戏状态--多少血（只能存在文件或者缓存，不能存到数据库，序列化后，把函数序列化到文件）
#pickle只能在python中使用
#字典转换成字符串 --叫序列化
#字符串转换成字典 --叫反序列化
#将数据通过特殊的形式转换成只有python才能认识的字符串
# data = {"k1":"v1","k2":"v2"}
# p_str = pickle.dumps(data)
# print(p_str)
# #b'\x80\x03}q\x00(X\x02\x00\x00\x00k2q\x01X\x02\x00\x00\x00v2q\x02X
# # \x02\x00\x00\x00k1q\x03X\x02\x00\x00\x00v1q\x04u.'
#
# #将字符串写入文件
# f = open("pickle1.txt","wb") #这里必须加上b，否则报错
# f.write(p_str)
# f.close()
#方法2 将字典转换pickle.dump成只有python才认识的字符串(文件打开乱码，因为只有python才认识)，并且同时写入到文件
data = {"k1":"v1","k2":"v2"} #定义字典
f = open("pickle2.txt","wb") #新建空白文件
pickle.dump(data,f) #转换成只有python认识的字符串，写入文件（省去write）
f.close() #关闭文件
模块导入
需求：如何将当前py文件的上3级目录添加到环境变量
#将当前的py文件的上3级目录(3个os.path.dirname)添加到环境变量
base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
#一个os.path.dirname显示上一级目录，3个os.path.dirname显示上三级目录
sys.path.append(base_dir)
print(sys.path)
浙公网安备 33010602011771号