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() 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(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 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 = "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))
<list_reverseiterator object at 0x00000000021D39B0>

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-8
print(bs)

 

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

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

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

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

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

print(ord("中"))  #找到对应字符的编码位置 20013  
print(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 in range(len(lst)):
    print(i, lst[i])

 

 

for i in enumerate(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, []])) # or

if any([5>8, 3 > 5, 1 < 0]):
    pass
if 5 > 8 or 3 > 5 or  1 < 0:
    pass

 

zip()    # 拉链

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

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

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

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

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

 

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

 

 

字符串类型代码的执行：

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

 

print(eval("2+2")) # 4
n = 8
print(eval("2+n")) # 10
def 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 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': 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):
    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":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))
# <map object at 0x00000000023C3BA8>
# [1, 4, 9, 16, 25]

 

改写成lambda

mp = map(lambda x:x * x,lst)
for el in mp:
    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 in mp:
    print(el)

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

 

二. 递归函数

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

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

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

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

 

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

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


import os
def read_dir(s, n):
    # 1. 打开这个文件夹
    lst = os.listdir(s) # 打开文件夹. 拿到文件
    for el in lst: # 拿到的都是文件的名字
        # 2. 拼接出文件的路径
        real_path = os.path.join(s, el) # D:\25期周末班\a\b
        print("----"*n, el)  # 打印文件名字
        # 3. 判断是否是文件夹
        if os.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)