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 <class 'str'>
print(oct(10),type(oct(10)))  # 0o12 <class 'str'>
print(hex(10),type(hex(10)))  # 0xa <class 'str'>

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)   #<memory at 0x008A0BF8>
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)  #<filter object at 0x006327B0>
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