共计 7253 个字符,预计需要花费 19 分钟才能阅读完成。
函数
- 函数是代码的一种组织模式
- 函数应该能实现一项特定的工作,而且个别一个函数只实现一项工作
- 有些语言,分函数和过程两个概念,艰深解释是,有返回后果的是函数,无返回后果的叫过程,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)
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)
3
100
3
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)
3
30
3
30
# 关键字参数案例 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: 此函数没有返回值
正文完