Python(10)文件操作(IO 技术)、OS模块、递归

文件操作(IO 技术)

一个完整的程序一般都包括数据的存储和读取；我们在前面写的程序数据都没有进行实际的存储，因此 python 解释器执行完数据就消失了。实际开发中，我们经常需要从外部存储介质（硬盘、光盘、U 盘等）读取数据，或者将程序产生的数据存储到文件中，实现“持久化”保存。 有基础的同学知道，很多软件系统是将数据存储的数据库中；数据库实际也是基于文件形式存储的

文本文件和二进制文件

按文件中数据组织形式，我们把文件分为文本文件和二进制文件两大类。

1. 文本文件
   文本文件存储的是普通“字符”文本，python 默认为 unicode 字符集（两个字节表示一个字符，最多可以表示：65536 个），可以使用记事本程序打开。但是像 word 软件编辑的文档不是文本文件。
2. 二进制文件
   二进制文件把数据内容用“字节”进行存储，无法用记事本打开。必须使用专用的软件解码。常见的有：MP4 视频文件、MP3 音频文件、JPG 图片、doc 文档等等。

文件操作相关模块概述

Python 标准库中，如下是文件操作相关的模块:

创建文件对象 open()

open()函数用于创建文件对象，基本语法格式如下：
open(文件名[,打开方式])

如果只是文件名，代表在当前目录下的文件。文件名可以录入全路径，比如：D:\a\b.txt。为了减少“\”的输入，可以使用原始字符串：r“d:\b.txt”。示例如下： f = open(r"d:\b.txt",“w”)
打开方式有如下几种：

文本文件对象和二进制文件对象的创建： 如果我们没有增加模式“b”，则默认创建的是文本文件对象，处理的基本单元是“字符”。如果是二进制模式“b”，则创建的是二进制文件对象，处理的基本单元是“字节”。

基本的文件写入操作

文本文件的写入一般就是三个步骤： 1. 创建文件对象 2. 写入数据 3. 关闭文件对象

f=open(r"a.txt",'a')
f.write("天天向上")
f.close()

常用编码介绍

在操作文本文件时，经常会操作中文，这时候就经常会碰到乱码问题。为了让大家有能力解 决中文乱码问题，这里简单介绍一下各种编码之间的关系。 常用编码之间的关系如下：

ASCII

全称为 American Standard Code for Information Interchange，美国信 息交换标准代码，这是世界上最早最通用的单字节编码系统，主要用来显示现代 英语及其他西欧语言。 ASCII 码用 7 位表示，只能表示 128 个字符。只定义了 27=128 个字符，用 7bit 即可完全编码，而一字节 8bit 的容量是 256，所以一字节 ASCII 的编码最 高位总是 0。 0～31 表示控制字符如回车、退格、删除等；32～126 表示打印字符即可以 通过键盘输入并且能显示出来的字符；其中 48～57 为 0 到 9 十个阿拉伯数字， 65～90 为 26 个大写英文字母，97～122 号为 26 个小写英文字母，其余为一 些标点符号、运算符号等，具体可以参考 ASCII 标准表（大家自行百度，不在此赘述）。

ISO8859-1

ISO-8859-1 又称 Latin-1，是一个 8 位单字节字符集，它把 ASCII 的最高 位也利用起来，并兼容了 ASCII，新增的空间是 128，但它并没有完全用完。 在 ASCII 编码之上又增加了西欧语言、希腊语、泰语、阿拉伯语、希伯来语 对应的文字符号，它是向下兼容 ASCII 编码 。

GB2312

GB2312 全称为信息交换用汉字编码字符集，是中国于 1980 年发布，主要用于计算机系统中的汉字处理。GB2312 主要收录了 6763 个汉字、682 个符号。 GB2312覆盖了汉字的大部分使用率，但不能处理像古汉语等特殊的罕用字， 所以后来出现了像 GBK、GB18030 这种编码。 GB2312 完全兼容 ISO8859-1。

GBK

GBK全称为 Chinese Internal Code Specification，即汉字内码扩展规范，于 1995 年制定。 它主要是扩展了 GB2312，在它的基础上又加了更多的汉字，它一共收录了 21003 个汉字

GB18030

