总结九

一.函数简介

什么是函数：函数就是具有某个具体功能的工具

为什么要用函数：1.提供开发效率  2.减少代码冗余 3.提高程序的扩展性

定义一个函数

def是定义函数的关键字

函数名的命名规则与变量名一致：

1.不能用关键字

2.函数也应该做到见明知意

函数在定义的时候只检测函数体语法，不执行函数体代码

调用函数的固定格式：

　　函数名+括号

　　函数名只要遇到括号会立即执行函数体代码

　　代码中遇到函数名加括号，优先级最高

　　先去执行函数，再看下面的代码

 

s = 'hello'

print(len(s))   #  len()  内置函数：python提前给你写好的函数，直接调用即可

n = 0

for i in s:

    n += 1

print(n)

 

 

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

my_len()    #  函数必须先定义后调用，定义了的函数可以在任意位置调用

def my_len():  #  自定义函数

    n = 0

    for i in s:

        n += 1

    print(n)

res = my_len()

print(res)

res = my_len()

print(res)

len(s)

len(l)

len(s)

len(l)

s = 'hello world'

l = [1,2,3,4,5,6]

my_len()

print(len(s),len(l))

"""

我们自己写的函数现在的问题：

       1.没有返回值，只能固定的执行打印操作

　　2.只能固定的统计某一个容器类型的长度

"""

 

二.函数的返回值

def func():

　　return 'abcdefg'

res = func()

print(res)

 

函数内要想返回给调用者值，必须用关键字return

"""

 

不写return

只写return

写return  None

写return 返回一个值

写return 返回多个值

"""

不写return：函数默认返回None

def func():

　　print('abc')

res = func()

print(res)

 

只写return：return除了可以返回值之外，还可以直接结束整个函数的运行

                   只写return返回的也是None（None表示啥都么有）

def func():

　　l = ['ab','cd','ef']

　　while True:

　　　　for i in l：

　　　　    if i == 'cd':    #  当i为cd的时候，直接结束函数运行

　　　　　　# break

　　　　　    return

　　　　            # print('abcdefghijk')   #  这一行代码永远都不会运行

　　　　    print(i)

res = func()

print(res)

 

写return  None:跟上面的只写return是一样的

def func():

　　return None

res = func()

print(res)

 

写return返回一个值：这个值可以是python任意数据类型

def func():

　　return '123'

def func1():

　　return [1,2,3]

def func2():

　　return {'name':'jason'}

print(func(),func1(),func2())

 

写return返回多个值：return会自动将多个值以元组的形式返回给调用者

"""

1.为什么组织成元组返回：函数不希望自己处理的结果被修改

2.如何不返回元组

"""

def func():

　　return 1,2,3,4    #  返回的是（1,2,3,4）

res = func()

print(res)

 

def func1():

　　return 'a','b','c'    #   ('a','b','c')

res = func1()

print(res)

 

def func2():

　　return [1,2,3],[1,2,3],[1,2,3]    #  ([1,2,3],[1,2,3],[1,2,3])

res1 = func2()

print(res1)

 

def func3():

　　retuen {'name':'jason'},{'username':'tzz'},{'user_name':'txl'}   #  ({'name':'jason'},{'username':'tzz'},{'user_name':'txl'})

#  返回多个值，并且不想让return帮你做处理，自己手动加上你想返回的数据类型符号

def func4():

　　return [[1,2,3,4],[1,2,3,4],[1,2,3,4]]

res = func4()

print(res)

"""

1.所有的函数都有返回值，无论你写不写return

   python中所有的函数都有返回值，不写的情况下默认返回None

2.光写return或者return None并不是为了考虑返回值，而是为了结束函数的运行

"""

 

三.函数的参数概要

"""

positional   arguments:位置参数

param  参数

required  需求的

"""

s = `hello`

l = [1,2,3,4]

print(len(s))

print(len(l))

def my_len(args):    #  需要0个参数

　  print(args)

      n = 0

　  for i in args:

　　   n += 1

　  return n

res = my_len()

print(res)

my_len(l)    #  给my_len传了一个参数

my_len('asda')

print(my_len('hello'))

print(my_len('hello world'))

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

"""

函数参数的两大类型

1.形参：在函数的定义阶段，括号内写额变量名，叫做该函数的形式参数

2.实参：在函数的调用阶段，括号内实际传入的值，叫做实际参数，简称实参

 

形参与实参的关系

形参就相当于变量名，而实参就相当于变量的值

函数调用传参的过程，就是给形参变量名赋值的过程

注意：形参和实参的绑定关系只在函数的调用阶段有效，函数运行结束关系自动结束

           只在函数内部有效，函数外部无任何影响

 

函数的简易结构

def 函数名(形参1，形参2...)：

　  ''' 函数的注释：用来描述该函数的作用以及各个形参的类型 '''

      函数体代码1

      函数体代码2

      ...

      return 函数的返回值   

"""

 

