一、递归调用

1.一个函数自己调用自己就是递归调用，最多一个函数递归调用自己999次，超过就会出错
2.递归必须有一个明确的结束条件
3.每次进入更深一层递归时，问题规模相比上次递归都应有所减少
4.递归效率不高，少用递归

eg:
def test1():
    num = int(input(‘please enter a number：‘))
    if num%2==0:#判断输入的数字是不是偶数
       return True #如果是偶数的话，程序就退出了，返回true
    print(‘不是偶数请重新输入！‘)
    return test1()#如果不是偶数的话继续调用自己，输入值
test1()#这样为什么不返回return
# print(test1())#调用test

二、高阶函数

1.如果一个函数的入参是一个函数名的话，那么这个函数就是高阶函数
2.函数即变量

eg:
def hello(name):
    print(name)
new_hello = hello
print(type(hello))
print(type(new_hello))
hello(‘hello..‘)
new_hello(‘new_hello‘)

eg1:
#如果不明白函数即变量，就看这里
def add(x,y,z):#如果一个函数的入参是一个函数名的话，那么这个函数就是高阶函数
    #参数z是要传入一个函数名
    res = z(x)+z(y)
    return res
print(add(‘98‘,‘100‘,int))

三、python内置函数的用法

1、作用域

1??函数的作用域,是就近原则，从里往外找，如果自己函数里有，就拿过去用，如果自己的函数里面没有的话，就去它父级函数里面找
2??函数只有被调用才会被执行

eg:
name = ‘python‘
def warpper():
    name = ‘wubing‘
    def deco():
        name = ‘陈冬瓜‘
        print(‘我在里面%s‘%name)
        def hhh():
            name = ‘zhangying‘
            print(‘www%s‘%name)
        hhh()
    deco()
    print(‘外面的name是%s‘%name)
warpper()

2、装饰器

1??函数里面也可以嵌套的定义一个函数
2??高阶函数
a.装饰器说白了就是函数嵌套＋高阶函数
b.装饰器的作用就是不改变原有函数的调用方式，入参的情况下，给函数添加新功能
c.偷偷摸摸的给函数加上新功能，但是不改变原来的函数

eg1:
import time
def run():
    print(‘run。。‘)
    time.sleep(1)
def run_time(func):
    start_time = time.time()#开始时间
    func()
    end_time = time.time()#结束时间
    print(‘run函数运行是‘,end_time-start_time)
run_time(run)

eg2:
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#==run
def run():
    print(‘run。。‘)
    time.sleep(1)
run = timer(run)#run == deco
run()
@timer
def run2(name):
    print(name)
    time.sleep(2)
run2(‘niuhanyang‘)

上面这个函数其实就是返回了一个函数名而已
1.调用timer函数的时候，要传入一个方法名，timer函数在函数内部定义了一个函数叫作deco，又在函数deco函数内部调用了timer里面传入的方法
2.run保存的是deco，deco是一个函数，调用r就是调用deco

3、内置函数

print(all([1,2,3,4]))#判断可迭代的对象里面的值是否都为真
print(any([0,0,0,0,0]))#判断可迭代的对象里面的值是否有一个为真
print(bin(10))#十进制转二进制
下面这些函数都是强制类型转换
print(bool(‘s‘))#把一个对象转换成布尔类型
int()#整形
float()#小数
str()#zifuc
dict()#字典
list()#列表
set()#集合
tuple()#元组
def func():
    pass
print(callable(func))#判断传入的对象是否可调用
print(chr(98))#打印数字对应的ascii
print(ord(‘b‘))#打印字符串对应的ascii码
print(dict(a=1,b=2))#转换字典
print(dir(‘a‘))#打印传入对象的可调用方法

print(eval(‘a=1‘))
执行python代码，只能执行简单的，定义数据类型和运算
print(exec(‘def a():pass‘))#执行python代码
def func(num):
    name = ‘88‘
    print(locals())
    print(globals())
    return num
func(11)
print(list(filter(func,[0,1,2,3,4])))#在python3里面这么用是没问题
print(filter(func,[0,1,2,3,4]))#在python2里面这么用是没问题

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

print(globals())#返回程序内所有的变量，返回的是一个字典,函数里面的局部变量不会返回
print(locals())#返回局部变量
print(hex(111))#数字转成16进制
print(max(111,12,13,14,16,19))#取最大值
print(oct(111))#把数字转换成8进制
print(round(11.1198,2))#取几位小数,会四舍五入
print(sorted([2,31,34,6,1,23,4],reverse=False))#排序

