美文网首页
Python-lesson 3-函数

Python-lesson 3-函数

作者: noodlesbook | 来源:发表于2020-02-19 20:50 被阅读0次

1、函数知识体系

  1. 什么是函数?
    在程序中具备某一功能的工具就是函数
    函数的使用原则:先定义、后调用

  2. 为什么要用函数?
    (1)代码冗余
    (2)程序组织结构不清晰、可读性差
    (3)扩展性差

  3. 函数的分类:
    (1)内置函数
    python自带的
    (2)自定义函数
    自己定义的

  4. 自定义函数和使用
    函数的定义分为两个阶段:定义和调用
    函数定义: 定义只检测语法不执行代码

def 函数名(参数1,参数2...):          //必须
"""
文档注释
"""
    函数代码块1                  //必须
    函数代码块2
    ...
    return 值

函数调用:开始执行函数代码
函数名()

  1. 定义函数的三种方式
    (1)无参函数
    def func():
    print('......')
    func()

(2)有参函数
def func(x,y):
if x > y:
return(x)
else:
return(y)

res=func(1,2)

(3)空函数
def register():
pass

  1. 调用函数的三种形式
    (1)语句模式
    def func():
    print('......')
    func()

(2)表达式形式
def func(x,y):
if x > y:
return(x)
else:
return(y)

res=func(1,2) * 12
print(res)

(3)函数的调用可以当作另外一个函数的参数传入
def func(x,y):
if x > y:
return(x)
else:
return(y)

res=func(func(1,2),3)
print(res)

  1. 返回值的特点
    (1)返回值没有类型限制,也没有个数限制
    (2)return是函数结束运行的标志,函数内可以有多个return,但只要执行一次return函数就立即结束,并且将return后的值当作本次调用的结果返回。

  2. 函数的参数
    形参即变量名,实参即变量值,函数调用时,将值绑定到变量名上,函数调用结束,解除绑定

  3. 函数参数详解
    (1)形参

  • 位置形参:按照从左至右的顺序依次定义的形参
    特点:必须被传值

  • 默认参数:在定义阶段,就已经为某个形参赋值,该形参称之为默认形参
    特点:在定义阶段就已经有值,意味着调用阶段不用为其传值
    def func(x,y=2):
    print(x,y)

func(1)

注意:位置形参与默认形参可以混用,位置形参必须放在默认形参的前面

(2)实参

  • 位置实参:在调用阶段,按照从左到右的顺序依次传入的值
    特点:这种传值方式会与形参一一对应

  • 关键字实参:在调用阶段,按照key=value的格式传值
    特点:可以完全打乱位置,但仍然能为指定的形参传值

注意:
1、可以混用位置实参与关键字实参,但是同一个形参只能被赋值一次
2、位置实参必须在关键字实参的前面

(3)形参中*与**的用法

  • 形参中带*,*会将溢出的位置实参存成元组的形式然后赋值其后变量名
def func(x,y,*args):
    print(x,y,args)
print(1,2,3,4,5,6)
  • 形参中带**;**会将溢出的关键字实参存成字典的格式然后赋值其后变量名
def func(x,y,**kwargs):
    print(x,y,kwargs)
print(1,y=2,z=3,m=4,n=5)

(4)实参中* 与**的用法

  • 实参中带*;先将实参打散成位置实参,然后再与形参做对应
def func(x,y,z):
    print(x,y,z)

func(*[1,2,3])
func(*'llo')
  • 实参中带**;先将实参打散成关键字实参,然后再与形参做对应
def func(x,y,z):
    print(x,y,z)

func(**{'x':1,'z':3,'y':2})    //func(z=3,y=2,x=1)

将一个函数的参数完全转给另一个函数

def index(x,y,z)
    print(x,y,z)

def wrapper(*args,**kwargs):           
    index(*args,**kwargs)
#以上两行意思是将一个函数的参数完全传给另一个函数

wrapper(1,2,3)

2、函数对象

函数对象:把函数的内存地址当作一种变量值去使用,函数对象不加();如果内存地址加()就是在调用函数

与变量相同的用法:可以被引用、可以当作参数传递、返回值可以是函数、可以被储存到容器类型(列表、字典、元组)

独有的用法:加()可以运行其内部代码

  1. 可以被引用
def func1()
    print('from func')

func2=func1
func2()
  1. 可以当作参数传递
def func1()
    print('from func')

def bar(xxx)
    xxx()

bar(func1)
  1. 返回值可以是函数
def func1()
    print('from func')

def bar()
    return func1

