07>>>函数

2021/10/4 23:11:13

编程Tag： 函数参数 index print def 07 username

本文主要是介绍07>>>函数，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

函数

　　今天来学习函数的概念。不要惊慌，python中使用的函数和数学课上学的函数并不是同一个概念。

函数的定义

　　如果我们现在从程序员改行当了汽修工，日常工作是给各位顾客的汽车做保养维护、检修等等工作，我们不可避免地要使用各种各样的螺丝刀、扳手、老虎钳、千斤顶等等工具来作业。

　　但是，我们并不是每日上工前架好炼钢炉从熔炼铁矿开始从头锻造工具。而是一开始就去五金店或工厂购买一整套工具。这些工具都是耐用品，不至于用上一次就坏掉要买新的。

　　python中的函数也是一样。这里的函数就相当于我们从五金店买来的工具，事先定义好后续可以反复使用，这样就避免了代码冗余的情况，大大节省了程序员们的劳动量。

# 函数的语法结构
def 函数名(参数1,参数2):
    '''函数的注释'''
    函数体代码
    return 函数的返回值
eg：
def print_sth():
    '''随便打印些什么东西'''
    print('something')
    return '^_^'

　　接下来我们来详细说说函数语法的各个组成部分。

1.def：定义函数的关键字。

2.函数名：函数名的命名规则与变量名保持一致，见名知意。

3.参数：函数在使用之前还可以接收外部传入的参数（即限制条件）。

4.函数的注释：类似于产品说明书。

5.函数体代码：整个函数主要功能逻辑，是整个函数的核心。

6.return：执行完函数之后可以给调用者一个反馈结果。

　　注意：函数一定要先定义后使用！！！

使用要点

　　定义函数需要使用关键字def，后面跟着函数名加括号（如果函数需要参数那么括号里额外传递参数）。

1.定义阶段

　　函数在定义阶段只检测函数体语法不执行函数体代码。如果函数体中有语法错误，定义阶段是不会报错的。

2.调用阶段

　　函数名加括号。调用函数的时候才会执行函数体代码。

函数的返回值

　　什么是返回值？

　　答：返回值即执行完某个方法后，该方法反馈出来的结果。

　　如何获取返回值？

　　答：通过变量名与赋值符号即可。

变量名 = 方法/函数()

1.当函数体没有return关键字时，默认返回None

def index():
    print('hello world')

res = index()
print(res)  # None即空 表示没有

2.return关键字后面写什么，函数就返回什么

def index():
    print('hello world')
    return 123

res = index()
print(res)  # 123

3.return后面跟多个值，默认会组织成元组的形式返回

def index():
    print('hello world')
    return 114, 514, 9527, 42, 666

res = index()
print(res)  # (114, 514, 9527, 42, 666)

4.函数体代码遇到return立刻结束整个函数的运行

def index():
    print('hello world')
    return
    print('disco disco good good!')

index()

　　函数中的return类似于循环中的break。

函数的类型

1.无参函数：函数在定义阶段没有参数，调用阶段也不需要参数

def 函数名():
    函数体代码
eg:
def index():
    print('hello world!')
    
index()

2.有参函数：函数在定义阶段括号内填写了变量名，即需要参数

def 函数名(参数):
    函数体代码
eg:
def welcome_word(x):
    print('欢迎使用windows', x)

welcome_word('joe')

　　在使用有参函数时必须给一个参数，可以是任意数据，所以只要想一个打印标语的函数记忆就可以了。

3.空函数（没有具体的函数体代码）

　　一般用于前期的架构搭建。在没有想好具体的功能时先暂且记下，功能类似于占位符。

def run():
    pass  # 补全语法结构 本身没有任何含义
def fight():
    pass
def talk():
    pass

函数的参数

　　函数在定义阶段括号内书写的变量名称之为函数的形式参数，简称为形参。函数的形参相当于变量名。

　　函数在调用阶段括号内书写的值称之为函数的实际参数，简称为实参。函数的实参相当于变量值。

