python递归函数公式_python之内置函数，匿名函数，递归函数

一. 内置函函数

什么是内置函数？就是Python给你提供的，拿来直接用的函数，比如print，input等等。截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。这些函数有些我们已经用过了，有些我们还没用到过，还有一些需要学完面向对象才能继续学习的。今天我们就一起来认识一下python的内置函数。

函数分类：

https://www.processon.com/mindmap/5c459eb7e4b0fa03cea19d8f

作用域相关：

locals()  　　 返回当前作用域中的变量

globals() 　　返回全局作用域中的变量

a = "lishichao"b= "123"print(locals())

print(globals())

print(globals()islocals())

#True 这两个一样，因为是在全局执行的。

def func():

c= "lishichao"print(globals()islocals())

func()

#False

迭代器相关:

range() 　　生成数据

next()迭代器向下执行一次, 内部实际使用了__next__()方法返回迭代器的下一个项目

iter()

lst = ["宅", "上班", "加班", "坐地铁", "睡觉"]

# 获取迭代器

it1=lst.__iter__() # 类的特殊成员,特定的场景固定的调用方式

# print(it1)

it2=iter(lst) # 内部执行的就是__iter__()

# print(it2)

# 迭代器向下执行一次

print(it1.__next__())

print(next(it2))

输入和输出相关:

input() 　　获取用户输入的内容

print() 　　 打印输出

内存相关:

hash() 　　获取到对象的哈希值(int, str, bool, tuple)

print(hash("哈哈哈")) # 哈希值就是一个数字

print(hash(456)) # 数字的哈希值就是它本身

id() 　　     获取到对象的内存地址

a = "123"b=a

print(id(a))

print(id(b))

文件操作相关:

open() 用于打开一个文件, 创建一个文件句柄

模块相关:

__import__() 　　用于动态加载类和函数

# import os 正常导入

mokuai= input("请输入你要导入的模块")

__import__(mokuai) #动态导入

帮助：

help() 　　 函数用于查看函数或模块用途的详细说明

>>>print(help(str)) # 在命令行模式下，查看帮助信息

Help onclass str in module __builtin__:

调用相关:

callable() 　　用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功

# # callable 判断你给的参数是否可以被调用

def func(fn):if callable(fn): # 判断你传进来的这个东西能不能+()

print("哈哈哈哈哈")

fn()

print("哇哈哈哈哈哈")else:

print("不可以被调用")

def chi():

print("吃自助餐了")

foo= "123"func(chi) #可以被调用

func(foo) #不可以被调用

查看内置属性:

dir() 　　查看对象的内置属性, 方法. 访问的是对象中的__dir__()方法

print(dir(str))

基础数据类型相关:

数字相关:

bool() 　　　　将给定的数据转换成bool值. 如果不给值. 返回False

print(bool(2)) # True

print(bool(0)) # False

a= ""b= " "print(bool(a)) # False

print(bool(b)) # True

# 所有的空都为False

int() 　　　　    将给定的数据转换成int值. 如果不给值, 返回0

float() 　　　　 将给定的数据转换成float值. 也就是小数

complex() 　　 创建一个复数. 第一个参数为实部, 第二个参数为虚部. 或者第一个参数直接用字符串来描述复数

进制转换:

bin() 　　 将给的参数转换成二进制

otc() 　　 将给的参数转换成八进制

hex() 　　 将给的参数转换成十六进制

a =0b101 # 二进制

print(a)

a=0o11 # 八进制

print(a)

a= 0x12# 十六进制

print(a)

print(bin(5)) # 二进制 0b101

print(oct(9)) # 八进制 0o11

print(hex(18)) # 十六进制 0x12

数学运算:

abs() 　　　　 返回绝对值

divmode()　　 返回商和余数

round() 　　　 四舍五入

# 保留两位小数

print(round(0.456,2))

# 执行结果: 0.46

pow(a, b) 　　 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余

sum() 　　　   求和

min() 　　　    求最小值

max() 　　　   求最大值

和数据结构相关:

列表和元组:

list() 　　　　   将一个可迭代对象转换成列表

tuple() 　　　　将一个可迭代对象转换成元组

reversed()　　  将一个序列翻转, 返回翻转序列的迭代器

lst = ["宅", "上班", "加班", "坐地铁", "睡觉"]

print(reversed(lst))

slice() 　　　 　切片，多个数据都需要固定的切片时。

s = "你好啊, 我叫周杰伦"ss= "巴拉巴拉巴拉巴拉巴拉"sss= "哈哈进口红酒客户"s1= slice(2, 9)

print(s[s1])

print(ss[s1])

print(sss[s1])

字符串相关:

format()　　     　　与具体数据相关, 用于计算各种小数, 精算等

print(format(1.23456789, ".2f")) # 保留小数点2位

print(format(10.000000000000000005, ".2f"))

print(format(10/3, ".3")) # 保留小数点2位

bytes() 　　　　  　把字符串转化成bytes类型

s = "你好"bs= s.encode("UTF-8")

print(bs)

