python基础知识——函数（上）_python函数 def fun

python基础——函数（上）

---

1. 函数简介

• 函数也是一个对象
• 函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用

#语法
def 函数名([形参1,形参2,形参3,.....]):
	代码块
1
2
3

注意：
函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)
print是函数对象 print()是调用函数

def fun():
	print('这是我的第一个函数')

fun()  #调用函数
1
2
3
4

2.函数分类

1. 内置函数
   直接可以拿来用的函数：str() len() int() list()
2. 标准库函数
   通过import导入库，使用其中定义的函数
3. 第三方库
   Python社区有许多高质量的库。下载安装这些库，通过import语句导入并使用
   安装方法可以访问链接
4. 用户自定义函数
   用户自定义，适应自身需求

3.函数的参数

3.1 形参和实参

• 形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值
• 实参(实际参数)指定了形参，那么在调用函数时必须传递实参，实参将会赋值给对应的形参，简单来说有几个形参就要有几个实参

def fun():
	a = 1
	b = 2
	print(a+b)
fun()

def fun_1(a,b):     #a,b称为形参 也叫形式上的参数
	print(a+b)
	
fun_1(1,2)   #实参 实际参数  调用的时候传递实际参数，传递的实参数量和形参数量要保持一致
fun_1(120,250)
1
2
3
4
5
6
7
8
9
10
11

3.2 函数的传递方式

• 定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效

def fun(a,b,c=2):   #c=2为形参c设定默认值
	print(a,b,c)
fun(1,3)     #结果为a=1,b=3,c=2
fun(1,3,4)   #结果为a=1,b=3,c=4,用户传递了参数则默认值不会生效
1
2
3
4

• 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参

def fun(a,b,c):
	print(a,b,c)
fun(1,2,3)   #1对应a,2对应b,3对应c
1
2
3

• 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递

def fun(a,b,c):
	print(a,b,c)
fun(a=1,b=2,c=3)
1
2
3

• 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去

def fun(a,b,c):
	print(a,b,c)

fun(1,b=2,c=3)
fun(a=1,b=2,3)  #会报错，位置参数写到关键字参数前面写成fun(3,a=1,b=2)

def fun_1(a):
	a=10
	print(a)
b=1
fun_1(b)
'相当于把b=1当作实参传递给形参a，及a=b=1,但是a=10将a=1覆盖了，所有打印出来的a=10'
def fun_2(a):
	a[0]=10
	print(a)
b=[1,2,3]
fun_2(b)
print(b)
'a为多少，b为多少，均为[10,2,3]'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

传参的类型

def fun(a):
	print(a)

def fun_1():
	pss
b=1   #整数
b=[1,2,3]  #列表
b=True    #布尔
b='ab'		#字符串
b={'name':"lyj"}   #字典
b=(1,2,3)    #元组
b={1,2,3}	#集合
b=fun_1   #函数
fun(b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4. 不定长参数

• 定义函数时，可以在形参前面加一个*,这样这个形参可以获取到所有的实参，它会将所有的实参保存到一个元组中

#不定长参数的名字并非不可变的，只是有时候会用args去命名
def fun(*args):
	print(args)
fun(1,2,3,4,5,6,7)
1
2
3
4

• 带*号的形参只能有一个，可以和其他参数配合使用

def fun_1(a,*args):
	print(a,args)
fun_1(1,2,3,4,5,6,7,8)

def fun_2(a,*args,b):
	print(a,args,b)
fun_2(1,2,3,4,5,6,7,8,9) #会报错，这样定义程序会分不清那几个是传递给*args，哪个传递给b
1
2
3
4
5
6
7

• *形参只能接受位置参数，不能接受关键字参数

def fun(a,*args):
	print(a,args)
fun(1,234)
1
2
3

• **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值
• **形参只有一个，并且必须写在所有参数的后面

def fn(**kwargs):
   print(kwargs)
fn(a=1, b=2, c=3)
1
2
3

5. 参数的解包

• 传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递
• 要求序列中的元素的个数必须和形参的个数一致

def fun(a,b,c):
	print(a)
	print(b)
	print(c)
tuple_1=(1,2,3)
dict_1={'a':1,'b':2,'c':3}
#fun(tuple_1[0],tuple_1[1],tuple_1[2])
#参数拆包
fun(*tuple_1)
fun(**dict_1)
1
2
3
4
5
6
7
8
9
10

6.练习

1. 打印名片程序:输入姓名，电话号码，性别，最后打印出来名片
   • 控制姓名长度为6-20
   • 电话号码长度11
   • 性别只能允许输入男或女
   • 每一样信息不允许为空

# 1. 打印名片程序:输入姓名，电话号码，性别，最后打印出来名片
'''• 控制姓名长度为6-20
• 电话号码长度11
• 性别只能允许输入男或女
• 每一样信息不允许为空'''
def fun(a,b,c):
    print("姓名：{}".format(a))
    print(f"性别:{b}")
    print("tel:%s"%c)
fun(a="lyj",b="F",c='1334567894')  # F 女性  M 男性
1
2
3
4
5
6
7
8
9
10

2. 使用函数求前20个斐波那契数列斐波那契数列：1,1,2,3,5,8,13,21…即: 起始两项均为1，此后的项分别为前两项之和

# 2. 使用函数求前20个斐波那契数列斐波那契数列：1,1,2,3,5,8,13,21...即: 起始两项均为1，此后的项分别为前两项之和
def fun_1():
    # 获取用户输入数据
    t = int(input("输入项数："))
    # 第一和第二项
    a,b,c = 0,1,2
    # 判断输入的值是否合法
    if t <= 0:
        print("请输入一个正整数。")
    elif t == 1:
        print("斐波那契数列：")
        print(a)
    else:
        print("斐波那契数列：")
        print(a, ",", b, end=" , ")
        while c < t:
            d = a + b
            print(d, end=" , ")
            # 更新值
            a,b = b,d
            c += 1
fun_1()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3. 编写一段代码，定义一个函数求1-100之间所有整数的和，并调用该函数打印出结果

# 3. 编写一段代码，定义一个函数求1-100之间所有整数的和，并调用该函数打印出结果
def fun_2(t):
    a = 0
    for i in range(0,t):
        a += i
    print(a)
fun_2(101)
1
2
3
4
5
6
7

总结

本文为学习笔记，转载请标明出处，本文仅供交流学习，请勿用于非法途径，希望本文对大家有帮助。

仅是个人意见，如有不足之处或者侵权，请留言