python匿名函数里用for_Python基础之（内置函数、匿名函数、递归）

一、内置函数

1.1、作用域相关

locals() #以字典的类型返回当前位置的全部局部变量。

globals() #以字典的类型返回全部全局变量。

1.2、迭代器生成器相关

range() #可创建一个整数对象，一般用在 for 循环中

next() #内部实际使用了__next__方法，返回迭代器的下一个项目。

iter() #用来生成迭代器(将一个可迭代对象，生成迭代器)同于：__iter__()

1.3、基础数据类型相关

bool() #用于将给定参数转换为布尔类型，如果没有参数，返回 False

int() #用于将一个字符串或数字转换为整型。

float() #用于将整数和字符串转换成浮点数。

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

tuple() #将一个可迭代对象转化成元祖

dict() #创建一个字典

set() #创建一个集合

str() #转化成字符串

1.4、转换及运算相关

bin() #将十进制转换成二进制并返回。

oct()#将十进制转化成八进制字符串并返回

hex()#将十进制转化成十六进制字符串并返回。

print(bin(10),type(bin(10))) # 0b1010

print(oct(10),type(oct(10))) # 0o12

print(hex(10),type(hex(10))) # 0xa

abs()#返回数字的绝对值。

divmod()#计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

round()#保留浮点数的小数位数，默认保留整数。

pow()#求x**y次幂。(三个参数为x**y的结果对z取余)

print(abs(-5)) # 5

print(divmod(7,2)) # (3, 1)

print(round(7/3,2)) # 2.33

print(round(7/3)) # 2

print(round(3.32567,3)) # 3.326

print(pow(2,3)) # 两个参数为2**3次幂 结果8

print(pow(2,3,3)) # 三个参数为2**3次幂，对3取余。 余数2

sum()#对可迭代对象进行求和计算(可设置初始值)。

min()#返回可迭代对象的最小值(可加key，key为函数名，通过函数的规则，返回最小值)

max()#返回可迭代对象的最大值(可加key，key为函数名，通过函数的规则，返回最大值)

print(sum([1,2,3])) #6

print(sum((1,2,3),100)) #106

print(min([1,2,3])) # 返回此序列最小值1

ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值

print(ret) #1

dic = {'a':3,'b':2,'c':1}

print(min(dic,key=lambda x:dic[x]))# x为dic的key，lambda的返回值(即dic的值进行比较)返回最小的值对应的键

print(max([1,2,3])) # 返回此序列最大值3

