1.参数的介绍

(1)可变和不可变参数

(2)必选参数

(3)默认参数

(4)可变参数

(5)关键字参数

---

1.1.可变和不可变参数

不可变类型：

类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：

类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

引用。

---

1.2.必选参数

必选参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

例如:

def f(a,b):

print('jjjjjj')

return a+b

print(f(1,2))

输出结果为:

jjjjjj

---

1.3.默认参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值

例如:

def f(a,b=100):

    print('********************')

    return a+b

print(f(1))

print(f(1,b=20))

print(f(1,3))

print('############################$$$#############################')

def f(a=100,b=200):

    print('****************')

    return a+b

print(f(1,2))

print(3,2)

print(f())

print(f(3))

输出结果为:

********************

101

********************

21

********************

4

############################$$$#############################

****************

3

3 2

****************

300

****************

203

---

1.4.可变参数-元组

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。参数组装成一个tutple

def calc(*numbers):

    sum = 0

   for n in numbers:

        sum = sum + n * n

        return sum

例如:

def f(*num):

    print(num)

f(1,2,3,4,5)

f(100,101)

f(111)

f([1,2,3,4],None,True,{'a':4})

f()

print('***********************************$$$**********************************')

def f1(*args):

    print(sum(args))

num1=1

num2=2

num3=3

f1(num1,num2,num3)

ls=[1,2,3,4,5]

f1(ls[0],ls[1],ls[2],ls[3],ls[4])

ls=[i for i in range(10)]

f(*ls)

f(ls)

输出结果为:

(1, 2, 3, 4, 5)

(100, 101)

(111,)

([1, 2, 3, 4], None, True, {'a': 4})

()

***********************************$$$**********************************

6

15

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],)

45

---

1.5.可变参数-字典

变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def person(name, age, **kw):

    print('name:', name, 'age:', age, 'other:', kw)

例如:

def f(**kvs):

    print(kvs)

f(a=1,b='abc',c=[1,2,3])

infos={'a':1,'b':2}

f(**infos)

输出结果为:

{'c': [1, 2, 3], 'a': 1, 'b': 'abc'}

{'a': 1, 'b': 2}

---

1.6.关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。

注意：如果要限制关键字参数的名字，就可以用命名关键字参数。

def person(name, age, *, city, job):

    print(name, age, city, job)

例如:

def f(a,b):

    print('a=%s,b=%s'%(a,b))

f(b=1,a=2)

输出结果为:

a=2,b=1

---

1.7.参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：

必选参数、默认参数、可变参数。

例如:

def f(a,b=1,*c,**d):

print(a)

print(b)

print(c)

print(d)

f(1,2,3,4,5,6,dd=100,bb=30)

输出结果为:

1

2

(3, 4, 5, 6)

{'bb': 30, 'dd': 100}

---

1.8.变量作用域介绍

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

全局变量

局部变量

(1).局部变量

局部变量，就是在函数内部定义的变量

不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响

局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

(2).全局变量

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

如果要再函数中修改全局变量，使用global声明。

例如:

a=100

print(a)

print('******************************')

def f():

    a=200

f()

print(a)

以上代码中，定义了一个全局变量，a=100,定义了一个没有返回值和参数的函数f,在函数中定义了一个局部变量a=200。

输出结果为:

100

******************************

100

第二个结果，虽然有局部变量但是没有被调用，调用的还是全局变量a=100.

def f(a):

    print('num=%s'%num)

num=111

f(100)

print(num)

输出结果为:

num=111

111

以上代码，定义了一个全局变量，而没有局部变量，num=111，当f=100时，会输出num=111.

def f(num):

    print('num=%s'%num)

num=111

f(100)

print(num)

输出结果为:

num=100

111

以上代码，定义了一个局部变量个一个全局变量，就近原则有限使用局部变量。

def f(num):

    num+=1

    print('num=%s'%num)

num=111

f(100)

print(num)

输出结果为:

num=101

111

以上代码，有一个局部变量，和一个全局变量，在函数运行时，调用了局部变量，此时的全局变量并没有变。

num=111

def f():

    global num

    print('num1=%s'%num)

    num+=1

    print('num2=%s'%num)

f()

print('num3=%s'%num)

输出结果为:

num1=111

num2=112

num3=112

以上代码中，global num 定义了一个全局变量，此时为全局变量。此时的全局变量已经改变。

---

1.9.全局和局部变量重名

如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量

在函数外边定义的变量叫做全局变量

全局变量能够在所以的函数中进行访问

如果在函数中修改全局变量，那么就需要使用global进行声明

如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，

小技巧强龙不压地头蛇

---

1.10.递归函数

如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

满足递归的条件：

有循环的内容

有跳出的条件

递归默认是有递归深度要求的。

---

1.11.匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

注意：

Lambda函数能接收任何数量的参数但只能返回一个表达式的值