函数

函数是代码的一种组织形式
函数应该能完成一项特定的工作，而且一般一个函数只完成一项工作
有些语言，分函数和过程两个概念，通俗解释是，有返回结果的是函数，无返回结果的叫过程，python不加以区分
函数的使用
- 函数使用需要先定义
- 使用函数，俗称调用

# 定义一个函数
# 只是定义的话不会执行
# 1. def关键字，后跟一个空格
# 2. 函数名，自己定义，起名需要遵循便令命名规则，约定俗成，大驼峰命名只给类用
# 3. 后面括号和冒号不能省，括号内可以有参数
# 4. 函数内所有代码缩进


def func():
    print("我是一个函数")
    print("爱生活")
    
print("函数结束了")

函数结束了

# 函数的调用
# 直接写出函数名字，后面小括号不能省略，括号内内容根据情况
func()

我是一个函数
爱生活

# 函数定义
def func():
    print('A')
    print('B')

func()

A
B

函数的参数和返回值

参数：负责给函数传递一些必要的数据或者信息
- 形参（形式参数）：在函数定义的时候用到的参数，没有具体值，只是一个占位符号
- 实参（实际参数）：在调用函数的时候输入的值
返回值：调用函数的时候的一个执行结果
- 使用return返回结果
- 如果没有值需要返回，我们推荐使用return None表示函数结束
- 函数一旦执行return，则函数立即结束
- 如果函数没有return关键字，则函数默认返回None

# 形参和实参的案例
# 参数person只是一个符号
# 调用的时候用另一个
def hello(person):
    print("{}，你好吗？".format(person))
    return None
    
p = "小明"
# 调用函数，需要把p作为实参传入
hello(p)

小明，你好吗？

p = "小五"
hello(p)

小五，你好吗？

pp = hello("小柒")
print(pp)

小柒，你好吗？
None

# return案例

def hello(person):
    print("{0}，你好吗？".format(person))
    return "提前结束！"
    print(1)
    
p = "小明"
rst = hello(p)
print(rst)

小明，你好吗？
提前结束！

# help负责随时为你提供帮助
help(None)  # 等价于help(peint())

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

# 九九乘法表
# version 1.0
for o in range(1, 10):  # 控制外循环 从 1 到 9
    for i in range(1, o + 1):     # 内循环，每次从第一个数字开始，打印到跟行数相同的数量
        print(o * i, end="  ")
    print()

1  
2  4  
3  6  9  
4  8  12  16  
5  10  15  20  25  
6  12  18  24  30  36  
7  14  21  28  35  42  49  
8  16  24  32  40  48  56  64  
9  18  27  36  45  54  63  72  81

help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

# 尝试用函数来打印九九乘法表

def jiujiu():
    for o in range(1, 10):  # 控制外循环 从 1 到 9
        for i in range(1, o + 1):     # 内循环，每次从第一个数字开始，打印到跟行数相同的数量
            print(o * i, end="  ")
        print()
    
    return None

jiujiu()
jiujiu()

1  
2  4  
3  6  9  
4  8  12  16  
5  10  15  20  25  
6  12  18  24  30  36  
7  14  21  28  35  42  49  
8  16  24  32  40  48  56  64  
9  18  27  36  45  54  63  72  81  
1  
2  4  
3  6  9  
4  8  12  16  
5  10  15  20  25  
6  12  18  24  30  36  
7  14  21  28  35  42  49  
8  16  24  32  40  48  56  64  
9  18  27  36  45  54  63  72  81

# 改造上面函数

def printLine(line_num):
    '''
    line_num；代表行号
    
    打印一行九九乘法表
    '''
    for i in range(1, line_num + 1):
        print(line_num * i, end=" ")
        
    print()

def jiujiu():
    for o in range(1, 10):  # 控制外循环 从 1 到 9
        printLine(o)
    return None

jiujiu()

1 
2 4 
3 6 9 
4 8 12 16 
5 10 15 20 25 
6 12 18 24 30 36 
7 14 21 28 35 42 49 
8 16 24 32 40 48 56 64 
9 18 27 36 45 54 63 72 81

参数详解

参考资料
python参考资料：headfirst python -> 零基础入门学习python（小甲鱼）、流畅的python -> 习题
参数分类
- 普通参数/位置参数
- 默认参数
- 关键字参数
- 收集参数

普通参数

c参见上例
定义的时候直接定义变量名
调用的时候直接把变量或者值放入指定位置

        def 函数名（参数1，参数2，.....）:
            函数体
            
        # 调用
        函数名（value1，value2，......）
        
        # 调用的时候，具体值参考的是位置，按位置赋值

默认参数
- 形参带有默认值
- 调用的时候，如果没有对相应形参赋值，则使用默认值
  def func_name(p1=v1,p2=v2,........):