s1= bs.decode("UTF-8")

print(s1)

bs= bytes(s, encoding="utf-8") # 把字符串编码成UTF-8print(bs)

bytearray() 　　　   返回一个新字节数组. 这个数字里的元素是可变的, 并且每个元素的值得范围是[0,256)

ret = bytearray('lishichao',encoding='utf-8')

print(ret[0])

print(ret)

memoryview() 　     查看bytes在内存中的情况

s = memoryview("麻花藤".encode("utf-8"))

print(s)

#

ord() 　　　　　　  输入字符找到字符编码的位置

chr() 　　　　　      输入位置数字找出对应的字符

print(ord("中")) #找到对应字符的编码位置 20013print(chr(20013)) # 找到对应编码位置的字符for i in range(65536):

print(chr(i), end=" ") # 打印0-65536编码位置的字符

ascii() 　　　　　　是ascii码中的返回该值 不是就返回\u....

s = "金角大王吧"print(ascii(s)) # 判断你的文字是否是ascii范畴得 内容

s1= "abc"print(ascii(s1))

#'\u91d1\u89d2\u5927\u738b\u5427'#'abc'

repr() 　　　　　　 返回一个对象的官方表示形式

# s = "哈哈哈哈" # =>变成C里面的字符串

# print(s)

# print(repr(s)) # 把字符串还原回最应该显示的样子

# s= "哈\哈哈" # \ 转义 \n \t \\ \"\'

# print(s)

# print(repr(s))

# s= "胡辣汤\\n蝙蝠侠"# print(s)

# print(repr(s))

# print(r"") # 原样输出 =>和repr没关系

# print(r"哈\n\\\n\]\\\\\\\\n哈\t哈") # 正则表达式

# 很重要

#1. str 普通字符串

#2. repr 还原最官方的字符串

#3. r"" 原样输出

str()　　　　　　　　  将数据转换成字符串

数据集合：

dict() 　　　　　　创建一个字典

set() 　　　　　　 创建一个集合

frozenset()　　　   创建一个冻结的集合. 冻结的集合不能进行添加和删除操作

s = {1,2,3} # 不可哈希. 因为可变

s.add(4)

s.add("刘老根")

print(s)

s= frozenset({1,2,3})

print(hash(s)) # 可哈希,因为不可变

# list=>tuple

#set => fronzenset

其他相关:

len() 　　　　　　返回一个对象中的元素的个数

for i inrange(len(lst)):

print(i, lst[i])

for i inenumerate(lst):

print(i) # 拿到的是元祖

(0, '刘老根')

(1, '药匣子')

(2, '马大帅')

(3, '西游记')

元祖解包：for i, el in enumerate(lst, 100): #第二个参数，可以指定从多少开始

print(i, el)

#执行结果:

101 药匣子

102 马大帅

103 西游记

# all

print(all([0, 1, "哈哈哈", '呵呵呵'])) # and

# any

print(any([0, None, True, []])) # orif any([5>8, 3 > 5, 1 < 0]):

passif 5 > 8 or 3 > 5 or 1 < 0:

pass

zip()    # 拉链

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

lst1 = ["赵本山", "范伟", "于月仙"]

lst2= ["相亲", "卖拐"]

lst3= [28, 60, 50]

z=zip(lst1, lst2, lst3) # 水桶效应

print(z) #

for el inz:

print(el)

#执行结果:

# ('赵本山', '相亲', 28)

# ('范伟', '卖拐', 60)

sorted() 　　　 对可迭代对象进行排序操作(讲完lamda后再讲这个)

filter() 　　　　 过滤(讲完lamda)

map() 　　　　会根据提供的函数对指定序列做映射(lamda)

字符串类型代码的执行：

eval() 　　执行字符串类型的代码. 并返回最终结果

print(eval("2+2")) # 4n= 8print(eval("2+n")) # 10def func():

print(666)

eval("func()") # 666

# evel使用：

#把字典直接写到文件

lst= [{"name":"电脑", "price":1999}, {"name":"鼠标", "price":10}, {"name":"波多老师", "price":99999}, {"name":"七天", "price":123456}]

#

f= open("商品.txt", mode="a", encoding="utf-8")for el inlst:

f.write(str(el)+"\n")

f.flush()

f.close()

# 读取，使用eval直接读取文件中字典

f= open("商品.txt", mode="r", encoding="utf-8")for line in f: #每一行的数据 {'name': '电脑', 'price': 1999}

s=line.strip()

d= eval(s) # {'name': '电脑', 'price': 1999} =>字典

print(d)

print(d['name'])

exec() 　　执行字符串类型的代码

exec("""for i in range(10):

print(i)""")

exec("""def func():

print("我是周杰伦")

func()""")

compile() 将字符串类型的代码编译. 代码对象能够通过exec语句来执行或者eval()进行求值