　　两者在调用函数时临时绑定，函数运行结束分开。

def 函数名(形式参数):  # 定义阶段
    函数需要执行的代码
函数名(实际参数)  # 调用阶段
eg:
def index(name):  # 括号内的是形参
    print(name)
index('joe')  # 括号内是实参；相当于变量name = 'joe'

参数类型

1.位置参数：按照位置一一对应传值，多一个不行少一个也不行

def 函数名(位置形参1, 位置形参2...)
    函数需要执行的代码
函数名(位置实参1, 位置实参2)
eg:
def index(x, y):
    print(x, y)

index()  '报错'# 不传不可以
index(1)  '报错'# 传少了也不行
index(1,2)  # 个数正确可以
index(1,2,3,4,5,6,7)  '报错'# 传多了也不行

不传不行

传少了不行

个数正确可以

传多了不行

2.关键字参数：指名道姓地给形参传值，可以打破位置限制

def 函数名称(关键字形参1, 关键字形参2)
    函数需要执行的代码
函数名(关键字实参1=xxx, 关键字实参2=xxx)
eg:
def index(x, y):
    print(x, y)

index(x=111, y=222)  # 按照参数顺序传值，可以
index(y=111, x=222)  # 颠倒参数顺序传值，可以
index(111, y=222)  # 先按照位置参数传值，后按照关键字，可以
index(111, x=222)  '报错'# 位置参数必须和参数顺序一致
index(y=111,222)  '报错'# 位置参数一定要在关键字参数的前面

按照参数顺序传值没问题

颠倒参数顺序传值没问题

先按照位置参数传值，后按照关键字没问题

位置参数必须和参数顺序一致

位置参数一定要在关键字参数的前面

3.默认参数：函数在定义阶段就给形参赋值了

def 函数名(参数1, 参数2, 默认参数1=xxx):
    函数需要执行的代码
函数名(参数1, 参数2, 若数据不同于默认参数1时自行赋值)
eg:
def register(name, age, gender='male'):
    print(name, age, gender)
'''默认参数不给值的情况下就使用默认的 给了就使用给了的'''
register('joe', 18)
register('simon', 20)
register('frank', 22)
register('diana', 17, 'female')  # 这条登记的是女性，所以要把默认参数修改掉

4.可变长参数（使用频率最高）

　　现在甲方提出了一个需求：函数如何做到无论接收多少个位置参数都可以正常运行？

　　这里就需要用到可变长参数了。

def func(a, *b):
    print(a, b)