f=bar()
f()
  1. 可以被储存到容器类型(列表、字典、元组)
def func1()
    print('from func')

l=[func1,]
l[0]()

3、函数嵌套

嵌套调用:在一个函数中调用了另一个函数
嵌套定义:在一个函数中定义的一个函数,只能在函数里面使用,外界不能用

def func1()
    print('hello')

def func2()
    print('world')
    func1()

func2()
----------------------------------------
world
hello

4、名称空间

名称空间:就是存储名字与内存地址绑定关系的空间

4.1 名称空间的分类:

(1)内置名称空间:存储解释器自带的变量名称与值的对应关系(print、len、max、min);python解释器启动时创建内置名称空间,关闭解释器销毁
(2)全局名称空间:文件级别的名称,只要你的名字定义是顶着最左边(空格也算)写的就在全局空间,除了内置的和函数内的,都是全局名称空间;执行py文件创建全局名称空间,关闭解释器销毁
(3)局部名称空间:只要在函数里面就是局部的;调用函数时创建,函数执行完毕销毁

  • 名称空间的加载顺序
    内置的名称空间--->全局的名称空间---->局部的

  • 查找顺序
    局部的名称空间---->全局的名称空间----->内置的名称空间

  • 总结:
    1、名字的查找顺序是从当前位置往外查找
    2、名称空间的嵌套关系是在函数定义阶段就固定死的,与调用位置无关。

5、作用域(作用范围)

域:指的是区域,范围的意思
全局的名称空间和内置的名称空间,在使用上没有什么区别
局部的和全局的内置的就区别了,局部定义的只能在局部使用
函数的作用域在定义时就固定了,与调用的位置没有关系

  • 给三个空间划分范围
    全局的和内置的可以划分为同一个范围
    global 表示的全局范围 ,就是所谓的全局作用域

局部的单独划分为一个范围
local 局部作用域

# 查看全局作用域中的内容
print(globals())
# 查看全局作用域中的值
print(dir(globals()["_builtins_"]))

#明确使用函数外的变量
global age(函数名)

# nonlocal 明确声明使用上一层的函数变量,如果上一层没有,则找上上层的,但是不能找到全局的变量
 nonlocal a(函数名)

# 查看局部作用域中的内容
print(locals())
  • 总结:
    1、如果是不可变类型,函数内变量值改变不会改变全局变量,若要改变需要声明;如果是可变类型,函数内变量值改变会改变全局变量
    2、函数内变量尽量独立,不改变全局变量。

6、闭包函数

闭包函数与普通函数的区别
(1)定义在另一个函数中
(2)在内部的函数中使用了外部的变量(不包含全局的变量)

# 为函数体传值的方案一:直接以参数的形式传入
def f(x):
      print(x)

f(10)

# 为函数体传值的方案二:函数之上传入,并返回函数本身,打包成闭包函数,并且闭包函数的调用赋值给全局变量
def inner():
      x=10
      def f():
            print(x)
      return f       //在返回这个内部的函数时,不是单纯的返回函数,还把内部函数中访问到的局部名称一起打包返回,所以叫做闭包函数
y=inner()
y()
---------------------------------------------
10

# 第二种传参方式可以演变成:
def inner(x):
      def f():
            print(x)
      return f 

y=inner(11)
y()
----------------------------------------------
11

# _closure_用于访问,闭包时打包的数据
print(f._closure_[0].cell_contents)
print(f._closure_[1].cell_contents)

7、装饰器

7.1 什么是装饰器

装饰器:装饰器就是一个用于给其它函数增加功能的函数
装饰器本身可以是任意可调用对象
被装饰对象本身也可以是任意可调用对象

7.2 为什么要用装饰器

开闭原则:对扩展开放,对修改封闭(可以添加新功能,但是不能修改源代码和调用方式)

所以添加新功能,但是源代码不能动,调用方式也不能动;装饰器的目的就是在遵循开闭原则的基础上添加新功能

装饰器 和 闭包函数的关系:装饰器是一种设计代码的套路(在不修改源代码和调用方式的情况下增加功能),要完成装饰器,就需要使用闭包函数

# 装饰器
import time

def index():
    print("开始下载xxx.mp4")
    time.sleep(2)
    print("xxx.mp4 下载完成!")

def outter(func):
    def wrapper():
        start_time = time.time()           //此处可修改,添加新功能
        func()
        end_time = time.time()           //此处可修改,添加新功能
        print("下载耗时:",(end_time - start_time))
    return wrapper

index=outter(index)    //返回给wrapper内存地址;wrapper内存地址中又包括最原始的index内存地址
index()

