递归,自定义模块,time模块,datetime

递归:

def func(n):
    print(n)
    n += 1
    func(n)
func(1)

   #实际测试 998,997.官方说明 递归默认最大乘次1000.
递归的最大条件;1自己调用自己的本身
2有明确的终止或者结束条件

def age(n):
    n -= 1
    if n == 2:
        return '找到了'
    else:
        return age(n)
print(age(5))

拆分版:

def age1(n):
    n-=1
    if n==2:
        return '我找到了'
    else:
        pass

def age2(n):
    n-=1
    if n==2:
        return '我找到了'
    else:
        return age1(n)

def age3(n):
    n-=1
    if n==2:
        return '我找到了'
    else:
        return age2(n)
print(age3(5))


import sys
sys.setrecursionlimit(10000000)  #修改递归的深度.

def fun(n):
   print(n)
   n+=1
   fun(n)
fun(1)

递归的作用:
os:递归创建文件夹.删除, 查看文件:
递归查看文件

import os
def read(filepath,n): #filepath == s19期/day2.n 计数器
    files = os.listdir(filepath)   #获取到当前文件夹的所有文件,返回的是一个列表
    for fi in files:        #循环这个返回的列表,列表里放的就是当前19期文件夹下的所有人日哦那个
        #每个文件的名字
        fi_d = os.path.join(filepath,fi)    #加入文件夹,获取到文件夹+ 文件
        #fi_d = 19期/day2
        if os.path.isdir(fi_d): #判断咱们拼接好的19期/day2 是不是一个文件夹
            print('	'*n,fi)    #	是4个空格,day2
            read(fi_d,n+1)      #fi_d 19期/day2,1
        else:
            print(("	"*n,fi))      #函数执行到函数体的最后一行代码就自动退出
#递归遍历目录下的所有文件
read('../../',0)

自定义模块:

什么是模块?
一个py文件就是一个模块
模块的好处:# 1 拿来就用
2 省去咱们开发的时间
3 提升效率
4 结构化,便于查找,便于修改,便于维护
模块分为?
1 内置模块 2第三方模块 (pypi 第三方模块平台) 3自定义模块

import #后写模块名,不需要加后缀名的,导入相当于把里面的东西全都读出来
python 优化 ,第一次导入就放到内存里,先去内存里找,如果有就直接使用.避开重复导入

name = 'name'
print(test.name)
print(name)

import  asdedqwiuhdsaknd as f (给模块起别名),飘红不代表报错

 from 模块 import func
 好处:使用简单,直接调用
 坏处:容易和当前文件的功能冲突,冲突时优先使用当下文件

 import 模块 (将模块的所有内容都读取到,占内存)

 from 模块 import func as f 引入然后起别名,不冲突

from 模块 import *
*导入所有,不推荐使用,除非全部导入

import 模块,模块1
可以,不推荐使用,如果注释掉一个的话就全注掉了,最好分开,便于操作,查找.

from 模块 import 函数1 as f1,函数2 as f2
从模块下导入函数1,函数2功能,并可以起别名.

总结:
import 模块名   #把这个模块下所有东西全部导入
import 模块名,模块名  #不建议写到一行
import 模块名 as 别名 #起别名
import 导入过来的功能都需要,使用模块名点的方法去执行.
import 模块名 #多次导入的时候

from 模块名 import 指定导入哪些内容
from 模块名 import 多个功能
from 导入多个模块的时候要一行一行的导入
from 模块 import * #*导入所有,不推荐使用,除非全部导入
from 模块 import 功能 as 别名,功能2 as 别名
from...import... 与import对比

唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，
直接使用名字就可以了、无需加前缀：meet.
from...import...的方式有好处也有坏处
​好处：使用起来方便了
坏处：容易与当前执行文件中的名字冲突

from 模块 import *
foo()
__all__ == ['fun']在模块内添加,自定义指定使用*的时候导入的内容,其他内容不导入.
__name__在被当做模块的时候,__name__就是这模块的名字,__name__就会变成被导入的模块名.
__name__在本文件内就是'__main__'
if __name__=='__main__': #当前文件的启动接口
    #要执行测试的内容
foo('我当做模块在用)

绝对路径相对路径不能用然后:
from day1 import test
from day1.text import *

搜索路径:
from xxx import x:
#XXX 和当前文件在一个大的目录下.可以接着写文件夹的名字
绝对路径相对路径不能用然后:
from day1 import test
from day1.text import *

不在一个大的目录下,首先要导入sys模块
然后将要使用的模块路径添加到系统的环境变量
import sys
sys.path.insert(0,'我是外部的文件')
print(sys.path) #系统环境变量

编译文件:
被导入的模块会生成一个.pyc作为后缀的字节码.提升了编译(加载)效率,不提升运行效率.
文件被修改就会重新写一份.

模块的重载:
test文件被当做模块使用的时候,如果改变test里的代码,就需要重新运行一下导入他的文件.

循环导入:
会报错,他们导入的时候形成了一个环状,解决方案,打破环状.

time 模块:

import time
a = time.time()     #时间戳
print(time.time())
time.struct_time

print(time.gmtime())    #格林尼治时间
print(time.localtime()) #本地计算机时间

把时间戳换成字符串时间
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))
首先转换成结构化时间,然后再换成字符串
print(time.strftime('%Y-%m-%d',time.localtime(8445615010)))

datetime python的标准库.

import time
from datetime import datetime
print(datetime.now())   #获取当前时间,字符串的形式
f = datetime.now()
print(datetime.timestamp(f))   #获取时间戳
print(datetime.fromtimestamp(time.time())) #将时间戳转换成字符串

print(datetime.strptime('2018-10-1 13:14','%Y-%m-%d %H:%M')) #字符串转换成时间类型

datetime.now()
s = datetime.strftime(datetime.now(),'%Y-%m-%d %H:%M:%S')
print(type(s))

timedelta 修改时间的时候
修改时间,天数,修改周...

from datetime import datetime, timedelta
now = datetime.now()
datetime.datetime(2015, 5, 18, 16, 57, 3, 540997)
now + timedelta(hours=10)
datetime.datetime(2015, 5, 19, 2, 57, 3, 540997)
now - timedelta(days=1)
datetime.datetime(2015, 5, 17, 16, 57, 3, 540997)
now + timedelta(days=2, hours=12)
datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)