python之内置函数，匿名函数，递归函数

一. 内置函函数

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

函数分类：
https://www.processon.com/mindmap/5c459eb7e4b0fa03cea19d8f

作用域相关：

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

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

a = "lishichao"
b = ""
print(locals())
print(globals())
print(globals() is locals())
#True  这两个一样，因为是在全局执行的。

def func():
    c = "lishichao"
    print(globals() is locals())

func()
#False

迭代器相关:
range() 　　生成数据

python函数之 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()) # 数字的哈希值就是它本身

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

a = ""
b = a
print(id(a))
print(id(b))

文件操作相关:
open() 用于打开一个文件, 创建一个文件句柄

模块相关:
__import__() 　　用于动态加载类和函数

# import os 正常导入
mokuai = input("请输入你要导入的模块")
__import__(mokuai) #动态导入

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

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

Help on class str in module __builtin__:

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

# # callable 判断你给的参数是否可以被调用
def func(fn):
    if callable(fn): # 判断你传进来的这个东西能不能+()
        print("哈哈哈哈哈")
        fn()
        print("哇哈哈哈哈哈")
    else:
        print("不可以被调用")

def chi():
    print("吃自助餐了")

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

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

print(dir(str))

基础数据类型相关:
数字相关:
bool() 　　 　　将给定的数据转换成bool值. 如果不给值. 返回False

print(bool())   # True
print(bool())   # 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())   # 二进制 0b101
print(oct())   # 八进制 0o11
print(hex())  # 十六进制 0x12

数学运算:

abs() 　　　　 返回绝对值

divmode()　　 返回商和余数

round() 　　　 四舍五入

# 保留两位小数
print(round(0.456,))  
# 执行结果: 0.46

pow(a, b) 　　 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
sum() 　　　   求和
min() 　　　    求最小值
max() 　　　   求最大值

和数据结构相关:
列表和元组:
list() 　　　　   将一个可迭代对象转换成列表
tuple() 　　　　将一个可迭代对象转换成元组
reversed()　　  将一个序列翻转, 返回翻转序列的迭代器

lst = ["宅", "上班", "加班", "坐地铁", "睡觉"]
print(reversed(lst))
<list_reverseiterator object at 0x00000000021D39B0>

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

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

print(s[s1])
print(ss[s1])
print(sss[s1])

字符串相关:

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

