python_函数

定义函数

>>> def a2_333():----------------------------------------定义函数
...     pass
...

调用函数

>>> a2_333()----------------------------------------------调用函数
>>> a2_333
<function a2_333 at 0x0000027B7FE86AE8>

函数返回值

def count_letter(s):
    result=0
    for i in s:
        if i >= 'a' and i<='z':
            result+=1
    return result

print (count_letter('ad124$^&'))

练习：统计数字的个数

>>> def count_number(s):
	result=0
	for i in s:
		if i>='0' and i<='9':
			result+=1
	return result

>>> count_number('djkd341324')
6

多个返回值

>>> def aaa(a,b):
...     return a*10,b*10           #返回值为元组类型
>>> aaa(1,1)
(10, 10)
>>> a,b=(10,10)
>>> a
10
>>> b
10
>>> type(aaa(1,1))
<class 'tuple'>

return短路功能

def add(a,b):
	if isinstance(a,(str)) and \
	isinstance(b,(str)):
		return a+b
	else:               #可以不写else，因为函数体if里有return，所以后面代码被短路
		print ('输入有误')
		return None
print (add('a','b'))输入有误

def add(a,b):
	if isinstance(a,(str)) and \
	isinstance(b,(str)):
		return a+b
	print ('输入有误')
	return None
print (add('a','b'))
print (add(1,2))

变量作用域

>>> n=1
>>> def func():
...     n=2            #在函数内部的变量定义，叫局部变量，函数外不可以被访问
...     return n
...
>>>print ( func())
2
>>> print (n)
1
>>> func=10            #函数名被赋值
>>> func()              
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable----整数对象不可被调用，把非函数对象当成函数对象调用
>>> del func
>>> func()             #删掉也不行，需重新定义（内置函数可以，比如len）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'func' is not defined
>>> print (len('abc'))
3
>>> len=10            #内置函数可以，不需要再重新定义
>>> print (len)
10
>>> print (len('abc'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> del len
>>> print (len('abc'))
3

函数变量

调用函数，参数不能少，除非有默认参数

#默认值
>>> def add(a,b=100):          #默认值必须在非默认值之后，add(a=100,b)报错
...     return a+b
...
>>> add(1)                   #a=1,b=100
101
>>> add(1,10)                 #如果有参数值，就不用默认值
11
>>> add(a=1,b=1)              #也可以带上参数名
2
>>> add(b=1,a=3)              #调换参数名顺序也可以
4

def add(a=100,b):              #默认值必须在非默认值之后，add(a=100,b)报错
	return a+b
	
print (add(1,10))

函数需要注意的几个问题

1

#函数体里没有定义变量，去函数体外找
n=1
def func():
	return n+1

print (func())           #函数体里没有定义n，就会去函数体外找
 

2

#局部变量在赋值前被引用
n=1
def func():
	n=n+1                #局部变量n在赋值前被引用了
	return n

print(func())           

3

#可以这样引用，如下：
n=1
def func():
	global n              #global表示全局变量，函数体可以引用并会改变其值
	n=n+1
	return n

print (func())
print (n)                  

4

#如果想使用函数体外的n，推荐使用方法：
n=1
def func(a):
	a=a+1
	return a

print (func(n))
print (n)

5

#可变类型变量
n=[]
def func():
	n.append(1)       #与代码块2中的  n=n+1做对比，这个就不会报错
	return n
	
print (func())
print (n)       

6

n=[]
def func(a):
	a.append(1)
	return a
	
print (func(n))
print (n)         

另外，代码块4和6作对比得出的结论如下：
如果传入的参数是个变量a，这个变量是不可变类型（str,int,float），那么函数内部对于这个参数的所有操作结果都不会影响外部的参数值；
如果传入的参数是个变量a，这个变量是可变类型（list,dict,set），那么函数内部对于这个参数的所有操作结果都会影响外部参数值。

可变参数

#*c--tuple
def add(a,b,*c):
	print(type(c))
	print(c)
	
add(1,2,3,4,5)
执行结果：
<class 'tuple'>
(3, 4, 5)

练习：把上面的函数中的所有值，求和并返回

def add(a,b,*c):
	result=a+b
	for i in c:
		result+=i
	return result
	
print(add(1,2,3,4,5))

#**c--dict
def add(a,b,**c):
	print(type(c))
	print(c)
add(1,2,c=3,d=4,e=5)
执行结果：
<class 'dict'>
{'c': 3, 'd': 4, 'e': 5}

练习：把上面的函数中的所有值，求和并返回

def add(a,b,**c):
	result=a+b
	for i in c.values():
		result=result+i
	return result
		
print(add(1,2,c=3,d=4,e=5))

练习：两种可变类型求和并返回

def add(a,b,*c,**d):
	result=a+b
	for i in c:
		result+=i
	for i in d.values():
		result=result+i
	return result
	
	
print(add(1,2,3,4,5,c=6,d=7,e=8))