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)
# 执行结果
# 24

# 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
递归函数

 

posted on 2018-09-02 20:10  ppc_server  阅读(202)  评论(0编辑  收藏  举报

导航