递归调用、高阶函数、函数作用域、python内置函数、装饰器、模块、random、json串和积累

一、递归调用

　　递归调用就是一个函数自己调用自己，自我调用最多调用999次。

　　特性：1.必须有一个明确的结束条件；

　　　　　2.每次进入更深一层递归时，问题规模相比上次递归都应该有所减少；

　　　　　3.递归效率不高，建议少用递归

def test():
    n=int(input(‘please input a number: ‘))
    if n%2==0:
        return True
    print(‘输入的不是偶数‘)
    test()
even=test  
# test()    #函数即变量，test是函数的内存地址，test()执行test函数
even()    #even和test指向的同一个内存地址，所以他们两个是一样的

二、高阶函数

　　高阶函数即一个函数的入参是一个函数名（函数即变量）。

def add(x,y,z):
    res=z(x)+z(y)
    return res
print(add(‘98‘,‘100‘,int))

三、函数作用域

　　函数的作用域，是就近原则，从里往外找。若是自己函数有，就直接用，若没有，就会去它父级函数里找。（注：函数只有被调用才会执行）

def warpper():#1
    name=‘西瓜‘
    def deco():#2
        name =‘草莓‘
        def he():#3
            print(‘最里面的水果是%s‘%name)
        print(‘中间的水果是%s‘%name)
        he()  #函数只有被调用才会执行
    deco()
    print(‘最外面的水果是%s‘%name)
warpper()

四、python内置函数

　　1.print(bool(‘s‘))  #把一个对象转换成布尔类型

　　2.int() #整型

　　3.float()  #小数

　　4.str()  #字符串

　　5.dict()  #字典

　　6.list()  #列表

　　7.set()  #集合

　　8.tuple()  #元组

　　9.print(round(11.12345,3))  #取小数位数（例子为取3位小数）

　　10.print(sorted([2,12,35,5,4,7,19],reverse=False))  #排序

　　11.print(max(111,22,334,4,7,9))  #取最大值

　　12.print(list(filter(func,[0,1,2,3,4])))  #根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，返回true保存

　　13.print(list(map(func,[0,1,2,3,4])))  #根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，保存前面函数返回的结果

　　14.print(dir(‘a‘))  #打印传入对象的可调用方法

　　15.print(callable(func))  #判断传入的对象是否可以调用

　　16.print(bin(10))  #十进制转二进制

　　17.print(oct(10))  #转八进制

　　18.print(hex(10))  #转十进制

　　19.print(chr(98))  #打印数字对应的ascii码

　　20.print(ord(‘b‘))  #打印字符串对应的ascii码

　　21.print(eval(‘a=1‘))  #执行python代码，只能执行简单的，定义数据类型和运算

　　22.print(exec(‘def a():pass‘))  #执行python代码

　　23.print(globals())  #返回程序内所有的变量，返回的是一个字典，函数里面的局部变量不会返回

　　24.print(locals())  #返回局部变量

　　25.print(all([1,2,3,4]))  #判断可迭代的对象里面的值是否都为真

　　26.print(any([1,2,3,0]))  #判断可迭代对象里面的值是否有一个为真

五、装饰器

　　特点：函数里面嵌套定义一个函数；高阶函数。

　　作用：在不改变原有函数的调用方式和入参的情况下，给函数添加新功能。

import time
def timer(func):
    def deco(*args,**kwargs):    #*args,**kwargs用来接收传入函数的参数
        start_time = time.time()
        res = func(*args,**kwargs)    #获取返回值
        end_time = time.time()
        print(‘runtime‘,end_time-start_time)
        return res
    return deco
@timer
def hello(name):
    print(‘hello %s‘%name)
    time.sleep(1)

# hello=timer(hello)  #等同于上方的@timer
hello(‘world‘)

六、模块

　　模块的实质是一个python文件

# model.py

def run():
    print(‘run...‘)
def run1():
    print(‘run1***‘)
def run2():
    print(‘run2!!!‘)
name = 5
print(‘66666‘)

　　模块调用的三种方式

# 方式一：
import model
model.run1()
model.run2()
model.run()

# 方式二：
from model import run,run1   #只导入某个函数的时候
run()
run1()

# 方式三：
from model import *   #从一个模块里面导入所有的函数，这种方法不建议用
run()
run1()
run2()

　　导入模块的时候，python首先在当前目录下查找这个模块，如果当前目录没有该文件，那么就会去环境变量里面的目录找。若是需要调用的模块在其他目录下，有如下方法：

from model import hello
from day4.set1 import he
import sys
sys.path.append(r‘E:\byz_code‘)  #添加环境变量
print(sys.path)   #看系统环境变量
he()

七、random

　　1.print(random.randint(1,20))   #随机取整数 

　　2.print(random.choice([1,2,3,4,5]))   #随机取一个元素（数据为可迭代对象）

　　3.print(random.sample(‘hello‘,3))   #从序列中随机取几个值，返回的是一个list

　　4.print(random.unform(1,999))   #随机取浮点数，可指定范围

　　5.x=[1,2,3,4,5]

　　   random.shuffle(x)   #洗牌，打乱顺序，改变原list的值

　　　print(x)

　　6.print(random.random())

八、json串

　　json和python的字典类型相似，但是json里只能是双引号，不能是单引号。

　　json串实际上是一个字符串。

　　dump和dumps是字典转json

　　load和loads是json转字典

jsons=‘{"name":"python","how":"i love"}‘
json_d=json.loads(jsons)   #json串(字符串)转成字典,loads方法是把json转成字典
print(json_d)

fr=open(‘users‘)
json_dict=json.load(fr)  #json串(字符串)转成字典,load方法是传入一个文件对象，然后load方法自动去读这个文件的内容，然后转成字典
print(json_dict)


d={‘admin‘: {‘password‘: ‘123456‘, ‘money‘: 80000}, ‘hhh‘: {‘password‘: ‘123456‘, ‘price‘: ‘90000‘}}
d_json=json.dumps(d)   #把字典变成json串（字符串）
print(d_json)

fw=open(‘users.json‘,‘w‘)
json.dump(d,fw)   #字典转json并写入文件

 九、积累

　　import time

　　now_time=time.strftime(‘%Y-%m-%d %H:%M:%S‘)   #获取当前时间

　　print(now_time)　

python基础四