python——函数

1.介绍:

在过去的十年间,大家广为熟知的编程方法无非两种:面向对象和面向过程,其实,无论哪种,都是一种编程的规范或者是如何编程的方法论。而如今,一种更为古老的编程方式:函数式编程,以其不保存状态,不修改变量等特性重新进入人们的视野。下面我们就来依次了解这一传统的编程理念,让我们从基本的函数概念开始。

2.函数定义:

初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数。自变量x的取值范围叫做这个函数的定义域,编程语言中函数定义:函数是逻辑结构化和过程化的一种编程方法。

函数定义规范

def 函数名(arg1,arg2,arg3):

"描述信息"

函数体

return 1

查看函数注释:

def foo():
'foo function'
print("from the foo")
print(foo.__doc__)

输出结果:

foo function

2.1 定义无参函数 

def foo():
print("from the foo")

2.2 定义有参函数

 def bar(x,y):
res=x+y
return res

2.3 定义空函数  

 def auth():
pass

2.4有参与无参的区别及其应用场景 

 这个功能需要外部传值,就是有参函数,否则,就是无参函数

3、调用函数:

3.1 调用无参、有参和空函数

  调用无参函数:(定义无参,调用也无参)
foo()
调用有参函数:(定义有参,调用也必须有参)
res=bar(1,2)
调用空函数:
auth()

4、语句和表达式形式调用函数 

语句形式调用:foo()
表达式形式调用: (此时函数有返回值)
res=bar(1,2)*10
bar(bar(1,2),3) #函数调用作为另一个函数的参数

  

5、函数返回值return

(1)函数返回值可以是任意类型数据

(2)无参函数通常没有返回值,有参函数通常有返回值

(3)函数没有return返回值但会返回None

没有return---> None

def foo():
print("from the foo")
res=foo()
print(res)

输出结果:

from the foo
None

(4)返回多个值会作为元组类型返回

return 1---->1
return 1,2,3 -----> (1,2,3)
def my_max(x,y):
res=x if x>y else y
return res
res1=my_max(1,2)
print(res1)

输出结果:

2
def bar(x,y):
return 1,2,3,4,5,[1,2],{"a":2},{1,2,3}
res1=bar(1,2)
print(res1)

输出结果:

(1, 2, 3, 4, 5, [1, 2], {'a': 2}, {1, 2, 3})

(5)接收返回值:

单个返回值:res=bar(1,2)

多个返回值:res=bar(1,2)  res是元组类型

多个返回值:a,b,c=bar(1,2)  a,b,c分别接收返回值

 

def bar(x,y):
return 1,2,3
a,b,c=bar(1,2)
print(a)
print(b)
print(c)

输出结果:

1
2
3

(6)函数只会执行一个return,就结束函数并返回值,无论写多少return

小知识:解压变量

6、有参函数的参数  

 python是弱类型语言,参数的类型不需要指定类型,但是会有不合法的数据类型,python不能限制,只能注释提醒

例:X,y没有指定数据类型,所以什么类型都行。使用灵活,但是乱用会报错。可以使用注释信息提醒

def my_max(x,y):
res=x if x>y else y
return res
print(my_max(1,2))
print(my_max('a','b'))
print(my_max('a',1))

输出结果:

2

b

TypeError: unorderable types: str() > int() #报错

  

6.0函数写注释方法

方法1:   

def my_max(x,y):
"""x->int,y->int,res->int,cal max value"""
res=x if x>y else y
return res

方法2:

def my_min(x:int,y:int)->int:
print(x if x<y else y)
my_min(1,2)
print(my_min.__annotations__)

输出结果:  

1
{'y': <class 'int'>, 'x': <class 'int'>, 'return': <class 'int'>}

__annotations__用显示出函数的注释信息

6.1 形参和实参的概念 

形参与实参的定义

 def foo(x,y):  # 在函数定义阶段,括号内定义的参数-->形式参数(本质就是变量名)
print(x)
print(y)
foo(1,2) ##在函数调用阶段,括号内定义的参数-->实际参数(本质就是变量值,实参必须有一个确定的值)
# 形参和实参的绑定关系在定义时没有生效,在调用时生效,形参被赋值实参的值,函数结束时解除绑定

实参要保证是不可变的类型:字符,数字,元组,如果是可变的类型,形参也可以修改实参。因此需要注意:不要在函数内动用全局变量,函数的功能就与函数有关,不要动全局变量。 

