函数参数的定义方式：
位置形参
星号元组形参
命名关键字形参
双星字典形参

1.位置形参
语法：
def 函数名（形参名1，形参名2，…………）：
语句块

例子：

    len(args))
        print("args =", args)def myadd(a, b, c, d):  abcd为位置形参
        return a + b + c + d 

星号元组形参：
语法：
def 函数名(*元组形参名)：
语句块
作用： 收集多余的位置传参

例子：

    def func(*args):
        print("实参个数"）

    func(1,2,3,4)
    func(1,2,3,4)
    不接受关键字传参

    关键字传参：
        语法：
            def　函数名　（＊，命名关键字形参列表)
            def　函数名（*args,命名关键字形参）

双星号字典形参
语法：
def 函数名（＊＊字典形参名）：
作用：
用于收集多余的关键字传参

函数的参数说明：
　 位置形参，星号元组形参，命名关键字形参，双星号字典形参和缺省形参可以混合使用

函数参数自左至右的顺序为：
    位置形参，星号元组形参，命名关键字形参，双星号字典形参

    def 

可以接收任意的位置传参和关键字传参的函数
def fn (*args, **kwargs):
pass

示例：
mymax函数与max功能相同

函数变量
函数名是变量，它创建一个函数时绑定一个函数

示例：
　　def f() #f为变量，f绑定一个函数
        print("hello")
        print("world")
    f1 = f #注意f 没有加（）
    f1()　  #？？？？

 示例２:
    def  f1():
         print("hello")
    def  f2():
         print("world")

    f1, f2 = f2, f1

一个函数可以做为另一个函数的参数
示例１：
def say_hello():
print("hello world")

def f2(f):
    print(f)
    f() #调用f变量绑定的函数

f2(say_hello)  #????

示例２：
def goodbye(L):
for x in L:
print("再见", x)

def hello(L):
for x in L:
print("您好", x)

def operator(fn, L):
fn(L)
#调用fn绑定的函数

operator(goodbye,["tom", "jerry"])

示例３：
def myadd(x, y)
return x + y
def mymul(x, y)
return x * y

def get_op(s):
if s == "加"
return myadd
elif s == "乘"

return mymul

s = input("请输入公式:")
L = s.split()
a = int(L[0])
b = int(L(2))
fn = get_op([L])
print("结果是:",fn(a, b)

函数的嵌套：
函数的嵌套是指一个函数用def语句来创建其他的函数的情况

示例：
 def fn_otter():
    print("fn_outter被调用!")
    def fn_inner():
        print("fn_inner():                  

全局变量和局部变量
局部变量
定义在函数内部的变量名称为局部变量（函数的形参也是局部变量）
局部变量只能在函数内部使用
局部变量在函数调用时被自动创建，在函数调用之后自动销毁
全局变量
定义在函数外部，模块内部的变量为全局变量
全局变量，所有的函数都可以直接访问（但函数内不能将其直接赋值）

python作用域
作用域也叫命名空间，是访问变量时查找变量名的范围空间

python的四个作用域LEGB
作用域
局部作用域（函数内） Ｌocal Function L
外部嵌套函数作用域 Enclosing function locals E
函数定义所在模块的作用域 Global(module) G
python内置模块作用域 Builtin(python) B

变量名的查找规则：
在访问比变量时，先查找本地变量，然后是包裹此函数的外部函数内的变量，之后是全局变量，最后是内置变量
　L -> E -> G -> B
示例：
注意: 在访问比变量时，先查找本地变量，然后是包裹此函数的外部函数内的变量，之后是全局变量，最后是内置变量

v = 100#全局变量
def fun1():
v = 200#局部变量，也是fun2外部嵌套的作用域的变量
def fun2():
v = 300#局部变量
print(v)
fun2()

fun1()

函数在找函数是以自内向外查找的方式………

删除本地的变量，全局变量就会被调用…………

python作用域
作用域也叫命名空间，是访问变量时查找变量名的范围空间

python的四个作用域ＬＥＦＧ
作用域
局部作用域（函数内） Ｌocal Function L
外部嵌套函数作用域 Enclosing function locals E
函数定义所在模块的作用域 Global(module) G
python内置模块作用域 Builtin(python) B

变量名的查找规则：
在访问比变量时，先查找本地变量，然后是包裹此函数的外部函数内的变量，之后是全局变量，最后是内置变量
　L -> E -> G -> B

在默认的情况下，变量赋值会创建或者修改本地作用域的变量

v = 100

def f():
print(v)
v = 200

f()

global语句
作用：
告诉解释器,global语句声明的一个或多个变量，这些变量的作用域为模块级的作用域，也称作全局变量
全局声明（global)将赋值变量映射到模块文件内部的作用域
语法：
global 变量１　变量２，…………

global声明：
全局变量如果要在函数内部被赋值，则必须经过全局声明（否则会被认为是全局变量）
全局变量在函数内部不经过声明就可以直接访问（如果变量已经在且关联一个对象）
不能声明局部变量，再用global声明为全局变量，次做法不符合规则
global变量列表里的变量名不能出现在此形参列表里
nonlocal语句
作用：
告诉解释器，nonlocal声明的变量不是局部变量，也不是全局变量，而是外部嵌套内的变量

语法：
nonlocal 　变量１　变量２　…………
示例：

说明：
　１．nonlocal语句只能在被嵌套的函数内部进行使用
　　　２．访问nonlocal变量将对外部嵌套函数作用域内的变量进行操作
３．当有两层或两层以上函数嵌套时，访问nonlocal变量只对最近的一层变量进行操作
　　４．nonlocal语句的变量列表的变量名，不能出现在此函数的参数列表中

var = 100
2.
def outter():
var = 200
1.
def inner():
nonlocal var
var += 1
3:
inner()
print("outter.var=", var)

4.
outter()
print("global var=", var)

　示意：
def f1():
v = 100:
def f2():
v = 200:
def f3():
nonlocal v
f3():
f2():
f1():
练习：
def mysum(n):
....n < 0:
for x in
n = int(input("请输入一个整数:"))
print(mysum(n))

代码# mysum.py

def mysum(n):
#方法一： s = 0
for x in range(1, n + 1):

　　 s += x

return s
#方法二：
return sum(range(1, n + 1))
n = int(input("请输入一个整数:"))
print(mysum(n))

2.
给出一个数n写一个函数来计算n！(n的阶乘）
n! = 123*...n

3.
给出一个数n写一个函数来计算１＋２＊＊２　＋　３＊＊３　＋．．．＋ｎ＊＊ｎ的和

原文地址：http://blog.51cto.com/12348050/2072453