python基础篇（四）
- 内置函数
- A：基础数据相关（38）
- B：作用域相关（2）
- C：迭代器，生成器相关（3）
- D：反射相关（4）
- E：面向对象相关（9）
- F：其他（12）
- 匿名函数
- A：匿名函数基础格式
- 递归函数
- A：初识递归函数
- B：递归函数实例
♣一：内置函数
内置函数是python本身携带的功能，当你打开解释器的时候就随之启动存在了，可以直接去调用，经过python这么多年的发展内置函数也在变多，这个可以去python官网去查询内置函数的说明，这些函数都有一个特点就是可以在函数名后面加上（）。
内置函数表：
| abs() | callable() | enumerate() | globals() | isinstance() | memoryview() | print() | silce() | vars() |
| all() | chr() | eval() | hasattr() | issubclass() | min() | property() | sorted() | zip() |
| any() | classmethod() | exec() | hash() | iter() | next() | range() | staticmethos() | import() |
| ascii() | compoile() | filter() | help() | len() | object() | repr() | str() | |
| bin() | delattr() | float() | hex() | list() | oct() | reversed() | sun() | |
| bool() | dict() | format() | id() | locals() | open() | round() | super() | |
| bytearray() | dir() | frozenset() | input() | map() | ord() | set() | tuple() | |
| bytes() | divmod() | getattr() | int() | max() | pow() | setattr() | type() |
A：基础数据相关（38）
和数字相关（数据类型）
bool，int，float，complex（复数）
和数字相关（进制转换）：
bin（二进制），oct（八进制），hex（十六进制）
和数字相关（数学运算）：
abs，divmod（求模取余），round（小数精确），pow（幂运算），sum，min，max
with open('userinfo',encoding='utf8')as f: #打开userinfo文件 l = f.readlines() page_num = int(input('请输入页码：')) #然用户输入页数 pages,mod = divmod(len(l),5)#判断总页数，有没有剩余的行数 if mod: #如果有剩余的行数+1 pages += 1 if page_num > pages or page_num <=0: #判断用户输入大于页数或者小于等于0的情况 print('输入有误') elif page_num == pages and mod !=0: #如果用户输入的页是最后一页，且之前有过剩的行数 for i in range(mod): print(l[(page_num-1)*5 +i].strip()) #只输出这一页上剩余的行数 else: for i in range(5): print(l[(page_num-1)*5 +i].strip()) #输入正常的5行
数据结构相关（列表和元祖）
list，tuple
数据结构相关（相关内置函数）
reversed，slice
数据结构相关（字符串）
str，format，bytes，bytearray，memoryview，ord，chr，ascii，repr
数据结构相关（数据集合）
dict，set，frozenset
数据结构相关（相关内置函数）
len，enumerate，all，any，zip，filter，map
内置函数里面max，min，filter，map，sorted这几个是最常用的，而且同时也是匿名函数里面常用的。
stockinfo = [ {'name':'德新交运','num':200,'price':21.18}, {'name':'纵横通讯','num':2000,'price':27.19}, {'name':'白云电器','num':100000,'price':11.14}, {'name':'玉龙股份','num':500,'price':6.08} ] #计算股票总价 ret = map(lambda dic : {dic['name']:dic['num']*dic['price']},stockinfo) print(list(ret)) 执行结果 [{'德新交运': 4236.0}, {'纵横通讯': 54380.0}, {'白云电器': 1114000.0}, {'玉龙股份': 3040.0}]
stockinfo = [ {'name':'德新交运','num':200,'price':21.18}, {'name':'纵横通讯','num':2000,'price':27.19}, {'name':'白云电器','num':100000,'price':11.14}, {'name':'玉龙股份','num':500,'price':6.08} ] 求出单价超过20的股票 ret = filter(lambda dic:True if dic['price']>20 else False,stockinfo) print(list(ret)) 执行结果 [{'name': '德新交运', 'num': 200, 'price': 21.18}, {'name': '纵横通讯', 'num': 2000, 'price': 27.19}]
B：作用域相关（2）
locals() #以字典的形式返回本地作用域中的名字 print(locals()) #执行结果 #{'__name__': '__main__', '__doc__': None, '__package__': None, '。。。。。。 def run(args): a = 'k' print(locals()) #在函数里面使用会当前位置返回全部的局部变量 run(4) 执行结果： {'a': 'k', 'args': 4}
globals() #以字典的形式返回全局作用域中的名字 print(globals()) #执行结果 #{'__name__': '__main__', '__doc__': None, '__package__': None, '。。。。
C：迭代器，生成器相关（3）
这个里面包含iter，next，range，这三种方法前面都用到过，不清楚可以查看前面的用法。
D：反射相关（4）
后续补全
E：面向对象相关（9）
后续补全
F：其他（12）
print(dir(())) 执行结果 ['__add__', '__class__', '__contains__', ....... 查看变量拥有的所有方法
print(callable(print)) print(callable(range)) a = 1 print(callable(a)) 执行结果 True True False 检查一个对象是否能被调用
help()查看帮助
import()导入模块
open()操作文件
id()查看内存地址
hash()是否能被hash，这个hash有个好处，例如你有一个文件里面1万个数字，另外一个文件是从原文件拷贝出去的，怎么检查数据是否有差异，就可以用hash，只要两个里面有个数字不一样，两个文件hash出来的结果就不一样。
print()打印
import time for i in range(0,101,2): time.sleep(0.2) char_num = i//2 per = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num) print(per,end='',flush=True) 如果有很多进度条处理的建议研究progress bar http://www.runoob.com/bootstrap/bootstrap-tutorial.html
inport()输出
exec('print(123)') eval('print(123)') #执行结果 123 123 exec和eval都能执行后面内容是正常的python语句 print(exec('4+6+8')) #exec可以看到结果，其实特也执行了，只是没有返回值而已，等同于不加print去计算1+2一样 print(eval('2+6+8')) #eval这个函数有时候能将外面的代码变得简单，但是eval存在安全争议，所以eval只能适合写死的代码部分。 #执行结果 None exec适合处理简单的流程控制 16 code = '''for i in range(3): print(i*'*') ''' exec(code) 执行结果 * ** 可以看到exec能将注释的代码给执行掉，因为里面是正常的python语句 https://blog.csdn.net/hshl1214/article/details/46583149
compile()是将字符串类型的代码编译成计算机能识别的字节码，这个执行需要交给exec和eval来执行。假如你有一段需要重复执行的代码，就可以使用compile一次编译，多次执行，实际用到的很少。
♣二：匿名函数
A：匿名函数基础格式
函数都是def 函数名（位置参数）:要使用直接调用函数名即可，匿名函数的基本格式就是在调用的时候加上lambda，函数名 = lambda 参数：返回值的基本格式，如果有多个参数，参数与参数之间，号隔开。而且匿名函数还有一个特点就是参数：后面的返回值，不管多复杂多长，只能写一行。
def cacl(a): return a**a print(cacl(10)) cacl=lambda n:n**n print(cacl(10)) 执行结果 10000000000 10000000000
# 找字典里面最大值的key # dic = {'a':10,'b':20,'c':50} # def func(key): # return dic[key] # print(max(dic,key=func)) # # 执行结果 # # c # print(max(dic,key=lambda k:dic[k])) # # 执行结果 # # c # 可以看到我使用匿名函数直接不需要使用我上面的func函数，直接传值进来，func函数三行内容，匿名函数一行解决 # a = lambda k:k*2 # b = lambda k:k*3 # x = 2 # x = a(x) # x = b(x) # x = a(x) # print(x) # 执行结果 # 24 # print(list(map(lambda tup:{tup[0]:tup[1]},zip((('a'),('b')),(('c'),('d')))))) # 执行结果 # [{'a': 'c'}, {'b': 'd'}]
num = [1,2,3,4,5,6,7,8,9] ret=filter(lambda x:True if x%2==0 else False,num) #lambda后面可以接列表推导式，三元运算符，一些简单的判断条件 print(list(ret)) 执行结果 [2, 4, 6, 8]
a = lambda i:i*1
我们第一眼看上去是发现没有函数名的，在匿名函数里面其实是有函数的名的，整个lambda就是函数，将执行的结果赋值给a，a就是函数名。
匿名函数有个很重要的点就是，要想去实现一些功能，必须结合我们前面学习的内置函数方法，特别是一个简单的功能，自己从头到尾写一个函数结果是能通过内置方法完成的时候，匿名函数就显得尤为重要。
♣三：递归函数
A：初识递归函数
def stock(): print('乐视股份涨幅百分之50') stock() #递归函数就是在函数内部调用函数本身 stock() # 执行结果： # 乐视股份涨幅百分之50 # 乐视股份涨幅百分之50Traceback (most recent call last): # RecursionError: maximum recursion depth exceeded while calling a Python object # 可以看到递归函数不加以控制，到后面就会报错，这个是因为递归函数在执行的时候回不停的开辟内存空间，python自己会加以控制 # 上面这个错误意思其实是说超过了递归的最大深度 def stock(): print('乐视股份涨幅百分之50') stock() #递归函数就是在函数内部调用函数本身 print('这是下面一句话') stock() 执行结果 乐视股份涨幅百分之50Traceback (most recent call last): RecursionError: maximum recursion depth exceeded while calling a Python object 可以发现一直执行到报错了，还是没有打印函数最后面的那句话，可见递归函数具有一个特性就是在函数内部调用的地方并不会结束。 k = 0 def stock(): global k k+=1 print(k) stock() stock() 执行结果 998Traceback (most recent call last): RecursionError: maximum recursion depth exceeded while calling a Python object 可以看到一直到报错，python内部限制是998次 import sys sys.setrecursionlimit(10000) k = 0 def stock(): global k k+=1 print(k) stock() stock() 执行结果 4048 4049 可以通过上面的模块方法解除python对递归函数的内存限制，但是我上面给的是10000，但是跑出来最后的结果是4049，这个是和电脑配置有关系，不是python的限制了
递归函数的缺点之一就是占用内存空间，而且我们也知道递归函数有个特性就是python对内存的限制，从几个方面来看，如果你的程序是需要大量循环执行的，递归函数是不适合的。
当然递归函数也是有优点的，他包含了所有函数共有的有点就是可以重复调用和让代码变得简单。
B：递归函数实例
通过上面递归函数的初步认识，我们也能大致描述出来递归函数的使用场景，1：求解一个问题的结果是不能直接拿到的，需要通过解决另外一个问题得到答案，2：而另外一个问题还是需要解决在另外一个问题的答案而得到。
def num(k): if k == 4: return 40 elif k>0 and k<4: return num(k+1)*2 print(num(2)) 执行结果 160