递归和time

我是python小白

递归
递归调用：一个函数，调用自身，称为递归调用

递归函数：一个会调用自身的函数称为递归函数

方式：

1、写出临界调条件

2、这这一次和上一次的关系

3、假设当前函数已经能用，调用自身计算上一次的结果，在求出本次的结果。

入一个数（大于等于1），求1+2+3+............+n的和

1. def sum(n):
   
2.     if n == 1：
   
3.             return 1
   
4.     else:
   
5.                return n + sum(n-1)
   

复制代码

栈和堆队列
栈：

栈的特点：先进后出

压栈（向栈里存数据）

出栈：在栈里取数据

队列：

队列的特点：先进先出

1. #模拟
   
2. import collections
   
3. #创建一个队列
   
4. queue = collections.deque()
   
5. print(queue)
   
6. #进队
   
7. queue.append("a")
   
8. queue.append("b")
   
9. queue.append("c")
   
10. #出队
    
11. res1 = queue.popleft()
    
12. #这个出的是a
    

复制代码

目录遍历：
递归遍历目录：

1. import os
   
2. 
   
3. def getAllDirRE(path):
   
4.     #得到当前目录下所有文件
   
5.     filesList = os.listdir(path)
   
6.     #处理每个文件
   
7.     for fileName in fileList:
   
8.         #使用绝对路径
   
9.         fileAbsPath = os.path.join(path, fileName)
   
10.         if os.path.isdir(fileAbsPath):
    
11.             print("目录：", fileName)
    
12.             getAllDir(fileAbsPath)
    
13.         else:
    
14.             print("文件", fileName)
    
15. 
    
16. 
    
17. getAllDir(r"c:\user\xlg\t\r\e\s\day\dir")
    

复制代码

"栈模拟递归遍历，（深度遍历）"

1. def getAllDirDE(path):
   
2.     stack = []
   
3.     stack.append(path)
   
4.    
   
5.     #处理栈，当栈为空的时候结束循环
   
6.     while len(stack) != 0:
   
7.         #从栈里取出数据
   
8.         dirPath = stact.pop()
   
9.         #目录下所有文件
   
10.         fileList = os.listdir(dirpath)
    
11.         #处理每一个文件，如果是普通文件则打印出来，如果是目录文件则将该目录的地址压栈
    
12.         for fileName in filesList:
    
13.             filrAbspath = os.path.join（dirpath, fileName)
    
14.                 if os,path.isdir(fileAbsPath):
    
15.                 #目录就压栈
    
16.                 print("目录：", fileName)
    
17.                 stack.append(fileAbsPath)
    
18.             else:
    
19.                 #打印普通文件
    
20.                 print("普通：" + fileName)
    
21.          
    

复制代码

队列模拟递归，广度遍历

1. import os,collections
   
2. 
   
3. def getAllDirQUE(path):
   
4.     queue = cllections.deque()
   
5.     #进队
   
6.     queue.append(path)
   
7.     while len(queue) != 0:
   
8.         #出队数据
   
9.         dirpat = queue.popleft()
   
10.         #找出所有的文件
    
11.         fileList = os.listdir(dirPath)
    
12.         for fielName in fileList:
    
13.             #绝对路径
    
14.             fileAbsPath = os.path.join(dirpath, fileName)
    
15.             if os.path.isdir(fileAbsPath):
    
16.                 print("目录："，fileName)
    
17.                 queue.append(fileAbspath)
    
18.             else:
    
19.                 print("文件：", fileName)
    

复制代码

Time模块
utc世界协调时间：格林尼治天文时间，世界标准时间，在中国来说就是utc+8

DST（夏令时）：是一种节约能源而认为规定时间制度，在夏季调快一小时

时间表示形式：

1.时间轴：以整型或浮点型表示时间的一个以秒为单位的时间间隔，这个时间间隔的基础值是从1970年1月1日，开始算起

2、元组：一种python的整数结构表示，这个元组9个整型内容

ear

onth

ay

ours

inutes

econds

eekday

ulia day

lag(1或-1或0)

3、格式化字符串

|格式|        含义|

-|---|

|  %a  | 本地（locale）简化星期名称|

|  %A  |本地完整星期名称|

|  %b  | 本地简化月份名称|

|  %B  | 本地完整月份名称|

|  %c  | 本地相应的日期和时间表示|

%d  | 一个月中的第几天（01 - 31）|

