Python函数的学习总结-阿里云开发者社区

1 函数的创建和调用

1.1 函数创建

创建函数即定义函数
使用关键字def实现
语法：

def fname([pname]):
    ["comm"]
    [fuc]

说明：

def：定义函数的，固定写法
fname：函数名
pname：参数，可选，指定向函数中传入的参数，若有多个的话，参数之间用逗号隔开
comm：可选，函数的注释，即说明函数的功能、传递的参数，提升代码可阅读性
fuc：函数体，可选，具体的函数功能，如有返回值，使用return()
comm和fuc必须要进行缩进显示
如果想定义空函数，函数体直接用pass作占位符即可

# -*- coding:utf-8 -*-

import random

def mgame(num):
    """
    模拟石头剪刀布游戏：
    :param num: 输入一个0-2之间的任意一个整数(0:石头、1：剪刀、2：布)
    :return: 返回输入的num以及计算机随机给的数值
    """
    computernum = random.randint(0, 2)
    if num == computernum:
        print("平局！")
    elif num == 0 and computernum == 1 or num == 1 and computernum == 2 or num == 2 and computernum == 0:
        print("我赢了！")
    else:
        print("计算机赢了")
    return num, computernum

结果：

D:\Python37\python.exe F:/python_study/main.py

进程已结束，退出代码 0

运行上边的代码，不显示任何内容，也不会抛出异常，因为函数没有调用！！！

1.2 函数调用

函数调用即执行函数
简单理解一下：函数就是实现某种功能或者用途的工具，而调用函数就是使用这个工具
语法：

fname([pname])

说明：

fname：函数名
panme：参数，根据函数的定义来确定传入参数的类型以及是否传入参数

# -*- coding:utf-8 -*-

import random

def mgame(num):
    """
    模拟石头剪刀布游戏：
    :param num: 输入一个0-2之间的任意一个整数(0:石头、1：剪刀、2：布)
    :return: 返回输入的num以及计算机随机给的数值
    """
    computernum = random.randint(0, 2)
    if num == computernum:
        print("平局！")
    elif num == 0 and computernum == 1 or num == 1 and computernum == 2 or num == 2 and computernum == 0:
        print("我赢了！")
    else:
        print("计算机赢了")
    return num, computernum

out = mgame(2) # 调用函数，因为这个函数定义了有返回值，所以调用函数后，并且把结果给out变量；因为函数定义的时候有一个参数num，所以调用的时候给了一个传入参数2
print(out) # 使出变量out的值

结果：

# 每次结果可能不一样，因为计算机是随机给的值，我这里运行了好几次，取了几个结果如下：
计算机赢了
(2, 1)
我赢了！
(2, 0)
平局！
(2, 2)

1.3 pass空语句

pass语句表示空语句，不做任何事情，一般起到占位符的作用
怎么用呢？比如我们写一个函数，暂时不确定他的功能，可以使用pass来填充，告诉别人以后我会加上的，哈哈

def fname():
    pass

在python中上边的pass可以使用三个连续的点来代替

def fname():
    ...

2 参数传递

如【1.2 函数调用】中的函数pname就是参数，但是参数也有两个：实际参数(实参)和形式参数(形参)

2.1 形式参数和实际参数

如何理解两个的区别？

通过作用理解

① 就是通过她两的作用来定的，书本上是这么说的 ” 在定义函数时，函数名后边括号中的参数为【形式参数】，称形参；在调用函数时，函数名后边括号中的参数为【实际参数】，称实参“.......
②说实话上一句话，真没有理解！！！
在这里插入图片描述
③举个例子：

# 定义和创建函数的时候，这里的num就是形式参数
def test(num):
    print(num)

# 调用函数，此时的函数参数5，(11, 22, 33 44)就是实际参数
test(5)
test((11, 22, 33, 44))

结果：

5
(11, 22, 33, 44)

④根据实参的类型不同，可将实参的传递分为【值转递】和【引用传递】，这里当然是把实参传递给形参了，怎么区分这两个概念呢？

