一、python3函数

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

函数能提高应用的模块性,和代码的重复利用率。可以自己创建函数,这被叫做用户自定义函数。

1、定义函数规则

  • 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()
  • 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始,并且缩进。
  • return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

2、语法

python定义函数使用def关键字,格式如下:

def 函数名(参数列表):

  函数体

>>> def hello():      #定义简单函数
... print('hello world')
...
>>> hello() #执行函数
hello world
>>> def yourname(name): #传参函数
... print('your are name is:',name)
...
>>> yourname('qi') #执行传参函数
your are name is: qi >>> def multiplication(x,y): #传参运算函数
... return x*y
...
>>> multiplication(8,9)
72

3、函数调用

定义一个函数:给函数一个名称,并指定了函数里包含的参数和代码块结构。这个函数的基本结构完成以后。

可以通过另一个函数调用执行,也可以直接从python命令提示符执行

>>> def times(date):
... '打印当前时间'
... print(date);
... return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
...
>>> import time
>>> times('当前时间是')
当前时间是
'2017-09-30 23:23:27'

4、参数传递

在 python 中,类型属于对象,变量是没有类型。

可更改(mutable)与不可更改(immutable)对象

在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。

  • 不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。

  • 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。

python 函数的参数传递:

  • 不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。

  • 可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响

python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。不可变实例:

>>> def changeint(x):   #定义函数传参赋值
... x = 100
...
>>> i1 = 200
>>> changeint(i1) #当将定义的变量赋值给函数调用后,原变量还是不变,只是把i1变量的值复制给了x,它们同时指向这个对象。
>>> print(i1)
200

传可变对象实例:

可变对象在函数里修改了参数,那么在调用这个函数的函数里,原始的参数也被改变了。

>>> def changelist(l1,v):   #定义列表插入函数
... l1.insert(2,v)
... return l1
...
>>> list1 = [1,2,3,4] #列表
>>> changelist(list1,'python') #应用外面的列表,即会影响外面列表的内容
[1, 2, 'python', 3, 4]
>>> print(list1) #列表内容被改变
[1, 2, 'python', 3, 4]

5、参数类型

必须参数:在一个函数指定需要参数时,在执行函数是必须指定参数,否则会报错

关键字参数:使用关键字传递参数时,参数顺序可以随意,解释器会根据参数名来匹配参数传递

默认参数:调用函数时,如果没有传递参数,则会使用默认参数。

不定长参数:如传递列表,元祖,字典时,参数的个数不定长,可以使用(*)代表不定长,

>>> def foo(user):        #必须参数
... print(user,'去旅游')
...
>>> foo('张三')
张三 去旅游
>>> foor() #如不传递参数执行函数会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'foor' is not defined
>>> def foo(user,action):
... print(action,'去了',user) #通过关键字传递参数给函数实体调用,不用不按顺序
...
>>> foo('李四','上班')
上班 去了 李四 >>> def foo(user,action='北京'): #定义默认参数是必须在最后定义
... print(user,'来自',action)
...
>>> foo('zhangsan','shanghai') #如指定则输出指定值
zhangsan 来自 shanghai
>>> foo('shangsan') #如指定一个参数则输出默认值
shangsan 来自 北京 >>> def foo(user,where='北京',action='旅游'): #定义默认参数
... print(user,'去',where,action)
...
>>> foo('zhangsan','shanghai','gongzuo') #指定参数输出
zhangsan 去 shanghai gongzuo
>>> foo('lisi') #如只指定一个参数则使用默认参数
lisi 去 北京 旅游
>>> foo('lisi',action='工作') #在有多个默认参数时,需指定参数名传参
lisi 去 北京 工作
>>> foo('lisi',where='上海',action='学习')
lisi 去 上海 学习 >>> def show(*args): #不定长传参
... for i in args:
... print(i)
...
>>> show('zhangsan','lisi','wangwu')
zhangsan
lisi
wangwu
>>> l1 = [1,2,3,4]
>>> show(l1)
[1, 2, 3, 4]
>>> show(*l1) #在列表传参是必须使用*来不定长传参
1
2
3
4 >>> def show(**kargs): #两参数不定长传参,也就是字典传参
... for i in kargs.items():
... print(i)
...
>>> show(name='zhangsan',age=9999)
('age', 9999)
('name', 'zhangsan')
>>> dict = {'k1':123,'k2':456,'k3':678}
>>> show(dict) #在传参字典时会将字典当一个参数传入会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: show() takes 0 positional arguments but 1 was given
>>> show(**dict) #必须使用(**)将参数分隔传参
('k1', 123)
('k2', 456)
('k3', 678)

