Python基础-函数初识

一 函数的作用

1. 解决代码复用的问题

2. 提高代码的可维护性

3. 程序的组织结构更清晰，提高程序的可读性

 

1.1 函数的定义与调用

# 定义函数：
def my_len():
    '''计算s1的长度'''
    s1 = 'fdsgdfkjlgdfgrewioj'
    count = 0
    for i in s1:
        count += 1
    # print(count)

my_len()  # 函数名+()  执行函数 #函数的调用

定义：
    def  关键词开头，空格之后接函数名称和圆括号()，最后还有一个':'。
    def  是固定的，不能变  它是定义函数的关键字
    空格: 为了将def与函数名分开，必须空！
    函数名: 函数名的定义与变量一致，只能包含字符串、下划线和数字，且不能以数字开头。要求函数名尽量简短，并且能表达函数功能
    括号: 必须添加
    
    注释：每一个函数都应该对功能和参数进行相应的说明，应该写在定义函数的下一行，一增强代码的可读性。
    调用： 就是 函数名()   要记得加上括号

 

1.2 函数的返回值 return

'''
    1,遇到return，结束函数。
    def func1():
        print(111)
        return
        print(222)
    func1()  #只打印111 
    2,给函数的调用者(执行者)返回值。
        无 return 返回None
        return 不写 或者 None 返回None
        return 返回单个数.
        return 返回多个数，将多个数放在元组中返回。
'''

s1 = 'fdsgdfkjlgdfgrewioj'

##函数返回值是str类型
def my_len():
    count = 0
    for i in s1:
        count += 1
    return 666  ##将666返回给函数执行结果
print(my_len(),type(my_len())   

## 返回多个值的时候，会将多个值放在元组中
def my_len():
    count = 0
    for i in s1:
        count += 1
    return 666,222,count,'老男孩'
print(my_len(),type(my_len()))
#在元组中分别赋值：
def my_len():
    count = 0
    for i in s1:
        count += 1
    return 666,222,count
ret1,ret2,ret3 = my_len()  # (666, 222, 19,)
print(ret1)
print(ret2)
print(ret3)

 

1.3 函数的传参

1.3.1 参数的定义

li = [1, 2, 3, 43, 'fdsa', 'alex']
s1 = 'fdsgdfkjlgdfgrewioj'
def my_len(a):    # 函数的定义 ()里放的是形式参数，形参
    count = 0
    for i in a:
        count += 1
    return count
ret = my_len(li)  # 函数的执行（） 实际参数，实参
print(ret)
print(len(s1))

# 从实参角度
    #1，位置参数。 必须一一对应，按顺序
def func1(x,y):
    print(x,y)
func1(1, 2)
    #2，关键字参数。必须一一对应，不分顺序。
def func1(x,y,z):
    print(x,y,z)
func1(y=2,x=1,z=5,)

# 参数练习
def max(a,b):
    if a > b:
        return a
    else:
        return b
print(max(100,102))

#简写形式
def max(a,b):return a if a > b else b
print(max(100,102))

参数的定义

1. 形参：在函数名后面的()中的参数，为形式参数，称为形参

2. 实参：在调用函数时写入()的参数，为实际参数，称为实参。

3. 从实参角度，又分为：

　　1) 位置参数：按实际位置、顺序一一对应的参数

　　2)关键字参数：a=b，必须一一对应，但不分顺序

　　3)混合参数： 一一对应，切关键字参数必须在位置参数后面

# 混合参数。 关键字参数必须在位置参数后面
def func2(argv1,argv2,argv3):
    print(argv1)
    print(argv2)
    print(argv3)
func2(1,2,argv3=4)

4.从形参角度：

　　1)位置参数，必须一一对应，按顺序

　　2)默认参数，必须在位置参数后面

def register(name,sex='男'):
    with open('register',encoding='utf-8',mode='a') as f1:
        f1.write('{} {}\n'.format(name,sex))

while True:
    username = input('请输入姓名：/q 或者 Q 退出')
    if username.upper() == 'Q':break
    if 'a' in username:
        sex = input('请输入性别：')
        register(username,sex)
    else:
        register(username)

　　3)动态参数 *args *kwargs   万能参数

# args 与 kwargs接收的内容
def func2(*args,**kwargs):
    print(args)  # 元组(所有位置参数)
    print(kwargs)  # 字典，所有关键字参数
func2(1,2,3,4,5,6,7,11,'alex','老男孩',a='ww',b='qq',c='222')

混合参数中，arte与kwargs的位置
# 位置参数，*args, 默认参数
def func3(a,b,*args,sex='男'):
    print(a)
    print(b)
    print(sex)
    print(args)
func3(1,2,'老男孩','alex','wusir',sex='女')
# 位置参数，*args, 默认参数, **kwargs
def func3(a,b,*args,sex='男',**kwargs):
    print(a)
    print(b)
    print(sex)
    print(args)
    print(kwargs)
func3(1,2,'老男孩','alex','wusir',name='alex',age=46)

args与kwargs的使用

def func1(*args,**kwargs):  #　函数的定义 * 聚合。
    print(args)
    print(kwargs)
l1 = [1,2,3,4]
l11 = (1,2,3,4)
l2 = ['alex','wusir',4]
# func1(l1,l2,l11)  。
# func1(*l1,*l2,*l11)  # 函数的执行：* 打散功能。
# func1(1,2,3,4,'alex','wusir',4,1,2,3,4)
dic1 = {'name1':'alex'}
dic2 = {'name2':'laonanhai'}
func1(**dic1,**dic2)  # * 打散功能

1.4 命名关键字参数

# 命名关键字参数：在*后面定义的形参称为命名关键字参数，必须是被以关键字实参的形式传参。

# 命名关键字参数：在*后面定义的形参称为命名关键字参数，必须是被以关键字实参的形式传参。
def foo(name,age,*,sex='male',group):
    print(name)
    print(age)
    print(sex)
    print(group)

foo('wph',18,group='ops')  ##因为在形参的*后面，sex和group必须以关键字的方式传参