GB18030是现在最新的内码字集，于 2000 年发布，并于 2001 年强制执行，包含了中国大部分少数 民族的语言字符，收录汉字数超过 70000 余个。 它主要采用单字节、双字节、四字节对字符编码，它是向下兼容 GB2312 和 GBK 的， 虽然是我国的强制使用标准，但在实际生产中很少用到，用得最多的反而是 GBK 和 GB2312

Unicode

Unicode 编码设计成了固定两个字节，所有的字符都用 16 位(2^16=65536) 表示，包括之前只占 8 位的英文字符等，所以会造成空间的浪费，Unicode在很长的一段时间内都没有得到推广应用。Unicode 完全重新设计，不兼容 iso8859-1，也不兼容任何其他编码。

UTF-8

对于英文字母，unicode 也需要两个字节来表示。所以 unicode 不便 于传输和存储。因此而产生了 UTF 编码，UTF-8 全称是（8-bit Unicode Transformation Format）。 UTF 编码兼容 iso8859-1 编码，同时也可以用来表示所有语言的字符， 不过，UTF 编码是不定长编码，每一个字符的长度从 1-4 个字节不等。其中， 英文字母都是用一个字节表示，而汉字使用三个字节。

一般项目都会使用 UTF-8。unicode 中虽然汉字是两个字节， UTF-8 中汉字是 3 个字节。但是互联网中一个网页也包含了大量的英文字母， 这些英文字母只占用 1 个字节，整体占用空间，UTF-8 仍然优于 Unicode。

中文乱码问题

windows 操作系统默认的编码是 GBK，Linux 操作系统默认的编码是 UTF-8。Python程序默认的编码是Unicode。当我们用 open()时，调用的是操作系统打开的文件，默认的编码是 GBK。

f=open(r"a.txt",'a')#a.txt中默认的编码是 GBK，中文会出现乱码
f.write("天天向上")
f.close()

f=open(r"a.txt",'a',encoding='utf-8') #通过指定文件编码解决中文乱码问题。
f.write("天天向上")
f.close()

write()/writelines()写入数据

write(a)：把字符串 a 写入到文件中
writelines(b)：把字符串列表写入文件中，不换行，若需要换行自己添加换行符

f=open(r'aaa.txt','a')
f.write("hello")
f.writelines(['cat','dog','fish','\n'])
f.writelines(['cat\n','dog\n','fish\n'])
f.close()
'''result:
hellocatdogfish
cat
dog
fish
'''

close()关闭文件流

由于文件底层是由操作系统os控制，所以我们打开的文件对象必须显式调用 close()方法关闭文件对象。当调用 close()方法时，首先会把缓冲区数据写入文件(也可以直接调用 flush() 方法)，再关闭文件，释放文件对象。 为了确保无论何种情况都能关闭打开的文件对象，一般结合异常机制的 finally 或者 with 关键字实现（因为如果不采用异常机制，当close()前面的代码出现问题时候，程序就不往后运行了，无法关闭文件流）。

try:
    f = open(r"c.txt","w")
    strs = ["aa\n","bb\n","cc\n"]
    f.writelines(strs)
except BaseException as e:
    print(e)
finally:
    f.close()

with 语句(上下文管理器)

with 关键字（上下文管理器）可以自动管理上下文资源，不论什么原因跳出 with 块，都能确保文件正确的关闭，并且可以在代码块执行完毕后自动还原进入该代码块时的现场。常用！

with open(r'b.txt','a') as f:
		f.write('yuan')

文本文件的读取

文件的读取一般使用如下三个方法：

1. read([size]) 从文件中读取 size 个字符，并作为结果返回。如果没有 size 参数，则读取整个文件。 读取到文件末尾，会返回空字符串。
2. readline() 读取一行内容作为结果返回。读取到文件末尾，会返回空字符串。
3. readlines() 文本文件中，每一行作为一个字符串存入列表中，返回该列表

读取一个文件前 4 个字符:

with open(r'e.txt','r') as f:
		print(f.read(4))

文件较小，一次将文件内容读入到程序中:

with open(r"d:\bb.txt","r") as f: 
		print(f.read())

按行读取一个文件:

with open(r"bb.txt","r") as f: 
		while True: 
			fragment = f.readline() 
			if not fragment: 
				break 
			else:
				print(fragment,end="")

使用迭代器（每次返回一行）读取文本文件(常用):

with open(r"d:\bb.txt","r") as f: 
	for a in f: 
		print(a,end="")

enumerate()为文本文件每一行增加行号

小测试：