Ａ、当实参为不可变对象时，为值传递；
Ｂ、当实参为可变对象时，为引用传递；
Ｃ、本质区别为：值传递后，不会改变形参的值，实参的值也不变；引用传递后，改变形参的值，实参的值也改变。

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
有点感觉了，貌似理解了！不过，还是不太清楚！
在这里插入图片描述

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
⑤再举个例子：

# -*- coding:utf-8 -*-

def test(name):
    print("原来的值：", name)
    name += name

# 调用函数
print("=======1、开始进行值传递======")
mtr = "我们都有一个梦想，那就是明年不止挣一个亿！"
print("调用前：", mtr)
test(mtr)
print("调用后：", mtr)

print("=======2、开始进行引用传递======")
mlist = ["1个亿", "2个亿", "3个亿"]
print("调用前：", mlist)
test(mlist)
print("调用后：", mlist)

结果：

=======1、开始进行值传递======
调用前： 我们都有一个梦想，那就是明年不止挣一个亿！
原来的值： 我们都有一个梦想，那就是明年不止挣一个亿！
调用后： 我们都有一个梦想，那就是明年不止挣一个亿！
=======2、开始进行引用传递======
调用前： ['1个亿', '2个亿', '3个亿']
原来的值： ['1个亿', '2个亿', '3个亿']
调用后： ['1个亿', '2个亿', '3个亿', '1个亿', '2个亿', '3个亿']

使用一个比喻来理解

函数定义时参数列表的参数就是形参，而函数调用时传递进来的参数就是实参，比如就像：
剧本中的角色就是形参，而演角色的演员就是实参。＝＝＝＝这句话，不是我说的，来源课本！！

2.2 位置参数

即必备参数，必须按照正确的顺序传到函数中
即调用时的数量和位置必须和定义时时一样的

①数量必须与定义时一致

# -*- coding:utf-8 -*-
# 也就是说 在调用函数时，指定的实参数量与形参数量一致，否则会抛出异常TypeError

def test(num1, num2):
    sum = 0
    sum = num1 + num2
    print(sum)

test(1, 2)
test(2) # 这个会抛出异常，因为参数数量不一致

结果：

3
Traceback (most recent call last):
  File "F:/python_study/main.py", line 12, in <module>
    test(2)
TypeError: test() missing 1 required positional argument: 'num2'

②位置必须与定义时一致

# -*- coding:utf-8 -*-

# 也就是说 在调用函数时，指定的实参位置与形参位置一致，否则会抛出异常TypeError或者不抛异常，但是程序存在bug

def person(name, age, height):
    print(name, age, height)

person("小张", 18, 170)

# 位置换一下，如果类型不一样，虽然结果没有抛出异常，但是名字是18，年龄是小张，好像不合适，有bug
person(18, "小张", 170)

结果：

小张 18 170
18 小张 170

2.3 关键字参数

即使用形参的名字来确定输入的参数值
此方式指定实参时，无须与形参的位置完全一致，只需将参数名写正确即可

# -*- coding:utf-8 -*-

def person(name, age, height):
    print(name, age, height)

person(height=170, name="小张", age=18)

结果：

小张 18 170

2.4 为参数设置默认值

即定义函数时，直接指定形式参数的默认值
当没有传入参数时直接使用默认值
语法：

def fname(pname=defaultname):
    [func]

说明：

fname：函数名称
pname：参数，可选
defaultname：参数pname的默认值
func：函数体

# -*- coding:utf-8 -*-

def person(name="小张"):
    print(name)

person() # 没有传参，使用默认值
person("小李") # 传参了，使用传入的值

结果：

小张
小李

可使用" 函数名.__ defaults__"来查看函数的默认值参数的当前值，结果为元组

# -*- coding:utf-8 -*-

def person(name="小张", age=18, height=172):
    print(name)

person() # 没有传参，使用默认值
person("小李") # 传参了，使用传入的值
print(person.__defaults__) # 查看函数参数的默认值

结果：

小张
小李
('小张', 18, 172)

2.5 可变参数

即不定长参数
即传入函数中的实参可为0个，1个，两个以及任意个
定义可变参数的形式有两种：parameter 和 *parameter

① *parameter：表示接收任意多个实参并将其放到元组中

# -*- coding:utf-8 -*-

def person(*name):
    print(name)
    for item in name:
        print(item)