%H  | 一天中的第几个小时（24 小时制，00 - 23）|

%l  | 一天中的第几个小时（12 小时制，01 - 12）|                     |       |

%j  | 一年中的第几天（001 - 366）|                                  |       |

%m  | 月份（01 - 12）  |                                            |       |

%M  | 分钟数（00 - 59） |                                           |       |

|  %p  | 本地 am 或者 pm 的相应符  |

%S  | 秒（01 - 61）    |

%U  | 一年中的星期数（00 - 53 星期天是一个星期的开始）第一个星期天之前的所有天数都放在第 0 周 | *注3* |

%w  | 一个星期中的第几天（0 - 6，0 是星期天）|

|  %W  | 和 %U 基本相同，不同的是 %W 以星期一为一个星期的开始|

|  %x  | 本地相应日期     |

|  %X  | 本地相应时间  |

%y  | 去掉世纪的年份（00 - 99）    |                                |       |

|  %Y  | 完整的年份  |

%z  | 用 +HHMM 或 -HHMM 表示距离格林威治的时区偏移（H 代表十进制的小时数，M 代表十进制的分钟数） |

|  %Z  | 时区的名字（如果不存在为空字符） |

|  %%  | %号本身   |

1. #返回当前时间戳，浮点数心事，不需要参数
   
2. c = time.time()
   
3. print(c)
   
4. #将时间戳转换utc时间元组
   
5. c = time.gmtime(c)
   
6. #将时间戳转换成本地时间元组
   
7. b =time.localtime(c)
   
8. #将本地时间元祖转成时间戳
   
9. m = time.mktime(b)
   
10. #将时间元组转成字符串
    
11. s = time.asctime(b)
    
12. #将时间戳转为字符串
    
13. p = time.ctime(c)
    
14. #将时间元组转换成给定的字符串，参数2是一个本地时间元组，默认是当前时间
    
15. q = time.strftime("%Y-%m-%d %H:%M:%S",b)
    
16. #将时间字符串转为时间元组
    
17. tome.strptime(q,"%Y-%m-%d %x")
    
18. #延迟一个小时，整型或者浮点型
    
19. time.sleep(4)
    
20. #返回当前程序的cpu执行时间，Unix形式始终返回全部的运算时间，window从第二次开始，都是以第一个调用次函数的开始时间戳作为基数。
    
21. y1 = time.clock()
    
22. time.sleep(2)
    
23. y2 = time.clock()
    
24. print("%d", y2)
    

复制代码

DATAtime
datatime比time高级不少，可以理解为datetieme基于time进行封装提供了更为实用的函数，datetime模块的借口更直观，跟容易调用

模块中的类：

atatime 同时又时间和日期

imedelta 主要用于计算时间跨度

zinfo  时区相关

ime只关注时间

ata只关注日期

1. #获取当前时间
   
2. d1 = datetime.datetime.now()
   
3. #获取指定时间
   
4. d2 = datetime.datetime(1999, 10, 1, 10, 25, 28,11111111)
   
5. #将时间转为字符串
   
6. d3 = d1.strftime('%y-%d %x')
   
7. #将格式化字符串转为datetime对像
   
8. #转换格式要与字符串一致
   
9. d4 = datetime.date.strptime(d3, "%y-%m-%d %x")
   
10. #时间计算
    
11. d5 = d1- d2
    
12. #间隔天数和秒数
    
13. print(d5)
    
14. #间隔的天数
    
15. print(d5.day)
    
16. #间隔天数除外的秒数
    
17. print(d7.seconds)
    

复制代码

calendar(日历)
日历模块：

1. #使用
   
2. #返回指定某年某月的日历
   
3. print(calendar.month(2017,7))
   
4. #返回指定年的日历
   
5. print(calendar.caalendar(2017))
   
6. #闰年返回True，否则返回False
   
7. print(calendar.isleap(2000))
   
8. #返回某个月的weekday的第一天和这个月所有的天数
   
9. print(calendar.monthrange(2017,5))
   
10. #返回某个月以每一周为元素的列表
    
11. print(calendar.monthcalendar)
    

复制代码

cwhsmile

time.clock()已经不建议使用了，改用time.perf_counter()或者time.time.process_time()

我是python小白

cwhsmile 发表于 2019-4-23 00:03
time.clock()已经不建议使用了，改用time.perf_counter()或者time.time.process_time()

谢谢你的建议。