#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
a=['aaa\n','bbb\n','ccc\n','一\n']
b=enumerate(a)
print(b is enumerate(a))
print(b==enumerate(a))
print("###enumerate(a):####")
print(enumerate(a))#enumerate(a)的value
print(list(enumerate(a)))
print(id(enumerate(a)))

print("###b:####")
print(b) #b的value
print(list(b)) #序列号和对应的字符串以元组的形式存储
print(id(b))

c=[line.rstrip()+'#'+ str(index) for index,line in enumerate(a)]#line.rstrip()用于去除“\n”
print("\nc:",c)
'''result:
False
False
###enumerate(a):####
<enumerate object at 0x000001CE22A52A48>
[(0, 'aaa\n'), (1, 'bbb\n'), (2, 'ccc\n'), (3, '一\n')]
1984856140360
###b:####
<enumerate object at 0x000001CE22A14F98>
[(0, 'aaa\n'), (1, 'bbb\n'), (2, 'ccc\n'), (3, '一\n')]
1984855887768

c: ['aaa#0', 'bbb#1', 'ccc#2', '一#3']

Process finished with exit code 0
'''

打开文本文件并用enumerate()为文本文件每一行增加行号：

with open(r"e.txt",'r',encoding='utf-8') as f:
    lines=f.readlines()
    print(lines)
    lines=[line.rstrip()+'#'+str(index) for index,line  in  enumerate(lines)]#推导式生成列表
    print(lines)

with open (r'e.txt','w',encoding='utf-8') as f: #写进去
    f.writelines(lines)
'''result:
['aaa\n', 'bbb\n', '好好学习\n']
['aaa#0', 'bbb#1', '好好学习#2']
####运行后e.txt的内容为：
aaa#0bbb#1好好学习#2
'''

二进制文件的读取和写入

二进制文件的处理流程和文本文件流程一致。首先还是要创建文件对象，不过，我们需要指 定二进制模式，从而创建出二进制文件对象。例如：

f = open(r"d:\a.txt", 'wb') #可写的、重写模式的二进制文件对象 
f = open(r"d:\a.txt", 'ab') #可写的、追加模式的二进制文件对象 
f = open(r"d:\a.txt", 'rb') #可读的二进制文件对象

不加‘b’默认处理文本文件。
创建好二进制文件对象后，仍然可以使用 write()、read()实现文件的读写操作。

with open("aa.gif","rb") as f:
    with open("aa_copy.gif","wb") as w:
        for l in f.readlines():
            w.write(l)

print("图片拷贝完成.........")

文件对象的常用属性和方法

文件对象封装了文件相关的操作。在前面我们学习了通过文件对象对文件进行读写操作。本节我们详细列出文件对象的常用属性和方法，并进行说明：

文件任意位置操作

with open("e.txt","r",encoding="utf-8") as f:
    print("文件名是：{0}".format(f.name))
    print(f.tell())
    print("读取一行的内容：{0}".format(str(f.readline())))
    print(f.tell())
    f.seek(0)
    print("读取的内容：{0}".format(str(f.read())))
    print(f.tell())
'''result:
文件名是：e.txt
0
读取一行的内容：aaa #1

8
读取的内容：aaa #1
bbb #2
好好学习 #3

33
'''

使用 pickle 序列化

Python 中，一切皆对象，对象本质上就是一个“存储数据的内存块”。有时候，我们 需要将“内存块的数据”保存到硬盘上，或者通过网络传输到其他的计算机上。这时候，就 需要“对象的序列化和反序列化”。 对象的序列化机制广泛的应用在分布式、并行系统上。 序列化指的是：将对象转化成“串行化”数据形式，存储到硬盘或通过网络传输到其他 地方。反序列化是指相反的过程，将读取到的“串行化数据”转化成对象。 我们可以使用 pickle 模块中的函数，实现序列化和反序列操作。
序列化我们使用：
pickle.dump(obj, file) obj 就是要被序列化的对象，file 指的是存储的文件
pickle.load(file) 从 file 读取数据，反序列化成对象

import pickle

a1 = "yuan"
a2 = 9785
a3 = [10,20,30,40]

with open("data.abc","wb") as f: # 后缀是什么无所谓。  操作二进制文件
    pickle.dump(a1,f)
    pickle.dump(a2,f)
    pickle.dump(a3,f)