person("小张", "小李", "老王", "隔壁老王") # 字符串直接写
person(*["小张", "小李", "老王", "隔壁老王"]) # 如果传入的可变参数时列表，需要在列表前加*号

结果：

('小张', '小李', '老王', '隔壁老王')
小张
小李
老王
隔壁老王
('小张', '小李', '老王', '隔壁老王')
小张
小李
老王
隔壁老王

② **parameter：表示接收任意多个显示赋值的实参，并将其放到一个字典中

# -*- coding:utf-8 -*-

def person(**name):
    print(name)
    for key, value in name.items():
        print(""+key+"的英文名为：", value)

person(小张="xiaozhang", 小李="xiaoli", 老王="laowang", 隔壁老王="gblw")

结果：

{'小张': 'xiaozhang', '小李': 'xiaoli', '老王': 'laowang', '隔壁老王': 'gblw'}
小张的英文名为： xiaozhang
小李的英文名为： xiaoli
老王的英文名为： laowang
隔壁老王的英文名为： gblw

到这一步，感觉可以歇歇了
在这里插入图片描述

3 返回值

使用return语句为函数指定返回值
无论return在什么位置，执行到return后，就会结束函数的执行

# -*- coding:utf-8 -*-

def name_to_xname(name):
    xname = ""
    if name == "小张":
        xname = "xiaozhang"
    elif name == "老王":
        xname = "laowang"
    elif name == "老李":
        xname = "laoli"
    elif name == "隔壁老王":
        xname = "gblw"
    else:
        print("输入的名字不存在，请重新输入以下内容中的一个：", ["小张", "老王", "老李", "隔壁老王"])
    return(xname)

while True:
    name = input("请输入以下名称中的任意一个,请输入:")
    xname = name_to_xname(name)
    print("{} 的英文名为：{}".format(name, xname))

结果：

请输入以下名称中的任意一个,请输入:小李
输入的名字不存在，请重新输入以下内容中的一个： ['小张', '老王', '老李', '隔壁老王']
小李 的英文名为：
请输入以下名称中的任意一个,请输入:小张
小张 的英文名为：xiaozhang
请输入以下名称中的任意一个,请输入:老王
老王 的英文名为：laowang
请输入以下名称中的任意一个,请输入:老李
老李 的英文名为：laoli
请输入以下名称中的任意一个,请输入:隔壁老王
隔壁老王 的英文名为：gblw

4 变量的作用域

即程序代码能够访问该变量的区域
根据变量的”有效范围“，将变量分为局部变量和全局变量

4.1 局部变量

即在函数内部定义并使用的变量，只在函数内有效

# -*- coding:utf-8 -*-

def love():
    love_to_you = "如果上天能再给我一次机会，我将对那个...(此处略去一万字！)"
    print("我是局部变量:", love_to_you)  # 打印这个局部变量

love()
print("这里打印会报错：", love_to_you)  # 如果在函数以外来打印这个局部变量就会报错

结果：

我是局部变量: 如果上天能再给我一次机会，我将对那个...(此处略去一万字！)

Traceback (most recent call last):
  File "F:/python_study/main.py", line 8, in <module>
    print("这里打印会报错：", love_to_you)  # 如果在函数以外来打印这个局部变量就会报错
NameError: name 'love_to_you' is not defined

4.2 全局变量

即能够作用于函数内外的变量，有以下两种情况：

①变量在函数外定义，此变量可在函数外和函数内都可被访问到，即在函数体外定义的变量为全局变量

# -*- coding:utf-8 -*-

love_to_you = "曾经有一份真挚的爱情摆在我的面前，可是我没有珍惜，如果..."
love_recive = "没有如果，你活该，早知现在，何必当初！！"
love_to = "说实话，省略号后的内容，我是忘记怎么说了，哈哈哈"

def love():

    print("我是全局变量1:", love_to_you)  # 打印这个全部变量

def love_add():
    love_to_you_add = love_to_you + love_recive
    print("我是全局变量2:", love_to_you_add)

love()
love_add()

print("我是全局变量3:", love_to)

结果：