6、return语句

return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

>>> def foo():
... 1+1
... return
...
>>> print(foo()) #默认返回None
None
>>> def foo():
... 1+1
... return 0 #指定返回值
...
>>> print(foo())
0
>>> def foo():
... return 1+1
...
>>> print(foo())
2
>>> def foo():
... print(1+1)
... return 1+2
...
>>> print(foo())
2
3

7、变量作用域

Python 中,程序的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种,分别是:

  • L (Local) 局部作用域
  • E (Enclosing) 闭包函数外的函数中
  • G (Global) 全局作用域
  • B (Built-in) 内建作用域

以 L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内建中找。

>>> m = 'girl'    #全局作用域变量
>>> def func():
... m = 'boy' #局部作用域变量
... return m
...
>>> func() #优先使用局部作用域变量
'boy'
>>> print(m) #但不改变全局作用域的变量
girl >>> def foo():
... num = x + 100 #变量x没有定义会报错
... return num
...
>>> foo()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in foo
NameError: name 'x' is not defined
>>> x = 11 #定义一个全局变量
>>> foo() #则函数会调用全局变量
111 >>> num = 100
>>> def func():
... num = 200
... x = num + 100
... return x
...
>>> func()
300 >>> n = 10 #全局
>>> def foo():
... global n #使用global定义局部变量为全局变量,并会覆盖前面的变量值
... n = 100
... return n
...
>>> foo()
100
>>> print(n) #全局变量值会改变
100 >>> def foo(): #定义一个嵌套函数
... num = 5
... def bar(): #嵌套使用闭包作用域变量
... print(num)
... bar()
... print(num)
...
>>> foo()
5
5 >>> def foo():
... num1 = 20
... def bar():
... z = 30
... print(num1)
... bar()
... print(z)
...
>>> foo()
20
Traceback (most recent call last): #而当嵌套内闭包作用域在未定义时引用就会报错
File "<stdin>", line 1, in <module>
File "<stdin>", line 7, in foo
NameError: name 'z' is not defined >>> def foo():
... m = 111
... def bar():
... n = 222
... print(m+n) #在bar()函数中的m就是一个既不属于全局域又不属于局部域的闭包变量,它存活在一个函数的名称空间和作用域,即嵌套作用域
... bar()
... print(m)
...
>>> foo()
333
111 def foo():
num2 = 400
def bar():
print(num2)
num2 = 333
print(num2)
bar()
foo() Traceback (most recent call last): #错误原因为num2为不可变类型,此处不能重新定义
File "<stdin>", line 1, in <module>
File "<stdin>", line 7, in foo
File "<stdin>", line 4, in bar
UnboundLocalError: local variable 'num2' referenced before assignment def foo():
num2 = [400]
def bar():
print(num2[0])
num2[0] = 333 #如果定义为列表则不会报错了
print(num2[0])
bar()
foo()
400
333

二、匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。

  • lambda 只是一个表达式,函数体比 def 简单很多。
  • lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。

1、语法

lambda函数的语法只包含一个语句

lambda [arg1 [,arg2....argn]]:expression

>>> funct1 = lambda x,y:x+y     #生成一个匿名函数
>>> print(funct1(10,43))
53
>>> funct2 = lambda x:x**3
>>> print(funct2(2))
8
>>> funct3 = lambda x,y=3,z=4:x+y+z #参数可以设置默认值
>>> print(funct3(3))
10
>>> print(funct3(3,4,5))
12
>>> print(funct3(3,y=9)) #注意多参数传值时需指定参数名
16
>>> print(funct3(3,z=8,y=9))
20
>>> list(map(lambda x:x**3,[1,2,3,4,5])) #使map生成序列
[1, 8, 27, 64, 125]
>>> list(map(lambda x,y:x+y,[11,22,33,44],[1,2,3,4])) #多个参数传值,如不匹配则以最少为准
[12, 24, 36, 48]
>>> list(map((lambda x:x+5),range(10))) #使用迭代器
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> l1 = [(lambda x:x+5),(lambda x:x**2),(lambda x:x/2)] #生成可变列表
>>> print(l1[0](5),l1[1](3),l1[2](10))
10 9 5.0
>>> dict1 = {'k1':(lambda x:x**2),'k2':(lambda x:x**3),'k3':(lambda x:x**4)}
>>> print(dict1['k1'](2),dict1['k2'](2),dict1['k3'](2)) #生成可变字典
4 8 16