实参的值为不可变类型时: 形参不能改变实参的值  

def bar(x):
print(x)
x=3
x=1
bar(x)
print(x)

输出结果:

1
1

实参的值为可变类型时: 形参可以改变实参的值

def bar(x):
x.append(4)
x=[1,2,3]
bar(x)
print(x)

输出结果:

[1, 2, 3, 4]

6.2  实参的角度分析:书写三种方式  

(1)位置实参

按照位置传值,按照位置写就是位置实参

def foo(x,y):
print("x=",x,",y=",y)
foo(1,2)
foo(2,1)

输出结果:

x= 1 ,y= 2
x= 2 ,y= 1

  

(2)关键字实参

按照关键字传值:关键字实参

什么等于什么 就是关键字传值

def foo(x,y):
print("x=",x,",y=",y)
foo(x=1,y=2)
foo(y=2,x=1)

输出结果为:

x= 1 ,y= 2
x= 1 ,y= 2

  

(3)位置实参和关键字实参混着用

1 位置参数必须在关键字参数之前。 按位置传值必须在按关键字传值的前面 

def foo(x,y):
print("x=",x,",y=",y)
foo(1,y=2)

输出结果:

x= 1 ,y= 2
def foo(x,y):
print("x=",x,",y=",y)
foo(y=2,1)

输出结果:

SyntaxError: positional argument follows keyword argument  #报错

2 对于一个形参只能赋值一次,不能重复赋值

def foo(x,y):
print("x=",x,",y=",y)
foo(1,x=1,y=2)

输出结果:

TypeError: foo() got multiple values for argument 'x'  #报错

6.3 形参的角度分析

(1)位置形参

必须传值的参数,传值时多或少都不行

def foo(x,y):
print("x=",x,",y=",y)
foo(1,2,3)

输出结果:

TypeError: foo() takes 2 positional arguments but 3 were given  #报错

(2)默认形参

1 常用的,变化比较小的值设为形参的默认值

2 形参设置默认形参时,必须放到形参中位置形参的后面

3 默认形参在函数定义的时候就已经被赋值了

4 在函数定义阶段,python只是会检查函数的语法是否错误;

在函数调用阶段,python才会输出执行函数代码的错误

5 默认形参也可以传值,也可以不传

1 常用的,变化比较小的值设为参数的默认值 

def foo(x,y=1):
print("x=",x,"y=",y)
foo(1)

输出结果:

x= 1 y= 1

Python自带许多有默认形参的函数

2 形参设置默认参数时,必须放到形参中位置参数的后面

 

可以这样理解:函数名相当于变量名,函数的代码相当于变量的值,定义函数相当给函数名与函数代码绑定,

引用函数名,就是引用函数代码

在函数定义阶段,函数绑定到一堆代码,python只是会检查函数的语法是否错误;

在函数调用阶段,python才会输出执行函数代码的错误

 

3 形参默认参数在函数定义的时候就可以被赋值了

x='male'
def register(sex=x):
print(sex)
x=None
register()

输出结果为:

male

4 默认参数是可变类型时

x=[]
def register(name,name_list=x):
name_list.append(name)
register("wen")
register("yan")
register("jie")
print(x)

输出结果:

['wen', 'yan', 'jie']

(3)形参:*args

1 功能:将实参那边的位置参数传值多余的值都接收,成元组类型

2 也是属于位置参数,但要放在其他位置参数的后面

形参参数排序:1 其他位置参数  2 *args  3 默认参数

一般*args和默认参数不要一起用

3 *args可以看做是无穷的位置参数,根据实参的数量而变化

4 * 的功能就相当于将形参名打散成多个,接收实参过来的值

*也可以用在实参里,将值打散分成多个传给形参

对以后装饰器有用

1 功能:将实参那边的位置参数传值多余的值都接收,成元组类型

def foo(x,*args):
print(x)
print(args)
foo(1,2,3,4,5,6,7,8,'a','b')

输出结果:

1
(2, 3, 4, 5, 6, 7, 8, 'a', 'b')

2 形参参数排序:1 其他位置参数  2 *args  3 默认参数 。 一般*args和默认参数不要一起用

def foo(x,y=1,*args):
print("x=",x)
print("y=",y)
print("args=",args)
foo(1,2,3,4,5)

