python基础篇（四）

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

递归函数