python3函数的更多相关文章

  1. python015 Python3 函数

    Python3 函数函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段.函数能提高应用的模块性,和代码的重复利用率.你已经知道Python提供了许多内建函数,比如print().但你也可 ...

  2. Python3函数中特殊形参的使用:*、*args、**kwargs

    Python3函数中特殊形参的使用:*.*args.**kwargs ==用法1:不定长参数== 当函数需要的参数数量不确定的时候,可以使用*args 和 **kwargs , 所有的位置参数保存在* ...

  3. 07 . Python3函数

    Python3函数 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段. 函数能提高应用的模块性,和代码的重复利用率.Python提供了许多内建函数,比如print().我们可以直接调用 ...

  4. 汉诺塔python3函数编写和过程分析

    !/usr/bin/env python3 -- coding: utf-8 -- 利用递归函数计算阶乘 N! = 1 * 2 * 3 * ... * N def fact(n): if n == 1 ...

  5. Python3 函数注解

    Python3提供一种语法,用于为函数声明中的参数和返回值附加元数据.下面的例子是注解后的版本,特点在第一行: 1 def clip(text : str, max_len : 'int > 0 ...

  6. 5 Python3 函数进阶&迭代器与生成器

    1.函数进阶 1.1.名称空间 又名name space, 顾名思义就是存放名字的地方,存什么名字呢?举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的 ...

  7. Python3 函数作用域

    一 LEGB 什么是LEGB? L:local 函数内部作用域 E:enclosing 函数内部与内嵌函数之间 G:global 全局作用域 B:build-in 内置作用域 顺序是什么? 跟名字一样 ...

  8. python系列十:python3函数

    #!/usr/bin/python #-*-coding:gbk-*- '''函数的简单规则:    函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ().    任何传入参数和自变量必 ...

  9. Python3 函数 一

    什么是函数? 函数一词来源于数学,但编程中的「函数」概念,与数学中的函数是有很大不同的,编程中的函数在英文中也有很多不同的叫法.在BASIC中叫做subroutine(子过程或子程序),在Pascal ...

随机推荐

  1. C++map类型 之 简单介绍

    一:map的前世今生 (1)从关联容器与顺序容器说起.关联容器通过键(key)存储和读取元素.而顺序容器则通过元素在容器中的位置顺序存储和訪问元素(vector,queue,stack,list等). ...

  2. ListView原理

    表明转载自http://blog.csdn.net/iispring/article/details/50967445 在自己定义Adapter时,我们经常会重写Adapter的getView方法,该 ...

  3. C#设计模式之二十一职责链模式(Chain of Responsibility Pattern)【行为型】

    一.引言   今天我们开始讲"行为型"设计模式的第八个模式,该模式是[职责链模式],英文名称是:Chain of Responsibility Pattern.让我们看看现实生活中 ...

  4. Python之Metaclass详解,Python之元类

    本人Java程序员一枚,这几天闲来无事就自学了下Python,学到Metaclass感觉有点迷惑,就在网上查相关资料,在栈溢出(stackoverflow)网站上看到一个关于metaclass的回答, ...

  5. Python的几个常用模块

    一.sys 用于提供对Python解释器相关的操作: sys.argv 命令行参数List,第一个元素是程序本身路径 sys.exit(n) 退出程序,正常退出时exit(0) sys.version ...

  6. 为什么要使用消息认证码(MAC)而非对称密钥?

    问题: 看了消息认证码的介绍后,小丽心想"如果用对称密码将消息加密后再发送的话,是不是就不需要消息认证码了呢?"原因有下: 1.对称密码的密文只有使用和加密时相同的密钥才能正确解密 ...

  7. OC学习14——谓词

    一.谓词的基本概念与使用 1.谓词(NSPredicate)用于定义一个逻辑条件,通过该条件可执行搜索或内存中的过滤操作.上一篇文章中介绍的集合都提供了使用谓词对集合进行过滤的方法.OC中的谓词操作是 ...

  8. Qt之移动硬盘热插拔监控

    最近在做一个通用对话框,类似于windows的资源管理器,当然了没有windwos资源管理器那么强大.用户报了一个bug,说通用对话框打开之后不能实时监控U盘插入,随手在百度上搜索了一圈,这个问题还是 ...

  9. 1-MySQL数据库(android连接MySQL数据库)

    很好的链接 http://www.cnblogs.com/best/p/6517755.html  一个小时学会MySQL数据库 http://www.cnblogs.com/klguang/p/47 ...

  10. 刚实习的自己-php

    刚毕业的大学生,可能你的理论知识很丰富,但是你要清楚的是:你缺少实战经验.            正式实习的时候是在下午,老板给了我一个他们几年前开发好的系统(cms),这是一个展示型的网站,也就是发 ...