输出结果:

x= 1
y= 2
args= (3, 4, 5)
def foo(x,*args,y=1):
print("x=",x)
print("y=",y)
print("args=",args)
foo(1,2,3,4,5)

输出结果:

x= 1
y= 1
args= (2, 3, 4, 5)

  

 3 *的概念

* 的功能就相当于将形参名打散成多个,接收实参过来的值

*也可以用在实参里,将值打散分成多个传给形参

例:将args分成多个形参接收实参过来的值

*args=1,2,3
args=(1,2,3)
*(1,2,3)=1,2,3

从形参角度:

def foo(*args):
print(args)
foo(1,2,3)

输出结果: 

(1, 2, 3)

从实参角度:将实参的元组打散分别传给形参

def bar(x,y,z):
print(x)
print(y)
print(z)
bar(*(1,2,3))

输出结果:

1
2
3

*功能的再一例子:

def my_sum(nums):
res=0
for i in nums:
res+=i
return res
print(my_sum((1,2,3,4,5)))
def my_sum(*nums):   #比上面例子多一个*号
res=0
for i in nums:
res+=i
return res
print(my_sum(1,2,3,4,5)) #比上面例子少一对括号

(3)形参:**kwargs

接收关键字参数

1  功能:将实参那边的多余的关键字传值变成字典类型,赋值给kwargs

2  混着用的位置:在形参角度看,**kwargs位于*args之后

3  **的概念

* 的功能就相当于将形参名打散成多个对(默认参数,即x=1),接收实参过来的值

* 也可以用在实参里,将字典打散分成多个关键字参数(即x=1)传给形参

4  *args和**kwargs联用

1 将实参那边的关键字传值多余的变成字典类型,赋值给kwargs

def foo(x,**kwargs):
print(x)
print(kwargs)
foo(1,y=2,a=3,b=4)

输出结果:

1
{'a': 3, 'y': 2, 'b': 4}

使用**kwargs报错的例子:

def foo(x,**kwargs):
print(x)
print(kwargs)
foo(1,2,3,4)

输出结果:

TypeError: foo() takes 1 positional argument but 4 were given  #报错

  

2  **的概念

* 的功能就相当于将形参名打散成多个对(默认参数,即x=1),接收实参过来的值

* 也可以用在实参里,将字典打散分成多个关键字参数(即x=1)传给形参

从形参的角度:

def foo(**kwargs):
print(kwargs)
foo(x=1,y=2,z=3)

输出结果:

{'z': 3, 'x': 1, 'y': 2}

 

从实参角度:

def foo(x,y,z=1):
print(x)
print(y)
print(z)
foo(**{'x':1,'y':2,'z':3}) #相当于 foo(x=1,y=2,z=3)
输出结果为:

输出结果:

1
2
3

 

3 在形参角度,**kwargs位于*args之后

def foo(x,*args,**kwargs):
print(x)
print(args)
print(kwargs)
foo(1,y=1,z=2)

输出结果:

1
()
{'y': 1, 'z': 2}

再例:

def foo(x,*args,**kwargs):
print(x)
print(args)
print(kwargs)
foo(1,2,3,4,5,6,a=7,y=1,z=2)

输出结果:

1
(2, 3, 4, 5, 6)
{'y': 1, 'a': 7, 'z': 2}

  

4 *args和**kwargs联用的好处:灵活

调用auth函数参数输入灵活,实参是关键字参数和位置参数都可以,实参输入位置参数的时候注意位置

def auth(name,password,sex='female'):
print(name)
print(password)
print(sex)
def foo(*args,**kwargs):
print("from foo")
auth(*args,**kwargs)
foo('yuan','123')
foo('wen','123',sex='male')
foo(name='wen',password='123',sex='male')

  

5 *args和**kwargs联用实现执行函数的计时问题

计时功能:

import time
def auth(name,password,sex='male'):
time.sleep(1)
print(name,password,sex)
def timmer(*args,**kwargs):
start_time=time.time()
auth(*args,**kwargs)
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
timmer(name=1,password=123,sex='female')

输出结果:

1 123 female
run time is 1.0004379749298096

