正文
time | sys | os 模块，递归删除文件，项目分析
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
一，复习
'''
1.跨文件夹导包 - 不用考虑包的情况下直接导入文件夹(包)下的具体模块
2.__name__: py自执行 '__main__' | py被导入执行 '模块名'
3.包：一系列模块的集合体，通过包内的__init__文件来管理包中所有模块提供给外界的名字
-- 存放所以模块的文件夹名就是包名
4.导包三件事：
1）编译__init__文件的pyc
2）执行__init__文件形成全局名称空间，作为包的全局名称空间，包能直接使用的名字全部是__init__文件中提供的
3）在导包文件中形成一个名字指向包的名称空间
5.包的管理：通过__init__文件来管理，在包中使用相对导入
. 代表当前文件所在目录
.. 代表当前文件所在目录的上一级目录
# .开头的导包语法，from .开头 import 名字，只能存活在包内
'''
二，今日内容
'''
1.时间模块
2.系统模块
3.项目开发目录规范
4.loggin
5.json
三，sys模块
"""
sys是system的缩写,表示系统,但是要注意
sys指的是解释器自身,而非操作系统
所以该模块主要是处理与解释器相关的操作的
提供的函数和属性:
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
"""""
其中提供了有一个argv属性用于接收从控制台传入的参数,当你要开发一款命令行程序时,该属性非常重要
案例:开发一款命令行界面的文件复制工具
思路:第一个参数是当前执行文件本身,第二个参数用于接收源文件,第三个参数用于接收目标文件
import sys
source_path = sys.argv[1]
target_path = sys.argv[2]
print(source_path)
print(target_path)
with open(source_path, "rb") as f1:
with open(target_path, "wb") as f2:
while True:
data = f1.read(1024)
if not data:
break
f2.write(data)
四，calendar 模块
"""
判断闰年：calendar.isleap(year) 能被4整除但不能被100整除的年份为普通闰年
查看某年某月日历：calendar.month(year, mouth)
查看某年某月起始星期与当月天数：calendar.monthrange(year, mouth)
查看某年某月某日是星期几：calendar.weekday(year, month, day)
"""""
import calendar
print(calendar.isleap(2020)) #True
print(calendar.month(2019,6)) #日历表
print(calendar.monthrange(2019,6)) #(5, 30)
print(calendar.weekday(2019,5,7)) #1
五，time 模块
"""
时间戳(timestamp)：time.time()
延迟线程的运行：time.sleep(secs)
(指定时间戳下的)当前时区时间：time.localtime([secs])
(指定时间戳下的)格林威治时间：time.gmtime([secs])
(指定时间元组下的)格式化时间：time.strftime(fmt[,tupletime])
"""
import time
'''时间戳'''
# print(time.time()) #1557212208.8409944
'''延迟线程的运行'''
time.sleep(3)
print('结束了')
'''# 自定义睡觉'''
old_time = time.time()
while time.time() - old_time <= 3:
pass
print(time.time())
print('醒了')
'''当前时区时间'''
print(time.localtime()) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=7, tm_hour=14, tm_min=59, tm_sec=32, tm_wday=1, tm_yday=127, tm_isdst=0)
time_old = time.localtime()
print(time_old)
print(time_old.tm_year) #
'''格林威治时间'''
print(time.gmtime()) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=7, tm_hour=10, tm_min=44, tm_sec=56, tm_wday=1, tm_yday=127, tm_isdst=0)
time_obj2 = time.gmtime()
print(time_obj2)
print(time_obj2.tm_hour) #
print(time_obj2.tm_wday) #1 星期从周一开始计算，周一为数字0
print(time.localtime(1557302208)) #将时间戳转化成时间对象
print(time.gmtime(1557012208)) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=4, tm_hour=23, tm_min=23, tm_sec=28, tm_wday=5, tm_yday=124, tm_isdst=0)
'''格式化时间'''
res = time.strftime('%Y-%m-%d') #2019-05-07
print(res)
res = time.strftime("%Y-%m-%d %H:%M:%S", (2008, 8, 8, 8, 8, 8, 0, 0, 0))
print(res)
六，datetime 模块
"""
当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datetime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)
"""""
import datetime
print(datetime.datetime.year)
now_time = datetime.datetime.now()
print(now_time) # 2019-05-07 19:17:33.200227 当前时间
res = str(now_time)
print(res[:-7]) # 2019-05-07 19:19:03 时间截取
# 7天的时间对象
days = datetime.timedelta(days=7)
print(days, type(days)) # 7 days, 0:00:00 <class 'datetime.timedelta'>
# 免登陆时间运算|会员过期时间
time_obj = now_time + days # 当前时间 + 7天
print(time_obj, type(time_obj)) # 2019-05-14 19:23:26.698641 <class 'datetime.datetime'>
now_time_obj = time_obj.replace(year=2000, day=1, second=0)
print(now_time_obj) #2000-05-01 19:25:00.294593
print(datetime.date.fromtimestamp(1557094560)) #2019-05-06
print('=========')
print(datetime.datetime.now() + datetime.timedelta(days=-1)) #昨天 2019-05-06 22:10:01.758706
print(datetime.datetime.now() - datetime.timedelta(days=-1)) #明天 2019-05-08 22:10:01.758706
七，os 模块
'''
os翻译过来就是操作系统,os模块提供了与操作系统打交道需要用到的函数,
那我们什么时候需要与操作系统打交道呢?
在操作系统中,我们最最常用的操作就是,对文件及文件夹的操作, 所以 当你需要操作文件时,就应该想到os模块了
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 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
'''''
import os
print(os.sep) #\
print(os.linesep)
print(os.name) #nt
print(os.pathsep) #;
print(os.environ)
os.mkdir('abc') #在当前文件所在路径下创建abc文件夹，如果文件存在会报错
os.mkdir('D:\\abc') #就是在指定的绝对路径下创建abc文件夹
os.mkdir('a/b/c') #a,b必须提前存在，c不能存在
os.makedirs(r'a\b\c') #a,b存在与否都可以，c不能存在
os.rename('abc','aaa') #修改文件名
print(os.getcwd()) #获取工作目录 D:\Python_Project\ClassRoom\day18
os.rmdir('aaa') #删除单层空文件
os.removedirs('a/b/c') #删除多层空文件
os.remove('aa/1.py') #删除指定文件
print(os.listdir('D:\Python_Project\ClassRoom\day18')) #输入当前目录下的目录 ['a', 'abc', 'calendar模块.py', 'datetime模块.py', 'os模块.py', 'part5', 'sys模块.py', 'time模块.py']
八，os.path 模块
"""
该模块用于处理路径,我们知道python是一门跨平台的语言,二每种操作系统,文件路径是截然不同的,为了使程序可以在不同平台生正确运行,
python提供了该模块,使用该模块可以实现路径在不同品台下的自动转换,从而实现跨平台
今后只要涉及到文件或文件夹路径,就应该使用该模块
提供的函数:
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
"""""
import os
print(__file__) #当前执行文件路径 D:/Python_Project/ClassRoom/day18/os_path模块.py
res = os.path.abspath('D://Python_Project/\ClassRoom/day18//os_path模块.py') #规范化
print(res)
res = os.path.split('D:/Python_Project/ClassRoom/day18/os_path模块.py')
print(res,res[1]) #('D:/Python_Project/ClassRoom/day18', 'os_path模块.py') os_path模块.py
print(r'D:\Python_Project\ClassRoom\day18\os_path模块.py'.rsplit(os.sep ,1 )) #['D:\\Python_Project\\ClassRoom\\day18', 'os_path模块.py']
print(__file__)
print(os.path.dirname(__file__))
print(os.path.dirname(os.path.dirname(__file__)))
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
print(BASE_DIR) #该项目根目录是在执行时，自动获取到当前项目根目录的绝对路径
#案例：项目根目录的应用场景
import sys
sys.path.append(BASE_DIR) #所有导包\导模块都依赖BASE_DIR
print(sys.path)
from part3.abc import new
print(new) #<module 'part5.abc.new' from 'D:/Python_Project/ClassRoom\\part5\\abc\\new.py'>
from part5.x import y
print(y.x)
from part5 import mm
print(mm.mmmm)
from mm import mmmm
print(mmmm)
part1_path = os.path.join(BASE_DIR,'part1') #BASE_DIR + os.sep + 'part1'
sys.path.append(part1_path)
part3_path = os.path.join(BASE_DIR,'part3')
sys.path.append(part3_path)
print(sys.path)
#最后一级名称
print(os.path.basename('D:/Python_Project/ClassRoom/day18/os_path模块.py')) #os_path模块.py
#路劲拼接：
new_path = os.path.join(BASE_DIR,'part3','abc','new.py')
print(new_path) #D:/Python_Project/ClassRoom\part3\abc\new.py
"""
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path)
"""
print(os.path.exists(new_path)) #是否存在
print(os.path.isabs(new_path)) #是否绝对路径
print(os.path.exists('abc'))
print(os.path.isabs('abc'))
print(os.path.isfile(new_path)) #是否是文件
print(os.path.isdir(new_path)) #是否是路径
print(os.path.isfile('abc'))
print(os.path.isdir('abc'))
print(__file__)
file_path = 'D:/Python_Project/ClassRoom/day18/os_path模块.py'
print(os.path.getctime(file_path))
print(os.path.getatime(file_path)) #最后存储时间
print(os.path.getmtime(file_path)) #最后修改时间
'''
1557230709.9831052
1557233680.8510375 #修改了文件会进行更新
1557233680.8540661
'''
print(os.path.normcase('D:/Python_Project/\ClassRoom/day18/os_path模块.py')) #d:\python_project\\classroom\day18\os_path模块.py
print(os.path.normpath('D:/Python_Project/ClassRoom/day18/..')) #D:\Python_Project\ClassRoom
九，os案例 ：
'''将part5下的mm.py移动到part6下abc文件中'''
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def move_file(file,folder):
#如果文件不存在或不是文件文件
if not (os.path.exists(file) and os.path.isfile(file)):
print('文件不存在或不是文件')
return False
#如果文件不存在则创建文件
if not os.path.exists(folder):
os.makedirs(folder)
#提取part5中的mm.py文件
file_name = os.path.split(file)[1]
#第二种方式提取 file_name = os.path.basename(file)
print(file_name) #mm.py
#将提取出来的mm.py文件添加到part6\abc中
new_file = os.path.join(folder,file_name)
print(new_file) #D:/Python_Project/ClassRoom\part6\abc\mm.py
#打开文件提取内容
with open(file,'rb')as r,open(new_file,'wb')as w:
for line in r:
w.write(line)
#将part5中的mm.py 删除
os.remove(file)
file = os.path.join(BASE_DIR,'part5','mm.py')
print(file) #D:/Python_Project/ClassRoom\part5\mm.py
folder = os.path.join(BASE_DIR,'part6','abc')
print(folder) #D:/Python_Project/ClassRoom\part6\abc
# move_file(file,folder)
'''递归删除的思路'''
def delete_dir(folder):
for path in os.listdir(folder):
# 如果path是文件夹 delete_dir(path)
# 如果是文件os.remove(path)
pass
# for走完了代表folder内部删空了，可以删folder
'''#遍历打印目标路径中所有的txt文件'''
def print_txt(folder):
#判断文件是否存在，是否是文件
if not (os.path.exists(folder) or os.path.isfile(folder)):
print('文件不存在或不是文件')
return
#循环遍历文件下的目录
for path in os.listdir(folder):
#将文件名循环出来添加到D:/Python_Project/ClassRoom\part6后面
file_path = os.path.join(folder,path)
print(file_path) #D:/Python_Project/ClassRoom\part6\a\b
#如果是文件并且以.txt结尾的，就输出
if os.path.isfile(file_path) and file_path.endswith('.txt'):
print(path)
#如果是文件继续循环
elif os.path.isdir(file_path):
print_txt(file_path) #递归调用自己
target_path = os.path.join(BASE_DIR,'part6')
# print(target_path) #D:/Python_Project/ClassRoom\part6
print_txt(target_path)
十 , 作业
'''
1.创建一个函数，该函数可以实现查找指定目录下指定文件后缀的文件，最终返回存放该目录及子目录下所有满足需求文件绝对路径的列表
def find_file(abs_path, suffix):
:param abs_path: 目标目录，绝对路径，str类型数据
:param suffix: 文件后缀，str类型数据
:return: 装有所有目录及子目录下满足文件后缀文件的列表
注：文件夹用abc.txt来命名也是合法的，但是不是文件
'''''
import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def find_file(abs_path, suffix,ls = []):
#判断文件是否存在或是否是文件
if not(os.path.exists(abs_path) or os.path.isfile(abs_path)):
print('文件不存在或不是文件')
return ls
#读取该文件中所有目录
for path in os.listdir(abs_path):
file_path = os.path.join(abs_path,path) #添加到abs_path路径中
#如果是文件并且以suffix结尾的，就添加到列表中
if os.path.isfile(file_path) and file_path.endswith(suffix):
ls.append(path)
#如果是文件就继续循环读取
else:
find_file(file_path,suffix)
return ls
path = os.path.join(BASE_DIR,'part6')
res = find_file(path,'.txt')
print(res)
'''
2.删除目标目录
def delete_path(abs_path):
:param abs_path: 要删除的目录路径
:return: 删除成功与否
分析：
1）如果是文件，直接删除
2）如果是文件夹，就进入，然后删除里面的所有子资源，删除成功后，出来就可以删除文件夹了
if os.path.isdir(path):
# 用递归再进入，把path作为目标路径删除
# 上一步走完了，就可以删除该文件夹了
3）除了2）的方式，也可以把所有所有文件全部删除，那么就全部是空文件夹，可以一次性删除所有空文件夹
'''
def delete_path(abs_path):
#判断文件是否为空
if not os.path.exists(abs_path):
print('文件不存在')
return False
#判断是否是文件
if os.path.isfile(abs_path):
os.remove(abs_path)
return True
#循环文件
for path in os.listdir(abs_path):
#添加路径到abs_path中
new_file = os.path.join(abs_path,path)
#判断是否是文件
if os.path.isfile(new_file):
os.remove(new_file)
#递归
else:
delete_path(new_file)
#走完了删除最后的空文件
os.rmdir(abs_path)
p = os.path.join(BASE_DIR,'part7')
res = delete_path(p)
print(res)
十一，项目开发分析：
'''
1.调研
2.需求分析
3.架构师完成项目demo，完成项目架构
4.分工
5.写代码
6.白盒黑盒测试
7.项目审核发布 => 项目 -> 产品
'''
'''
bin: 可执行文件，入口，入口也可以放在项目根目录下
core: 核心代码
db：数据库相关文件
interface：接口
lib：包、模块、第三方文件夹
log：日志
setting：配置
static：静态文件
'''
'''
1.跨文件夹导包 - 不用考虑包的情况下直接导入文件夹(包)下的具体模块 2.__name__: py自执行 '__main__' | py被导入执行 '模块名' 3.包：一系列模块的集合体，通过包内的__init__文件来管理包中所有模块提供给外界的名字
-- 存放所以模块的文件夹名就是包名 4.导包三件事：
1）编译__init__文件的pyc
2）执行__init__文件形成全局名称空间，作为包的全局名称空间，包能直接使用的名字全部是__init__文件中提供的
3）在导包文件中形成一个名字指向包的名称空间 5.包的管理：通过__init__文件来管理，在包中使用相对导入 . 代表当前文件所在目录
.. 代表当前文件所在目录的上一级目录
# .开头的导包语法，from .开头 import 名字，只能存活在包内 '''
'''
1.时间模块
2.系统模块
3.项目开发目录规范
4.loggin
5.json
三，sys模块
"""
sys是system的缩写,表示系统,但是要注意
sys指的是解释器自身,而非操作系统
所以该模块主要是处理与解释器相关的操作的
提供的函数和属性:
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
"""""
其中提供了有一个argv属性用于接收从控制台传入的参数,当你要开发一款命令行程序时,该属性非常重要
案例:开发一款命令行界面的文件复制工具
思路:第一个参数是当前执行文件本身,第二个参数用于接收源文件,第三个参数用于接收目标文件
import sys
source_path = sys.argv[1]
target_path = sys.argv[2]
print(source_path)
print(target_path)
with open(source_path, "rb") as f1:
with open(target_path, "wb") as f2:
while True:
data = f1.read(1024)
if not data:
break
f2.write(data)
四，calendar 模块
"""
判断闰年：calendar.isleap(year) 能被4整除但不能被100整除的年份为普通闰年
查看某年某月日历：calendar.month(year, mouth)
查看某年某月起始星期与当月天数：calendar.monthrange(year, mouth)
查看某年某月某日是星期几：calendar.weekday(year, month, day)
"""""
import calendar
print(calendar.isleap(2020)) #True
print(calendar.month(2019,6)) #日历表
print(calendar.monthrange(2019,6)) #(5, 30)
print(calendar.weekday(2019,5,7)) #1
五，time 模块
"""
时间戳(timestamp)：time.time()
延迟线程的运行：time.sleep(secs)
(指定时间戳下的)当前时区时间：time.localtime([secs])
(指定时间戳下的)格林威治时间：time.gmtime([secs])
(指定时间元组下的)格式化时间：time.strftime(fmt[,tupletime])
"""
import time
'''时间戳'''
# print(time.time()) #1557212208.8409944
'''延迟线程的运行'''
time.sleep(3)
print('结束了')
'''# 自定义睡觉'''
old_time = time.time()
while time.time() - old_time <= 3:
pass
print(time.time())
print('醒了')
'''当前时区时间'''
print(time.localtime()) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=7, tm_hour=14, tm_min=59, tm_sec=32, tm_wday=1, tm_yday=127, tm_isdst=0)
time_old = time.localtime()
print(time_old)
print(time_old.tm_year) #
'''格林威治时间'''
print(time.gmtime()) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=7, tm_hour=10, tm_min=44, tm_sec=56, tm_wday=1, tm_yday=127, tm_isdst=0)
time_obj2 = time.gmtime()
print(time_obj2)
print(time_obj2.tm_hour) #
print(time_obj2.tm_wday) #1 星期从周一开始计算，周一为数字0
print(time.localtime(1557302208)) #将时间戳转化成时间对象
print(time.gmtime(1557012208)) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=4, tm_hour=23, tm_min=23, tm_sec=28, tm_wday=5, tm_yday=124, tm_isdst=0)
'''格式化时间'''
res = time.strftime('%Y-%m-%d') #2019-05-07
print(res)
res = time.strftime("%Y-%m-%d %H:%M:%S", (2008, 8, 8, 8, 8, 8, 0, 0, 0))
print(res)
六，datetime 模块
"""
当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datetime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)
"""""
import datetime
print(datetime.datetime.year)
now_time = datetime.datetime.now()
print(now_time) # 2019-05-07 19:17:33.200227 当前时间
res = str(now_time)
print(res[:-7]) # 2019-05-07 19:19:03 时间截取
# 7天的时间对象
days = datetime.timedelta(days=7)
print(days, type(days)) # 7 days, 0:00:00 <class 'datetime.timedelta'>
# 免登陆时间运算|会员过期时间
time_obj = now_time + days # 当前时间 + 7天
print(time_obj, type(time_obj)) # 2019-05-14 19:23:26.698641 <class 'datetime.datetime'>
now_time_obj = time_obj.replace(year=2000, day=1, second=0)
print(now_time_obj) #2000-05-01 19:25:00.294593
print(datetime.date.fromtimestamp(1557094560)) #2019-05-06
print('=========')
print(datetime.datetime.now() + datetime.timedelta(days=-1)) #昨天 2019-05-06 22:10:01.758706
print(datetime.datetime.now() - datetime.timedelta(days=-1)) #明天 2019-05-08 22:10:01.758706
七，os 模块
'''
os翻译过来就是操作系统,os模块提供了与操作系统打交道需要用到的函数,
那我们什么时候需要与操作系统打交道呢?
在操作系统中,我们最最常用的操作就是,对文件及文件夹的操作, 所以 当你需要操作文件时,就应该想到os模块了
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 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
'''''
import os
print(os.sep) #\
print(os.linesep)
print(os.name) #nt
print(os.pathsep) #;
print(os.environ)
os.mkdir('abc') #在当前文件所在路径下创建abc文件夹，如果文件存在会报错
os.mkdir('D:\\abc') #就是在指定的绝对路径下创建abc文件夹
os.mkdir('a/b/c') #a,b必须提前存在，c不能存在
os.makedirs(r'a\b\c') #a,b存在与否都可以，c不能存在
os.rename('abc','aaa') #修改文件名
print(os.getcwd()) #获取工作目录 D:\Python_Project\ClassRoom\day18
os.rmdir('aaa') #删除单层空文件
os.removedirs('a/b/c') #删除多层空文件
os.remove('aa/1.py') #删除指定文件
print(os.listdir('D:\Python_Project\ClassRoom\day18')) #输入当前目录下的目录 ['a', 'abc', 'calendar模块.py', 'datetime模块.py', 'os模块.py', 'part5', 'sys模块.py', 'time模块.py']
八，os.path 模块
"""
该模块用于处理路径,我们知道python是一门跨平台的语言,二每种操作系统,文件路径是截然不同的,为了使程序可以在不同平台生正确运行,
python提供了该模块,使用该模块可以实现路径在不同品台下的自动转换,从而实现跨平台
今后只要涉及到文件或文件夹路径,就应该使用该模块
提供的函数:
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
"""""
import os
print(__file__) #当前执行文件路径 D:/Python_Project/ClassRoom/day18/os_path模块.py
res = os.path.abspath('D://Python_Project/\ClassRoom/day18//os_path模块.py') #规范化
print(res)
res = os.path.split('D:/Python_Project/ClassRoom/day18/os_path模块.py')
print(res,res[1]) #('D:/Python_Project/ClassRoom/day18', 'os_path模块.py') os_path模块.py
print(r'D:\Python_Project\ClassRoom\day18\os_path模块.py'.rsplit(os.sep ,1 )) #['D:\\Python_Project\\ClassRoom\\day18', 'os_path模块.py']
print(__file__)
print(os.path.dirname(__file__))
print(os.path.dirname(os.path.dirname(__file__)))
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
print(BASE_DIR) #该项目根目录是在执行时，自动获取到当前项目根目录的绝对路径
#案例：项目根目录的应用场景
import sys
sys.path.append(BASE_DIR) #所有导包\导模块都依赖BASE_DIR
print(sys.path)
from part3.abc import new
print(new) #<module 'part5.abc.new' from 'D:/Python_Project/ClassRoom\\part5\\abc\\new.py'>
from part5.x import y
print(y.x)
from part5 import mm
print(mm.mmmm)
from mm import mmmm
print(mmmm)
part1_path = os.path.join(BASE_DIR,'part1') #BASE_DIR + os.sep + 'part1'
sys.path.append(part1_path)
part3_path = os.path.join(BASE_DIR,'part3')
sys.path.append(part3_path)
print(sys.path)
#最后一级名称
print(os.path.basename('D:/Python_Project/ClassRoom/day18/os_path模块.py')) #os_path模块.py
#路劲拼接：
new_path = os.path.join(BASE_DIR,'part3','abc','new.py')
print(new_path) #D:/Python_Project/ClassRoom\part3\abc\new.py
"""
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path)
"""
print(os.path.exists(new_path)) #是否存在
print(os.path.isabs(new_path)) #是否绝对路径
print(os.path.exists('abc'))
print(os.path.isabs('abc'))
print(os.path.isfile(new_path)) #是否是文件
print(os.path.isdir(new_path)) #是否是路径
print(os.path.isfile('abc'))
print(os.path.isdir('abc'))
print(__file__)
file_path = 'D:/Python_Project/ClassRoom/day18/os_path模块.py'
print(os.path.getctime(file_path))
print(os.path.getatime(file_path)) #最后存储时间
print(os.path.getmtime(file_path)) #最后修改时间
'''
1557230709.9831052
1557233680.8510375 #修改了文件会进行更新
1557233680.8540661
'''
print(os.path.normcase('D:/Python_Project/\ClassRoom/day18/os_path模块.py')) #d:\python_project\\classroom\day18\os_path模块.py
print(os.path.normpath('D:/Python_Project/ClassRoom/day18/..')) #D:\Python_Project\ClassRoom
九，os案例 ：
'''将part5下的mm.py移动到part6下abc文件中'''
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def move_file(file,folder):
#如果文件不存在或不是文件文件
if not (os.path.exists(file) and os.path.isfile(file)):
print('文件不存在或不是文件')
return False
#如果文件不存在则创建文件
if not os.path.exists(folder):
os.makedirs(folder)
#提取part5中的mm.py文件
file_name = os.path.split(file)[1]
#第二种方式提取 file_name = os.path.basename(file)
print(file_name) #mm.py
#将提取出来的mm.py文件添加到part6\abc中
new_file = os.path.join(folder,file_name)
print(new_file) #D:/Python_Project/ClassRoom\part6\abc\mm.py
#打开文件提取内容
with open(file,'rb')as r,open(new_file,'wb')as w:
for line in r:
w.write(line)
#将part5中的mm.py 删除
os.remove(file)
file = os.path.join(BASE_DIR,'part5','mm.py')
print(file) #D:/Python_Project/ClassRoom\part5\mm.py
folder = os.path.join(BASE_DIR,'part6','abc')
print(folder) #D:/Python_Project/ClassRoom\part6\abc
# move_file(file,folder)
'''递归删除的思路'''
def delete_dir(folder):
for path in os.listdir(folder):
# 如果path是文件夹 delete_dir(path)
# 如果是文件os.remove(path)
pass
# for走完了代表folder内部删空了，可以删folder
'''#遍历打印目标路径中所有的txt文件'''
def print_txt(folder):
#判断文件是否存在，是否是文件
if not (os.path.exists(folder) or os.path.isfile(folder)):
print('文件不存在或不是文件')
return
#循环遍历文件下的目录
for path in os.listdir(folder):
#将文件名循环出来添加到D:/Python_Project/ClassRoom\part6后面
file_path = os.path.join(folder,path)
print(file_path) #D:/Python_Project/ClassRoom\part6\a\b
#如果是文件并且以.txt结尾的，就输出
if os.path.isfile(file_path) and file_path.endswith('.txt'):
print(path)
#如果是文件继续循环
elif os.path.isdir(file_path):
print_txt(file_path) #递归调用自己
target_path = os.path.join(BASE_DIR,'part6')
# print(target_path) #D:/Python_Project/ClassRoom\part6
print_txt(target_path)
十 , 作业
'''
1.创建一个函数，该函数可以实现查找指定目录下指定文件后缀的文件，最终返回存放该目录及子目录下所有满足需求文件绝对路径的列表
def find_file(abs_path, suffix):
:param abs_path: 目标目录，绝对路径，str类型数据
:param suffix: 文件后缀，str类型数据
:return: 装有所有目录及子目录下满足文件后缀文件的列表
注：文件夹用abc.txt来命名也是合法的，但是不是文件
'''''
import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def find_file(abs_path, suffix,ls = []):
#判断文件是否存在或是否是文件
if not(os.path.exists(abs_path) or os.path.isfile(abs_path)):
print('文件不存在或不是文件')
return ls
#读取该文件中所有目录
for path in os.listdir(abs_path):
file_path = os.path.join(abs_path,path) #添加到abs_path路径中
#如果是文件并且以suffix结尾的，就添加到列表中
if os.path.isfile(file_path) and file_path.endswith(suffix):
ls.append(path)
#如果是文件就继续循环读取
else:
find_file(file_path,suffix)
return ls
path = os.path.join(BASE_DIR,'part6')
res = find_file(path,'.txt')
print(res)
'''
2.删除目标目录
def delete_path(abs_path):
:param abs_path: 要删除的目录路径
:return: 删除成功与否
分析：
1）如果是文件，直接删除
2）如果是文件夹，就进入，然后删除里面的所有子资源，删除成功后，出来就可以删除文件夹了
if os.path.isdir(path):
# 用递归再进入，把path作为目标路径删除
# 上一步走完了，就可以删除该文件夹了
3）除了2）的方式，也可以把所有所有文件全部删除，那么就全部是空文件夹，可以一次性删除所有空文件夹
'''
def delete_path(abs_path):
#判断文件是否为空
if not os.path.exists(abs_path):
print('文件不存在')
return False
#判断是否是文件
if os.path.isfile(abs_path):
os.remove(abs_path)
return True
#循环文件
for path in os.listdir(abs_path):
#添加路径到abs_path中
new_file = os.path.join(abs_path,path)
#判断是否是文件
if os.path.isfile(new_file):
os.remove(new_file)
#递归
else:
delete_path(new_file)
#走完了删除最后的空文件
os.rmdir(abs_path)
p = os.path.join(BASE_DIR,'part7')
res = delete_path(p)
print(res)
十一，项目开发分析：
'''
1.调研
2.需求分析
3.架构师完成项目demo，完成项目架构
4.分工
5.写代码
6.白盒黑盒测试
7.项目审核发布 => 项目 -> 产品
'''
'''
bin: 可执行文件，入口，入口也可以放在项目根目录下
core: 核心代码
db：数据库相关文件
interface：接口
lib：包、模块、第三方文件夹
log：日志
setting：配置
static：静态文件
'''
"""
sys是system的缩写,表示系统,但是要注意
sys指的是解释器自身,而非操作系统
所以该模块主要是处理与解释器相关的操作的
提供的函数和属性:
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
"""""
其中提供了有一个argv属性用于接收从控制台传入的参数,当你要开发一款命令行程序时,该属性非常重要 案例:开发一款命令行界面的文件复制工具 思路:第一个参数是当前执行文件本身,第二个参数用于接收源文件,第三个参数用于接收目标文件 import sys source_path = sys.argv[1]
target_path = sys.argv[2]
print(source_path)
print(target_path)
with open(source_path, "rb") as f1:
with open(target_path, "wb") as f2:
while True:
data = f1.read(1024)
if not data:
break
f2.write(data)
"""
判断闰年：calendar.isleap(year) 能被4整除但不能被100整除的年份为普通闰年
查看某年某月日历：calendar.month(year, mouth)
查看某年某月起始星期与当月天数：calendar.monthrange(year, mouth)
查看某年某月某日是星期几：calendar.weekday(year, month, day)
"""""
import calendar
print(calendar.isleap(2020)) #True
print(calendar.month(2019,6)) #日历表
print(calendar.monthrange(2019,6)) #(5, 30)
print(calendar.weekday(2019,5,7)) #1
五，time 模块
"""
时间戳(timestamp)：time.time()
延迟线程的运行：time.sleep(secs)
(指定时间戳下的)当前时区时间：time.localtime([secs])
(指定时间戳下的)格林威治时间：time.gmtime([secs])
(指定时间元组下的)格式化时间：time.strftime(fmt[,tupletime])
"""
import time
'''时间戳'''
# print(time.time()) #1557212208.8409944
'''延迟线程的运行'''
time.sleep(3)
print('结束了')
'''# 自定义睡觉'''
old_time = time.time()
while time.time() - old_time <= 3:
pass
print(time.time())
print('醒了')
'''当前时区时间'''
print(time.localtime()) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=7, tm_hour=14, tm_min=59, tm_sec=32, tm_wday=1, tm_yday=127, tm_isdst=0)
time_old = time.localtime()
print(time_old)
print(time_old.tm_year) #
'''格林威治时间'''
print(time.gmtime()) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=7, tm_hour=10, tm_min=44, tm_sec=56, tm_wday=1, tm_yday=127, tm_isdst=0)
time_obj2 = time.gmtime()
print(time_obj2)
print(time_obj2.tm_hour) #
print(time_obj2.tm_wday) #1 星期从周一开始计算，周一为数字0
print(time.localtime(1557302208)) #将时间戳转化成时间对象
print(time.gmtime(1557012208)) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=4, tm_hour=23, tm_min=23, tm_sec=28, tm_wday=5, tm_yday=124, tm_isdst=0)
'''格式化时间'''
res = time.strftime('%Y-%m-%d') #2019-05-07
print(res)
res = time.strftime("%Y-%m-%d %H:%M:%S", (2008, 8, 8, 8, 8, 8, 0, 0, 0))
print(res)
六，datetime 模块
"""
当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datetime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)
"""""
import datetime
print(datetime.datetime.year)
now_time = datetime.datetime.now()
print(now_time) # 2019-05-07 19:17:33.200227 当前时间
res = str(now_time)
print(res[:-7]) # 2019-05-07 19:19:03 时间截取
# 7天的时间对象
days = datetime.timedelta(days=7)
print(days, type(days)) # 7 days, 0:00:00 <class 'datetime.timedelta'>
# 免登陆时间运算|会员过期时间
time_obj = now_time + days # 当前时间 + 7天
print(time_obj, type(time_obj)) # 2019-05-14 19:23:26.698641 <class 'datetime.datetime'>
now_time_obj = time_obj.replace(year=2000, day=1, second=0)
print(now_time_obj) #2000-05-01 19:25:00.294593
print(datetime.date.fromtimestamp(1557094560)) #2019-05-06
print('=========')
print(datetime.datetime.now() + datetime.timedelta(days=-1)) #昨天 2019-05-06 22:10:01.758706
print(datetime.datetime.now() - datetime.timedelta(days=-1)) #明天 2019-05-08 22:10:01.758706
七，os 模块
'''
os翻译过来就是操作系统,os模块提供了与操作系统打交道需要用到的函数,
那我们什么时候需要与操作系统打交道呢?
在操作系统中,我们最最常用的操作就是,对文件及文件夹的操作, 所以 当你需要操作文件时,就应该想到os模块了
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 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
'''''
import os
print(os.sep) #\
print(os.linesep)
print(os.name) #nt
print(os.pathsep) #;
print(os.environ)
os.mkdir('abc') #在当前文件所在路径下创建abc文件夹，如果文件存在会报错
os.mkdir('D:\\abc') #就是在指定的绝对路径下创建abc文件夹
os.mkdir('a/b/c') #a,b必须提前存在，c不能存在
os.makedirs(r'a\b\c') #a,b存在与否都可以，c不能存在
os.rename('abc','aaa') #修改文件名
print(os.getcwd()) #获取工作目录 D:\Python_Project\ClassRoom\day18
os.rmdir('aaa') #删除单层空文件
os.removedirs('a/b/c') #删除多层空文件
os.remove('aa/1.py') #删除指定文件
print(os.listdir('D:\Python_Project\ClassRoom\day18')) #输入当前目录下的目录 ['a', 'abc', 'calendar模块.py', 'datetime模块.py', 'os模块.py', 'part5', 'sys模块.py', 'time模块.py']
八，os.path 模块
"""
该模块用于处理路径,我们知道python是一门跨平台的语言,二每种操作系统,文件路径是截然不同的,为了使程序可以在不同平台生正确运行,
python提供了该模块,使用该模块可以实现路径在不同品台下的自动转换,从而实现跨平台
今后只要涉及到文件或文件夹路径,就应该使用该模块
提供的函数:
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
"""""
import os
print(__file__) #当前执行文件路径 D:/Python_Project/ClassRoom/day18/os_path模块.py
res = os.path.abspath('D://Python_Project/\ClassRoom/day18//os_path模块.py') #规范化
print(res)
res = os.path.split('D:/Python_Project/ClassRoom/day18/os_path模块.py')
print(res,res[1]) #('D:/Python_Project/ClassRoom/day18', 'os_path模块.py') os_path模块.py
print(r'D:\Python_Project\ClassRoom\day18\os_path模块.py'.rsplit(os.sep ,1 )) #['D:\\Python_Project\\ClassRoom\\day18', 'os_path模块.py']
print(__file__)
print(os.path.dirname(__file__))
print(os.path.dirname(os.path.dirname(__file__)))
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
print(BASE_DIR) #该项目根目录是在执行时，自动获取到当前项目根目录的绝对路径
#案例：项目根目录的应用场景
import sys
sys.path.append(BASE_DIR) #所有导包\导模块都依赖BASE_DIR
print(sys.path)
from part3.abc import new
print(new) #<module 'part5.abc.new' from 'D:/Python_Project/ClassRoom\\part5\\abc\\new.py'>
from part5.x import y
print(y.x)
from part5 import mm
print(mm.mmmm)
from mm import mmmm
print(mmmm)
part1_path = os.path.join(BASE_DIR,'part1') #BASE_DIR + os.sep + 'part1'
sys.path.append(part1_path)
part3_path = os.path.join(BASE_DIR,'part3')
sys.path.append(part3_path)
print(sys.path)
#最后一级名称
print(os.path.basename('D:/Python_Project/ClassRoom/day18/os_path模块.py')) #os_path模块.py
#路劲拼接：
new_path = os.path.join(BASE_DIR,'part3','abc','new.py')
print(new_path) #D:/Python_Project/ClassRoom\part3\abc\new.py
"""
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path)
"""
print(os.path.exists(new_path)) #是否存在
print(os.path.isabs(new_path)) #是否绝对路径
print(os.path.exists('abc'))
print(os.path.isabs('abc'))
print(os.path.isfile(new_path)) #是否是文件
print(os.path.isdir(new_path)) #是否是路径
print(os.path.isfile('abc'))
print(os.path.isdir('abc'))
print(__file__)
file_path = 'D:/Python_Project/ClassRoom/day18/os_path模块.py'
print(os.path.getctime(file_path))
print(os.path.getatime(file_path)) #最后存储时间
print(os.path.getmtime(file_path)) #最后修改时间
'''
1557230709.9831052
1557233680.8510375 #修改了文件会进行更新
1557233680.8540661
'''
print(os.path.normcase('D:/Python_Project/\ClassRoom/day18/os_path模块.py')) #d:\python_project\\classroom\day18\os_path模块.py
print(os.path.normpath('D:/Python_Project/ClassRoom/day18/..')) #D:\Python_Project\ClassRoom
九，os案例 ：
'''将part5下的mm.py移动到part6下abc文件中'''
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def move_file(file,folder):
#如果文件不存在或不是文件文件
if not (os.path.exists(file) and os.path.isfile(file)):
print('文件不存在或不是文件')
return False
#如果文件不存在则创建文件
if not os.path.exists(folder):
os.makedirs(folder)
#提取part5中的mm.py文件
file_name = os.path.split(file)[1]
#第二种方式提取 file_name = os.path.basename(file)
print(file_name) #mm.py
#将提取出来的mm.py文件添加到part6\abc中
new_file = os.path.join(folder,file_name)
print(new_file) #D:/Python_Project/ClassRoom\part6\abc\mm.py
#打开文件提取内容
with open(file,'rb')as r,open(new_file,'wb')as w:
for line in r:
w.write(line)
#将part5中的mm.py 删除
os.remove(file)
file = os.path.join(BASE_DIR,'part5','mm.py')
print(file) #D:/Python_Project/ClassRoom\part5\mm.py
folder = os.path.join(BASE_DIR,'part6','abc')
print(folder) #D:/Python_Project/ClassRoom\part6\abc
# move_file(file,folder)
'''递归删除的思路'''
def delete_dir(folder):
for path in os.listdir(folder):
# 如果path是文件夹 delete_dir(path)
# 如果是文件os.remove(path)
pass
# for走完了代表folder内部删空了，可以删folder
'''#遍历打印目标路径中所有的txt文件'''
def print_txt(folder):
#判断文件是否存在，是否是文件
if not (os.path.exists(folder) or os.path.isfile(folder)):
print('文件不存在或不是文件')
return
#循环遍历文件下的目录
for path in os.listdir(folder):
#将文件名循环出来添加到D:/Python_Project/ClassRoom\part6后面
file_path = os.path.join(folder,path)
print(file_path) #D:/Python_Project/ClassRoom\part6\a\b
#如果是文件并且以.txt结尾的，就输出
if os.path.isfile(file_path) and file_path.endswith('.txt'):
print(path)
#如果是文件继续循环
elif os.path.isdir(file_path):
print_txt(file_path) #递归调用自己
target_path = os.path.join(BASE_DIR,'part6')
# print(target_path) #D:/Python_Project/ClassRoom\part6
print_txt(target_path)
十 , 作业
'''
1.创建一个函数，该函数可以实现查找指定目录下指定文件后缀的文件，最终返回存放该目录及子目录下所有满足需求文件绝对路径的列表
def find_file(abs_path, suffix):
:param abs_path: 目标目录，绝对路径，str类型数据
:param suffix: 文件后缀，str类型数据
:return: 装有所有目录及子目录下满足文件后缀文件的列表
注：文件夹用abc.txt来命名也是合法的，但是不是文件
'''''
import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def find_file(abs_path, suffix,ls = []):
#判断文件是否存在或是否是文件
if not(os.path.exists(abs_path) or os.path.isfile(abs_path)):
print('文件不存在或不是文件')
return ls
#读取该文件中所有目录
for path in os.listdir(abs_path):
file_path = os.path.join(abs_path,path) #添加到abs_path路径中
#如果是文件并且以suffix结尾的，就添加到列表中
if os.path.isfile(file_path) and file_path.endswith(suffix):
ls.append(path)
#如果是文件就继续循环读取
else:
find_file(file_path,suffix)
return ls
path = os.path.join(BASE_DIR,'part6')
res = find_file(path,'.txt')
print(res)
'''
2.删除目标目录
def delete_path(abs_path):
:param abs_path: 要删除的目录路径
:return: 删除成功与否
分析：
1）如果是文件，直接删除
2）如果是文件夹，就进入，然后删除里面的所有子资源，删除成功后，出来就可以删除文件夹了
if os.path.isdir(path):
# 用递归再进入，把path作为目标路径删除
# 上一步走完了，就可以删除该文件夹了
3）除了2）的方式，也可以把所有所有文件全部删除，那么就全部是空文件夹，可以一次性删除所有空文件夹
'''
def delete_path(abs_path):
#判断文件是否为空
if not os.path.exists(abs_path):
print('文件不存在')
return False
#判断是否是文件
if os.path.isfile(abs_path):
os.remove(abs_path)
return True
#循环文件
for path in os.listdir(abs_path):
#添加路径到abs_path中
new_file = os.path.join(abs_path,path)
#判断是否是文件
if os.path.isfile(new_file):
os.remove(new_file)
#递归
else:
delete_path(new_file)
#走完了删除最后的空文件
os.rmdir(abs_path)
p = os.path.join(BASE_DIR,'part7')
res = delete_path(p)
print(res)
十一，项目开发分析：
'''
1.调研
2.需求分析
3.架构师完成项目demo，完成项目架构
4.分工
5.写代码
6.白盒黑盒测试
7.项目审核发布 => 项目 -> 产品
'''
'''
bin: 可执行文件，入口，入口也可以放在项目根目录下
core: 核心代码
db：数据库相关文件
interface：接口
lib：包、模块、第三方文件夹
log：日志
setting：配置
static：静态文件
'''
"""
时间戳(timestamp)：time.time()
延迟线程的运行：time.sleep(secs)
(指定时间戳下的)当前时区时间：time.localtime([secs])
(指定时间戳下的)格林威治时间：time.gmtime([secs])
(指定时间元组下的)格式化时间：time.strftime(fmt[,tupletime])
""" import time
'''时间戳'''
# print(time.time()) #1557212208.8409944 '''延迟线程的运行'''
time.sleep(3)
print('结束了') '''# 自定义睡觉'''
old_time = time.time()
while time.time() - old_time <= 3:
pass print(time.time())
print('醒了') '''当前时区时间'''
print(time.localtime()) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=7, tm_hour=14, tm_min=59, tm_sec=32, tm_wday=1, tm_yday=127, tm_isdst=0) time_old = time.localtime()
print(time_old)
print(time_old.tm_year) # '''格林威治时间'''
print(time.gmtime()) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=7, tm_hour=10, tm_min=44, tm_sec=56, tm_wday=1, tm_yday=127, tm_isdst=0) time_obj2 = time.gmtime()
print(time_obj2)
print(time_obj2.tm_hour) #
print(time_obj2.tm_wday) #1 星期从周一开始计算，周一为数字0 print(time.localtime(1557302208)) #将时间戳转化成时间对象
print(time.gmtime(1557012208)) #time.struct_time(tm_year=2019, tm_mon=5, tm_mday=4, tm_hour=23, tm_min=23, tm_sec=28, tm_wday=5, tm_yday=124, tm_isdst=0) '''格式化时间'''
res = time.strftime('%Y-%m-%d') #2019-05-07
print(res) res = time.strftime("%Y-%m-%d %H:%M:%S", (2008, 8, 8, 8, 8, 8, 0, 0, 0))
print(res)
"""
当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datetime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)
""""" import datetime print(datetime.datetime.year)
now_time = datetime.datetime.now()
print(now_time) # 2019-05-07 19:17:33.200227 当前时间 res = str(now_time)
print(res[:-7]) # 2019-05-07 19:19:03 时间截取 # 7天的时间对象
days = datetime.timedelta(days=7)
print(days, type(days)) # 7 days, 0:00:00 <class 'datetime.timedelta'> # 免登陆时间运算|会员过期时间
time_obj = now_time + days # 当前时间 + 7天
print(time_obj, type(time_obj)) # 2019-05-14 19:23:26.698641 <class 'datetime.datetime'> now_time_obj = time_obj.replace(year=2000, day=1, second=0)
print(now_time_obj) #2000-05-01 19:25:00.294593 print(datetime.date.fromtimestamp(1557094560)) #2019-05-06 print('=========')
print(datetime.datetime.now() + datetime.timedelta(days=-1)) #昨天 2019-05-06 22:10:01.758706
print(datetime.datetime.now() - datetime.timedelta(days=-1)) #明天 2019-05-08 22:10:01.758706
七，os 模块
'''
os翻译过来就是操作系统,os模块提供了与操作系统打交道需要用到的函数,
那我们什么时候需要与操作系统打交道呢?
在操作系统中,我们最最常用的操作就是,对文件及文件夹的操作, 所以 当你需要操作文件时,就应该想到os模块了
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 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
'''''
import os
print(os.sep) #\
print(os.linesep)
print(os.name) #nt
print(os.pathsep) #;
print(os.environ)
os.mkdir('abc') #在当前文件所在路径下创建abc文件夹，如果文件存在会报错
os.mkdir('D:\\abc') #就是在指定的绝对路径下创建abc文件夹
os.mkdir('a/b/c') #a,b必须提前存在，c不能存在
os.makedirs(r'a\b\c') #a,b存在与否都可以，c不能存在
os.rename('abc','aaa') #修改文件名
print(os.getcwd()) #获取工作目录 D:\Python_Project\ClassRoom\day18
os.rmdir('aaa') #删除单层空文件
os.removedirs('a/b/c') #删除多层空文件
os.remove('aa/1.py') #删除指定文件
print(os.listdir('D:\Python_Project\ClassRoom\day18')) #输入当前目录下的目录 ['a', 'abc', 'calendar模块.py', 'datetime模块.py', 'os模块.py', 'part5', 'sys模块.py', 'time模块.py']
八，os.path 模块
"""
该模块用于处理路径,我们知道python是一门跨平台的语言,二每种操作系统,文件路径是截然不同的,为了使程序可以在不同平台生正确运行,
python提供了该模块,使用该模块可以实现路径在不同品台下的自动转换,从而实现跨平台
今后只要涉及到文件或文件夹路径,就应该使用该模块
提供的函数:
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
"""""
import os
print(__file__) #当前执行文件路径 D:/Python_Project/ClassRoom/day18/os_path模块.py
res = os.path.abspath('D://Python_Project/\ClassRoom/day18//os_path模块.py') #规范化
print(res)
res = os.path.split('D:/Python_Project/ClassRoom/day18/os_path模块.py')
print(res,res[1]) #('D:/Python_Project/ClassRoom/day18', 'os_path模块.py') os_path模块.py
print(r'D:\Python_Project\ClassRoom\day18\os_path模块.py'.rsplit(os.sep ,1 )) #['D:\\Python_Project\\ClassRoom\\day18', 'os_path模块.py']
print(__file__)
print(os.path.dirname(__file__))
print(os.path.dirname(os.path.dirname(__file__)))
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
print(BASE_DIR) #该项目根目录是在执行时，自动获取到当前项目根目录的绝对路径
#案例：项目根目录的应用场景
import sys
sys.path.append(BASE_DIR) #所有导包\导模块都依赖BASE_DIR
print(sys.path)
from part3.abc import new
print(new) #<module 'part5.abc.new' from 'D:/Python_Project/ClassRoom\\part5\\abc\\new.py'>
from part5.x import y
print(y.x)
from part5 import mm
print(mm.mmmm)
from mm import mmmm
print(mmmm)
part1_path = os.path.join(BASE_DIR,'part1') #BASE_DIR + os.sep + 'part1'
sys.path.append(part1_path)
part3_path = os.path.join(BASE_DIR,'part3')
sys.path.append(part3_path)
print(sys.path)
#最后一级名称
print(os.path.basename('D:/Python_Project/ClassRoom/day18/os_path模块.py')) #os_path模块.py
#路劲拼接：
new_path = os.path.join(BASE_DIR,'part3','abc','new.py')
print(new_path) #D:/Python_Project/ClassRoom\part3\abc\new.py
"""
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path)
"""
print(os.path.exists(new_path)) #是否存在
print(os.path.isabs(new_path)) #是否绝对路径
print(os.path.exists('abc'))
print(os.path.isabs('abc'))
print(os.path.isfile(new_path)) #是否是文件
print(os.path.isdir(new_path)) #是否是路径
print(os.path.isfile('abc'))
print(os.path.isdir('abc'))
print(__file__)
file_path = 'D:/Python_Project/ClassRoom/day18/os_path模块.py'
print(os.path.getctime(file_path))
print(os.path.getatime(file_path)) #最后存储时间
print(os.path.getmtime(file_path)) #最后修改时间
'''
1557230709.9831052
1557233680.8510375 #修改了文件会进行更新
1557233680.8540661
'''
print(os.path.normcase('D:/Python_Project/\ClassRoom/day18/os_path模块.py')) #d:\python_project\\classroom\day18\os_path模块.py
print(os.path.normpath('D:/Python_Project/ClassRoom/day18/..')) #D:\Python_Project\ClassRoom
九，os案例 ：
'''将part5下的mm.py移动到part6下abc文件中'''
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def move_file(file,folder):
#如果文件不存在或不是文件文件
if not (os.path.exists(file) and os.path.isfile(file)):
print('文件不存在或不是文件')
return False
#如果文件不存在则创建文件
if not os.path.exists(folder):
os.makedirs(folder)
#提取part5中的mm.py文件
file_name = os.path.split(file)[1]
#第二种方式提取 file_name = os.path.basename(file)
print(file_name) #mm.py
#将提取出来的mm.py文件添加到part6\abc中
new_file = os.path.join(folder,file_name)
print(new_file) #D:/Python_Project/ClassRoom\part6\abc\mm.py
#打开文件提取内容
with open(file,'rb')as r,open(new_file,'wb')as w:
for line in r:
w.write(line)
#将part5中的mm.py 删除
os.remove(file)
file = os.path.join(BASE_DIR,'part5','mm.py')
print(file) #D:/Python_Project/ClassRoom\part5\mm.py
folder = os.path.join(BASE_DIR,'part6','abc')
print(folder) #D:/Python_Project/ClassRoom\part6\abc
# move_file(file,folder)
'''递归删除的思路'''
def delete_dir(folder):
for path in os.listdir(folder):
# 如果path是文件夹 delete_dir(path)
# 如果是文件os.remove(path)
pass
# for走完了代表folder内部删空了，可以删folder
'''#遍历打印目标路径中所有的txt文件'''
def print_txt(folder):
#判断文件是否存在，是否是文件
if not (os.path.exists(folder) or os.path.isfile(folder)):
print('文件不存在或不是文件')
return
#循环遍历文件下的目录
for path in os.listdir(folder):
#将文件名循环出来添加到D:/Python_Project/ClassRoom\part6后面
file_path = os.path.join(folder,path)
print(file_path) #D:/Python_Project/ClassRoom\part6\a\b
#如果是文件并且以.txt结尾的，就输出
if os.path.isfile(file_path) and file_path.endswith('.txt'):
print(path)
#如果是文件继续循环
elif os.path.isdir(file_path):
print_txt(file_path) #递归调用自己
target_path = os.path.join(BASE_DIR,'part6')
# print(target_path) #D:/Python_Project/ClassRoom\part6
print_txt(target_path)
十 , 作业
'''
1.创建一个函数，该函数可以实现查找指定目录下指定文件后缀的文件，最终返回存放该目录及子目录下所有满足需求文件绝对路径的列表
def find_file(abs_path, suffix):
:param abs_path: 目标目录，绝对路径，str类型数据
:param suffix: 文件后缀，str类型数据
:return: 装有所有目录及子目录下满足文件后缀文件的列表
注：文件夹用abc.txt来命名也是合法的，但是不是文件
'''''
import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def find_file(abs_path, suffix,ls = []):
#判断文件是否存在或是否是文件
if not(os.path.exists(abs_path) or os.path.isfile(abs_path)):
print('文件不存在或不是文件')
return ls
#读取该文件中所有目录
for path in os.listdir(abs_path):
file_path = os.path.join(abs_path,path) #添加到abs_path路径中
#如果是文件并且以suffix结尾的，就添加到列表中
if os.path.isfile(file_path) and file_path.endswith(suffix):
ls.append(path)
#如果是文件就继续循环读取
else:
find_file(file_path,suffix)
return ls
path = os.path.join(BASE_DIR,'part6')
res = find_file(path,'.txt')
print(res)
'''
2.删除目标目录
def delete_path(abs_path):
:param abs_path: 要删除的目录路径
:return: 删除成功与否
分析：
1）如果是文件，直接删除
2）如果是文件夹，就进入，然后删除里面的所有子资源，删除成功后，出来就可以删除文件夹了
if os.path.isdir(path):
# 用递归再进入，把path作为目标路径删除
# 上一步走完了，就可以删除该文件夹了
3）除了2）的方式，也可以把所有所有文件全部删除，那么就全部是空文件夹，可以一次性删除所有空文件夹
'''
def delete_path(abs_path):
#判断文件是否为空
if not os.path.exists(abs_path):
print('文件不存在')
return False
#判断是否是文件
if os.path.isfile(abs_path):
os.remove(abs_path)
return True
#循环文件
for path in os.listdir(abs_path):
#添加路径到abs_path中
new_file = os.path.join(abs_path,path)
#判断是否是文件
if os.path.isfile(new_file):
os.remove(new_file)
#递归
else:
delete_path(new_file)
#走完了删除最后的空文件
os.rmdir(abs_path)
p = os.path.join(BASE_DIR,'part7')
res = delete_path(p)
print(res)
十一，项目开发分析：
'''
1.调研
2.需求分析
3.架构师完成项目demo，完成项目架构
4.分工
5.写代码
6.白盒黑盒测试
7.项目审核发布 => 项目 -> 产品
'''
'''
bin: 可执行文件，入口，入口也可以放在项目根目录下
core: 核心代码
db：数据库相关文件
interface：接口
lib：包、模块、第三方文件夹
log：日志
setting：配置
static：静态文件
'''
'''
os翻译过来就是操作系统,os模块提供了与操作系统打交道需要用到的函数,
那我们什么时候需要与操作系统打交道呢?
在操作系统中,我们最最常用的操作就是,对文件及文件夹的操作, 所以 当你需要操作文件时,就应该想到os模块了
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 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
''''' import os print(os.sep) #\
print(os.linesep)
print(os.name) #nt
print(os.pathsep) #;
print(os.environ) os.mkdir('abc') #在当前文件所在路径下创建abc文件夹，如果文件存在会报错
os.mkdir('D:\\abc') #就是在指定的绝对路径下创建abc文件夹 os.mkdir('a/b/c') #a,b必须提前存在，c不能存在
os.makedirs(r'a\b\c') #a,b存在与否都可以，c不能存在 os.rename('abc','aaa') #修改文件名
print(os.getcwd()) #获取工作目录 D:\Python_Project\ClassRoom\day18 os.rmdir('aaa') #删除单层空文件
os.removedirs('a/b/c') #删除多层空文件
os.remove('aa/1.py') #删除指定文件 print(os.listdir('D:\Python_Project\ClassRoom\day18')) #输入当前目录下的目录 ['a', 'abc', 'calendar模块.py', 'datetime模块.py', 'os模块.py', 'part5', 'sys模块.py', 'time模块.py']
"""
该模块用于处理路径,我们知道python是一门跨平台的语言,二每种操作系统,文件路径是截然不同的,为了使程序可以在不同平台生正确运行,
python提供了该模块,使用该模块可以实现路径在不同品台下的自动转换,从而实现跨平台
今后只要涉及到文件或文件夹路径,就应该使用该模块
提供的函数:
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
"""""
import os print(__file__) #当前执行文件路径 D:/Python_Project/ClassRoom/day18/os_path模块.py res = os.path.abspath('D://Python_Project/\ClassRoom/day18//os_path模块.py') #规范化
print(res) res = os.path.split('D:/Python_Project/ClassRoom/day18/os_path模块.py')
print(res,res[1]) #('D:/Python_Project/ClassRoom/day18', 'os_path模块.py') os_path模块.py print(r'D:\Python_Project\ClassRoom\day18\os_path模块.py'.rsplit(os.sep ,1 )) #['D:\\Python_Project\\ClassRoom\\day18', 'os_path模块.py'] print(__file__)
print(os.path.dirname(__file__))
print(os.path.dirname(os.path.dirname(__file__))) BASE_DIR = os.path.dirname(os.path.dirname(__file__))
print(BASE_DIR) #该项目根目录是在执行时，自动获取到当前项目根目录的绝对路径
#案例：项目根目录的应用场景
import sys
sys.path.append(BASE_DIR) #所有导包\导模块都依赖BASE_DIR
print(sys.path) from part3.abc import new
print(new) #<module 'part5.abc.new' from 'D:/Python_Project/ClassRoom\\part5\\abc\\new.py'> from part5.x import y
print(y.x) from part5 import mm
print(mm.mmmm) from mm import mmmm
print(mmmm)
part1_path = os.path.join(BASE_DIR,'part1') #BASE_DIR + os.sep + 'part1'
sys.path.append(part1_path)
part3_path = os.path.join(BASE_DIR,'part3')
sys.path.append(part3_path)
print(sys.path) #最后一级名称
print(os.path.basename('D:/Python_Project/ClassRoom/day18/os_path模块.py')) #os_path模块.py #路劲拼接：
new_path = os.path.join(BASE_DIR,'part3','abc','new.py')
print(new_path) #D:/Python_Project/ClassRoom\part3\abc\new.py """
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path)
""" print(os.path.exists(new_path)) #是否存在
print(os.path.isabs(new_path)) #是否绝对路径 print(os.path.exists('abc'))
print(os.path.isabs('abc')) print(os.path.isfile(new_path)) #是否是文件
print(os.path.isdir(new_path)) #是否是路径 print(os.path.isfile('abc'))
print(os.path.isdir('abc')) print(__file__)
file_path = 'D:/Python_Project/ClassRoom/day18/os_path模块.py'
print(os.path.getctime(file_path))
print(os.path.getatime(file_path)) #最后存储时间
print(os.path.getmtime(file_path)) #最后修改时间 '''
1557230709.9831052
1557233680.8510375 #修改了文件会进行更新
1557233680.8540661
''' print(os.path.normcase('D:/Python_Project/\ClassRoom/day18/os_path模块.py')) #d:\python_project\\classroom\day18\os_path模块.py
print(os.path.normpath('D:/Python_Project/ClassRoom/day18/..')) #D:\Python_Project\ClassRoom
九，os案例 ：
'''将part5下的mm.py移动到part6下abc文件中'''
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def move_file(file,folder):
#如果文件不存在或不是文件文件
if not (os.path.exists(file) and os.path.isfile(file)):
print('文件不存在或不是文件')
return False
#如果文件不存在则创建文件
if not os.path.exists(folder):
os.makedirs(folder)
#提取part5中的mm.py文件
file_name = os.path.split(file)[1]
#第二种方式提取 file_name = os.path.basename(file)
print(file_name) #mm.py
#将提取出来的mm.py文件添加到part6\abc中
new_file = os.path.join(folder,file_name)
print(new_file) #D:/Python_Project/ClassRoom\part6\abc\mm.py
#打开文件提取内容
with open(file,'rb')as r,open(new_file,'wb')as w:
for line in r:
w.write(line)
#将part5中的mm.py 删除
os.remove(file)
file = os.path.join(BASE_DIR,'part5','mm.py')
print(file) #D:/Python_Project/ClassRoom\part5\mm.py
folder = os.path.join(BASE_DIR,'part6','abc')
print(folder) #D:/Python_Project/ClassRoom\part6\abc
# move_file(file,folder)
'''递归删除的思路'''
def delete_dir(folder):
for path in os.listdir(folder):
# 如果path是文件夹 delete_dir(path)
# 如果是文件os.remove(path)
pass
# for走完了代表folder内部删空了，可以删folder
'''#遍历打印目标路径中所有的txt文件'''
def print_txt(folder):
#判断文件是否存在，是否是文件
if not (os.path.exists(folder) or os.path.isfile(folder)):
print('文件不存在或不是文件')
return
#循环遍历文件下的目录
for path in os.listdir(folder):
#将文件名循环出来添加到D:/Python_Project/ClassRoom\part6后面
file_path = os.path.join(folder,path)
print(file_path) #D:/Python_Project/ClassRoom\part6\a\b
#如果是文件并且以.txt结尾的，就输出
if os.path.isfile(file_path) and file_path.endswith('.txt'):
print(path)
#如果是文件继续循环
elif os.path.isdir(file_path):
print_txt(file_path) #递归调用自己
target_path = os.path.join(BASE_DIR,'part6')
# print(target_path) #D:/Python_Project/ClassRoom\part6
print_txt(target_path)
十 , 作业
'''
1.创建一个函数，该函数可以实现查找指定目录下指定文件后缀的文件，最终返回存放该目录及子目录下所有满足需求文件绝对路径的列表
def find_file(abs_path, suffix):
:param abs_path: 目标目录，绝对路径，str类型数据
:param suffix: 文件后缀，str类型数据
:return: 装有所有目录及子目录下满足文件后缀文件的列表
注：文件夹用abc.txt来命名也是合法的，但是不是文件
'''''
import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def find_file(abs_path, suffix,ls = []):
#判断文件是否存在或是否是文件
if not(os.path.exists(abs_path) or os.path.isfile(abs_path)):
print('文件不存在或不是文件')
return ls
#读取该文件中所有目录
for path in os.listdir(abs_path):
file_path = os.path.join(abs_path,path) #添加到abs_path路径中
#如果是文件并且以suffix结尾的，就添加到列表中
if os.path.isfile(file_path) and file_path.endswith(suffix):
ls.append(path)
#如果是文件就继续循环读取
else:
find_file(file_path,suffix)
return ls
path = os.path.join(BASE_DIR,'part6')
res = find_file(path,'.txt')
print(res)
'''
2.删除目标目录
def delete_path(abs_path):
:param abs_path: 要删除的目录路径
:return: 删除成功与否
分析：
1）如果是文件，直接删除
2）如果是文件夹，就进入，然后删除里面的所有子资源，删除成功后，出来就可以删除文件夹了
if os.path.isdir(path):
# 用递归再进入，把path作为目标路径删除
# 上一步走完了，就可以删除该文件夹了
3）除了2）的方式，也可以把所有所有文件全部删除，那么就全部是空文件夹，可以一次性删除所有空文件夹
'''
def delete_path(abs_path):
#判断文件是否为空
if not os.path.exists(abs_path):
print('文件不存在')
return False
#判断是否是文件
if os.path.isfile(abs_path):
os.remove(abs_path)
return True
#循环文件
for path in os.listdir(abs_path):
#添加路径到abs_path中
new_file = os.path.join(abs_path,path)
#判断是否是文件
if os.path.isfile(new_file):
os.remove(new_file)
#递归
else:
delete_path(new_file)
#走完了删除最后的空文件
os.rmdir(abs_path)
p = os.path.join(BASE_DIR,'part7')
res = delete_path(p)
print(res)
十一，项目开发分析：
'''
1.调研
2.需求分析
3.架构师完成项目demo，完成项目架构
4.分工
5.写代码
6.白盒黑盒测试
7.项目审核发布 => 项目 -> 产品
'''
'''
bin: 可执行文件，入口，入口也可以放在项目根目录下
core: 核心代码
db：数据库相关文件
interface：接口
lib：包、模块、第三方文件夹
log：日志
setting：配置
static：静态文件
'''
'''将part5下的mm.py移动到part6下abc文件中'''
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR) def move_file(file,folder):
#如果文件不存在或不是文件文件
if not (os.path.exists(file) and os.path.isfile(file)):
print('文件不存在或不是文件')
return False
#如果文件不存在则创建文件
if not os.path.exists(folder):
os.makedirs(folder) #提取part5中的mm.py文件
file_name = os.path.split(file)[1]
#第二种方式提取 file_name = os.path.basename(file)
print(file_name) #mm.py #将提取出来的mm.py文件添加到part6\abc中
new_file = os.path.join(folder,file_name)
print(new_file) #D:/Python_Project/ClassRoom\part6\abc\mm.py #打开文件提取内容
with open(file,'rb')as r,open(new_file,'wb')as w:
for line in r:
w.write(line) #将part5中的mm.py 删除
os.remove(file) file = os.path.join(BASE_DIR,'part5','mm.py')
print(file) #D:/Python_Project/ClassRoom\part5\mm.py
folder = os.path.join(BASE_DIR,'part6','abc')
print(folder) #D:/Python_Project/ClassRoom\part6\abc
# move_file(file,folder) '''递归删除的思路'''
def delete_dir(folder):
for path in os.listdir(folder):
# 如果path是文件夹 delete_dir(path)
# 如果是文件os.remove(path)
pass
# for走完了代表folder内部删空了，可以删folder '''#遍历打印目标路径中所有的txt文件'''
def print_txt(folder):
#判断文件是否存在，是否是文件
if not (os.path.exists(folder) or os.path.isfile(folder)):
print('文件不存在或不是文件')
return #循环遍历文件下的目录
for path in os.listdir(folder): #将文件名循环出来添加到D:/Python_Project/ClassRoom\part6后面
file_path = os.path.join(folder,path)
print(file_path) #D:/Python_Project/ClassRoom\part6\a\b #如果是文件并且以.txt结尾的，就输出
if os.path.isfile(file_path) and file_path.endswith('.txt'):
print(path) #如果是文件继续循环
elif os.path.isdir(file_path):
print_txt(file_path) #递归调用自己 target_path = os.path.join(BASE_DIR,'part6')
# print(target_path) #D:/Python_Project/ClassRoom\part6
print_txt(target_path)
'''
1.创建一个函数，该函数可以实现查找指定目录下指定文件后缀的文件，最终返回存放该目录及子目录下所有满足需求文件绝对路径的列表
def find_file(abs_path, suffix):
:param abs_path: 目标目录，绝对路径，str类型数据
:param suffix: 文件后缀，str类型数据
:return: 装有所有目录及子目录下满足文件后缀文件的列表
注：文件夹用abc.txt来命名也是合法的，但是不是文件
'''''
import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR) def find_file(abs_path, suffix,ls = []):
#判断文件是否存在或是否是文件
if not(os.path.exists(abs_path) or os.path.isfile(abs_path)):
print('文件不存在或不是文件')
return ls #读取该文件中所有目录
for path in os.listdir(abs_path):
file_path = os.path.join(abs_path,path) #添加到abs_path路径中 #如果是文件并且以suffix结尾的，就添加到列表中
if os.path.isfile(file_path) and file_path.endswith(suffix):
ls.append(path)
#如果是文件就继续循环读取
else:
find_file(file_path,suffix)
return ls path = os.path.join(BASE_DIR,'part6')
res = find_file(path,'.txt')
print(res) '''
2.删除目标目录
def delete_path(abs_path):
:param abs_path: 要删除的目录路径
:return: 删除成功与否 分析：
1）如果是文件，直接删除
2）如果是文件夹，就进入，然后删除里面的所有子资源，删除成功后，出来就可以删除文件夹了
if os.path.isdir(path):
# 用递归再进入，把path作为目标路径删除
# 上一步走完了，就可以删除该文件夹了
3）除了2）的方式，也可以把所有所有文件全部删除，那么就全部是空文件夹，可以一次性删除所有空文件夹
'''
def delete_path(abs_path):
#判断文件是否为空
if not os.path.exists(abs_path):
print('文件不存在')
return False #判断是否是文件
if os.path.isfile(abs_path):
os.remove(abs_path)
return True #循环文件
for path in os.listdir(abs_path):
#添加路径到abs_path中
new_file = os.path.join(abs_path,path)
#判断是否是文件
if os.path.isfile(new_file):
os.remove(new_file)
#递归
else:
delete_path(new_file)
#走完了删除最后的空文件
os.rmdir(abs_path) p = os.path.join(BASE_DIR,'part7')
res = delete_path(p)
print(res)
十一，项目开发分析：
'''
1.调研
2.需求分析
3.架构师完成项目demo，完成项目架构
4.分工
5.写代码
6.白盒黑盒测试
7.项目审核发布 => 项目 -> 产品
'''
'''
bin: 可执行文件，入口，入口也可以放在项目根目录下
core: 核心代码
db：数据库相关文件
interface：接口
lib：包、模块、第三方文件夹
log：日志
setting：配置
static：静态文件
'''
'''
1.调研
2.需求分析
3.架构师完成项目demo，完成项目架构
4.分工
5.写代码
6.白盒黑盒测试
7.项目审核发布 => 项目 -> 产品
''' '''
bin: 可执行文件，入口，入口也可以放在项目根目录下
core: 核心代码
db：数据库相关文件
interface：接口
lib：包、模块、第三方文件夹
log：日志
setting：配置
static：静态文件
'''