with open("data.abc","rb") as f:
    b1 = pickle.load(f);b2 = pickle.load(f);b3 = pickle.load(f)
    print(b1);print(b2);print(b3) #放的时候是a123的顺序，取得时候也是a123的顺序

    print(id(a1));print(id(b1))
'''result:
yuan
9785
[10, 20, 30, 40]
2101511228080
2101513705008
'''

CSV 文件的操作

csv(Comma Separated Values)是逗号分隔符文本格式，常用于数据交换、Excel 文件和数据库数据的导入和导出。与 Excel 文件不同，CSV 文件中： 值没有类型，所有值都是字符串， 不能指定字体颜色等样式 ，不能指定单元格的宽高，不能合并单元格，没有多个工作表 ，不能嵌入图像图表。Python 标准库的模块 csv 提供了读取和写入 csv 格式文件的对象。我们在 excel 中建立一个简单的表格：

另存为"csv(逗号分隔)"，我们用记事本打开查看这个 csv 文件内容：
ID,姓名,年龄,爱好
1001,王一宝,24,摩托
1002,王甜甜,18,滑板
1003,季向空,23,电竞

csv.reader 对象于从 csv 文件读取数据：

#测试CSV文件的读取和写入
import csv
with open("dd.csv","r") as f:
    a_csv = csv.reader(f) #创建 csv 对象,它是一个包含所有数据的列表，每一行为一个元素
    print((a_csv))
    print（list（a_csv））
'''result:
<_csv.reader object at 0x000002B2F4C5B6D8>
[['ID', '姓名', '年龄', '爱好'], ['1001', '王一宝', '24', '摩托'], ['1002', '王甜甜', '18', '滑板'], ['1003', '季向空', '23', '电竞']]
'''

import csv

with open("dd.csv","r") as f:
    a_csv = csv.reader(f) #创建 csv 对象,它是一个包含所有数据的列表，每一行为一个元素
    print((a_csv))
    #print(list(a_csv)) #如果加上这个的话，打印以后指针已经在列表的最后了，后面运行for row...时就无法打印，结果和上面那段代码一样
    for row in a_csv: 
        print(row)
'''result:
<_csv.reader object at 0x000001F5CEB0B6D8>
['ID', '姓名', '年龄', '爱好']
['1001', '王一宝', '24', '摩托']
['1002', '王甜甜', '18', '滑板']
['1003', '季向空', '23', '电竞']
'''

csv.writer 对象写一个 csv 文件

import csv
with open("ee.csv","w") as f:
    b_csv = csv.writer(f) #此时ee.csv的原内容已经被清空  #创建 csv 对象
    b_csv.writerow(["ID", "姓名", "爱好"]) #写入一行
    b_csv.writerow(["1001", "小绿", "滑板"])

    c = [["1002", "小蓝", "摩托"], ["1003", "小紫", "悠悠球"]]
    b_csv.writerows(c) #写入多行
'''result:
ee.csv的内容如下：
ID,姓名,爱好

1001,小绿,滑板

1002,小蓝,摩托

1003,小紫,悠悠球

'''

os模块

os 模块可以帮助我们直接对操作系统进行操作。我们可以直接调用操作系统的可执行文件、命令，直接操作文件、目录等等。在系统运维的核心基础。

os.system

os.system 可以帮助我们直接调用系统的命令

import os 
os.system("notepad.exe")#打开记事本
os.system("regedit")#打开注册表
os.system("ping www.baidu.com")#调用 windows 系统中 ping 命令
'''result:
正在 Ping www.a.shifen.com [111.206.223.206] 具有 32 字节的数据: 
来自 111.206.223.206 的回复: 字节=32 时间=9ms TTL=56 
来自 111.206.223.206 的回复: 字节=32 时间=7ms TTL=56 
来自 111.206.223.206 的回复: 字节=32 时间=6ms TTL=56 
来自 111.206.223.206 的回复: 字节=32 时间=9ms TTL=56 
111.206.223.206 的 Ping 统计信息: 
	数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)， 
往返行程的估计时间(以毫秒为单位): 
	最短 = 6ms，最长 = 9ms，平均 = 7ms
'''

os.system(“ping www.baidu.com”)若出现乱码现象，则点击File—Settings—搜索encoding—将Global Encoding改为GBK再运行一下就不会乱码了.
【注】Linux 是命令行操作更容易，我们可以通过 os.system 可以更加容易的调用相关的命令；

