一.函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码 高度服用 低频率耦合的代码段
二.语法:
函数体
return XXX
可以返回多个值,返回的多个值组成一个元组,返回值加上一个中括号,则返回一个列表
函数分为定义和调用
def math(num):
return(1,2,3)
range=math(1)
print(type(range))
print(range)执行命令得
<class 'tuple'>
(1, 2, 3)如果return()后面返回的是中括号return[]则返回的是列表
加减乘除函数
def jisuan(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 = jisuan (6,6,'*')
print(result)执行命令得
36三.可更改(mutable)与不可更改(immutable)对象
在python中,strings ,tuples,和numbers是不可更改的对象,而list,dict等则是可以修改的对象.
不可变类型:变量赋值a=5后再赋值a=10,在这里实际上是新生成一个int值的对象10,再让a指向它,而5被放弃,不是改变a的值,相当于新生成了a.
可变类型:变量赋值sb=[1,2,3,4,5]后再赋值la[2]=100则是list la 的第三个元值更改,本身sb没有动只是其内容的指引地址改变了.
python 函数的参数传递：
不可变类型:
值传递(复制副本),如整数.字符串,元组.
例如:在fun(a)内部修改a的值,只是修改另一个复制的对象,不会影响a本身.
可变类型:
引用传递,值传递的数据类型是可变类型用值传递方式(复制内存地址的副本)去传递 可变类型-可变内容 不改变原来的地址.如 列表,字典.
例如:fun(sp),则是将sp真正的值传过去,修改后fu外部的sp的内容也会受影响
#不可变类型 值传递 比如int类型
def fun(num):
num+=6
return num
a=7
print(fun(a))
print(a)
#可变类型 引用传递 比如列表类型
def ap(num):
num[0]+=3
return num
a=[7]
print(ap(a))
print(a)执行结果得
13
7
[10]
[10]四.以下是调用函数时可使用的正式参数类型##:
函数下一个”文档内容 doc 函数名.doc
在python中定义函数,可以使用必选参数.默认参数.可变参数.命名关键字参数.关键字参数
(1)必选参数
形参和实参—对应(个数.数据类型.顺序).*
形参:定义当法时的参数
实参:调用方法时的参数
def show(name,age):#形参
print('姓名:{0} 周岁:{1} 虚岁{2}'.format(name,age,age+1)
show('王小二',18)#实参姓名:王小二 周岁:18 虚岁:19
(2).默认参数:
(缺省参数)必须写在后面,可以不指定参数名,但是要保证顺序,否则则要指定参数名
def showI(name='',age=10):#初始化(不写)年龄为10
print('姓名:{0} 周岁:{1} 虚岁{2}'.format(name,age,age+1))
showI('王小二')执行命令得
姓名:王小二 周岁:10 虚岁11(3)命名关键字参数:name=value
def showII(sex,name='',age=16):#形参
print('姓名:{0} 周岁:{1} 虚岁{2} 性别{3}'.format(name,age,age+1,sex))
showII('男','王小二',18)#保证顺序
showII('男',name='王小二',age=18)#要么指定顺序 要么指定参数值 定义的时候要么在最后 要么这个值之后都是默认值执行命令得
姓名:王小二 周岁: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,sex='女')执行命令得
name:jack age:20 other{'sex': '女', 'city': '北京'}
name:李四 age:18 other{'sex': '女'}
(5).不定长参数(可变参数):
可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple
定义可变参数和定义一个list或tuple参数相比,仅仅在参数前面加了一个*号.在函数内部,参数nums接收到的是一个tuple,因此,函数代码完全不变.但是,调用该函数时,可以传入任意个参数,包括0参数
如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做
sb=[1,2,3,4]
cl=(sb[0],sb[1],sb[2],sb[3])
这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple前面加一个*号,把list或tuple得元素变成可变参数传进去
def cl(*nums):
print (type(nums))
sum=0
for n in nums:
sum+=n
return sum
ns=[1,2,3]
print(cl(*ns))#自动解析逐个带入
ns=(3,4,5)
print(cl(*ns))执行命令得
<class 'list'>
6
<class 'tuple'>
12简单来说就是
def cl(ns):
print(type(ns))
ns=[1,2,3]
print(ns)
print(*ns)执行得
[1, 2, 3]
1 2 3(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
*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.3) #内建作用域
g_count = 0 #全局作用域
def outer():六.全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问,调用函数时,所有在函数内声明的变量名称都将被加入到作用域中
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()执行命令得
5 global和nonlocal关键字
当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了
g_a=10
def test():
a=20
global g_a#声明这里g_a是全局变量
g_a+=a
print(g_a)
test() 执行命令得
30如果要修改嵌套作用域(enclosing)外层非全局作用域)中的变量则需要nonlocal关键字了
def outer():
num=10
def inner():
nonlocal num #nonlocal关键字声明
num=100
print(num)
inner()
print(num)
outer() 执行命令得
100
100 当全局变量和局部变量同名时，局部变量优先
例如:
g_a=10
def li():
global g_a #告诉程序这里是一个全局变量
g_a=20
print(g_a)
def li2():
print(g_a)
li()
li2()执行命令得
20
20七.lanbda匿名函数
语法：lambda [参数列表]:函数体内部代码
例如:
sum = lambda arg1,arg2:arg1+arg2
def lam(arg1,arg2):
return arg1+arg2
sum=lam(10,20)
print("相加后的值为 : ", sum( 10, 20 ))执行命令得
相加后的值为 : 30def add(a,b,fun):
print(fun(a,b))
add(11,22,lambda arg1, arg2: arg1 - arg2)执行命令得
-11python map()
map()函数接收两个参数，一个是函数，一个是序列，map将序列的每个元素传入函数中执行，并把结果作为新的list返回。
foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
li=(filter(lambda x: x % 3 == 0, foo))#取3的倍数
print(list(li))执行命令得
[18, 9, 24, 12, 27]map=(list(map(lambda x: x % 2, range(0,7))))
print(map)执行命令得
[0, 1, 0, 1, 0, 1, 0]
python filter():对于序列中的元素进行筛选，最终获取符合条件的序列
li = [11, 22, 33]
new_list = list(filter(lambda arg: arg >11, li))#(条件,列表)
print(new_list)执行命令得
[22, 33]利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：
def hehe(s):
return s and len(s.strip()) > 0
s=['test', None, '', 'str', ' ', 'END']
sb=list(filter(hehe, s))
print(sb)执行命令得
['test', 'str', 'END']
练习： 请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
fang=filter(is_sqr, range(1, 101))
print(list(fang))执行命令得
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]python reduce():对于序列内所有元素进行累计操作