函数

函数

1.函数如何定义、调用：

def mylen():  #定义函数
    name = 'alexaaa'  #字符串
    length = 0
    for char in name:
        length += 1
    print(length)

mylen()     #函数的调用

 

2.return的作用:

def my_max():
    a = 111
    b = 222
    if a > b:
        return a
    else:
        return b

a = my_max()
print('a : ' ,a)
返回值的关键字 return

①return能够返回值

②return可以结束一个函数的执行

 

3.返回None:函数里什么都不写，return 后面没有返回值，return None

4.可返回一个值和多个值：

（1）返回一个值：return可以返回任意内容

（2）多返回值：多个返回值以逗号隔开以元组的形式被返回

5.接收返回值：

（1）返回一个值，接收一个值

（2）返回多少个值就用几个变量去接收，必须不多不少

def find():
    l = [1,2,3,4,5,6]

    for i in l:
        if i % 3 == 0:
            return i
num = find()
print(num)                                     #只能找到从左往右的第一个数



def find2():
    l = [1, 2, 3, 4, 5, 6]
    new_l = []
    for i in l:
        if i%3 == 0:
            new_l.append(i)
    return new_l

n_l = find2()
print(n_l)                                         #可以找到能被3整除的所有数
  

 

def func():
    a = 10
    if a>5:
        # return 1,2,3  #===(1,2,3)
        return [1,2,3]  #===[1,2,3]

a,b,c = func()
print(a,b,c)

6.参数：

（1）参数可以是任意的数据类型

（2）实参和形参的个数相等

 

7.站在函数调用的角度上：位置传参、关键字传参、混用（先按位置传参，再关键字传参）----都是实参

（1）位置传参

（2）关键字传参

（3）混用

def func(a,b):        #站在函数定义的角度上：位置参数
    print(a,b)

                            #站在调用函数的角度上
func(1,2)               #按照位置传参
func(b=1,a=2)       #按照关键字传参
func(1,b=2)           #混用：先按照位置传参，在按照关键字传参

定义一个函数，接收两个参数（列表）：返回最长的列表
def func(lista,listb):
    if len(lista)>len(listb):
        return lista
    else:
        return listb
li=[1,2,3]
li1=[1,2,4,5]
print(func(li,li1))             #位置传参

 

8.站在函数定义的角度上：位置参数、动态参数（*）、默认参数、动态参数（**）----都是形参

（1）默认参数：可以不传，不传的话默认是设置的默认值，如果传就

             用传入的值；默认的值在定义阶段就确定了

def welcome(name,sex='male'):   #sex默认参数
    print('welcome,%s,sex:%s'%(name,sex))
welcome('ss')
welcome('dd')
welcome('qq','female')

（2）默认参数陷阱，只针对可变的数据类型

def age(age,my_age=18):
    if  age>my_age:
        return  False
    else:
        return True
a=18
def age(a1,a2=a):

    print(a1,a2)
a=20
age(10)       #永远是18

 demo3(a=[]):
    a.append(1)
    print(a)
demo3()
demo3()
demo3()
demo3([])
demo3([])
demo3([])

def func(l=[]):
    l.append(123)
    print(l)
func()
func([])
func()

（3）动态参数：(*args,**kwargs)接收参数个数不确定的时候
     ①站在函数定义的角度上：*做聚合用，将一个一个的参数组合成一个元组

       站在函数调用的角度上：*做打散用，讲一个列表或元组打散成多个参数

       *只针对按位置传参

     ②**kwargs：接收按关键字传递过来的参数，组织成一个字典

def demo4(**kwargs):
    print(kwargs)
# demo4(a=1,b=2,c=3)
d={'a':1,'b':2,'c':3}
demo4(**d)

def demo5(*args,**kwargs):
    print(args)
    print(kwargs)
demo5(1,2,3,a=10,b=20)   #必须先位置传参，再关键字传参

def func(位置参数1,位置参数2,*args,默认参数=10,**kwargs):
    print(位置参数1,位置参数2)
    print(默认参数)
    print(args)
    print(kwargs)
func(1,5,3,4,5,默认参数='dddd',a=2,b=5)
func(1,2,3,4,5,a=10,b=20)

9.函数的嵌套定义：

def func():
    print(123)
    def func2():
        print(234)
    func2()
func()

嵌套函数：为了保证某些功能特有的函数不被其他人随意调用

def func(x,y,z):
    print(x,y,z)
    def func_inner(a,b,c):
        print('func_inner',a,b,c)
    func_inner(x,y,z)