```
func_block
```
  调用1
  func_name()
  调用2
  value1=100
  value2=200
  func_name(value1,value2)
关键字参数
- 语法
```
    def func(p1=v1, p2=v2....):
        func_body
        
    被调函数;
    func(p1=value1, p2=value2....)
    
```
- 比较麻烦，但也有好处：
  - 不容易混淆，一般实参和形参只是按照位置一一对应即可，容易出错
  - 使用关键字参数，可以不考虑参数位置
收集参数
把没有位置，不能和定义是的参数位置相对应的参数，放入一个特定的数据结构中

语法

    def func(*args):
        func_bady
        按照List使用方式访问args得到传入的参数
        
    调用：
    func(p1,p2,p3....)

参数名args不是必须这么写，但是，推荐直接用args，约定俗成
参数名args前需要有星号
收集参数可以和其他参数共存

# 普通参数案例

def normal_para(one, two, three):
    print(one + two)
    return None

normal_para(1,2,3)

# 默认参数案例1

def default_para(one, two, three=100):
    print(one + two)
    print(three)
    return None
    
default_para(1,2)
default_para(1,2,3)

# 默认参数案例2
# 报名函数，需要知道学生性别
# 学习python的学生基本都是男生。所以，报名的时候如果没有特别指定，我们认为是男生
def reg(name, age, gender="male"):
    if gender == "male":
        print("{0} is {1}, and he is a good student".format(name, age))
    else:
        print("{0} is {1}, and she is a good student".format(name, age))

# 调用默认参数函数案例

reg("mingyue",21)

reg("xiaojing",23,"female")

mingyue is 21, and he is a good student
xiaojing is 23, and she is a good student

# 关键字参数案例1

def keys_para(one, two, three):
    print(one + two)
    print(three)
    return None

keys_para(one=1, two=2, three=30)

keys_para(three=30, two=2, one=1)

# 关键字参数案例2
def stu(name, age, addr):
    print("I am a student")
    print("我叫 {0}, 我今年 {1}岁了，我住{2}".format(name, age, addr))
    
n = "jingjing"
a = 18
addr = "我家"

# 普通参数，只按照位置传递，容易出错
stu(a, n, addr)

def stu_key(name="No name", age=0, addr="No addr"):
    print("I am a student")
    print("我叫 {0}, 我今年 {1}岁了，我住{2}".format(name, age, addr))
    
n = "jingjing"
a = 18
addr = "我家"

# 普通参数，只按照位置传递，容易出错
stu_key(name=n, age=a, addr=addr)

I am a student
我叫 18, 我今年 jingjing岁了，我住我家
I am a student
我叫 jingjing, 我今年 18岁了，我住我家

# 收集参数案例
# 函数模拟一个学生进行自我介绍，但具体内容不清楚
# args把他看作一个List
def stu( *args):
    print("Hello 大家好，我自我介绍一下，简单说两句：")
    # type函数作用是检测变量的类型
    print(type(args))
    for item in args:
        print(item)


stu("Liuying", 18, "北京大通州区", "wangxiaojing", "single")

stu("周大神")

Hello 大家好，我自我介绍一下，简单说两句：
<class 'tuple'>
Liuying
18
北京大通州区
wangxiaojing
single
Hello 大家好，我自我介绍一下，简单说两句：
<class 'tuple'>
周大神

# 收集参数案例
# 说明收集参数可以不带任何参数调用，此时收集参数为空tuple
stu()

Hello 大家好，我自我介绍一下，简单说两句：
<class 'tuple'>

# 如果使用关键字参数格式调用，会出现问题
stu(name="Liuying")

收集参数之关键字收集参数

把关键字参数按字典格式存入收集参数
语法：
def func( **kwargs):
```
func_body
```
调用;
func(p1=v1, p2=v2, p3=v3....)
kwargs一般约定俗成
调用的时候，把多余的关键字参数放入kwargs
访问kwargs需要按字典格式访问

# 收集参数案例
# 自我介绍
# 调用的时候需要使用关键字参数调用
def stu( **kwargs):
    # 在函数体内对于kwargs的使用不用带星号
    print("Hello 大家好，我先自我介绍一下：")
    print(type(kwargs))
    # 对于字典的访问，python2 和python3有区别
    for k,v in kwargs.items():
        print(k, "---", v)

stu(name="Liuying", age=19, addr="北京大通州区" , lover="王晓静", work="Teaccher")

print("*" * 50)

stu(name="周大神")

Hello 大家好，我先自我介绍一下：
<class 'dict'>
name --- Liuying
age --- 19
addr --- 北京大通州区
lover --- 王晓静
work --- Teaccher
**************************************************
Hello 大家好，我先自我介绍一下：
<class 'dict'>
name --- 周大神

