• Python面向过程、模块的使用


    一、Python面向过程

    '''
    面向过程编程
        核心过程二字,过程指的是解决问题的步骤,即先干什么、再干什么、然后干什么...
        基于该思想编写程序就好比在设计一条流水线,是一种机械式的思维方式
    
        优点
            复杂的问题流程化、进而简单化
        缺点
            扩展性极差
    
    '''
    # 将一个用户的注册功能拆成三个功能块,在利用函数的嵌套调用
    # 接收用户输入用户名,进行用户名合法性校验,拿到合法的用户名
    def check_user():
        while True:
            name = input('username>>').strip()
            if name.isalpha():
               return name
            else:
                print('用户名必须为字母,傻叉')
    
    # 接收用户输入密码,进行密码合法性校验,拿到合法的密码
    def check_pwd():
        while True:
            pwd1=input('password>>: ').strip()
            if len(pwd1) < 5:
                print('密码的长度至少5位')
                continue
            pwd2=input('again>>: ').strip()
            if pwd1 == pwd2:
                return pwd1
            else:
                print('两次输入的密码不一致')
    
    def check_age():
        pass
    
    # pwd=check_pwd()
    # print(pwd)
    # 将合法的用户名与密码写入文件
    def insert(user,pwd,age,path='db.txt'):
        with open(path,mode='a',encoding='utf-8') as f:
            f.write('%s:%s:%s
    ' %(user,pwd,age))
    
    def register():
        user=check_user()
        pwd=check_pwd()
        age=check_age()
        insert(user,pwd,age)
        print('register successfull')
    
    register()
    
    
    # 框架使用面向过程进行编写
    # 用户功能层
    def register():
        while True: # 检测用户名
            name=input('username>>: ').strip()
            #检测用户是否重复,如果重复了则重新输入,否则break
            res=check_user_interface(name)
            if res:
                print('用户存在')
            else:
                break
    
        while True: # 检测密码
            pwd1 = input('pwd1>>: ').strip()
            pwd2 = input('pwd2>>: ').strip()
            if pwd1 != pwd2:
                print('两次输入密码不一致,重新输入')
            else:
                break
    
    
    def tell_info():
        name=input('>>: ').strip()
        info=select(name)
        print(info)
    
    # 接口层
    def check_user_interface(name):
        res = select(name)  # res=['egon','123']
        if res:
            return True
        else:
            return False
    
    
    # 数据处理层
    def select(name):
        with open('db.txt', 'r', encoding='utf-8') as f:
            for line in f:
                info = line.strip('
    ').split(':') #info=['egon','123']
                if name == info[0]:
                    return info

    二、模块的介绍

    '''
    1、什么是模块
        模块是一系列功能的集合体
        常见的模块形式(自定义模块、第三方模块、内置模块):
            1、一个module.py文件就是一个模块,文件名是module.py,而模块名是module
            2、一个包含有__init__.py文件的文件夹也是模块
    
            3、已被编译为共享库或DLL的C或C++扩展
            4、使用C编写并链接到python解释器的内置模块
    
    
    2、为什么要用模块
        1、用第三方或者内置的模块是一种拿来主义,可以极大地提升开发效率
        2、自定义模块即将我们自己程序中需要用到的公共的功能写入一个python文件
            然后程序的各部分组件可以通过导入的方式来引用/重用自定义模块中的功能
    
    
    
    3、如何用模块
        导入的方式有两种
        import 模块名
        from 模块名 import 具体的功能
    
    '''

    三、模块的使用

    '''当前执行文件'''
    # 当前的执行文件-------run.py
    x=1
    y=2
    # 首次导入模块发生了3件事:
    #1、以模块为准创造一个模块的名称空间
    #2、执行模块对应的文件,将执行过程中产生的名字都丢到模块的名称空间
    #3、在当前执行文件中拿到一个模块名
    import spam
    
    # 之后的重复导入会直接引用之前创造好的结果,不会重复执行模块的文件
    # import spam #spam=spam=模块名称空间的内存地址
    
    # spam.名字
    # print(x)
    # spam.x
    # print(spam.money)
    # print(spam.read1)
    # print(spam.read2)
    # print(spam.change)
    # money=11111111111111
    # spam.read1()
    # def read1():
    #     print('执行文件的read1')
    # spam.read2()
    
    # spam.change()
    # print(spam.money)
    # print(money)
    
    # import spam as sm
    # print(sm.money)
    
    import time,spam,os,sys
    # import spam
    # import os
    # import sys
    
    
    
    
    
    
    '''被导入模块'''
    #spam.py:被导入的模块------spam.py
    # print('from the spam.py')
    
    money=1000
    
    def read1():
        print('spam模块:',money)
    
    def read2():
        print('spam模块')
        read1()
    
    def change():
        global money
        money=0

    四、模块的导入应用

    """当前的执行文件----run.py-----"""
    # x=1
    # y=2
    # 首次导入模块发生了3件事:
    #1、以模块为准创造一个模块的名称空间
    #2、执行模块对应的文件,将执行过程中产生的名字都丢到模块的名称空间
    #3、在当前执行文件中拿到一个模块名
    # import spam
    
    
    # 之后的重复导入会直接引用之前创造好的结果,不会重复执行模块的文件
    # import spam #spam=spam=模块名称空间的内存地址
    
    # spam.名字
    # print(x)
    # spam.x
    # print(spam.money)
    # print(spam.read1)
    # print(spam.read2)
    # print(spam.change)
    # money=11111111111111
    # spam.read1()
    # def read1():
    #     print('执行文件的read1')
    # spam.read2()
    
    # spam.change()
    # print(spam.money)
    # print(money)
    
    # import spam as sm
    # print(sm.money)
    
    # import time,spam,os,sys
    # import spam
    # import os
    # import sys
    
    
    # import spam
    # spam.money
    
    # from ... import ...首次导入也发生了三件事:
    #1、以模块为准创造一个模块的名称空间
    #2、执行模块对应的文件,将执行过程中产生的名字都丢到模块的名称空间
    #3、在当前执行文件的名称空间中拿到一个名字,该名字直接指向模块中的某一个名字,意味着可以不用加任何前缀而直接使用
    
    # x=1
    # y=2
    #
    # from spam import money,read1
    # money=10
    # print(money)
    # print(read1)
    
    # from .... import ... 对比 import 。。。
    # 优点:不用加前缀,代码更为精简
    # 缺点:容易与当前执行文件中名称空间中的名字冲突
    
    # 相同点:
    # 1、都会执行模块对应的文件,都会产生模块的名称空间
    # 2、调用功能时,需要跑到定义时寻找作用域关系,与调用位置无关
    # 不同点
    # 1、一种需要加前缀,一种不需要加前缀
    
    
    # from spam import money,read1,read2,change
    # money=111111111111111111
    # read1()
    # def read1():
    #     print('当前执行文件的read1',money)
    
    # read1()
    
    # def read1():
    #     print('当前执行文件的read1',money)
    
    # read2()
    
    # change=1
    # change()
    # print(money)
    
    
    # from spam import money
    # from spam import read1
    # from spam import read2
    # from spam import change
    
    from spam import *
    print(money)
    print(read1)
    
    print(change)
    # print(read2)
    
    
    
    
    
    
    """"spam.py:被导入的模块"""
    # print('from the spam.py')
    __all__=['read1','money']
    
    money=1000
    
    def read1():
        print('spam模块:',money)
    
    def read2():
        print('spam模块')
        read1()
    
    def change():
        global money
        money=0
  • 相关阅读:
    jQuery--.wrap()方法
    ECharts学习(4)--仪表盘
    ECharts学习(3)--toolbox(工具栏)
    jQuery之核心API
    STM32片上Flash内存映射、页面大小、寄存器映射
    typedef struct bit0 : 1
    ***WARNING L15: MULTIPLE CALL TO SEGMENT
    C/C++ 打印文件名、行号、函数名的方法
    ISP与IAP的区别
    sprintf函数 %6.2f
  • 原文地址:https://www.cnblogs.com/sui776265233/p/9189071.html
Copyright © 2020-2023  润新知