一.函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码
高度复用 低频率耦合的代码段
二.语法:
def 函数名(参数列表):
函数体
return xxx
可以返回多个值,返回的多个值组成一个元组,返回值加上一个中括号,则返回一个列表
函数分为定义和调用
def getrange(num):
return (1,2,3)#[1,2,3]
range=getrange(1)
print(type(range))
print(range)执行命令得
<class 'tuple'>#<class 'list'>
(1, 2, 3)#[1,2,3]
练习
加减乘除函数
def yunsuan(num1,num2,sign):
if '+'.__eq__(sign):
return num1+num2
elif '-'.__eq__(sign):
return num1-num2
elif '*'.__eq__(sign):
return num1*num2
elif '/'.__eq__(sign):
return num1//num2
result=yunsuan(6,6,'*')
print(result)执行命令得
36三.可更改(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没有动，只是其内部的一部分值被修改了。
4.python 函数的参数传递：
不可变类型：
值传递(复制副本)，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：
引用传递，值传递传递的数据类型是 可变类型用值传递传递方式（复制内存地址的副本）去传递 可变类型-可改变内容 不可改变原地址如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la的内容也会受影响
#不可变类型 值传递
def fun(num):
num=num+6
return num
a=7
print(fun(a))
print(a)
#可变类型 引用传递
def fun(num):
num[0]=num[0]+6
return num
a=[7]
fun(a)
print(a)执行命令得
13
7
[13]函数下第一个''' 文档内容 doc 函数名.__doc__
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，
这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。
但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数。
<1>必选参数
形参和实参一一对应(个数，数据类型，顺序)
形参:定义方法时的参数
实参：调用方法时的参数
<2>默认参数:(缺省参数)缺省参数必须写在后面,可以不指定参数名，但是顺序要保证，否则要指定参数名
<3>命名关键字参数:name=value
注意:书写顺序
def show(name,age):#形参
print('姓名:{0} 周岁:{1} 虚岁{2}'.format(name,age,age+1))
show('张三',18)#实参
def showInfo(name='',age=10):#初始化(不写)年龄为10
print('姓名:{0} 周岁:{1} 虚岁{2}'.format(name,age,age+1))
showInfo('张三')
def show(sex,name='',age=16):#形参
print('姓名:{0} 周岁:{1} 虚岁{2} 性别{3}'.format(name,age,age+1,sex))
show('男',name='张三',age=18)
show('男','张三',18)
执行命令得
姓名:张三 周岁:18 虚岁19
姓名:张三 周岁:10 虚岁11
姓名:张三 周岁:18 虚岁19 性别男
姓名:张三 周岁:18 虚岁19 性别男<4>关键字参数:
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
(**+可迭代元素)解析字典 (*+可迭代元素)节系列表元组
关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装成为一个字典类型(dict)
下面是在函数show()调用时使用参数名例:
关键字参数:**kw
def show(name,age,**kw):
print('name:{} age:{} other{}'.format(name,age,kw))
dict={'sex':'女','city':'北京'}
show('jack',20,**dict)
show('李四',18,'女')执行命令得
name:jack age:20 other{'sex': '女', 'city': '北京'}
name:李四 age:18 other{'sex': '女'}<5>不定长参数(可变参数):
可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple
定义可变参数和定义一个list或tuple参数相比,仅仅在参数前面加了一个*号.在函数内部,参数nums接收到的是一个tuple,因此,函数代码完全不变.但是,调用该函数时,可以传入任意个参数,包括0参数
如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做
ns=[1,2,3]
cala(ns[0],ns[1],ns[2])
这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple前面加一个*号,把list或tuple得元素变成可变参数传进去
def cala(*nums):
print(type(nums))
sum=0
for n in nums:
sum+=n
return sum
ns=[1,2,3]
print(cala(*ns))#自动解析逐个带入
ns=(3,4,5)
print(cala(*ns))执行命令得
<class 'tuple'>
6
<class 'tuple'>
12<6>参数组合
比如定义一个函数,包含上述若干种参数,通过一个tuple和dict,调用 (注意个数和顺序),对于任意函数,都可以通过类似f1(*args,**kw)得形式调用它,无论他的参数是如何定义的
注意!!!:
传参的原则一一对应,不允许重复赋值
name=value如果**kw实参前没有相应的实参 namw优先匹配形参的name
def f1(a,b,c=0,*args,**kw):#形参
print('a=',a,'b=',b,'c=',c,'args=',args,'kw=',kw)
s1=[1,2,3,4,5]#实参
s2={'aa':'哈哈','bb':'呵呵'}
f1(*s1,**s2)
def f2(a,b,c=0,*args,d,**kw):
print('a=',a,'b=',b,'c=',c,'args=',args,'d=',d,'kw=',kw)
s1=[1,2]
s2={'c':5,'d':'6','bb':'呵呵'}
f2(*s1,**s2)#错误写法f1(*s1,d=7,**s2)因为s2中已经为cd赋值执行命令得
a= 1 b= 2 c= 3 args= (4, 5) kw= {'aa': '哈哈', 'bb': '呵呵'}
a= 1 b= 2 c= 5 args= () d= 6 kw= {'bb': '呵呵'}小结
Python得函数具有非常灵活的参数形态,既可以实现简单的调用,也可以传入非常复杂的参数.
默认参数一定要用不可变对象,如果是可变对象,程序运行时会有逻辑错误!
要注意定义可变参数和**kw关键字参数的语法::
*args是可变参数,args接收到的是tuple
**kw是关键子参数,kw接受的是一个dict
传参数:*args会复制原数据然后再逐个分割args逐个对应形参列表
**kw只能对应到形参列表的**kw
五.变量作用域
Python中,程序的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量在哪里复制的.
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称.Python得作用域一共有4种
| L(Local) | 局部作用域 |
| E(Enclosing) | 闭包函数外的函数中 |
| G(Global) | 全局作用域 |
| B(Built-in) | 内建作用域 |
以L-->E-->G-->B的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就回去全局找,在这区内建找
x = int(2.9) # 内建作用域
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作用域Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问
六.全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问,调用函数时,所有在函数内声明的变量名称都将被加入到作用域中
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)
执行命令得
函数内是局部变量:30
函数外事全局变量:0全局变量与局部变量的作用域不同,生命周期不同
当全局变量和局部变量同名时,局部变量优先
局部变量等同于形参
g_a=10#就近一致
def test():
g_a=5
print(g_5)#想要输出10 必须声明全局变量
test()执行命令得
5global和nonlocal关键字
当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了
g_a=10
def test():
a=20
global g_a#声明这里g_a是全局变量
g_a+=a
print(g_a)
test()执行命令得
30def outer():
num=10
def inner():
nonlocal num#nonlocal关键字声明
num=100
print(num)
inner()
print(num)
outer()执行命令得
100
100
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