func(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  # 1 (2, 3, 4, 5, 6, 7, 8, 9, 10)
func(1)  # 1 ()

　　*在形参中使用时，会接收多余的位置参数组织成元组的形式赋值给后面的变量名。

　　好神奇哦，但是仅此而已吗？

　　需求2：函数如何做到无论接收多少个关键字参数都可以正常运行？

def func(a,**b):
    print(a,b)
func(a=1, b=2, c=3, d=4 ,e=5)  # 1 {'b': 2, 'c': 3, 'd': 4, 'e': 5}
func(a=1)  # 1 {}

　　**在形参中使用时，会接收多余的关键字参数组织成字典的形式赋值给后面的变量名。

　　星号这个符号可以稍微记一下，接下来会在各种场景中以不同的身份或用法出现，它会成为我们的老朋友。

小练习

　　定义一个函数，该函数无论接收多少个位置参数还是关键字参数都可以正常运行。

def func(*a, **b):
    print(a, b)
func(1, 2, 3, a=1, b=2, c=3)  # (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
func(1, 2, 3, 4, 5, 6, 7)  # (1, 2, 3, 4, 5, 6, 7) {}
func(a=1, b=2, c=3， d=4, e=5)  # () {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

　　约定俗成方式：针对形参中的可变长参数，变量名推荐使用：

*args  # 位置参数
**kwargs  # 关键字参数
eg:
def sth(*args, **kwargs):
        print(args, kwargs)
sth(1, 2, 3, a=1, b=2, c=3)  # (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
sth(1, 2, 3, 4, 5, 6, 7)  # (1, 2, 3, 4, 5, 6, 7) {}
sth(a=1, b=2, c=3)  # () {'a': 1, 'b': 2, 'c': 3}

*与**在实参中的作用

　　现在有一个列表l和一个字典d，另有一个展示任意参数的函数。现在需要将列表l中的元素取出挨个打印，该怎么做？

l = [11, 22, 33, 44, 55]
d = {'username': 'joe', 'pwd': 123, 'hobby': 'read'}
def func(*args, **kwargs):
    print(args, kwargs)

1.*在实参中使用时，会将列表/元组内的元素打散成一个个位置参数传递给函数。

func(*l)  # (11, 22, 33, 44, 55) {}

　　现在需要将字典d中的元素取出挨个打印，该怎么做？

2.**在实参中使用时，会将字典内的元素打散成一个个关键字参数传递给函数。

func(**d)  # () {'username': 'joe', 'pwd': 123, 'hobby': 'read'}

封装代码

　　将面条版代码封装成函数版，遵循以下几条原则：

1.先写def和函数名

2.将代码缩进

3.查看内部需要哪些数据

4.在形参中定义出来即可

　　在实际封装代码时，尽量做到一个函数就是一个具体的功能。

利用函数对注册登录代码进行封装

def register():
    username = input('username>>>:').strip()
    password = input('password>>>:').strip()
    # 校验用户名是否存在
    with open(r'userinfo.txt', 'r', encoding='utf8') as f:
        for line in f:
            real_name = line.split('|')[0]
            if real_name == username:
                print('用户名已存在')
                return
    # 将用户名和密码写入文件
    with open(r'userinfo.txt', 'a', encoding='utf8') as f:
        f.write('%s|%s\n' % (username, password))
        print('%s注册成功' % username)

def login():
    username = input('username>>>:').strip()
    password = input('password>>>:').strip()
    with open(r'userinfo.txt', 'r', encoding='utf8') as f:
        for line in f:
            real_name, real_pwd = line.split('|')
            if real_name == username and password == real_pwd.strip('\n'):
                print('登录成功')
                return
    print('用户名或密码错误')

func_dict = {'1': register,
             '2': login
             }
while True:
    print("""
    1 注册
    2 登录
    """)
    choice = input('请输入执行功能编号>>>:').strip()
    if choice in func_dict:
        func_name = func_dict.get(choice)
        func_name()
    else:
        print('请输入正确的编号')

View Code

将单个功能封装成函数版本

def auth_username(username):
    # 校验用户名是否存在
    with open(r'userinfo.txt', 'r', encoding='utf8') as f:
        for line in f:
            real_name = line.split('|')[0]
            if real_name == username:
                print('用户名已存在')
                return True
    return False

def get_info():
    username = input('username>>>:').strip()
    password = input('password>>>:').strip()
    return username, password

def write_data(username, password):
    # 将用户名和密码写入文件
    with open(r'userinfo.txt', 'a', encoding='utf8') as f:
        f.write('%s|%s\n' % (username, password))
        print('%s注册成功' % username)

def register():
    username, password = get_info()
    # 调用校验用户名是否存在的函数
    is_exist = auth_username(username)
    if is_exist:
        return
    write_data(username, password)

def login():
    username, password = get_info()
    with open(r'userinfo.txt', 'r', encoding='utf8') as f:
        for line in f:
            real_name, real_pwd = line.split('|')
            if real_name == username and password == real_pwd.strip('\n'):
                print('登录成功')
                return
    print('用户名或密码错误')

func_dict = {'1': register,
             '2': login
             }
while True:
    print("""
    1 注册
    2 登录
    """)
    choice = input('请输入执行功能编号>>>:').strip()
    if choice in func_dict:
        func_name = func_dict.get(choice)
        func_name()
    else:
        print('请输入正确的编号')