python学习---函数

自定义函数

def 函数名(参数):
函数体 #定义函数

函数名()#调用函数

def hello():
    print("hello world") #自定义函数
hello() # 调用函数

'''自定义函数取个参数'''
def hello(object):
    print("hello "+object+" !")
hello("cat")

斜体样式

def calc(a,b):
    c=a+b
    return c
C=calc(10,20) #这个调用函数需要赋值，
print(C)#打出结果

''''函数参数调用'''
def fun(arg1,arg2):
    print('arg1 = ',arg1)
    print('arg2 = ',arg2)
    arg1=100
    arg2.append(100)
    print('arg1 = ', arg1)
    print('arg2 = ', arg2)
    return 0
n1=11
n2=[22,33,44]
res=fun(n1,n2) #将n1,n2的值 实参传递给形参
print(res)
print('n1',n1)
print('n2',n2)## 函数体的修改不会影响实参的值 如 arg1修改为100，不会影响n1的值

def oddeven(num):
    odd=[]## 奇数空列表
    even=[]##偶数空列表
    for i in num:
        if i%2==0:
            even.append(i)
        else:
            odd.append(i)
            '''注意else和if是并列的，且要注意冒号'''
            
    return odd,even
''' 要注意标上返回值，表示函数结束，注意返回值的缩进！！！！！！'''
lst=[1,2,3,4,5,6,7,8,9,10]
resu=oddeven(lst)
print(resu)

‘’’
函数的返回值
（1）如果函数没有返回值，函数执行完毕之后，不需要给调用处提供数据
（2）函数的返回值，如果是1个，直接返回类型
（3）函数的返回值，如果是多个，返回类型是元组
（4）函数如果有返回值，调用函数需要赋值 如fun（）有返回值，所以令res=fun（），再输出print（res）
‘’’

函数的参数定义

函数定义默认值参数

函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参

def func (a,b=10):

    return a,b
print('函数调用func(100)的结果为： ',func(100))
print('函数调用func(20,30)的结果为： ',func(20,30))

运行结果：
函数调用func(100)的结果为： (100, 10)
函数调用func(20,30)的结果为： (20, 30)

个数可变的位置参数

定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
使用*定义个数可变的位置形参
结果为一个元组

'''   定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
   使用*定义个数可变的位置形参
   结果为一个元组
   '''
def variable(*args): #定义可变位置参数的函数
    print(args)
variable(10)      #不同个数参数的调用函数
variable(10,30)
variable(30,400,50)

结果显示：
(10,)
(10, 30)
(30, 400, 50)

显示结果为元组
位置可变的参数只能定义一个

def func2(*args.*a)：  ##这样定义是会出错的

个数可变的关键字形参

定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
使用**定义个数可变的关键字形参
结果为一个字典

'''定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
使用**定义个数可变的关键字形参
结果为一个字典'''
def key(**args):
    print(args)
key(a=10)
key(a=30,b=60)

运行结果：
{‘a’: 10}
{‘a’: 30, ‘b’: 60}
显示结果为字典
个数可变的关键字参数也是只能在函数定义一个。

函数的位置传参和关键字形参

def fun(a,b,c): #a,b,c 在函数的定义处，所以是形式参数
 print('a = ',a)
 print('b = ',b)
  print('c = ',c)
  fun(10,20,30)#函数的调用时，参数传递，成为位置传参
  list=[11,22,33]
  fun(*list)##在函数调用时，将列表中的每个元素都转换为位置实参转入

小妙招：
list=[11,22,33]
fun(*list)
##在函数调用时，将列表中的每个元素都转换为位置实参转入

接上一块代码：

fun(a=100,c=300,b=200)#函数的调用，所以是关键字形参
fun(a=100,c=300,b=200)#函数的调用，所以是关键字形参
dict={'a':100,'b':200,'c':300}
fun(**dict)    ##在函数调用的时候，将字典中的每个键值对转换为关键字参数转入

结果显示为：
a = 100
b = 200
c = 300
a = 100
b = 200
c = 300

def func3(a,b=10):  ##b是在函数定义处，所以b是形参，而且进行了复制，所以b是默认值形参
    print('a = ',a)
    print('b = ',b)
    
def func2(*args):   ##个数可变的位置形参
    print(args)
def  fun3(**args):   ##个数可变的关键字形参
    print(args)

如果设计一个函数，他的部分实参传递只能使用关键字实参传递该怎么办呢？

 '''定义部分参数传递只能使用关键字实参传递,在函数定义前加一个‘*’号'''
def fun4(a,b,*,c,d):
    print(a,b,c,d)
fun4(10,20,c=10,d=30)
'''c,d如果不使用位置参数，那么系统就会报错'''