小笨蛋学习Python第三集

（3）python基础知识篇

本节知识要点：
函数的简介
函数定义
函数的调用
函数的文档说明
函数的参数
位置参数
默认参数
可变参数
关键字参数
命名关键字参数
参数的组合
函数返回值
递归函数
局部变量
全局变量

函数的简介
（1）函数：
在开发程序中，经常会遇到需要使用某块代码多次，这时为了提高编写的效率以及代码重用，所以把具有独立功能的代码组织为一个模块，这就是代数，类似与数学上的公式。用的时候直接调出来即可。Python有许多的内建函数，例如print()，我们也可以自己创建函数，这被叫做用户自定义函数。
（2）函数的定义和调用

定义格式：
def 函数名（）：
	代码	

比如下面这个：

#定义一个函数，能够完成打印信息的功能。
def printinfo(）：
	print（"------"）
	print("人生苦短，我用Python")
	print("------"）
printinfo()#调用

输出：
----
人生苦短，我用Python
----

调用：定义了函数之后，就相当于有力执行某些功能的代码，想要让这些代码执行，需要调用函数，通过**函数名（）**即可调用。

printinfo()#调用

注意：1、定义了函数之后，函数会从头开始执行，但这个函数的代码执行完毕之后，意味着调用结束。2、如果函数中执行到了return也会结束函数。

（3）函数的文档说明：使用help(函数名）查看：

#函数的文档说明
def test(a,b):
    '''用来对两个数进行求和'''
    print("%d"%(a+b))
test(11,9)
print("-----------------------------------------")
help(test)

输出：
#函数传参调用的结果
20
-----------------------------------------
#函数的文档说明
Help on function test in module __main__:
test(a, b)
用来对两个数进行求和

（4）函数的参数
函数的参数定义很简单，但灵活度很高，除了常用的必选参数外，还可以使用默认参数，可变参数、关键字参数。

1、位置参数：

#对于power(x）而言，参数x就是一个位置参数：
#当调用power或者func函数时，必须传入有且仅有的一个参数
def power(x):
    return x*x
power(9)

def func(x,y):
    return x*y+1 
func(6,9)

输出：
55

来看一道题，表示没看懂这道题解法的逻辑

#如皋要计算x的三次方、四次方……又该怎么做呢？
def power(x,n):
    s=1 
    while n>0:
        n=n-1 
        s=s*x 
    return s 
power(2,4)

输出：
	16

#我觉得可以直接这样：
#求a的n次方
def power(a,n):
    return a**n
power(2,4)

输出：
	16

2、默认参数：比如上面的位置参数有两个参数，但如果后面我们调用函数的时候少传入一个位置参数，这个时候程序就会报错。这个时候使用默认参数就很有必要了，来看一个实例：

#使用默认参数，当调用时不传入n值，也会正确计算出来
def power(x,n=2):
    s=1 
    while n>0:
        n=n-1 
        s=s*x 
    return s 
power(3)

输出：9

**注意要点：**1、默认参数可以简化函数的调用，但也要注意必选参数在前，默认参数在后，否则python 的解释器会报错；2、二是当函数有多个参数时，把变化大的参数放在前面，变化小的放在后面，变化小的就可以当做默认参数。

**使用默认参数的好处：可以降低函数调用的难度。**例如：
有两个默认参数age和city，那么学生在注册的时候，若与默认参数一致的，就只需要提供前两个必选参数的值就可以了，若与默认参数不一致的，直接上传额外的值也就ok了。

#使用默认参数的好处
def enroll(name,gender,age=6,city="Beijing"):
    print("name:",name) 
    print("gender:",gender)
    print("age:",age)
    print("city:",city) 
enroll("mike","F")

输出：
name: mike
gender: F
age: 9
city: Beijing

在有多个默认参数时，调用的时候既可以按照顺序提供默认参数，也可以不按照顺序提供部分默认参数值。但当不按照顺序提供默认参数的时候，需要把参数名加上。
**定义默认参数需要注意一点：默认参数必须指向不可变对象。**什么是不可变参数呢？比如None这个不变对象。

def add_end(L=None):
    if L is None:
        L=[]
    L.append("END")
    return L 
add_end()
add_end()

输出：
['END']

不变对象的好处：
因为不便对象一旦创建，内部数据无法修改，这样可以减少由于数据修改带来的错误。同时多任务环境下读取对象不需要加锁，读一点问题也没有。

3、可变参数：传入的参数是可变的。可以是0个，1个……

#可变参数
#一道数学题，计算a^2+b^2+c^2……的值。
def calc(numbers):
    sum=0 
    for n in numbers:
        sum=sum+n*n 
    return sum 
#调用的时候需要组装出一个list或者tuple
calc([1,2,3])
输出：14

#如果是使用可变参数，则函数的方式则可以简化为calc(1,2,3)，不需要改装成list。
#如何实现———通过修改参数为可变参数，即在参数前面加上*
def calc(*numbers):
    sum=0 
    for n in numbers:
        sum=sum+n*n 
    return sum 
calc(1,2,3)
输出：14

当传入的参数是一个元祖或列表时，可能比较繁琐。

#如果传入的是一个元组或者列表，要调用一个可变参数，可以采用下面这种方式，程序有些繁琐
def calc(*numbers):
    sum=0 
    for n in numbers:
        sum=sum+n*n 
    return sum 
nums=[1,2,3]
calc(nums[2])

输出：
	14

如何解决这种繁琐的情况呢？

#上面的方式过于繁琐，需要一个个的取出元素
#如何解决——可以在元组或者列表前面加*
def calc(*numbers):
    sum=0 
    for n in numbers:
        sum=sum+n*n 
    return sum 
nums=[1,2,3]
calc(*nums)

输出：14

*num把num这个list的所有元素作为可变参数传进去，这种写法相当有用。
4、命名关键字参数
对于关键字参数，函数调用者可以传入不受限制的关键字参数，至于到底传入了哪些？需要在函数内部通过kw检查。例如下面，我们检查是否有city和job参数：

def person(name,age,**kw):
    if "city"in kw:
        pass 
    if "job"in kw:
        pass
#对于关键字参数，函数的调用者可以传入不受限制的关键字参数，至于到底传入哪些？需要在函数内部通过kw来查看
print("name","age","other:",kw)
#但调用者仍然可以传入不受限制的关键字参数：
person("jack",24,city="beijing",addr="chaoyang",zipcode=123456)
输出：name age other: {'city': 'beijing', 'addr': 'chaoyang', 'zipcode': 123456}

如果要限制关键字参数的名字，则可以应用命名关键字参数，例如只接受“city”和job作为关键字参数：

#和关键字参数**kw不同，命名关键字需要有一个特殊分隔符*，后面的参数被视为命名关键字参数。
def person(name,age,*,city,job):
    print(name,age,city,job)
#调用方式如下： 命名关键字参数必须传入参数名，如果没有传入，将会报错。这和位置参数不同。
person ("jack",24,city="beijing",job="teacher")
输出：
jack 24 beijing teacher

命名关键字参数可以有缺省值，从而简化调用。

def person(name,age,*,city="beijing",job):
    print(name,age,city,job) 
#比如下面调用的时候可以不传入city，由于city具有默认值，因此结果出来也是有city参数的。
person("jack",24,job="teacher")

输出：jack 24 beijing teacher

注意：在使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符，

#如果缺少的话，Python解释器会将无法识别位置参数和命名关键字参数。
def person(name,age,city,job):
    #缺少的话，city 和job都会被视为位置参数。
    pass

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

#定义一个函数可以选用必选参数、默认参数、可变参数、关键字参数和命名关键字参数可以组合使用
def person1(a,b,c=0,*args,**kw):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)

def person2(a,b,c=0,*,d,**kw):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)

在函数调用的时候，Python解释器可以自动按照参数位置，和参数名把对应的参数传进去。

def person1(a,b,c=0,*args,**kw):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
person1(1,2) 
输出：
a= 1 b= 2 c= 0 args= () kw= {}

#在函数调用的时候，Python解释器可以自动按照参数位置，和参数名把对应的参数传进去。
def person1(a,b,c=0,*args,**kw):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
person1(1,2,c=3) 
输出：
a= 1 b= 2 c= 3 args= () kw= {}

def person1(a,b,c=0,*args,**kw):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
 
person1(1,2,3,"a","b")
输出：
a= 1 b= 2 c= 3 args= ('a', 'b') kw= {}

def person1(a,b,c=0,*args,**kw):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
 
person1(1,2,3,"a","b",x=99)

输出：
a= 1 b= 2 c= 3 args= ('a', 'b') kw= {'x': 99}

调用person2函数：

def person2(a,b,c=0,*,d,**kw):
    print("a=",a,"b=",b,"c=",c,"d=",d,"kw=",kw)
person2(1,2,d=99,ext=None)
输出：
a= 1 b= 2 c= 0 d= 99 kw= {'ext': None}

可以通过类似func(*args,**kw)的形式调用，无论它的参数是怎样的

#例如:通过一个元组和字典，可以调用上述函数：
def person1(a,b,c=0,*args,**kw):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
 
args=(1,2,3,4)
kw={"d":99,"x":"#"}
person1(*args,**kw)

输出：a= 1 b= 2 c= 3 args= (4,) kw= {'d': 99, 'x': '#'}

def person2(a,b,c=0,*,d,**kw):
    print("a=",a,"b=",b,"c=",c,"d=",d,"kw=",kw)
args=(1,2,3)
kw={"d":88,"x":"#"} 
person2(*args,**kw)

输出：a= 1 b= 2 c= 3 d= 88 kw= {'x': '#'}

（5）、函数返回值
程序中函数完成一件事，最后给调用者的结果。
带有返回值的函数：

#函数返回值
def add2num(a,b):
    c=a+b 
    return c
add2num(2,3)
输出：5

保存返回的函数返回值

def add2num(a,b):
     return a+b 
#调用函数，顺便保存函数的返回值
result=add2num(100,20)
#因为result 已经保存了add2num的返回值，所以接下来就可以使用了
print(result)

输出：120

多个return?

def create_nums(num):
    print("---1----")
    if num==100:
        print("---2----")
        return num+1 
    else:
        print("---3----")
        return num+2
    print("---4----")
result1=create_nums(100)
print(result1)
result2=create_nums(200)
print(result2)
输出：
---1----
---2----
101
---1----
---3----
202
#在Python中如何返回多个值？一个函数可以有多个return,但只要有一个return被执行到，
#那么这个函数就会结束了，因此后面的return就没用了。因为return除了有将数据返回之外，还有结束函数的功能。

一个函数返回多个数据的方式：只要能够存储多个数据类型，比如字典、列表、元组等，就可以返回多个数据。

def divid(a,b):
    shang=a//b 
    yushu=a%b 
    return shang,yushu
result=divid(5,2)
print(result)

输出：（2,1）

（6）、递归函数
在函数内部，可以调用其他函数，如果一个函数在内部调用自身，这个函数就是递归函数。

#计算阶乘!n=1*2*3*4*5*6……*n,用函数fact(n)来表示。
#fact(n)=n!=1*2*3*4*5*6……*(n-1)*n=(n-1)!n =fact(n-1)*n 
#所以n的阶乘可以用fact(n-1)*n 来表示，只有n=1时需要特殊处理。
#于是用递归的方式把fact(n)写出来：
def fact(n):
    if n==1:
        return 1
    return n*fact(n-1)
fact(5)
输出：120

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环不如递归清晰。
使用递归函数要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈会加一层栈帧，每当函数返回，栈就会减少一层栈帧。由于栈的大小不是无限的，所以递归调用的次数过多，会导致栈溢出。
解决栈溢出的方法是尾递归化，是指在函数返回的时候，调用函数自身，并且return语句不能包含表达式。这样编译器或者解释器就可以把尾递归化，使递归无论调用多少次，都只用一个栈帧，不会出现栈溢出的现象。
事实上，尾递归和循环的效果是一样的，所以把循环看成是一种特殊的尾递归函数也是可以的。
（7）、局部变量
局部变量：在函数内部定义的变量
作用范围：是在这个函数的内部使用，在外部不能使用，因为其作用范围是其函数内部，所以不同的函数可以定义相同名字的局部变量。
作用：为了临时保存数据需要在函数中定义变量来进行存储。

#局部变量
def show():
    score=100 
    print("分数：",score)
show()
输出：分数: 100

（8）全局变量
如果一个函数既能在一个函数中使用，也可以在其他函数中使用，那么这样的变量就是全局变量。

#全局变量
#定义全局变量
a=100 
def test1():
    print(a)#虽然没有定义变量a但是依然可以获取数据
def test2():
    print(a)#虽然没有定义变量a但是依然可以获取数据
#调用函数
test1()
test2()

输出：
100
100

当全局变量和局部变量相同的时候，函数内部中的变量=数据，此时理解为定义了一个局部变量，而不是修改全局变量的值。

#当全局变量和局部变量相同的时候
a=100
def test1():
    a=300 
    print(a)
test1()
输出：
300
200

修改全局变量：

#修改全部变量
a=100 
def test1():
    global a 
    print("修改之前：%d"%a)
    
    a=200 
    print("修改之后: %d"%a)
def test2():
    print("a=%d"%a)
test1()
test2()

输出：
修改之前：100
修改之后: 200
a=200

有好多题还是不会做，感觉没什么思路，也搞不懂为什么别人要这样写。看不懂代码，感觉好烦哦。