直接调用可执行的文件:

import os 
os.startfile(r"C:\Program Files (x86)\Tencent\WeChat\WeChat.exe")

os 模块-文件和目录操作

我们可以通过前面讲的文件对象实现对于文件内容的读写操作。如果，还需要对文件和目录做其他操作，可以使用 os 和 os.path 模块。
os 模块下常用操作文件的方法：

os 模块下关于目录操作的相关方法，汇总如下：

#coding=utf-8
#测试os模块中，关于文件和目录的操作
import os

#############获取文件和文件夹相关的信息################
print(os.name)    #获得操作系统信息 windows->nt    linux和unix->posix
print(os.sep)     #获得当前操作系统所使用的路径分隔符 windows->\     linux和unix->/
print(repr(os.linesep))   #获得当前操作系统所使用换行符 windows->\r\n   linux-->\n\

print(os.stat("my02.py")) #返回文件的所有属性

##############关于工作目录的操作###############
#print(os.getcwd())
#os.chdir("d:")      #改变当前的工作目录为：d:盘根目录
#os.mkdir("书籍")    #在当前工作目录（D盘）中创建一个“书籍”的目录
################创建目录、创建多级目录、删除#############
#os.mkdir("书籍")
#os.rmdir("书籍")   #相对路径都是相对于当前的工作目录

#os.makedirs("电影/港台/周星驰") #相对路径，在当前目录中创建电影/港台/周星驰的目录
#os.removedirs("电影/港台/周星驰")   #只能删除空目录

#os.makedirs("../音乐/香港/刘德华")    #../指的是上一级目录

#os.rename("电影","movie")

dirs = os.listdir("movie") #返回movie目录下的文件和目录列表（只返回儿子辈，不返回孙子辈）
print(dirs)
#############################

os.path 模块

os.path 模块提供了目录相关（路径判断、路径切分、路径连接、文件夹遍历）的操作

#coding=utf-8
#测试os.path中关于目录、路径的操作

import os
import os.path      #from os import path 若是这样的话，下面就不用写os.path....直接写path....就行

############判断：绝对路径、是否目录、是否文件、文件是否存在#############
print(os.path.isabs("d:/a.txt"))
print(os.path.isdir("d:/a.txt"))
print(os.path.isfile("d:/a.txt"))
print(os.path.exists("d:/a.txt"))

##############获得文件基本信息################
print(os.path.getsize("b.txt"))
print(os.path.abspath("b.txt"))
print(os.path.dirname("d:/a.txt")) #若是当前目录，则打印的是空

print(os.path.getctime("b.txt"))#返回创建时间
print(os.path.getatime("b.txt"))#返回最后访问时间
print(os.path.getmtime("b.txt"))#返回最后修改时间

##############对路径的操作#####################
path = os.path.abspath("b.txt") #返回绝对路径
print(os.path.split(path)) #返回一个元组，第一个元素是目录，第二个元素是文件
print(os.path.splitext(path)) #从路径中分割文件的扩展名,返回一个元组：（路径、扩展名）

print(os.path.join("aa","bb","cc"))
'''result:
True
False
False
False
33
D:\Download\2_文件处理\\mypro_io\test_os\b.txt
d:/
1617257555.142514
1617257609.3768897
1545392906.5002
('D:\\Download\\2_文件处理\\mypro_io\\test_os', 'b.txt')
('D:\\Download\\2_文件处理\\mypro_io\\test_os\\b', '.txt')
aa\bb\cc
'''

#coding=utf-8
#列出工作目录下所有的.py文件，并输出文件名

import os

path = os.getcwd()

file_list = os.listdir(path)  #列出子目录、子文件
for filename in file_list:
    if filename.endswith("py"):
        print(filename,end="\t")

print("###############")
file_list2 = [filename for filename in os.listdir(path) if filename.endswith("py") ]
for f in file_list2:
    print(f,end="\t")
'''result:
my01.py	my02.py	my03.py	my04.py	my05.py	###############
my01.py	my02.py	my03.py	my04.py	my05.py	
'''

os.walk()递归遍历所有文件和目录

os.walk()返回一个 3 个元素的元组，(dirpath, dirnames, filenames), dirpath：要列出指定目录的路径 ，dirnames：目录下的所有文件夹， filenames：目录下的所有文件

#coding=utf-8
#测试os.walk()递归遍历所有的子目录和子文件