dic={1:2,3:4,5:6,7:8}
print(sorted(dic.items()))#按照字典的key排序
print(sorted(dic.items(),key=lambda x:x[1]))#按照字典的value排序
__import__(‘decorator‘)#导入一个模块


下面的是必须要会的
print(bool(‘s‘))#把一个对象转换成布尔类型
int()#整形
float()#小数
str()#zifuc
dict()#字典
list()#列表
set()#集合
tuple()#元组
print(round(11.1198,2))#取几位小数,会四舍五入
print(sorted([2,31,34,6,1,23,4],reverse=False))#排序
# print(max(111,12,13,14,16,19))#取最大值
print(list(filter(func,[0,1,2,3,4])))#在python3里面这么用是没问题
print(filter(func,[0,1,2,3,4]))#在python2里面这么用是没问题
filter(func,[1,2,3,4])
根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，返回true保存
print(list(map(func, [0,1, 2, 3, 4])))
根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，保存前面函数返回的所有结果 </span>

四、常用模块

1、用哪个模块就要import哪个模块

eg：
import model
#import的本质就是把这个python从头到尾执行一遍

model.run1()
model.run2()
model.run()

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

from model import *
from model2 import *
#这种你不要用，从一个模块里面导入所有的函数
run()
run1()
run2()
from model import name
import sys

这个是在其他目录下的话
sys.path.append(r‘E:\byz_code‘)
from day4.set1 import hhh
hhh()

2、包和文件夹的区别就是包下面有个__init__.py，在python2里面,如果你要导入其他文件夹下面的python文件，那么必须是一个包，python3不需要，只是文件夹就行了
3、环境变量就是用来让你在任意一个目录都可以使用这个命令
4、导入模块的时候，python首先在当前目录下去找这个模块,如果在当前
5、目录下没有找到这个文件的话，那么就去环境变量里面的目录找

eg:

import sys
print(sys.path)#看系统环境变量
import model
model.run()

六、import random

# print(random.random())  # 随机浮点数，默认取0-1，不能指定范围
# print(random.randint(1, 20))  # 随机整数
# print(random.randrange(1, 20))  # 随机产生一个range
# print(random.choice([1,2,3,4,5]))  # 随机取一个元素
# print(random.sample([1,2,3,4,‘6‘], 3))  # 从序列中随机取几个元素,返回的是一个list
# print(random.uniform(1, 88888))  # 随机取浮点数，可以指定范围
x = [1, 2, 3, 4, 5, 6]
random.shuffle(x)  # 洗牌,打乱顺序，会改变原list的值

七、import string

# print(string.ascii_letters + string.digits)  # 所有的数字和字母
# print(random.randint(1, 20))  # 随机整数
#print(random.choice([1,2,3,4,5]))  # 随机取一个元素
#print(random.sample(‘hello‘, 3))  # 从序列中随机取几个元素,返回的是一个list
#print(random.uniform(1, 88888))  # 随机取浮点数，可以指定范围
# x = [1, 2, 3, 4, 5, 6]
# random.shuffle(x)  # 洗牌,打乱顺序，会改变原list的值
# print(x)

八、import json

1.json和python的字典类型，但是json里面只能是双引号，不能是单引号
2.json串实际上就是一个字符串
json_str = """
{
    "username": "niuhanyang",
    "passwd": 123456,
    "flag": true
}
"""
# fr = open(‘users‘)
# json_dic = json.loads(json_str)
3.json串(字符串)转成字典,loads方法是把json转成字典
# json_dic_file = json.load(fr)
4.json串(字符串)转成字典,load方法是传入一个文件对象，然后load方法自动去读这个文件的内容，然后转成字典
# print(json_dic_file)
# print(type(json_dic_file))

d = {
    "hhh": {
        "price": "90000",
        "password": "123456"
    },
    "admin": {
        "password": "123456",
        "money": 8000
    }
}

# fw = open(‘users.json‘,‘w‘)
# dic_str = json.dumps(d)
#把字典变成json串（字符串）
# json.dump(d,fw)
# print(dic_str)
# print(type(dic_str))
5.json可以用字典和list
6.dump和dumps字典转json串的
7.load和loads是json串转字典
8.带s就和字符串沾边，不带s和文件对象沾边

五、python函数、装饰器、内置函数、json及模块