我是全局变量1: 曾经有一份真挚的爱情摆在我的面前，可是我没有珍惜，如果...
我是全局变量2: 曾经有一份真挚的爱情摆在我的面前，可是我没有珍惜，如果...没有如果，你活该，早知现在，何必当初！！
我是全局变量3: 说实话，省略号后的内容，我是忘记怎么说了，哈哈哈

②在函数体内定义，使用关键字global修饰后的变量为全局变量，可在函数外调用，函数体内修改

# -*- coding:utf-8 -*-

def speak():
    global speak_to_all
    speak_to_all = "他大舅他二舅都是他舅，"
    print("全局变量1：", speak_to_all)

def speaks():
    global speak_to_one
    speak_to_one = "高桌子低板头都是木头"
    print("全局变量2：", speak_to_one)

def speakss():
    global speak_to
    speak_to = speak_to_all + speak_to_one

speak()
speaks()
speakss()
print("直接在外部调用全局变量1：", speak_to_all)
print("直接在外部调用全局变量2：", speak_to_one)
print("直接在外部调用全局变量3：", speak_to)

结果：

全局变量1： 他大舅他二舅都是他舅，
全局变量2： 高桌子低板头都是木头
直接在外部调用全局变量1： 他大舅他二舅都是他舅，
直接在外部调用全局变量2： 高桌子低板头都是木头
直接在外部调用全局变量3： 他大舅他二舅都是他舅，高桌子低板头都是木头

5 匿名函数

即没有名字的函数
应用在需要一个函数、但又不想去命名这个函数的场合
一般，这样的函数只会使用一次
可使用lambda表达式创建匿名函数
语法：

result = lambda[arg1[,arg2,......,argn]]:exp

说明：

result ：调用lambda表达式
[arg1[,arg2,......,argn]]：可选参数，指定要传递的参数列表，多参数间用逗号隔开
exp：必选参数，用于实现具体功能的表达式

# -*- coding:utf-8 -*-

def nsum(a, b):
    sums = a + b
    print(sums)

def lsum(c, d):
    lsum = lambda c,d:(c+d)
    print(lsum(c, d))

print("======普通方法计算两个数之和======")
nsum(100, 200)
print("======lambda计算两个数之和======")
lsum(100, 200)

结果：

======普通方法计算两个数之和======
300
======lambda计算两个数之和======
300

6 常用python内置函数

python内置，直接调用使用即可

python3.7中69个内置函数，点击此处查看

		内置函数
`abs()`	`delattr()`	`hash()`	`memoryview()`	`set()`
`all()`	`dict()`	`help()`	`min()`	`setattr()`
`any()`	`dir()`	`hex()`	`next()`	`slice()`
`ascii()`	`divmod()`	`id()`	`object()`	`sorted()`
`bin()`	`enumerate()`	`input()`	`oct()`	`staticmethod()`
`bool()`	`eval()`	`int()`	`open()`	`str()`
`breakpoint()`	`exec()`	`isinstance()`	`ord()`	`sum()`
`bytearray()`	`filter()`	`issubclass()`	`pow()`	`super()`
`bytes()`	`float()`	`iter()`	`print()`	`tuple()`
`callable()`	`format()`	`len()`	`property()`	`type()`
`chr()`	`frozenset()`	`list()`	`range()`	`vars()`
`classmethod()`	`getattr()`	`locals()`	`repr()`	`zip()`
`compile()`	`globals()`	`map()`	`reversed()`	`__import__()`
`complex()`	`hasattr()`	`max()`	`round()`

在这里插入图片描述

Python函数的学习总结

1 函数的创建和调用

1.1 函数创建

1.2 函数调用

1.3 pass空语句

2 参数传递

2.1 形式参数和实际参数

2.2 位置参数

2.3 关键字参数

2.4 为参数设置默认值

2.5 可变参数

3 返回值

4 变量的作用域

4.1 局部变量

4.2 全局变量

5 匿名函数

6 常用python内置函数

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Python函数的学习总结

1 函数的创建和调用

1.1 函数创建

1.2 函数调用

1.3 pass空语句

2 参数传递

2.1 形式参数和实际参数

2.2 位置参数

2.3 关键字参数

2.4 为参数设置默认值

2.5 可变参数

3 返回值

4 变量的作用域

4.1 局部变量

4.2 全局变量

5 匿名函数

6 常用python内置函数

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像