ret = max([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最大值-5

print(ret)

dic = {'a':3,'b':2,'c':1}

print(max(dic,key=lambda x:dic[x]))# x为dic的key，lambda的返回值(即dic的值进行比较)返回最大的值对应的键

reversed() #将一个序列翻转，并返回此翻转序列的迭代器。

slice() #构造一个切片对象，用于列表的切片

ite = reversed(['a',2,3,'c',4,2])

for i in ite:

print(i) #2 4 c 3 2 a

li = ['a','b','c','d','e','f','g']

sli_obj = slice(3)

print(li[sli_obj]) #['a', 'b', 'c']

sli_obj = slice(0,7,2)

print(li[sli_obj]) #['a', 'c', 'e', 'g'],开始、结束、步长

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

bytes()#用于不同编码之间的转化。

s = '你好'

bs = s.encode('utf-8')

print(bs) #b'\xe4\xbd\xa0\xe5\xa5\xbd'

bs = bytes(s,encoding='utf-8')

print(bs) #b'\xe4\xbd\xa0\xe5\xa5\xbd'

s1 = bs.decode('utf-8')

print(s1) #你好

bytearry()#返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256

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

print(id(ret))

print(ret)

print(ret[0])

ret[0] = 65

print(ret)

print(id(ret))

memoryview()

ret = memoryview(bytes('你好',encoding='utf-8'))

print(len(ret)) #6

print(ret) #

print(bytes(ret[:3]).decode('utf-8')) #你

print(bytes(ret[3:]).decode('utf-8')) #好

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

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

ascii()#是ascii码中的返回该值，不是就返回/u...

print(ord('a')) #97

print(ord('中')) #20013

#chr 输入位置数字找出其对应的字符

print(chr(97)) #a

print(chr(20013)) #中

#是ascii码中的返回该值，不是就返回/u...

print(ascii('a')) #"a"

print(ascii('中')) #'\u4e2d'

repr()#返回一个对象的string形式

1.5、常用相关

id() #用于获取对象的内存地址

hash#获取一个对象(可哈希对象：int，str，Bool，tuple)的哈希值

print() #输出

input() #输入

open() #打开文件

type() #对象类型

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

dir() #查看一个对象的方法

help() #帮助方法

isinstance() #来判断一个对象是否是一个已知的类型，类似 type()

a=123

isinstance (a,int) #True

__import__ #用于动态加载类和函数

__import__('a') # 导入 a.py 模块

1.6、其他相关

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

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

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

eval('2 + 2') # 4

s = '''

for i in [1,2,3]:

print(i)

'''

exec(s) #1 2 3

complex()#函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

filter()#过滤

def func(x):return x%2 == 0

ret = filter(func,[1,2,3,4,5,6,7])

print(ret) #

for i in ret:

print(i) #2,4,6

zip() #拉链方法

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

l1 = [1,2,3,]

l2 = ['a','b','c',5]

l3 = ('*','**',(1,2,3))

for i in zip(l1,l2,l3):

print(i) #(1, 'a', '*') (2, 'b', '**') (3, 'c', (1, 2, 3))

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

def square(x) : # 计算平方数

return x ** 2

map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 [1, 4, 9, 16, 25]

sorted()#对所有可迭代的对象进行排序操作

L = [('a', 1), ('c', 3), ('d', 4),('b', 2), ]

sorted(L, key=lambda x:x[1]) # 利用key[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

sorted(students, key=lambda s: s[2]) # 按年龄排序[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

sorted(students, key=lambda s: s[2], reverse=True) # 按降序[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

frozenset()#返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

enumerate()#枚举，返回一个枚举对象 (可迭代对象加序号)

li = ['a','b','c','d','e']

for i in enumerate(li):

print(i)

for index,name in enumerate(li,1): #索引默认从0开始，可改成1开始

print(index,name)

all()#可迭代对象中，全都是True才是True

any()#可迭代对象中，有一个True 就是True

callable() 检查是否是函数 返回True、False

def add(x,y):return x+y

callable(add) # 返回 True

a=123

callable(a) #返回False

1.7、类相关

object() #是Python中所有类的基类，如果定义一个类时没有指定继承哪个类，则默认继承object类。

staticmethod()#静态方法

classmethod()#是一个装饰器函数，用来标示一个方法为类方法

property()#静态属性

super() #用于调用父类(超类)的一个方法

issubclass() #方法用于判断参数 class 是否是类型参数 classinfo 的子类。如果 class 是 classinfo 的子类返回 True，否则返回 False。

vars() #返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()

hasattr(object,name) #判断name是否在object,判断object中是否有一个叫name的方法或者属性

getattr(object,name,"xxx")#取object中name 的值，xxx为找不到报错信息，否则找不到报错

setattr(x,y,v) #给x对象中的y属性设置值v

delattr(x,y)#删除对象x中y

1.8、几个重要的内置函数

zip()

filter()

map()

max()

min()

sorted()

enumerate()

二、匿名函数

lambda a,b:a**b

#关键字 参数：返回值

#参数可以有多个，用逗号隔开

#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值

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

三、递归函数

递归函数：在一个函数里在调用这个函数本身。

递归的最大深度：998

def fun(count):

print(count)

count += 1

fun(count)

fun(1)

可以修改递归最大深度

import sys

sys.setrecursionlimit(2000)

递归调用应该分为两个明确的阶段：递推，回溯

回溯就是从外向里一层一层递归调用下去，回溯阶段必须要有一个明确地结束条件，每进入下一次递归时，问题的规模都应该有所减少

递推就是从里向外一层一层结束递归

#a(5) = a(4) -10

#a(4) = a(3) -10

#a(3) = a(2) -10

#a(2) = a(1) -10

#a(1) = 50

def a(n):

if n == 1:

return 50

return a(n-1)-10

print(a(5)) #10

递归方式实现斐波那契(生成前20项)

def fun(n):

if n==0:

return 0

elif n==1 or n==2:

return 1

else:

return fun(n-1)+fun(n-2)

for i in range(20):

print(fun(i))

#循环方式

a,b=0,1

while b<1000:

print(b)

a,b=b,a+b

四、二分法  (递归)

想从一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法可以极大的缩小查找规模

l=[2,23,34,45,56,78,89,90]

def find(num,l,start=0,end=len(l)):

print(end,start)

if start <= end:

index=start+(end-start)//2

print('start:[%s] end:[%s] index:[%s] index_val:[%s]' %(start,end,index,l[index]))

if num > l[index]:

start=index+1

elif num < l[index]:

end=index-1

elif num == l[index]:

print('find it',index)

return

find(num,l,start,end)

else:

print("找不到了")

find(89, l) #find it 6