为什么要用函数
#len()
#len(s)
#len(s2)
#函数 mylen叫做函数名
#def是关键字 define
#():必须写
def mylen():
'''
计算字符串长度的函数
'''
s = 'hello world'
length = 0
for i in s:
length += 1
#print('s的长度是%s'%length)
#print(length)
return length
#函数的调用：函数名+括号
leng = mylen()
print(leng)
#函数名
#必须由字母下划线数字组成，不能是关键字，不能是数字开头
#函数名还是要有一定的意义能够简单说明函数的功能
参数
参数初识：
def mylen(s): #参数接收：形式参数，形参
'''
计算字符串长度的函数 ——函数的功能
参数s：接收要计算的字符串 ——参数的信息
return：要计算的字符串长度 ——返回值的信息
'''
#s = "helloworld"
length = 0
for i in s:
length += 1
return length
#参数
# sss = "helloworld"
# length1 = mylen(sss) #参数传入:实际参数，实参
# length2 = mylen('1234') #参数传入:实际参数，实参
# length3 = mylen('egon is somebody') #参数传入:实际参数，实参
# length4 = mylen('hello') #参数传入:实际参数，实参
# print(length1)
# print(length2)
# print(length3)
# print(length4)
#函数的定义
#函数的调用
#函数的返回值
#函数的参数
#实参和形参
#实参：函数调用的时候传入的参数值
#形参：是函数定义的时候定义的参数名
#参数可以是任意的数据类型
#可以传递0个或多个参数
#位置参数：按顺序定义参数
#默认参数：首先，不要设置可变数据类型的默认参数
#对于变化小的参数可以设置默认参数
#默认参数可以不传，不传的时候用的就是默认值
#如果传，会覆盖默认值
#默认的值是在定义函数的时候就已经确定了的
#调用函数时传参数：
#按照位置传参
#按照关键字传参
位置参数，关键字参数，默认参数（按照调用函数的角度上）
def my_max(a,b): #定义：位置参数
'''返回两个值之间的最大值'''
print(a,b)
if a > b:
return a
else:
return b
# print(my_max(10,20))
# print(my_max(30,20))
#站在传参的角度上
#按照位置传参数
# my_max(10,20)
#按照关键字传参数
#my_max(b = 10,a = 20)
# def func(a):
# print(a)
# func('a')
def login(user,pwd):
if user == 'egon' and pwd == 'somebody':
return True
else:
return False
# ret = login('egon','somebody')
# if ret:
# print('登录成功')
def stu_info(name,sex = 'male'): #默认参数，有一个默认值
print('name:%s,sex:%s'%(name,sex))
# stu_info('李淑旗') #默认参数可以不传值
# stu_info('高大鹏')
# stu_info('海燕','female') #如果传值了，覆盖默认值
注意
s = 'male'
def stu_info(name,sex = s): #默认参数，有一个默认值
print('name:%s,sex:%s'%(name,sex))
# s = 'female' #不影响定义时sex的值
# stu_info("李淑旗")
默认参数妖邪的用法（一般不用）
b = []
def func(a = []): #不要设置可变数据类型的默认参数
a.append(1)
print(a)
# func()
# func()
# func()
# func()
# func([])
# func([])
# func([])
# func([])
不要设置可变数据类型的默认参数
def my_max(a,b=5):#位置参数、默认参数
if a>b:
return a
else:
return b
#print(my_max(b = 10,a = 20)) #按照位置传和按照关键字传
#参数（站在定义函数的角度上）
#位置参数
#默认参数
#动态参数
#*args
#**kwargs
def func(a,b,*c):
my_sum = a+b
for i in c:
my_sum += i
return my_sum
#按位置传参数
# print(func(3,2))
# print(func(1,2,5,6))
def fun(a,b,**kwargs):
print(a,b,kwargs)
# 按照关键字传参数
#fun(a = 10,b = 20,cccc= 30,dddd = 50)
# def f(a,b,*args,defult=6,**kwargs):
# #位置参数，*args,默认参数，**kwargs
# print(a,b,args,defult)
#
# #传参数的时候：必须先按照位置传参数，再按照关键字传参数
# f(1,2,7,8,defult=10)
def fun2(*args):#*args代表把散列的元素拼成元组
print(args)
t = (1,2,3,4)
l = [1,2,3,4]
# fun2(t[0],t[1],t[2],t[3])
fun2(*t) #*代表把一个元组、列表拆了
fun2(*l) #*代表把一个元组、列表拆了
def fun3(**kwargs):#*args代表把按关键字传来的参数拼成字典
print(kwargs)
fun3(a = 10, b = 20)
d = {'a': 10, 'b': 20}
fun3(**d) #*代表把一个字典拆了
返回值
def func():
a = 111
b = [1,2,3]
#首先 返回值可以是任意的数据类型
return b
#如果有返回值：必须要用变量接收才会有效果
# ret = func()
# print(ret)
def func1():
a = 111
b = [1,2,3]
# ret = func1()
# print(ret)
#函数可以没有返回值
#当不写return的时候，一个函数默认的返回值是'None'
def func2():
a = 111
b = [1,2,3]
return
# ret = func2()
# print(ret)
#当只写一个return的时候，函数的返回值为None
def func3():
a = 111
b = [1,2,3]
return None
# ret = func3()
# print(ret)
#return None的时候函数的返回值也为None（几乎不用）
def func4():
print(1111)
return
print(2222)
# func4()
def func5():
for i in range(20):
if i == 5:
return
else:
print(i)
# func5()
#总结：
#函数的返回值为None有三种情况
#1.不写返回值
#2.只写一个return
#3.return None （几乎不用）
#return的作用：结束一个函数的执行
#函数的返回值不为None，有返回值
#return xxx 返回一个值（一个变量）
#return a,b 返回多个值(多个变量)，多个值之间用逗号区分
#接收：可以用一个变量接收，以元组的形式返回
# 也可以用多个变量接收，返回几个就用几个变量去接收
#函数要先定义 后 调用
def func6():
'''返回一个值'''
#return 111
#return 'abc'
return ['abc',123]
def func7():
'''返回多个值'''
a = 123
b = 'abc'
return a,b,[1,2,3]
# ret = func7()
# print(ret)
# m,n,k = func7()
# print(m)
# print(n)
# print(k)
def func8():
l = [1,2,3,4]
return l[-1]
# ret = func8()
# print(ret)
注意
1.最好不要在函数中打印（print）
2.一旦函数存在，函数读入内存，不用管函数的内容，遇到调用再查看函数内容在执行
3.return作为函数结束的标志
4.参数同变量的本质， def mylen(s) s ="abc"
5.参数可以是任意数据类型
6.不要设置可变类型数据为默认参数
7.
def fun3(**kwargs):#*args代表把按关键字传来的参数拼成字典
print(kwargs)
fun3(a = 10, b = 20)
d = {'a': 10, 'b': 20}
fun3(**d) #*代表把一个字典拆了
可以看做一个可逆的过程 ， 装包，解包的过程
浙公网安备 33010602011771号