# 收集参数可以为空案例
stu()

Hello 大家好，我先自我介绍一下：
<class 'dict'>

收集参数混合调用的顺序问题

收集参数，关键字参数，普通参数可以混合使用
使用规则就是。普通参数和关键字参数优先
定义的时候一般找普通参数，关键字参数，收集参数tuple，收集参数dict

# 收集参数混合调用案例
# stu模拟一个学生的自我介绍
def stu(name, age,  *args, hobby="没有", **kwargs):
    print("Hello 大家好")
    print("我叫 {0}, 我今年 {1}岁了。".format(name, age))
    if hobby == "没有":
        print("我没有爱好，so sorry")
    else:
        print("我的爱好是{0}".format(hobby))
        
    print("*" * 20)
    
    for i in args:
        print(i)
        
    print("#" * 30)
    
    for k,v in kwargs.items():
        print(k, "---", v)
        
# 开始调用函数
name = "Liuying"
age = 19

# 调用的不同格式
stu(name, age)

stu(name, age, hobby="游泳")

stu(name, age, "王晓静", "刘石头", hobby="游泳", hobby2="烹饪", hobby3="跟不同女生聊天")

Hello 大家好
我叫 Liuying, 我今年 19岁了。
我没有爱好，so sorry
********************
##############################
Hello 大家好
我叫 Liuying, 我今年 19岁了。
我的爱好是游泳
********************
##############################
Hello 大家好
我叫 Liuying, 我今年 19岁了。
我的爱好是游泳
********************
王晓静
刘石头
##############################
hobby2 --- 烹饪
hobby3 --- 跟不同女生聊天

收集参数的解包问题

把参数放入List或者字典中，直接把List/dict中的值放入收集参数中
语法：参考案例

# 收集参数的解包问题

def stu( *args):
    print("哈哈哈哈")
    # n 用来表示循环次数
    # 主要用来调试
    n = 0
    for i in args:
        print(type(i))
        print(n)
        n += 1
        print(i)
        
# stu("Liuying", "Wangxiaojing", 19, 20)

l = ["Liuying", 19, 20, "Wangxiaojing"]

stu(l)
# 此时，args的表示形式是字典内一个List类型的元素，即 args = (["Liuying", 19, 23, "Wangxiaojing",])
# 很显然跟我们最初的想法违背

# 此时的调用，我们就需要解包符号，即调用的时候前面加一个星号
stu(*l)

哈哈哈哈
<class 'list'>
0
['Liuying', 19, 20, 'Wangxiaojing']
哈哈哈哈
<class 'str'>
0
Liuying
<class 'int'>
1
19
<class 'int'>
2
20
<class 'str'>
3
Wangxiaojing

同理，dict类型收集参数一样可以解包，但是

对dict类型进行解包
需要用两个星号进行解包

函数文档

函数的文档的作用是对当前函数提供使用相关的参考信息
文档的写法：
- 在函数内部开始的第一行使用三引号字符串定义符
- 一般具有特定格式
- 参考案例
文档查看
- 使用help函数，形如 help(func)
- 使用__doc__，查看案例

# 文档案例

def stu(name, age, *args):
    '''
    这是第一行
    这是第二行
    这是第三行
    '''
    print("This is hanshu stu")
    pass

# 查看函数文档
help(stu)
stu.__doc__

Help on function stu in module __main__:

stu(name, age, *args)
    这是第一行
    这是第二行
    这是第三行






'\n    这是第一行\n    这是第二行\n    这是第三行\n    '

def stu(name, age):
    '''
    这是文档的文字内容
    :param name: 表示学生的姓名
    :param age: 表示学生的年龄
    :return: 此函数没有返回值
    '''
    pass

print(help(stu))

print("*" * 20)

print(stu.__doc__)

Help on function stu in module __main__:

stu(name, age)
    这是文档的文字内容
    :param name: 表示学生的姓名
    :param age: 表示学生的年龄
    :return: 此函数没有返回值

None
********************

    这是文档的文字内容
    :param name: 表示学生的姓名
    :param age: 表示学生的年龄
    :return: 此函数没有返回值

python函数详解

函数

函数的参数和返回值

参数详解

调用1

调用2

收集参数之关键字收集参数

调用;

收集参数混合调用的顺序问题

收集参数的解包问题

同理，dict类型收集参数一样可以解包，但是

函数文档

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

python函数详解

函数

函数的参数和返回值

参数详解

调用1

调用2

收集参数之关键字收集参数

调用;

收集参数混合调用的顺序问题

收集参数的解包问题

同理，dict类型收集参数一样可以解包，但是

函数文档

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像