print(format(1.23456789, ".2f"))  # 保留小数点2位
print(format(10.000000000000000005, ".2f"))
print(format(/, ".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-
print(bs)

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

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

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

s = memoryview("麻花藤".encode("utf-8"))
print(s)
#<memory at 0x00000000023D6288>

ord() 　　　　　　  输入字符找到字符编码的位置
chr() 　　　　　      输入位置数字找出对应的字符

print(ord("中"))  #找到对应字符的编码位置 20013
print(chr())  # 找到对应编码位置的字符

for i in range():
    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哈") # 正则表达式

# 很重要
# . str  普通字符串
# . repr 还原最官方的字符串
# . r""  原样输出

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

数据集合：
dict() 　　　　　　创建一个字典
set() 　　　　　　 创建一个集合
frozenset()　　　   创建一个冻结的集合. 冻结的集合不能进行添加和删除操作

s = {,,} # 不可哈希. 因为可变
s.add()
s.add("刘老根")
print(s)

s = frozenset({,,})
print(hash(s)) # 可哈希,因为不可变
# list => tuple
# set => fronzenset

其他相关:
len() 　　　　　　返回一个对象中的元素的个数

for i in range(len(lst)):
    print(i, lst[i])

for i in enumerate(lst):
    print(i)   # 拿到的是元祖
(, '刘老根')
(, '药匣子')
(, '马大帅')
(, '西游记')

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

　　101 药匣子
　　102 马大帅
　　103 西游记

# all
print(all([, , "哈哈哈", '呵呵呵'])) # and
# any
print(any([, None, True, []])) # or

if any([>,  > ,  < ]):
    pass
if  >  or  >  or   < :
    pass

zip()    # 拉链

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

lst1 = ["赵本山", "范伟", "于月仙"]
lst2 = ["相亲", "卖拐"]
lst3 = [, , ]

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

print(z) # <zip object at 0x00000000029632C8>

for el in z:
    print(el)
#执行结果:
# ('赵本山', '相亲', )
# ('范伟', '卖拐', )

sorted() 　　　 对可迭代对象进行排序操作(讲完lamda后再讲这个)
filter() 　　　　 过滤(讲完lamda)
map() 　　　　会根据提供的函数对指定序列做映射(lamda)

字符串类型代码的执行：

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

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

# evel使用：

#把字典直接写到文件
lst = [{"name":"电脑", "price":}, {"name":"鼠标", "price":}, {"name":"波多老师", "price":}, {"name":"七天", "price":}]
#
f = open("商品.txt", mode="a", encoding="utf-8")
for el in lst:
    f.write(str(el)+"\n")

f.flush()
f.close()

# 读取，使用eval直接读取文件中字典
f = open("商品.txt", mode="r", encoding="utf-8")
for line in f:      #每一行的数据 {'name': '电脑', 'price': }
    s = line.strip()
    d = eval(s)     # {'name': '电脑', 'price': } => 字典
    print(d)
    print(d['name'])

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

exec("""
for i in range():
    print(i)
""")
exec("""
def func():
    print("我是周杰伦")
func()
""")

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

'''
    参数说明:
        . resource 要执行的代码, 动态代码片段
        . 文件名, 代码存放的文件名, 当传入了第一个参数的时候, 这个参数给空就可以了
        . 模式, 取值有3个,
            . exec: 一般放一些流程语句的时候
            . eval: resource只存放一个求值表达式.
            . 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())

f = lambda n: n**n
print(f())

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

语法:

　　函数名 = lambda 参数: 返回值

注意:

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

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

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

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

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

# 逻辑排序题

lst = [,,-,,,-,-]

# 结果
# [,,,,-,-,-]

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

 sorted()

排序函数.
 语法: sorted(Iterable, key=None, reverse=False)
 Iterable: 可迭代对象
 key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
 reverse: 是否是倒叙. True: 倒叙, False: 正序(默认 从小到大排序)

lst = [,,,,]
lst2 = sorted(lst,reverse=True)
print(lst)      # 原列表不会改变
print(lst2)     # 返回的新列表是经过排序的

dic = {:'A', :'C', :'B'}
print(sorted(dic))     # 如果是字典. 则返回排序过后的key

# 和函数组合使用
# 根据字符串长度度进行排序
lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
# 计算字符串长度
def func(s):
    return len(s)
print(sorted(lst, key=func))

# 和lambda组合使用
# 根据字符串⻓度进⾏排序
lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
# 计算字符串度
def func(s):
    return len(s)

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

lst = [{"id":, "name":'alex', "age":},
 {"id":, "name":'wusir', "age":},
 {"id":, "name":'taibai', "age":}]

# 按照年龄对学生信息进行排序
print(sorted(lst, key=lambda e: e['age']))

filter()

筛选函数

　　 语法: filter(function. Iterable)

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

Iterable: 可迭代对象

lst = [,,,,,,]
ll = filter(lambda x: x%==,lst) #筛选所有的偶数,返回的是一个迭代器
print(ll)
print(ll.__next__())
print(list(ll))

lst = [{"id":, "name":'alex', "age":},
 {"id":, "name":'wusir', "age":},
 {"id":, "name":'taibai', "age":}]
fl = filter(lambda e: e['age'] > , lst)  # 筛选年龄大于16的数据
print(list(fl))

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

map()

映射函数

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

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

def func(e):
    return e * e

lst = [,,,,]
mp = map(func,lst)
print(mp)
print(list(mp))
# <map object at 0x00000000023C3BA8>
# [, , , , ]

改写成lambda

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

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

lst1 = [, , , , ]
lst2 = [, , , , ]
mp = map(lambda x, y: x+y, lst1, lst2)
for el in mp:
    print(el)

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

二. 递归函数

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

def func():
 print("我是谁")
 func()
func()

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

def foo(n):
     print(n)
     n +=
     foo(n)
foo()

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

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

import os
def read_dir(s, n):
    # . 打开这个文件夹
    lst = os.listdir(s) # 打开文件夹. 拿到文件
    for el in lst: # 拿到的都是文件的名字
        # . 拼接出文件的路径
        real_path = os.path.join(s, el) # D:\25期周末班\a\b
        print("----"*n, el)  # 打印文件名字
        # . 判断是否是文件夹
        if os.path.isdir(real_path):
            read_dir(real_path, n + ) # 递归的入口
        else:
            pass
            # open(real_path, mode="w", encoding="utf-8").write()

read_dir(r"c:\\", )