'''参数说明:1. resource 要执行的代码, 动态代码片段2. 文件名, 代码存放的文件名, 当传入了第一个参数的时候, 这个参数给空就可以了3. 模式, 取值有3个,1. exec: 一般放一些流程语句的时候2. eval: resource只存放一个求值表达式.3. single: resource存放的代码有交互的时候. mode应为single'''code1 = "for i in range(10): print(i)"c1= compile(code1, "", mode="exec")

exec(c1)

code2= "1+2+3"c2= compile(code2, "", mode="eval")

a=eval(c2)

print(a)

code3= "name = input('请输入你的名字:')"c3= compile(code3, "", mode="single")

exec(c3)

print(name)

有返回值的字符串形式的代码用eval().  没有返回值的字符串形式的代码用exec(). 一般很少用到compile()

二. lamda匿名函数

为了解决一些简单的需求而设计的一句话函数

# 计算n的n次方

def func(n):return n**n

print(func(10))

f= lambda n: n**n

print(f(10))

lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数

语法:

函数名 = lambda 参数: 返回值

注意:

1. 函数的参数可以有多个. 多个参数之间用逗号隔开

2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据

3. 返回值和正常的函数一样, 可以是任意数据类型

匿名函数并不是说一定没有名字. 这里前面的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的. 统一都叫 lambda. 在调用的时候没有什么特别之处.像正常的函数调用即可。

一般都配合下面三个函数一起使用。

# 逻辑排序题

lst = [0,2,-3,8,7,-5,-7]

# 结果

# [0,2,7,8,-3,-5,-7]

# print(sorted(lst, key=lambda x:__________))

print(sorted(lst, key=lambda x:x if x >= 0 else abs(x) + 10))

sorted()

排序函数.

语法: sorted(Iterable, key=None, reverse=False)

Iterable: 可迭代对象

key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序

reverse: 是否是倒叙. True: 倒叙, False: 正序(默认 从小到大排序)

lst= [1,5,3,4,6]

lst2= sorted(lst,reverse=True)

print(lst) # 原列表不会改变

print(lst2) # 返回的新列表是经过排序的

dic= {1:'A', 3:'C', 2:'B'}

print(sorted(dic)) # 如果是字典. 则返回排序过后的key

# 和函数组合使用

# 根据字符串长度度进行排序

lst= ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]

# 计算字符串长度

def func(s):returnlen(s)

print(sorted(lst, key=func))

# 和lambda组合使用

# 根据字符串⻓度进⾏排序

lst= ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]

# 计算字符串度

def func(s):returnlen(s)

print(sorted(lst, key=lambda s: len(s)))

lst= [{"id":1, "name":'alex', "age":18},

{"id":2, "name":'wusir', "age":16},

{"id":3, "name":'taibai', "age":17}]

# 按照年龄对学生信息进行排序

print(sorted(lst, key=lambda e: e['age']))

filter()

筛选函数

语法: filter(function. Iterable)

function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留此项数据

Iterable: 可迭代对象

lst = [1,2,3,4,5,6,7]

ll= filter(lambda x: x%2==0,lst) #筛选所有的偶数,返回的是一个迭代器

print(ll)

print(ll.__next__())

print(list(ll))

lst= [{"id":1, "name":'alex', "age":18},

{"id":2, "name":'wusir', "age":16},

{"id":3, "name":'taibai', "age":17}]

fl= filter(lambda e: e['age'] > 16, lst) # 筛选年龄大于16的数据

print(list(fl))

# filter 把可迭代对象进行迭代. 把每一项数据传递给前面的函数. 根据函数返回的true和false来决定该元素是否保留

map()

映射函数

语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射. 分别去执行function

计算列表中每个元素的平方 ,返回新列表

def func(e):return e *e

lst= [1,2,3,4,5]

mp=map(func,lst)

print(mp)

print(list(mp))

## [1, 4, 9, 16, 25]

改写成lambda

mp = map(lambda x:x *x,lst)for el inmp:

print(el)

计算两个列表中相同位置的数据的和

lst1 = [1, 2, 3, 4, 5]

lst2= [2, 4, 6, 8, 10]

mp= map(lambda x, y: x+y, lst1, lst2)for el inmp:

print(el)

# 把可迭代对象中每一项传递给前面的函数. 函数执行的结果作为整个运算的结果

二. 递归函数

在函数中调用函数本身. 就是递归。

def func():

print("我是谁")

func()

func()

在python中递归的深度最大到998

def foo(n):

print(n)

n+= 1foo(n)

foo(1)

递归的应用:

我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统. 可以使用递归来遍历该文件夹中的所有文件。

# 递归的一个应用: 遍历文件夹

import os

def read_dir(s, n):

#1. 打开这个文件夹

lst=os.listdir(s) # 打开文件夹. 拿到文件for el inlst: # 拿到的都是文件的名字

#2. 拼接出文件的路径

real_path=os.path.join(s, el) # D:\25期周末班\a\b

print("----"*n, el) # 打印文件名字

#3. 判断是否是文件夹ifos.path.isdir(real_path):

read_dir(real_path, n+ 1) # 递归的入口else:

pass

# open(real_path, mode="w", encoding="utf-8").write(1)

read_dir(r"c:\\", 0)