函数

1 什么是函数：

　　重复利用的工具

　　可以完成特定功能的代码块，函数就是存放代码块的容器

　　优点： 避免代码的冗余   让代码结构更加清晰   让代码具有复用性，便于维护

函数四部分

1. 　　函数名：使用该函数的依据   定义完后直接打印函数名只能看到函数式存放代码的地址
2. 　　函数体：完成功能的代码块
3. 　　返回值：功能完成的返回结果   可以用变量接收   |   可以直接打印   |   可以直接使用  
4. 　　参数：完成功能需要的条件信息

函数的定义与调用的完整语法：

1. 　　定义
   1. def 是声明函数的关键字，后面跟着函数名，括号内饰函数的参数
   2. 　　def 函数名（参数1，参数2，参数3）：
   3. '''    注释   '''
   4. 　　函数体  #函数体写具体的逻辑代码
   5. return 返回值  # return后面是函数的返回值，是函数体代码的运行结果

   6. 只检测语法，不执行代码。语法错误在函数定义阶段就会检测出来，而代码的逻辑错误只有在执行时才会知道

2. 　　调用：
   1. 　　函数名（参数1，参数2，参数3）
3. 　　 先定义在调用  函数名存放的是函数地址    （）会触发函数体的执行   函数执行完毕得到的是函数的返回结果，通常称之为函数的返回值，也称作函数值

根据函数体划分

1. 　　空函数：用来罗列功能  项目之初知道项目有哪些功能，但还没有明确功能体，可以用pass进行函数体填充

　　　　　　#空函数值的是函数体pass占位，pass代表什么也不做

　　　　　　def fun（）：

　　　　　　　　pass

　　　　　　#fun（）：调用后什么也不干

　　2.         非空函数：正常可以完成某项功能

　　　　　　def func（）：

　　　　　　print（'非空函数'）

　　　　　　#func()：调用后执行函数体

def auth(user,password):                             
    '''                                                           
    auth function                                                 
    :param user: 用户名                                              
    :param password: 密码                                           
    :return: 认证结果                                                 
    '''                                                           
    pass                                                          
                                                                  
def get(filename):                                                
    '''                                                           
    :param filename:                                              
    :return:                                                      
    '''                                                           
    pass                                                          
                                                                  
def put(filename):                                                
    '''                                                           
    :param filename:                                              
    :return:                                                      
    '''                                                           
def ls(dirname):                                                  
    '''                                                           
    :param dirname:                                               
    :return:                                                      
    '''                                                           
    pass                                                          

#程序的体系结构立见           

空函数

 

根据参数列表划分

1. 　无参函数：不需外界资源　

　　　　　def start():

　　　　　　print('系统启动')

　　　　　start()

　　　2.   有参函数：需要外键资源　

　　　　　　def login(usr, pwd):

　　　　　　　　if usr == 'owen' and pwd == '123':

　　　　　　　　　　print('登录通过')
　　　　　　　　else:
　　　　　　　　　　print('登录失败')

　　　　　　　login('owen', '123')

#定义阶段
def tell_tag(tag,n): #有参数
    print(tag*n)

def tell_msg(): #无参数
    print('hello world')

#调用阶段
tell_tag('*',12)
tell_msg()
tell_tag('*',12)

'''
************
hello world
************
'''

#结论：
#1、定义时无参，意味着调用时也无需传入参数
#2、定义时有参，意味着调用时则必须传入参数

无参、有参

 

根据返回值划分：return是用来结束函数的   逗号分隔多个值---元组

　　

空返回：返回None
    def demo(x, y):
    print( x + y )
    
def demo(x, y):
    print( x + y )
    return  # 用来强行结束函数的（像break结束循环一样）
 一个值返回
    def demo(x, y):
        return x + y
多个值返回：
    def demo(x, y):
        return x + y, x - y, x * y, x / y # 本质就是返回装有多个值的元组

函数的嵌套调用

# 求两个数最大值
def max_2(n1, n2):
    if n1 > n2:
        return n1
    return n2

# 求三个
def max_3(n1, n2, n3):
    m2 = max_2(n1, n2)
    return max_2(m2, n3)

# 求四个
def max_4(n1, n2, n3, n4):
    m2 = max_2(n1, n2)
    return max_3(m2, n3, n4)

# 循环调用：在一个函数的内部调用另一个函数

 

 # 获取文件中用户信息
def get_usr_map():
    usr_map = {}  # 该函数的参数与返回值
    with open('usr.txt', 'r', encoding='utf-8') as f:
        data = f.read()
        if data:
            k_vs = data.split('|')
            for k_vs in k_vs:
                k, v = k_vs.split(':')
                usr_map[k] = v
    return usr_map

#写入用户信息
def set_usr(usr,pwd):
    usr_map=get_usr_map()
    with open('usr.txt','a',encoding='utf-8') as w:
        if not usr_map:  #第一次写入信息  里面信息为空
            info=usr + ':' + pwd
        else:
            info = '|' + usr + ':' + pwd
        w.write(info)

# # 注册
def register():
    print('注册页面')
    usr_map=get_usr_map()   #输入账号，账号已存在，重新输入
    while True:
        usr = input('usr:')
        if usr in usr_map:
            print('用户名已存在')
            continue
        pwd = input('pwd:')  #账号合法，输入密码完成注册（将信息写入文件）
        set_usr(usr,pwd)
        return
# 登录
def longin():
    print('登录页面')
    usr_map=get_usr_map()
    #用户输入账号，错误三次进入注册

    count = 0
    while True:
        if count>=3:
            print('用户名输错3次')
            register()
            return
        #账户错误判断
        usr=input('usr:')
        if usr not in   usr_map:
            count+=1
        else:
            #账号正确可以进去输入面
            break
            #账号正确 密码错误三次，退出系统
    count2=0
    while True:
        if count2>=3:#错误三次
            print('密码错误3次')
            #要退出的是系统 系统循环用变量名条件判断 改条状态就可以结束循环：
        pwd=input('pwd:')
        if pwd!=usr_map.get(usr):
            print('登录失败')
            count2+=1
        else:
            print('登录成功')
            return  #只结束登录
            #teturn Ture 结束登录还结束系统
# 重启系统
def star():
    print('重启系统')
    #登录失败是退出系统的需求，所以系统中的循环应该设置出口，所以采用变值
    is_over=False
    while not is_over:
        choice = input('''
        0 退出
        1 登录
        2 注册
        ：
        ''')
        if choice.isdigit():
            choice=int(choice)
        if choice == 0:
            break
        elif choice == 1:
            is_over=longin()
        elif choice == 2:
            register()
        else:
            print('输入有误')
 #启动系统
 star()

 

转载于:https://www.cnblogs.com/lakei/p/10615250.html