python面向对象、模块讲解

（1）模块的介绍：
 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文件：from spam import *    *默认导入模块里的所有功能
 spam模块文件：__all__ =['read1'，‘read12’]     [函数1，函数2，。。。]可以限定run文件里*的调用范围

（2）模块的实际应用
 当前的执行文件
 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)

（3）面向过程编程介绍：

 面向过程编程
  核心过程二字，过程指的是解决问题的步骤，即先干什么、再干什么、然后干什么...
  基于该思想编写程序就好比在设计一条流水线，是一种机械式的思维方式

  优点
   复杂的问题流程化、进而简单化
  缺点
   扩展性极差

（4）面向过程编程的应用
 # 接收用户输入用户名,进行用户名合法性校验，拿到合法的用户名
 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