def func(x,y):

     """

     该函数的作用

     :param x:  对形参x的解释

     :param y:  对形参y的解释

     :return:   对函数返回值的解释

     """

     print('hahaha')

     return('houhou')

print(help(func))

print(help(len))

 

四.位置参数

位置参数：在函数定义阶段按照位置从左往右依次书写的变量名，叫做函数位置形参

位置形参在调用的时候，必须为其传值

求两个数的大小，返回大的那个

def my_max(x,y):

    print(x,y)

    if x > y:

        return x

    else:

        return y

res = my_max(1)   #  在调用函数的时候  少一个实参不行

res = my_max(1,2,3)   #  在调用函数的时候，第一个实参也不行

res = my_max(20,10)

 

位置实参：在函数的调用阶段，传入的参数会按照位置一一对应给形参

print(res)

 

 

第一种直接按照位置传   一一对应

第二种指名道姓的传      关键字传参

my_max(y=20,x=10)

my_max(10,y=20)    #  位置和关键字混合使用

my_max(20,y=40)

my_max(20,y=40,x=30)

"""

注意：在函数的调用阶段，位置参数和关键字参数可以混合使用

但必须保证

       1.位置参数必须在关键字参数的前面（越短的越靠前，越长的越复杂的越靠后）

       2.同一个形参不能被多次赋值

"""

 

五.默认值参数

默认值参数：在函数的定义阶段，形参（变量名）就已经被赋值了

在调用的时候，可以不为默认值形参传值，默认使用定义阶段就已经绑定的值

在调用的时候，如果可以给默认值形参传值，传了那么久使用你传的值

在定义阶段，默认值形参必须放在位置形参的后面

def register(username,age,gender='male'):

    print(username,age,gender)

register('a',18)

register('b',19)

register('c',20)

register('d',18,'female')

 

 

默认值参数的应用场景

当形参接收到的值比较单一的情况下，通常可以考虑用默认值形参

def info(username,hobby,l=None):

    if l == N

one:

        l = []

    l.append(hobby)

    print('%s 的爱好是 %s‘%(username,l))

info('jason','study')

info('tank','music')

info('kevin','sport')

info('egon','read') 

解决方法1

info('jason','study',[])

info('tank','music',[])

info('kevin','sport',[])

info('egon','read',[])

解决方法2

info('jason','study')

info('tank','music')

info('kevin','sport')

info('egon','read')

 

 

m = 100

def my_max(x,y=m):

    print(x,y)

m = 222

my_max(111)

 

def func(x,y=100):

    print(x,y)

"""

函数在定义阶段，内部所使用的变量都已经初始化完毕了

不会因为调用的位置的变化，而影响到内部的值

函数无论在什么地方被调用，都会跑到函数定义阶段去执行代码，

形参中用到的值都是往函数定义阶段代码往上找

"""

 

六.可变长参数

可变长参数：站在调用函数传递实参的角度，实参的个数不固定的情况，也就意味着形参也不固定

站在形参的角度，可以用*和**来接收多余的（溢出的）位置参数和关键字参数

 

站在形参的角度，看*

形参中的*会将多余的（溢出的）位置实参，统一用元组的形式处理，传递给*后面的形参名

def func(x,y,*z):

    print(x,y,z)

l = [1,2,3]

a,b,c = l

func(a,b,c)

func(*[1,2,3,4,5,6])    #  *会将列表打散成位置实参一一传入 等价于func(1,2,3,4,5,6)

func(*(1,2,3))    #  等价于func(1,2,3)

def func(x,*z):

    print(x,z)

func(1,*{1,2,3})   #  在形参中只能接收多余的位置实参，不能接收关键字实参

*只能将 列表，元组，集合，字符串 打散

*的内容你可以看成是for循环

 

 

站在形参的角度看 **

def func(x,y,**z):

    print(x,y,z)

func(1,2,3)

func(x=1,y=2,z=3)

d = {'x':1,'y':2,'z':3}

func(x=1,y=2,z=3)

func(**d)    #  等价于func(x=1,y=2,z=3)

**会将字典拆封成 key = value 的形式

"""

总结 * 与 **

* 在形参中能够接收多余的位置参数，组织成一个元组，赋值给*后面的变量名

**在形参中能够接收多余的关键字参数，组织成一个字典赋值给**后面的变量名

 

*：在实参中，*能够将列表，元组，集合，字符串 打散成位置实参的形式传递给函数

      （*就看成是for循环取值）

**：在实参中，能将字典打散成key = value的形式，按照关键字参数传递给函数

"""

需求：写的函数，无论调用者按照正确传参的方式无论怎么传，你的函数都能够正常运行

def func1(*x,**y):

    print(x,y)

func1(1,2,3,4,5,6,x=1,y=2,z=3)

"""

注意python推荐形参*和**通用的写法

"""

def func2(*args,**kwargs):

    print(args,kwargs)

func2(1,2,3,4,5,6,x=1,y=2,z=3)

 

转载于:https://www.cnblogs.com/TZZ1995/p/11158767.html