import os

all_files = []
path = os.getcwd()
list_files = os.walk(path)

for dirpath,dirnames,filenames in list_files:
    for dir in dirnames:
        all_files.append(os.path.join(dirpath,dir))
    for file in filenames:
        all_files.append(os.path.join(dirpath,file))

#打印所有的子目录和子文件
for file in all_files:
    print(file)
'''result:
D:\anaconda3\python.exe D:/Download/2_文件处理/文件处理课程源码和资料/mypro_io/test_os/my05.py
D:\Download\2_文件处理\mypro_io\test_os\movie
D:\Download\2_文件处理\mypro_io\test_os\b.txt
D:\Download\2_文件处理\mypro_io\test_os\my01.py
D:\Download\2_文件处理\mypro_io\test_os\my02.py
D:\Download\2_文件处理\mypro_io\test_os\my03.py
D:\Download\2_文件处理\mypro_io\test_os\my04.py
D:\Download\2_文件处理\mypro_io\test_os\my05.py
D:\Download\2_文件处理\mypro_io\test_os\movie\大陆
D:\Download\2_文件处理\mypro_io\test_os\movie\日本
D:\Download\2_文件处理\mypro_io\test_os\movie\港台
D:\Download\2_文件处理\mypro_io\test_os\movie\港台\周星驰
D:\Download\2_文件处理\mypro_io\test_os\movie\港台\周星驰\功夫.mp4
'''

shutil 模块(拷贝和压缩)

shutil 模块是 python 标准库中提供的，主要用来做文件和文件夹的拷贝、移动、删除等；还可以做文件和文件夹的压缩、解压缩操作。 os 模块提供了对目录或文件的一般操作。shutil 模块作为补充，提供了移动、复制、压缩、解压等操作，这些 os 模块都没有提供。

#coding=utf-8
#测试shutil和zipfile模块的用法：拷贝、压缩、解压缩

import shutil
import zipfile

shutil.copyfile("1.txt","1_copy.txt") #1.txt的内容拷贝给1_copy.txt
shutil.copytree("movie/港台","电影")   #注意："电影"目录不存在时才能正常拷贝
shutil.copytree("movie/港台","电影",ignore=shutil.ignore_patterns("*.txt","*.html")) #将movie/港台下面的内容拷贝到“电影”文件夹下，拷贝时忽略所有.txt和.html文件


#压缩
shutil.make_archive("电影/gg","zip","movie/港台") #压缩完以后压缩包所在的位置和名字，压缩的格式，要进行压缩的东西。即将movie/港台文件夹下的内容压缩到电影文件夹下生成gg.zip

#压缩:将指定的多个文件压缩到一个 zip 文件
z1 = zipfile.ZipFile("d:/a.zip","w")# 生成压缩包。写模式
z1.write("1.txt") #将1.txt放入压缩包中压缩
z1.write("1_copy.txt")
z1.close()

#解压缩
z2 = zipfile.ZipFile("d:/a.zip","r")
z2.extractall("电影") #设置解压的地址
z2.close()

递归算法

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。 利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。
递归结构包括两个部分：
 定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
 递归体。解答：什么时候需要调用自身方法。

#coding=utf-8

#使用递归计算n的阶乘(5!=5*4*3*2*1)

def factorial(n):
    if n==1:
        return n
    else:
        return n*factorial(n-1)


print(factorial(5))
'''result:
120
'''

递归的缺陷:
简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

使用递归算法遍历目录下所有文件：

#coding=utf-8
#递归打印所有的目录和文件

import os

allfiles = []
def getAllFiles(path,level):
    childFiles = os.listdir(path)
    for file in childFiles:
        filepath = os.path.join(path,file)
        if os.path.isdir(filepath):#如果是目录的话，就递归调用，找它的下级子目录
            getAllFiles(filepath,level+1)
        allfiles.append("\t"*level+filepath)


getAllFiles("test_os",0)

for f in reversed(allfiles):
    print(f)
'''result:
test_os\my05.py
test_os\my04.py
test_os\my03.py
test_os\my02.py
test_os\my01.py
test_os\movie
	test_os\movie\港台
		test_os\movie\港台\周星驰
			test_os\movie\港台\周星驰\功夫.mp4
	test_os\movie\日本
	test_os\movie\放牛班的春天.mp4
	test_os\movie\大陆
test_os\b.txt

'''