python入门-函数

  • 一、调用函数
  • 二、函数编写
  • 三、函数返回多值
  • 四、函数默认参数
  • 五、Python之定义可变参数
  • 5.1 *args
  • 5.1 **kw
  • 五、可更改(mutable)与不可更改(immutable)对象
  • 六、好的参考


一、调用函数

1）要调用一个函数，需要知道函数的名称和参数
2）查看内置函数定义
python官网：http://docs.python.org/2/library/functions.html#abs 交互式命令行查看：例如通过 help(abs) 查看abs函数的帮助信息

二、函数编写

def square_of_sum(L):
    sum = 0
    for num in L:
        sum = num*num + sum
    return sum

print square_of_sum([1, 2, 3, 4, 5])

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。
return None可以简写为return。

三、函数返回多值

函数可以返回多值，并用多值去接收，实际返回的是一个tuple。返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值。不需要的元素可以用_接收

import math
def test():
    return 1,2,3
x,y,_ = test()
print x #1
x= test()
print x#(1,2,3)

四、函数默认参数

def greet(a="world"):
    print "%s,%s." % ("Hello",a)
    print "Hello,%s." % a
greet()
greet('Bart')

五、Python之定义可变参数

5.1 *args

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：

def fn(*args):
    print args

Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。
定义可变参数的目的也是为了简化调用。假设我们要计算任意个数的平均值，就可以定义一个可变参数：

def average(*args):
    sum = 0
    if len(args) == 0:
        return float(0)
    for num in args:
        sum = sum + num
    return float(sum)/len(args)
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)

代码2：

def tupleArgs(arg1, arg2= 'B', *arg3):
    print('arg 1:%s ' % arg1)
    print('arg 2:%s ' % arg2)
    for eachArgNum in range(len(arg3)):
        print('the %d in arg 3 :%s ' % (eachArgNum,arg3[eachArgNum]))
if __name__ == '__main__':
    tupleArgs('A')
    #   arg 1:A 
    #   arg 2:B 
    tupleArgs('23','C')
    #   arg 1:23 
    #   arg 2:C
    tupleArgs('12','A','GF','L')
    #   arg 1:12 
    #   arg 2:A 
    #   the 0 in arg 3 :GF 
    #   the 1 in arg 3 :L

5.1 **kw

*args是非关键字参数，用于元组，**kw是关键字参数，用于字典

def dictArgs(kw1, kw2= 'B', **kw3):
    print('kw 1:%s ' % kw1)
    print('kw 2:%s ' % kw2)
    for eachKw in kw3:
        print('the %s ---->:%s ' % (eachKw,kw3[eachKw]))
if __name__ == '__main__':
    dictArgs('A')
    #   kw 1:A 
    #   kw 2:B 
    dictArgs('23','C')
    #   kw 1:23 
    #   kw 2:C 
    dictArgs('12','A', c = 'C',d = '12121212')
    #   kw 1:12 
    #   kw 2:A 
    #   the d ---->:12121212 
    #   the c ---->:C 
    dictArgs('kw',c = 'C',d = '12121212',kw = 'KW')
    #   kw 1:kw 
    #   kw 2:B 
    #   the kw ---->:KW 
    #   the d ---->:12121212 
    #   the c ---->:C

五、可更改(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 传不可变对象实例

#!/usr/bin/python
#-*- coding: UTF-8 -*-
def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)

print b # 结果是 2
实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

#!/usr/bin/python
#-*- coding: UTF-8 -*-
 
#可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print "函数内取值: ", mylist
   return

#调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print "函数外取值: ", mylist
实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：

函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]

六、好的参考

https://www.runoob.com/python/python-functions.html