函数详解day04

首页 > 代码库 > 函数详解day04

2024-09-27 07:32:38 216人阅读

1.函数对象：函数是第一类对象，即函数可以当做数据被传递... 1

2.函数的嵌套调用：在一个函数内部调用其他函数... 1

3.函数的嵌套定义：... 1

4.名称空间与作用域... 1

5.闭包函数：内部函数包含对外部作用而非全局作用域的引用，该内部函数就是闭包函数 2

1.函数对象：函数是第一类对象，即函数可以当做数据被传递

1.可以被引用

2.可以当做参数传递

3.返回值可以是函数

4.可以当做容器类型的元素

2.函数的嵌套调用：在一个函数内部调用其他函数

3.函数的嵌套定义：

def f1():

def f2():

print(‘f2‘)

def f3():

print(‘f3‘)

f1()

执行结果：什么都没有，因为只是定义了，没有调用f2

def f1():

def f2():

print(‘f2‘)

def f3():

print(‘f3‘)

f3()

f2()

f1()

输出结果：f2,f3

4.名称空间与作用域

全局作用域：内置名称空间，全局名称空间

局部作用：局部名称空间

变量查找顺序：局部->全局->内置

x = 1000

def func(y):

x=2

print(locals())#打印局部变量

print(globals())#打印全部变量

func(1)

输出结果：

{‘x‘: 2, ‘y‘: 1}

{‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x0000000000657B38>, ‘__spec__‘: None, ‘__name__‘: ‘__main__‘, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__doc__‘: None, ‘__package__‘: None, ‘x‘: 1000, ‘__file__‘: ‘D:/kinggsoft/python_file/day04/day04.py‘, ‘__cached__‘: None, ‘func‘: <function func at 0x0000000000711400>}

5.闭包函数：内部函数包含对外部作用而非全局作用域的引用，该内部函数就是闭包函数

def f1():

x = 1#外部非全局变量

def f2():

print(x)

return f2

res = f1()#返回f2地址

res()

函数外面包了一层函数，用来控制变量作用域

6.装饰器：

usr_info={‘username‘:None,‘state‘:False}

def auth(a):

def auth2(func):

def wrapper(*args,**kwargs):

if args[0] ==‘dodo‘ and args[1] == ‘111‘:

func(*args,**kwargs)

usr_info[‘username‘]=args[0]

usr_info[‘state‘]=True

if a == ‘dodo‘:

print(‘supper manger‘)

elif a:

print(‘ussall‘)

return wrapper

return auth2

@auth(adapt)#welcom=auth(welcome)

def welcome(name,pwd):

print(‘welcome,%s‘ %(name))

while True:

name =input(‘name:‘)

pwd = input(‘pwd‘)

a=welcome(name, pwd)

if a ==1:

break

6.装饰器：装饰别人的工具，修饰->添加功能，工具->函数

装饰器本身可能是任何可调用对象，函数（还有类）

被装饰对象也可能是任意可调用对象

为什么要用装饰器：对修改是封闭的，对扩张是开放的

装饰器就是为了在不修改源代码和函数调用方式的前提下，为其添加新功能

import time

def f(func):

def timmer(*args):

start = time.time()

func(*args)

end = time.time()

print(‘time:%s‘ %(end-start))

return timmer

@f#hello=timmer(hello)

def hello(name):

time.sleep(3)

print(‘hello!%s‘ %(name))

hello(‘egon’)

输出结果：

hello!egon

time:3.000171422958374

7.有参装饰器

#有参装饰器

def auth(driver):

def login(func):

def wrapper(*args,**kwargs):

if driver == ‘file‘:

if args[0]==‘dodo‘ and args[1] ==‘123‘:

a=func(*args,**kwargs)

return 1

else:

print(‘请输入正确的账号密码！‘)

else:

print(‘不识别的驱动‘)

return wrapper

return login

@auth(‘file‘)

def welcome(name,pwd):

print("*************welcome*************")

print("*************%s*************" %name)

return 1

while True:

name = input(‘name：‘)

pwd = input(‘pwd：‘)

a=welcome(name,pwd)

if a == 1:

break

8.多层装饰器嵌套

import time

def timmer(func):

def wrapper(*args,**kwargs):

start=time.time()

time.sleep(3)

func(*args,**kwargs)

end=time.time()

print(‘time:%s‘ %(end-start))

return 1

return wrapper

def login(func):#login = auth(login)

def wrapper(*args,**kwargs):

start = time.time()

time.sleep(3)

if args[0]==‘dodo‘ and args[1] ==‘123‘:

a=func(*args,**kwargs)

end = time.time()

print(‘logintime:%s‘ % (end - start))

return 1

else:

print(‘请输入正确的账号密码！‘)

return wrapper

@timmer

@login

def welcome(name,pwd,driver):

print("*************welcome*************")

print("*************%s*************" %name)

return 1

while True:

name = input(‘name：‘)

pwd = input(‘pwd：‘)

a=welcome(name,pwd,‘file‘)

if a == 1:

break

输出结果：

name：dodo

pwd：123

*************welcome*************

*************dodo*************

logintime:3.000171661376953

time:6.000343322753906

9.迭代器

重复的过程称为迭代，每次迭代都是下次迭代的初始值

为什么要用迭代器：对于没有索引的数据类型，必须提供一种不依赖于索引的迭代方式

