python初级007-函数-抽象

Posted 2020-08-22

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python初级007-函数-抽象相关的知识，希望对你有一定的参考价值。

抽象-函数

目录：function---函数 append--附加 range--列 definition--定义

1：编写一个小程序

2：抽象和结构

------创建函数

------文档化函数

3：参数的魔法

1：编写一个小程序

下面编写一小段代码计算婓波那契数列（前两个数的和是第三个数）

代码

fibs = [0,1] # 定义一个列表，初始内容是0，1

for i in range(8): #循环8次

fibs.append(fibs[-2]+fibs[-1]) #append在末尾追加一个数，这个是它前面两个数的和

#输入

>>> fibs

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

注释：fibs[-2]+fibs[-1]指的是fibs列表在的负数索引 -2代表0. -1代表1 ，相加为1，添加到新的列表中，重复8次。

>>> fibs = [0,1,2]

>>> for i in range(8):

fibs.append(fibs[-3]+fibs[-1])

>>> fibs

[0, 1, 2, 2, 3, 5, 7, 10, 15, 22, 32]

注：-3代表0，-1代表2 相加为2

2：抽象和结构

--------创建函数

语法：

def 函数名（函数的参数，形参）：

用def来做一个函数的定义，函数名之后要跟上小括号（），在小括号之后要跟上分号：

例子：

>>> def hello(name):

return ‘Hello.‘ + name + ‘!‘

>>> print hello(‘python‘)

Hello.python!

例子：用函数来写返回斐波那契数列，把用户输入获取数字改为作为参数接收数字

>>> def fibs(num): #定义函数名为fibs，参数为num

list=[0,1]

for i in range(num-2): #for循环，循环次数是参数-2的次数

list.append(list[-2]+list[-1]) #在列表末尾追加裂变中的强两位元素之和

return list #用来从函数中返回值

>>> fibs(10) #循环的次数是10-2=8次。

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34] #列表中的前两位是列表本身的，循环8次，得到8个新的元素追加到列表中，列表中共有10个元素

>>> fibs(6)

[0, 1, 1, 2, 3, 5]

----------文档化函数

文档化函数，简而言之，就是为了让使用函数的人好理解函数，在函数内容的开头加入注释，或者直接用字符串写一个开头语句。

例子：

>>> def square(x):

‘Calculates the square of the number x.‘

return x*x

>>> square(5)

----------并非真正函数的函数

>>> def test():

print ‘This is printed‘

return

print ‘This is not‘

>>> test()

This is printed

可以看到，return语句只起到结束函数的作用，第二个print并没有起到作用，直接被跳过了。

>>> x = test()

This is printed

>>> x

>>> print x

None

注：所有函数都返回了一些东西。当不需要返回值的时候，他就返回None.

----------函数中的形参与实参

>>> def function(name):

‘函数定义过程中的name是叫形参‘

#因为它只是一种形式,表示占据一个参数位置.

print (‘传递进来的‘ + name + ‘叫做实参,因为它是具体的参数值‘)

>>> function(‘Genal‘)

传递进来的Genal叫做实参,因为它是具体的参数值

注：定义函数的时候，name指的是形参，调用函数的时候，Genal指的是实参。

3：参数的魔法

-------改变函数的参数

通过调用函数的实参获得一系列值，参数是变量，在函数内为参数赋予新的值不会改变外部任何变量值。

例子：改变函数的参数

>>> def try_to_change(n): #定义一个新的函数

n = ‘Genal‘ #将形参定义变量

>>> name = ‘Alix‘

>>> try_to_change(name)

>>> name

‘Alix‘

结果：当变量n改变的时候，变量name不会改变。同样，当函数在内部把参数冲绑定赋值的时候，函数外的变量不会受到影响。

---------函数返回多个值

例子：返回多个值

>>> def back():

return [1,2.5,‘Genal‘]

>>> back()

[1, 2.5, ‘Genal‘] #返回的是列表

>>> print (back())

[1, 2.5, ‘Genal‘]

>>> def back():

return 1,2.5,‘Genal‘

>>> back()

(1, 2.5, ‘Genal‘) #返回的是元组

---------关键字参数和默认值

例子：位置参数

位置参数是指传递的参数都是根据位置来跟函数定义里的参数表匹配的，

>>> def test1(name,age):

print ‘%s,%s‘ % (name,age)

>>> test1(‘Geanal‘,‘42‘)

Geanal,42

>>> def test2(age,name):

print ‘%s.%s‘ % (age,name)

>>> test2(‘Geanal‘,‘42‘)

Geanal.42

>>> def test3(a,b):

print a

print b

>>> test3 (100,200)

100

200

解析：第一个例子中的第一个参数name位置匹配Genal，第二个例子中的第一个参数age匹配的是42。参数的位置进行了变化，最后打印的结果却是一致的，这就说明了，位置参数是根据参数的位置来进行匹配的，只要定义的参数位置发生了变化，根据位置来匹配的内容也是不同的。

例子：关键字参数

关键字参数就是根据参数名进行匹配的，与参数的所在位置无关。

情况：当我们使用位置参数的时候，定义的函数中的参数过多的话，我们是不会记住这些参数的位置的，这也就给我们带来一些麻烦，因此，就需要用关键字参数来解决这些问题的。

>>> def test4(name=‘Genal‘,age=‘42‘):

print name,age

>>> test4()

Genal 42

