Python函数的学习总结

举报
虫无涯 发表于 2023/01/13 11:37:46 2023/01/13
【摘要】 1 函数的创建和调用 1.1 函数创建创建函数即定义函数使用关键字def实现语法：def fname([pname]): ["comm"] [fuc]说明：def：定义函数的，固定写法fname：函数名pname：参数，可选，指定向函数中传入的参数，若有多个的话，参数之间用逗号隔开comm：可选，函数的注释，即说明函数的功能、传递的参数，提升代码可阅读性fuc：函数体，可选，具体的函数功能...

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内置函数

内置函数

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()

在这里插入图片描述

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Python 面向对象编程
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入