只要数据类型下有__iter__()方法就是可迭代的，执行iter方法得到的结果就是迭代器

i=[1,2,3,4].__iter__()

print(i)

print(i.__next__())

输出结果：

<list_iterator object at 0x0000000000A70278>

通过next方法遍历

对字典的遍历，只能取到key，取不到val

i={‘bb‘:2,‘aa‘:4}.__iter__()

print(i)

print(i.__next__())

输出结果

<dict_keyiterator object at 0x00000000011C5408>

用迭代器遍历字典

dic ={‘bb‘:2,‘aa‘:4}
i=dic.__iter__()
print(i)
while True:
val=i.__next__()
print(dic[val])

输出结果

Traceback (most recent call last):

File "D:/kinggsoft/python_file/day04/day04.py", line 187, in <module>

val=i.__next__()

StopIteration

<dict_keyiterator object at 0x0000000001195408>

如何判断一个对象是可迭代的对象，还是迭代器对象

from collections import Iterable,Iterator

‘abc‘.__iter__()
[].__iter__()
{}.__iter__()
{‘a‘:1}.__iter__()
(1,).__iter__()
with open(‘ceshi.py‘) as f :
f.__iter__()
print(isinstance(‘aa‘,Iterable))
print(isinstance(‘aa‘,Iterator))

输出结果：

True

False

可迭代对象只有iter方法，

迭代器有next和iter方法

迭代协议：

对象有__next__方法

对象有__iter__对于迭代器对象来说，迭代器执行__iter__方法得到的还是迭代器本身，

for循环，enumerate也是迭代器

#for循环
dic = {‘name‘:‘lili‘,‘age‘:18}
for i in dic:#k=iter(dic) i=next(k)
    print(i)

相当于
i=iter(dic)
while True:
    try:
        k=next(i)
        print(k)
    except StopIteration:
        break

迭代器的有点和缺点

有点

提供了不依赖下标的迭代方式
就迭代器本身来说更节省内存

缺点

没有序列不灵活
无法获取长度

10.生成器

生成器函数：只要函数体包含yeild关键字，该函数就叫做生成器函数

吧函数变成了迭代器

ps:只要函数中有yield，就加括号不会执行函数，而是把函数变成迭代器

yield

#yeild

def foo():

yield 1

yield 2

yield 3

g=foo()

print(g)

print(next(g))

输出结果：

def foo():

print(‘one‘)

yield 1

print(‘two‘)

yield 2

print(‘three‘)

yield 3

g=foo()

print(g)

res=print(next(g))

输出结果

one

yield:功能

相当于为函数封装好iter和next方法
return 只能返回一次值

yield返回多次值

 #tail -f |grep ‘python‘

def tail():

    import time

    with open(‘与铁林‘,‘r+‘) as f:

        f.seek(0, 2)  # 跳到文件末尾

        while True:



            line = f.readline()

            if line:

                if ‘python‘ in line:

                    yield line

            else:

                time.sleep(0.2)

a=tail()

print(next(a))

程序执行结果

直到文件有新内容输入保存为止

内置函数

abs——绝对值
all——对所有值进行bool值判断，如果是返回true

all([1,2,3])=ètrue

any——只要一个是true就是true，空也是false
bin——十进制转为二进制
hex——十进制转为十六进制
oct——十进制转为八进制
chr——ASCII转为字符
ord——字符转为ASCII
complex——复数
工厂函数——dict、int、list、str、set
dir——查看属性
divmod（100,3）——打印输出（33,1）主要是分页功能
eval——把字符串里的内容提取出来执行

cmd=‘print（‘哈哈哈’）’

eval（cmd）

frozenset——定义不可变集合
hash——主要做校验，是一种算法
1. 只要校验内容一致，hash也是一样的
2. 不可逆：不能根据hash值退回原值
3. 只要采用hash算法一样的，不论被校验的内容多长，hash一样长
id——看对象的身份
is——身份运算符

x=1

y=x

print(id(x),id(y))=è得到的值是一样的

print(x is y)èTrue

max——最大值
pow——pow(10,2,3)è10的平方%3
reverse——反转，反转返回的是一个迭代器，不会影响原值

l=[‘a‘,2,4]
a=reversed(l)
print(a)
print(reversed(l))
print(list(reversed(l)))
print(l)

输出结果：

<list_reverseiterator object at 0x0000000000820278>

<list_reverseiterator object at 0x0000000000820470>

[4, 2, ‘a‘]

[‘a‘, 2, 4]

超级重点：

l=[‘a‘,2,4]

a=reversed(l)

for i in a:

print(i)

print(reversed(a))

输出结果：

Traceback (most recent call last):

File "D:/kinggsoft/python_file/day04/day04.py", line 244, in <module>

print(reversed(a))

TypeError: argument to reversed() must be a sequence

因为for已经把迭代器走完

round——保留小数，默认两位，四舍五入
slice——切片
vars——如果不加参数同locals查看局部变量
zip——一一对应

s=‘hello‘
l=[1,2,3,4,5,6,7]
z=zip(s,l)è迭代器
print(z)
for i in z:
print(i)

输出结果：

(‘h‘, 1)

(‘e‘, 2)

(‘l‘, 3)

(‘l‘, 4)

(‘o‘, 5)

函数详解day04

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 函数详解day04