func(4,5,6)

def func(*args,**kwargs):
   print(args)
   print(kwargs)
   def func_inner(a,b,c):
        print('func_inner',a,b,c)
   func_inner(*args,**kwargs)
func(1,b=2,c=3)

 

10.三元运算：

a=10
b=15
c=a if a>b else b
print(c)

结果=if条件成立的结果else条件不成立的结果

11.启动python时：

　　（1）先加载内置的命名空间

　　（2）再加载全局命名空间的名字--从上到下去加载

　　（3）最后加载局部命名空间的名字--调用该函数的时候，从上到下去加载

12.函数命名空间分为：内置命名空间、全局命名空间、局部命名空间；

　　全局命名空间，除了函数内部的名字之外，我们自己的代码里所有的名字；

　　局部命名空间：函数内部的

13.局部可以使用全局命名空间的名字，但全局不可以使用局部的命名空间；对于局部来说，自己  　　有用自己的，自己没有用全局的

14.函数的作用域

（1）内置的命名空间：在任意地方都可以用

（2）全局的命名空间：在我们写的代码的任意地方用

（3）局部的命名空间：只能在自己的函数内使用

a=1
def demo1():
    a='demo1'
    print(a)
demo1()
print(a)


a=1
def demo1():
   def demo2():
        a=3
        print(a)
   demo2()
   print(a)
demo1()
print(a)

范围从大到小：内置命名空间--全局命名空间--局部命名空间

作用域：站在范围小的局部，局部有用局部，局部没有往上一层找，找到第一个可用的名字就用这个

a=0
def demo1():
    b=5
    print(globals())
    print(locals())
demo1()


 a=0
 def demo1(a):
     global a
     a=5
     print(a)


a=0
def demo1():
    a=1
    def demo2():
        nonlocal a
        a=2
        print(a)
    demo2()
    print(a)

demo1()
print(a)

demo1()
print(a)


a=0
def demo1():
    a=1
    def demo2():
        nonlocal a
        a=2
        print(a)
    demo2()
    print(a)

demo1()
print(a)

demo1()
print(a)
global   修改全局命名空间里的变量值
nonlocal   只修改局部命名空间里的，从内部到外部找到第一层

15.函数的名字：

（1）可以当做变量使用，函数是第一类对象

（2）是一个函数的内存地址

（3）可以赋值，可以作为其它列表等容器类型的元素

（4）可以作为函数的参数，作为函数的返回值

def alex():
    print(123)
a=alex
l=[alex]

print(alex)
print(l[0])
l[0]()





def alex():
    print(123)

def func():
    return alex
print(func())

16.闭包函数：内部函数引用了外部函数的变量，内部函数就叫做闭包函数

def func():   #外部函数
    name='egon'

    def inner():   #内部函数
       print(name)

    return inner
inner=func()
inner()
print(inner)

17.闭包的作用：在代码不改变的情况下，让代码只创建一次内存空间

import time
def timmer(func):
    #函数名可以当做函数的参数
    def inner():
        start=time.time()
        func()
        end=time.time()
        print(end-start)
def hahaha():
    time.sleep(0.1)
    print('aaaa')
#hahaha()
timmer(hahaha)
不能修改这个函数的调用方式
也不能修改原代码

hahaha=timmer  #timmer函数的地址给了hahaha
hahaha(hahaha)#实际上执行的是timmer

18.闭包的应用：

（1）装饰器：在不改变原函数调用方式的情况下，在这个函数前后加上扩展功能

格式：
def timmer(func):
    def inner(*args,**kwargs):
        '''添加函数调用之前的扩展代码'''
        ret=func(*args,**kwargs)
        '''添加函数调用之后的扩展代码'''
        return ret
    return inner

例子：
def wrapper(func):#装饰
    def inner(*args,**kwargs):

        ret=func(*args,**kwargs)

        return ret
    return inner
@wrapper
def aaa():
    print('dddddd')

aaa()

import time
def wrapper(func):#装饰
    def inner(*args,**kwargs):
        start=time.time()
        ret=func(*args,**kwargs)
        end=time.time()
        print(end-start)
        return ret
    return inner


@wrapper
def lll():
    time.sleep(0.2)
    print('hello')
lll()

（2）爬虫：从网页上爬取信息

from urllib.request import urlopen
def get_url():
    url='http://www.cnblogs.com/Eva-J/articles/7156261.html'
    def inner():
        ret=urlopen(url).read()
        return ret
    return inner
get_web=get_url()
res=get_web()
print(res)