python——函数的更多相关文章

  1. python 函数之day3

    一 函数的语法及特性 什么是函数? 定义:函数是一个功能通过一组语句的集合,由名字(函数名)将其封装起来的代码块,要想执行这个函数,只要调用其函数名即可. 特性: 减少重复代码 使程序变的可扩展 使程 ...

  2. Python函数作用域的查找顺序

    函数作用域的LEGB顺序 1.什么是LEGB? L:local 函数内部作用域 E:enclosing 函数内部与内嵌函数之间 G:global 全局作用域 B:build-in 内置作用域 2.它们 ...

  3. Python函数讲解

    Python函数

  4. Python函数信息

    Python函数func的信息可以通过func.func_*和func.func_code来获取 一.先看看它们的应用吧: 1.获取原函数名称: 1 >>> def yes():pa ...

  5. Python函数参数默认值的陷阱和原理深究"

    本文将介绍使用mutable对象作为Python函数参数默认值潜在的危害,以及其实现原理和设计目的 本博客已经迁移至: http://cenalulu.github.io/ 本篇博文已经迁移,阅读全文 ...

  6. Python开发【第四章】:Python函数剖析

    一.Python函数剖析 1.函数的调用顺序 #!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian #函数错误的调用方式 def fun ...

  7. Python函数解析

    对于Python的函数,我们需要记住的是: 1. 函数的默认返回值是None. 2. python是一个自上而下逐行解释并执行的语言.因此,函数的定义必须在函数被调用之前.同名的函数,后定义的会覆盖前 ...

  8. Python入门笔记(18):Python函数(1):基础部分

    一.什么是函数.方法.过程 推荐阅读:http://www.cnblogs.com/snandy/archive/2011/08/29/2153871.html 一般程序设计语言包含两种基本的抽象:过 ...

  9. Python函数1

    Python 函数命令的使用 想想我们之前数学中学到的函数,首先我们需要定义一个函数,例如f(x)=x, 当x输入任意数的时候,f(x)都能输出和x相等的数值. 那么在Python中是如何实现的呢? ...

  10. python函数传参是传值还是传引用?

    首先还是应该科普下函数参数传递机制,传值和传引用是什么意思? 函数参数传递机制问题在本质上是调用函数(过程)和被调用函数(过程)在调用发生时进行通信的方法问题.基本的参数传递机制有两种:值传递和引用传 ...

随机推荐

  1. [译]ASP.NET Core依赖注入深入讨论

    原文链接:ASP.NET Core Dependency Injection Deep Dive - Joonas W's blog 这篇文章我们来深入探讨ASP.NET Core.MVC Core中 ...

  2. async generator promise异步方案实际运用

    es7 async方案 /******************async***********************/ var timeFn=function(time){ return new P ...

  3. python-正铉

    第一步:安装插件 pip install Numpypip install matploatlib 第二步 导入包 import numpy as np import matplotlib.pylot ...

  4. Android_scaleType属性

    这里我们重点理解ImageView的属性android:scaleType,即ImageView.setScaleType(ImageView.ScaleType).android:scaleType ...

  5. Jmeter4.0----安装教程(2)

    1.检查安装环境 1.1 JDK要求 JDK版本:1.6 + 1.2 检查是否安装JDK win + R 快捷键打开运行,输入 cmd 打开面板,在面板中输入 java -version,出现如下信息 ...

  6. SSE(Server-sent events)技术在web端消息推送和实时聊天中的使用

    最近在公司闲着没事研究了几天,终于搞定了SSE从理论到实际应用,中间还是有一些坑的. 1.SSE简介 SSE(Server-sent events)翻译过来为:服务器发送事件.是基于http协议,和W ...

  7. 爬虫(requests)

    requests库包含两个对象:Response和Requests  Response对象属性:    r.status_code    HTTP请求的返回状态,200表示成功 r.text     ...

  8. Oracle的用户,权限以及角色

    一.用户 1.创建用户 创建用户u密码为aa. SQL> create user u identified by aa; 2.为用户赋予权限 这个用户还不能连接数据库,必须为其赋予一些权限才可以 ...

  9. 如何解决js递归里面出现的堆栈溢出

    16.下面的递归代码在数组列表偏大的情况下会导致堆栈溢出.在保留递归模式的基础上,你怎么解决这个问题? var list = readHugeList(); var nextListItem = fu ...

  10. 用jQuery.delegate()将事件绑定在父元素上面

    1.先看看官方的示例: <html> <head> <script type="text/javascript" src="/jquery/ ...