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行
divmod（翻页案例）
数据结构相关（列表和元祖）
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}]
map（算总价）
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}]
filter（算单价）
B：作用域相关（2）
locals() #以字典的形式返回本地作用域中的名字
print(locals())
#执行结果
#{'__name__': '__main__', '__doc__': None, '__package__': None, '。。。。。。
def run(args):
a = 'k'
print(locals()) #在函数里面使用会当前位置返回全部的局部变量
run(4)
执行结果：
{'a': 'k', 'args': 4}
locals()
globals() #以字典的形式返回全局作用域中的名字
print(globals())
#执行结果
#{'__name__': '__main__', '__doc__': None, '__package__': None, '。。。。
globals()
C：迭代器，生成器相关（3）
这个里面包含iter，next，range，这三种方法前面都用到过，不清楚可以查看前面的用法。
D：反射相关（4）
后续补全
E：面向对象相关（9）
后续补全
F：其他（12）
print(dir(()))
执行结果
['__add__', '__class__', '__contains__', .......
查看变量拥有的所有方法
dir()查看对象属性
print(callable(print))
print(callable(range))
a = 1
print(callable(a))
执行结果
True
True
False
检查一个对象是否能被调用
callable()
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
print()打印进度条
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
exec和eval
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)
# 执行结果
# # print(list(map(lambda tup:{tup[0]:tup[1]},zip((('a'),('b')),(('c'),('d'))))))
# 执行结果
# [{'a': 'c'}, {'b': 'd'}]
lambda()的使用
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
递归函数