>>> def test5(age=‘42‘,name=‘Genal‘):

print name,age

>>> test5()

Genal 42

解析：上述的两个例子中，都给函数的参数设了默认值，即使参数的位置进行了变化，得出的结果却是一样的，这就说明了关键字参数是根据参数的默认值来匹配的，和参数的位置是无关的。

例子：默认值---两个参数，只指定一个默认值时

>>> def test6(a,b=‘Alix‘):

print a,b

>>> test6(100)

100 Alix

>>> test6(100,200)

100 200

解析：在函数的定义中，参数啊，a,b中只有b指定了默认值，在调用函数的时候，只指定一个匹配参数test6(100)，参数a指定的是100，参数b指定的是默认参数，当调用函数，匹配两个实参，会自动将形参中的一个有默认值的参数进行覆盖。

--------收集参数

收集参数是指将参数收集为元组或者字典，在形参前面加上*号。实质上就是将多个实参收集成一个形参。

例子：利用位置参数进行收集操作

>>> def print_test1(*test1):

print test1

>>> print_test1(‘Genal‘)

(‘Genal‘,)

解析：结果作为元组打印出来，因为括号里面有个逗号。

例子：

>>> def print_test1(title,*test1):

print title,test1

>>> print_test1(‘Number:‘,1,2,3)

Number: (1, 2, 3)

>>> print_test1(‘Number:‘)

Number: ()

解析：有星号的参数将所有的值放置在一个元组中，将这些值收集起来，在调用函数的时候，将收集起来的元组传递给形参。当收集起来的值是空的时候，打印的时候也是空的元组。

例子：利用关键字是参数进行收集操作

利用关键字进行收集操作用到的是两个参数‘**’。

>>> def print_test2(**test2):

print test2

>>> print_test2(a=1,b=2,c=3,d=4)

{‘a‘: 1, ‘c‘: 3, ‘b‘: 2, ‘d‘: 4}

解析：关键字参数的收集操作是将值a=1,b=2,c=3,d=4收集成字典传递给形参test2.

-------作用域

作用域简单说就是一个变量的命名空间。代码中变量被赋值的位置，就决定了哪些范围的对象可以访问这个变量，这个范围就是命名空间。python赋值时生成了变量名，当然作用域也包括在内。全局变量可以在作用局部变量，可以调用局部变量。局部变量不能作用在全局变量，不能调用全局变量。

例子：局部变量

在函数内定义的变量名，只能被函数内部引用，不能在函数外引用这个变量名，这个变量的作用域就是局部的，也叫它为局部变量。作用范围就是只能在函数里面，对在函数外面的变量不影响，即是是同名函数，如果不在函数里面做global声明那么就不会对函数外面有影响

>>> count = 10 #这是函数外的变量，叫做全局变量，全局变量可以作用在局部变量中

>>> def print_local(): #定义函数

x = 5 #在定义函数下定义变量，是局部变量，只能作用在定义函数范围内。

print(count) #打印的是全局变量

print(x)#打印的是局部变量

>>> print_local()

例子：当全局变量名和局部变量名一样时。

>>> count = 10

>>> def print_local():

count = 5 #局部变量名和全局变量名相同，局部变量覆盖全局变量

print(count) #打印的是局部变量

>>> print_local()

解析：当全局变量名称和局部变量名称一样时，局部变量名称会覆盖全局变量，这个时候的局部变量名称和全局变量名称不是一个变量，是不同的。

例子：在函数内部定义局部变量，调用全局变量

>>> num = 100

>>> def func():

num += 100

print num

>>> func()

Traceback (most recent call last):

File "<pyshell#40>", line 1, in <module>

func()

File "<pyshell#39>", line 2, in func

num += 100

UnboundLocalError: local variable ‘num‘ referenced before assignment

解析：输出结果是：UnboundLocalError: local variable ‘num‘ referenced before assignment。提示错误：局部变量num在赋值前被应用。也就是说该变量没有定义就被错误使用。由此再次证明这里定义的是一个局部变量，而不是全局变量，在定义函数的过程中，不能调用全局变量。

例子：局部变量想要调用全局变量用global语句

从上面课的代码中可以发现，如果在函数体内声明的变量名和已经有的全局变量名重复，那么局部变量就会把全局变量覆盖掉。如果想要在函数体内使用全局变量，使用前需要先用global语句来声明下用到的这个变量是全局变量

>>> count = 10

>>> def print_local():

global count #声明count是全局的，调用全局变量

count = 5 #这个count就是上面的全局变量

print(count)

>>> def print_global():

print(count)

>>> print_local()

>>> print_global()

解析：

例子：是在定义函数print_local中调用全局变量，值改为5。print_global()打印的是5，这个时候调用就是上一个函数中全局变量的值.

---------递归函数

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

>>> def fact(n):

if n == 1: #调用了函数本身的参数，这就是函数的内部调用自身，称为递归函数

return 1

else:

return n*fact(n -1)

---------阶乘和幂函数

什么是阶乘？ factorial=阶乘

阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。例如所要求的数是4，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。例如所要求的数是6，则阶乘式是1×2×3×……×6，得到的积是720，720就是6的阶乘。例如所要求的数是n，则阶乘式是1×2×3×……×n，设得到的积是x，x就是n的阶乘。任何大于1的自然数n阶乘表示方法： n!=1×2×3×……×n 　或 n!=n×(n-1)! 5！=5*4*3*2*1=120。