09. 前 方 高能-初识函数
本节内容:
- 什什么是函数
- 函数定义, 函数名, 函数体以及函数的调 用
- 函数的返回值
- 函数的参数
一. 什什么是函数
1. 我们到 目前为 止, 已经可以完成 一些软件的基础功能了了. 那么我们来完成这样 一个功能: 约x:
print("拿出 手机") print("打开陌陌") print("找个漂亮的妹 子") print("问她, 约不不约啊?") print("oK. 走你!")
ok. so easy. 我们已经完成了了对 一个功能的描述. 那么问题来了了. 我还想再约 一次. 怎么办呢? 很简单. 再写 一次就好了了
# 约 一次print("拿出 手机") print("打开陌陌") print("找个漂亮的妹 子") print("问她, 约不不约啊?") print("oK. 走你!")
# 再来 一次print("拿出 手机") print("打开陌陌") print("找个漂亮的妹 子") print("问她, 约不不约啊?") print("oK. 走你!")
OK. 也很简单. 但是. 我现在还想约. 约个10次8次的. 怎么办呢? 也简单. 加个循环就好了了
while 1: print("拿出 手机") print("打开陌陌") print("找个漂亮的妹 子")
print("问她, 约不不约啊?") print("oK. 走你!")
哇, 终于可以不停的约了了.但是呢, 想想. 这样写出来的程序. 是不是 一直在约? 人啊. 要有节
制. 有需求了了再约, 这样比较好. 所以呢.这样写是不 行行的. 最好是我想什什么时候约就什什么时候约. 好了了. 说到这. 我们可以这样做, 把约会这个事情啊, 先计划 一下, 然后呢安排好流程. 在需要约的时候呢. 把这个约的流程拿出来执 行行 一下就好了了. 那么这 里里.我们可以先去定义 一个事情或者功能. 等到需要的时候直接去 用就好了了. 那么这 里里定义的东 西就是 一个函数.
函数: 对代码块和功能的封装和定义
二. 函数的定义, 函数名, 函数体以及函数的调 用
我们使 用def关键字来定义函数, 函数的定义语法:
def 函数名():
函数体
这 里里的函数名的命名规则和使 用和变量量基本 一样. 自 己回顾 一下变量量的命名规则.函数体: 就是函数被执 行行之后要执 行行的代码
来我们来定义 一个约x功能:
def yue(): print("拿出 手机") print("打开陌陌") print("找个漂亮的妹 子") print("问她, 约不不约啊?") print("oK. 走你!")
哦了了定义完了了. 但是这个时候去执 行行. 会发现什什么都没有发 生. 因为我只定义了了 一个函数. 但是还没有执 行行过这个函数.
函数的调 用: 使 用函数名可以调 用函数, 写法: 函数名(), 这个时候函数的函数体会被执 行行
# 调 用yue()函数 yue()
结果:拿出 手机打开陌陌
找个漂亮的妹 子问她, 约不不约啊? oK. 走你!
看 一下执 行行过程:
终于可以约了了. 如果我还想约呢? 多次调 用就可以了了. 很 方便便.
# 调 用yue()函数 yue()
yue()
yue()
yue()
yue()
继续分析. 约完了了之后你需要得到 一个结果吧. 比如. 约完了了得到了了 一个萝莉, 少妇, 大妈.总得有个结果. 那么这个结果怎么来描述和获得呢? 这个就涉及到函数的返回值的问题.
三. 函数的返回执 行行完函数之后. 我们可以使 用return来返回结果.
函数中return的使 用:
1. 函数中遇到return, 此函数结束, 不再继续执 行行.
def yue(): print("约你") print("约我") print("约他")
return
print("约谁呀") # 这句句话不不会被执 行行
yue()
2. 给函数的调 用者 一个访问结果
def yue(): print("约你") print("约我") print("约他") return "美 女女 一枚"
girl = yue()
print(girl) # 美 女女 一枚
函数的返回值可以有多个结果
def yue(): print("约你") print("约我") print("约他")
return "美 女女 一枚", "萝莉 一枚"
girl = yue() print(type(girl)) # tuple
总结 一下:
- 遇到return. 此函数结束, 函数后 面的东 西将不会再执 行行
- return 返回值
关于返回值:
如果return什什么都不写 或者 干脆不写return .那么返回的就是None如果return后 面写了了 一个值. 则调 用者可以接收 一个结果
如果return后 面写了了多个结果, 则调 用者可以接收 一个tuple, 调 用者可以直接解构成多个变量量
OK. 完美. 可以得到结果了了. 但是我们的约的 方式是不是有点 儿问题呢?, 陌陌现在还能约到么? 约不到了了吧. 该换探探了了. 那过两天探探也死掉了了呢? 是不是还会有 一个替代品. 那你想.有 一个替代的. 你就需要去改 一下代码. 是不是不太合适了了. 最好的 方式是不是想 用什什么约就 用什什么约? ok. 我们可以通过函数的参数来给函数传递 一些信息.
四. 函数的参数参数, 函数在调 用的时候指定具体的 一个变量量的值. 就是参数. 语法:
def 函数名(参数列列表):函数体
首先我们先把代码该 一下. 能够实现上 面的需求.
def yue(chat): print("拿出 手机") print("打开"+chat) print("找个漂亮的妹 子") print("约不不约")
yue("陌陌") yue("微信") yue("探探")
结果:
拿出 手机打开陌陌
找个漂亮的妹 子约不不约拿出 手机打开微信
找个漂亮的妹 子约不不约拿出 手机打开探探
找个漂亮的妹 子约不不约
perfect. 搞定了了. 我们在调 用yue的时候给chat 一个值. 然后再执 行行函数体.关于参数:
1. 形参
写在函数声明的位置的变量量叫形参. 形式上的 一个完整. 表 示这个函数需要xxx
2. 实参
在函数调 用的时候给函数传递的值. 叫实参, 实际执 行行的时候给函数传递的信息. 表 示给函数 xxx
3. 传参
给函数传递信息的时候将实际参数交给形式参数的过程被称为传参.
def yue(chat): # chat 形参print("拿出 手机") print("打开"+chat) print("找个漂亮的妹 子") print("约不不约")
yue("陌陌") # 实参
len("字符串串") # "字符串串"在这 里里就是实参print("麻花藤") # "麻花藤"就是实参
参数的分类:
首先我们先看实参: 4.1.1 位置参数
约到这 里里了了. 有没有想过这个问题. 啥样的都约么? 哪 里里的都约么? 不 一定吧. 比如, 我在
北京, 我很寂寞, 我喜欢 小姐姐. 强哥, 在哈尔滨, 很寂寞, 大妈就 行行了了. 需求是不 一样的. 而我们现在的函数没有这些功能. 那怎么办呢? 很简单, 多来 几个参数就好了了
def yue(chat, address, age): # 形参print("拿出 手机") print("打开"+chat)
print("找个"+address+"附近漂亮的"+str(age)+"岁妹 子") print("约不不约")
yue("微信", "北北京", 18) # 实参
结果:拿出 手机打开微信
找个北北京附近漂亮的18岁妹 子约不不约
分析: 在访问yue()的时候, 我们按照位置的顺序分别把"微信", "北京", 18 赋值给 chat, address, age. 在传参过程中. 系统会默认按照位置把实参赋值到形参.
练习: 编写函数, 给函数传递两个参数a, b. 比较a, b的 大 小, 返回 a, b中最 大的那个数
答案:
def my_max(a, b): if a > b:
return a else:
return b
# 有点 儿麻烦, 我们在这 里里学 一个三元运算符. def my_max(a, b):
c = a if a > b else b # 当a>b成 立返回a, 否则返回b return c
4.1.2 关键字参数
位置参数好不好呢? 如果是少量量的参数还算OK, 没有问题. 但是如果函数在定义的时候参数非常多怎么办? 程序员必须记住, 我有哪些参数, 而且还有记住每个参数的位置, 否则函数就不能正常调 用了了. 那则么办呢? python提出了了 一种叫做关键字参数. 我们不需要记住每个参数的位置. 只要记住每个参数的名字就可以了了
def yue(chat, address, age): print("拿出 手机") print("打开"+chat)
print("找个"+address+"附近漂亮的"+str(age)+"岁妹 子") print("约不不约")
yue(chat="微信", age=18, address="北北京") # 关键字参数.
结果:拿出 手机打开微信
找个北北京附近漂亮的18岁妹 子约不不约
搞定, 这样就不需要记住繁琐的参数位置了了.
4.1.3 混合参数
可以把上 面两种参数混合着使 用. 也就是说在调 用函数的时候即可以给出位置参数, 也可以指定关键字参数.
# 混合参数
yue("微信", age=18, address="上海 ") # 正确.第 一个位置赋值给chat, 后 面的参数开始指定关键字.
yue(age="18", "微信", address=" 广州") # 错误, 最开始使 用了了关键字参数, 那么后 面的
微信的位置就串串了了, 容易易出现混乱
注意: 在使 用混合参数的时候, 关键字参数必须在位置参数后 面
综上: 在实参的 角度来看. 分为三种:
- 位置参数
- 关键字参数
- 混合参数, 位置参数必须在关键字参数前 面
4.2 在形参 角度看. 一共分为三种. 今天我们学习两种
4.2.1 位置参数. 按照位置来赋值, 到 目前为 止, 我们编写的函数都是这种
def yue(chat, address, age): print("拿出 手机") print("打开"+chat)
print("找个"+address+"附近漂亮的"+str(age)+"岁妹 子") print("约不不约")
4.2.2 默认值参数. 在函数声明的时候, 就可以给出函数参数的默认值. 在调 用的时候可以给出具体的值, 也可以不给值, 使 用默认值.
比如, 我们录入咱们班学 生的基本信息. 通过调查发现. 我们班 大部分学 生都是男 生. 这个时候就可以给出 一个sex='男'的默认值.
def stu_info(name, age, sex='男'): print("录 入学 生信息")
print(name, age, sex) print("录 入完毕")
stu_info("张强强", 18)
注意, 必须先声明位置参数, 才能声明默认值参数.
综上: 在形参的 角度来看,
- 位置参数
默认值参数( 大多数传进来的参数都是 一样的, 一般 用默认参数
# while 1:
# print("首先, 打开手机")
# print("打开陌陌")
# print("找一个看着还不错的某一某")
# print("出来约一约.开开心心")
# print("各回各家,各找各妈")
# 需要把上面这个功能进行定义或者封装. 在需要的时候.随时拿过来执行, 封装的这个东西就是函数
# 定义一个功能叫yue
def yue():
# 函数体,代码块
print("首先, 打开手机")
print("打开陌陌")
print("找一个看着还不错的某一某")
print("出来约一约.开开心心")
print("各回各家,各找各妈")
# 函数的调用, 函数名()
yue() # 执行函数 # 第一次调用
print("正常上班")
yue() # 第二次调用
# def yue():
# print("约你")
# print("约他")
# print("我不约")
# return "大妈" # return 返回值 当函数结束的时候. 给调用方一个结果
#
# ret = yue()
# print(ret)
#
# ret2 = yue()
# print(ret2)
# 只要函数执行到return 函数就会停止执行
# 1. 每个函数如果在函数中不写return, 默认返回None
# 2. 我们也可以只写一个return, 也是返回None, 停止函数的执行
# 3. return 一个返回值. 你在调用方能接受到一个返回值
# 4. return 多个返回值. 多个值需要用,隔开 接收的位置. 接收的是元组.
# def yue():
# print("约一约")
# return # 函数就停止了
# ret = yue()
# print(ret)
# def yue():
# print("打开陌陌")
# print("大阳哥出马")
# return "大妈", "萝莉", "模特"
#
# a,b,c = yue() # 多个返回值在接受的位置接受到的是tuple类型的数据
# print(a)
# print(b)
# print(c)
def yue(fangshi, age): # 形参
print("打开手机")
print("打开%s" % fangshi)
print("找一个漂亮的妹子")
print("年龄最好是%s" % age)
print("出来约一约")
#
yue("微信",18)
yue("探探", 38)
# yue("陌陌", 26)
# def fn(a,b,c):
# print(a)
# print(b)
# print(c)
#
# fn(1, 2, 3)
# fn(b=3, a=2, c=1) # 在实参调用的时候 . 可以指定参数的值是多少. 关键字(形参)参数
# def gn(name, age, address, id, sex, hobby):
# print("人的名字叫%s, 年龄:%s, 地址:%s, id是:%s, 性别:%s, 爱好是:%s" % (name, age, address, id, sex, hobby))
# gn("太白", 58, "保定", 1, "不详", "女") # 位置参数
# gn(id=1, name="太白", address="保定", hobby="女", age=58, sex="不详") # 关键字(形参)参数
# gn("太白", 58, "保定", id="3", sex="女", hobby="不详")
# def regist(id, name, sex="男"):
# print("录入学生信息:id是%s, 名字是%s, 性别是:%s" % (id, name, sex))
#
# regist(1, "大阳哥")
# regist(2, "徐卫星")
# regist(3, "毛尖妹妹", "女")
# 参数: 在函数执行的时候给函数传递的信息
# 形参: 在函数声明的位置．声明出来变量
# 实参: 在函数调用的时候. 实际你给函数传递的值
# 函数的参数个数是没有要求的 但是,在运行的时候. 形参和实参要匹配. 按照位置把实参赋值给形参
# 参数的分类:
# 站在实参的角度:
# 1. 位置参数
# 2. 关键字参数
# 3. 混合参数, 注意顺序. 先写位置参数, 然后在写关键字参数. 否则会报错
# 站在形参的角度:
# 1. 位置参数
# 2. 默认值参数
# ３. 默认值参数和位置参数混合使用. 顺序: 先写位置参数. 然后在写默认值参数
# 1+2+3+4+5+6+7+8+9+....+100 = ? 5050
# 对功能的封装
# def sum(n):
# s = 0
# count = 1
# while count <= n:
# s = s + count
# count = count + 1
# return s
#
# ret = sum(456)
# print(ret)
# 计算n是奇数还是偶数
# def fn(n):
# if n%2 == 0:
# return "偶数"
# return "奇数"
#
# print(fn(456))
# lst = ["大阳哥", "徐卫星"]
# print(lst.append("胡辣汤")) # 没有ｒｅｔｕｒｎ
#
# s = "哈哈"
# print(s.replace("哈", "呵")) # 一定有ｒｅｔｕｒｎ
#作业
# 2. 写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
# def func(lst):
# ll = []
# for i in range(len(lst)):
# if i % 2 == 1:
# ll.append(lst[i])
# return ll
#
# a = [1, 5, 7, 9, 12,16]
# ret = func(a)
# print(ret)
# 3, 写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
# def func(a):
# # if len(a) > 5:
# # return True
# # else:
# # return False
# return len(a) > 5
# 4.写函数,检查传入列表的长度,如果大于2,将列表的前两项内容返回给调用者
# def func(lst):
# if len(lst) > 2:
# return lst[0], lst[1]
# 5.写函数，计算传入函数的字符串中, 数字、字母、空格 以及 其他内容的个数，并返回结果。
# def func(s=""): # function
# shuzi = 0
# zimu = 0
# kongge = 0
# qita = 0
# for c in s: # 循环字符串.拿到每个字符
# if c.isdigit(): # 数字
# shuzi += 1
# elif c.isalpha():
# zimu+=1
# elif c == ' ':
# kongge += 1
# else:
# qita += 1
# return shuzi, zimu, kongge, qita
# 6.写函数，接收两个数字参数，返回比较大的那个数字。
# def func(a, b):
# # if a > b:
# # return a
# # else:
# # return b
# c = a if a > b else b
# return c
# print(func(3, 5))
# 7. 写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
#
# dic = {"k1":"v1", "k2":[11,22]}
# PS:字典中的value只能是字符串或列表
#
# def func(dic):
# new_dic = {}
# for k, v in dic.items():
# if len(v) > 2:
# new_dic[k] = v[0:2]
# else:
# new_dic[k] = v
# return new_dic
# dic = {"k1": "v1v1", "k2": [11,22,33,44]}
# print(func(dic))
# 8.写函数,此函数只接收一个参数且此参数必须是列表数据类型,此函数完成的功能是返回给调用者一个字典,此字典的
#键值对为此列表的索引及对应的元素.例如传入的列表为:[11,22,33]返回的字典为{0:11,1:22,2:33}
# def func(lst):
# dic = {}
# for i in range(len(lst)):
# dic[i] = lst[i]
# return dic
# 9.写函数,函数接收四个参数分别为:姓名,性别,年龄,学历.用户通过输入这四个内容,然后将这四个内容传入函数中,此函数
#接收到这4个内容,将内容追加到一个student_msg文件中
# def func(name, age,edu):
# f = open("student.msg", mode="a", encoding="utf-8")
# f.write(name+"_"+str(age)+"_"+sex+"_"+edu+"\n")
# f.flush()
# f.close()
# n = input("请输入名字:")
# a = input("请输入年龄:")
# s = input("请输入性别:")
# e = input("请输入学历:")
# func(n,a,s,e)
# 10.对第9题升级:支持用户持续输入,Q或者q退出,性别默认为男,如果遇到女学生,则把性别输入女
# def func(name, age,edu,sex ="男"):
# f = open("student.msg", mode="a", encoding="utf-8")
# f.write(name+"_"+str(age)+"_"+sex+"_"+edu+"\n")
# f.flush()
# f.close()
#
#
# while 1:
# content = input("请问. 是否要录入学生信息, 输入q退出:")
# if content.upper() == "Q":
# break
# n = input("请输入名字:")
# a = input("请输入年龄:")
# s = input("请输入性别:")
# e = input("请输入学历:")
# if s == "":
# func(n,a,e)
# else:
# func(n,a,e,s)
#11.写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作（升级题）
# import os
# def func(filename, old, new):
# with open(filename, mode="r", encoding="utf-8") as f1,\
# open(filename+"_副本", mode="w", encoding="utf-8") as f2:
#
# for line in f1:
# s = line.replace(old, new)
# f2.write(s)
#
# os.remove(filename)
# os.rename(filename+"_副本", filename)
#
# func("student.msg", "本", "学")
# while 1:
# print("首先, 打开手机")
# print("打开陌陌")
# print("找一个看着还不错的某一某")
# print("出来约一约.开开心心")
# print("各回各家,各找各妈")
# 需要把上面这个功能进行定义或者封装. 在需要的时候.随时拿过来执行, 封装的这个东西就是函数
# 定义一个功能叫yue
def yue():
# 函数体,代码块
print("首先, 打开手机")
print("打开陌陌")
print("找一个看着还不错的某一某")
print("出来约一约.开开心心")
print("各回各家,各找各妈")
# 函数的调用, 函数名()
yue() # 执行函数 # 第一次调用
print("正常上班")
yue() # 第二次调用