# 装饰器改进
import time

def outter(func):
    @wraps(func)              //将被装饰对象的属性信息传给新的装饰器函数
    def wrapper(*args,**kwargs):     //将参数完全传给func()
        start_time = time.time()          
        res=func(*args,**kwargs)      //完全接受wrapper的参数;并且以变量的形式接收func()的返回值,也就是被装饰对象的返回值
        end_time = time.time()         
        print("下载耗时:",(end_time - start_time))
        return res
    return wrapper

@outter                //语法糖;index=outter(index) ,根据被装饰函数的名字,自动调用装饰器
def index():
    print("开始下载xxx.mp4")
    time.sleep(2)
    print("xxx.mp4 下载完成!")
    return 1234           //被装饰对象有返回值

@outter              //语法糖;home=outter(home)
def home(name):      //被装饰对象有参数
    time.sleep(1)
    print('welcome %s to home page' %name)

装饰器模板

from functools import wraps          //导入functools模块,装饰器wraps

def outter(func):
      @wraps(func)              //将被装饰对象的所有属性赋值给wrapper
      def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            return res
      return wrapper

@outter
def index():
      time.sleep(1)
      print('welcome to index page')
      return 1234

index()

7.3 多个装饰器

多个装饰器加载顺序:(由被装饰函数)由下至上
多个装饰器执行顺序:由上至下
加载顺序:


image.png

执行顺序:


image.png

8、三元表达式

x if x > y else y //条件成立返回左边,条件不成立返回右边
res='ok' if True else 'False' //条件成立执行左边,条件不成立执行右边

9、容器表达式

9.1 列表生成式

l=[i**2 for i in range(10)]    //将for循环的值按照左边表达式直接插入列表

l=[i**2 for i in range(10) if i > 4]   //将for循环的值判断条件,符合条件的值按照左边表达式直接插入列表

sbs=[name.upper() for name in names if name.endswith('sb')]              //在列表names里,如果有sb结尾的将其大写,插入sbs列表

9.2 字典生成式

res=[i:i**2 for i in range(10) if i > 4]
---------------------------------------------------
{5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

9.3 集合生成式

print({i for i in 'hello'})
----------------------------------------------------
{'l', 'o', 'e', 'h'}

10、匿名函数

匿名函数就是指定义了一个函数的内存地址,主要用于临时使用一次的场景

(lambda x,y:x+y)(1,2)            //x,y为参数,没有函数名;冒号后为代码块,自带return     
print(res)
-------------------------------------------------
3 

# 匿名函数通常和其它函数配合使用
print(max(salaries,key=lambda k:salaries[k]))    //以匿名函数作为参数比较大小;key的意思是以什么作为比较的参数,取最大

# 排序
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))             //以value从大到小排序

相关文章

  • Python-lesson 3-函数

    1、函数知识体系 什么是函数?在程序中具备某一功能的工具就是函数函数的使用原则:先定义、后调用 为什么要用函数?(...

  • 队列-击鼓传花

    1-创建队列对象 2-击鼓传花函数 3-调用函数 4-结果

  • Javascript(3-函数)

    HTML文档中的js函数必须包裹在 标签中,外链js文件则不需要 标签。函数使用function关键字定义,并可带...

  • 函数

    1-用来封装语句,可以在任何时候任何地方调用函数2-有匿名函数、命名函数之分3-严格模式下对函数的限制 (了解即可...

  • Spark语法

    SQL语法规范:分组语句中,select后面只能跟三种情况,1-分组字段,2-函数结果【聚合函数】,3-常量 cr...

  • 【python基础】3-函数

    def:定义函数 print 函数 range 函数 type 函数 变量作用域 def:定义函数 def关键字用...

  • 3-函数式编程

    函数声明 为了代码的可读性,在定义一个函数的时候,最好有其函数参数的说明。示例: 实现这种效果可以通过插件设置,比...

  • dart语法3-函数

    dart语法1dart语法2-内置类型dart语法3-函数dart语法4-操作符dart语法5-异常dart语法6...

  • 2018-12-08

    3-甲氧基-1-丙醇 中文名称:3-甲氧基-1-丙醇 中文别名:3-甲氧基丙醇,3-甲氧基-1-丙醇; 1,3-丙...

  • [Swift5.1] 3-函数

    函数定义 形参默认是let,也只能是let 无返回值 返回值()实质是空元组 隐式返回(Implicit Retu...

网友评论

      本文标题:Python-lesson 3-函数

      本文链接:https://www.haomeiwen.com/subject/umvbfhtx.html