06周总结

项目开发流程

项目需求分析

产品经理(甲方需求) -- 架构师 -- 开发经理
1. 架构师 负责 提前构思 需求大概需要用的技术方案，引导客户提出合理的要求 项目架构的设计
2. 决定项目所需要的编程语言  项目整体框架  数据库服务（主库，从库）
3. 项目分组开发 任务拆分
4. 各部分开始进行工作，然后自测没问题后交付测试
5. 测试通过后项目上线

项目的三层架构

第一层：数据展示层 一些前端的页面 负责展示数据和接收用户指令和输入
第二层：接口层，真正核心的业务逻辑和处理，负责处理用户的指定 然后把结果再返还给第一层
第三次：数据操作，负责针对用户数据，项目数据的存取功能，数据库的增删改查

三层架构的好处： 
1. 分工明确，出现问题也可以及时找寻问题并解决
2. 相对安全，第一层没有任何核心的代码，
3. 扩展性强，可以根据需求方便以后更改，每个功能都有独自的空间
4. 方便管理，方便大家合作创造，也方便针对每个功能调整 发现问题也方便修复
5. 数据库可变化，数据库影响核心逻辑和展示

项目实战ATM

1.三层架构创建
第一层 core文件夹 - src.PY 获取用户输入和指令 和 功能展示

第二层 interface文件夹接口层，根据不同的功能分类可以创建多个py文件，例如：用户注册 登录 可以为 user.py  购物方面 - shop.py 资金方面 - bank.py

第三层 db文件夹 - handlie.py 关于数据库操作的功能，存账号，取账号，更改数据等

公共设置： conf文件夹 - settings.py 比如一些 公共路径 公共的变量设置等等

配置功能： lib文件夹 - common.py  存放项目中 共用的 函数方法等 例如 加密方法，个别功能的装饰等等

项目日志：log文件夹 - 此文件下面用来储存项目的日志记录

启动文件：bin文件夹 - start文件 里面放 环境变量配置 和 启动指令 

这便是一个初步的 三层架构项目， 可以通过模块导入的方式让功能运转起来，也利于开发效率，需要什么功能调用什么功能即可，也可以多人协作，不同的人写不同的接口。

编程思想理论

1.面向对象编程 对象即是容器，数据与功能的结合体，python中一切皆可为对象
面向对象编程就是要创造出一个个的对象，把原本分散开的相关数据和功能整合到一个个的对象里，既方便使用，增加了耦合度 使代码可以重复利用 也增加了程序的可扩展性。例如游戏人物设计：

2.面向程序编程，过程即流程，按照流程解决问题 面向过程按照固定的流程一步一步的解决问题， 提出问题制定解决问题的方案，例如 常规的 登录 注册

类与对象

1.类：类是多个对象相同数据和功能的结合体，类主要是为了节约代码，如果有多个对象相同的数据与功能，那多个对象就属于同一个种类 类的概念
2.类的优点：可以把同一类对象相同的功能和数据放入类中，无需对每个对象都重复。这样每个对象只需要新增自己独有的数据和方法即可，即可提高了效率

类与对象的创建

1.首先要创建类 然后可以通过类产生对象
  类的语法结构：
  class 类名：
  		'''相关注释'''
    	对象的公共数据
      对象的公共功能
      
      
 class 是创建类的关键字:
 类名的命名和变量名几乎一直，唯一区别 类名首字母需要大写
 数据：其实就是变量名所绑定的数据 可以作为 类的子代码
 功能：其实就是函数 可以作为 类的子代码
  
 #类在创建好后 其实类里面的子代码已经被运行一边了，但是里面的变量名函数名都是在类的局部空间内，外界是无法直接调用的
  查看类的内部空间都有什么可用名称方法。类名.__dict__ 
  
  
2.如何创建对象
  选择一个创建好的类 然后通过这个类创建对象
  对象名 = 类()
  #类名加括号就会产生一个类的对象，一个类可以生成无数个对象，每次执行都会产生一个新的对象
  对象直接拥有类里面的 公共数据 和 公共方法 对象产生后可以直接调用类里面的方法和数据。
  #也可以使用 对象.__dict__ 方式查看该对象中都有什么数据和方法
  
  

如何给对象添加独特的数据

1.手动添加 
  obj1.__dict__['name'] = '张无忌'
  
2.在类中封装函数
  class 类名：
       公共数据
       def __init__(self，name，age, hobby):
         self.name = name
         self.age = age 
         self.hobby = hobby
          
        公共功能
        
   # 可以在产生对象的时候 通过传参的方式直接生成独有数据的对象
  
   对象名 = 类名('张无忌',18,'武功')
    
   # 当然也可以配合使用默认参数等知识
  

如何和对象添加独有的功能

  class 类名：
       公共数据
       def __init__(self，name，age, hobby):
         self.name = name
         self.age = age 
         self.hobby = hobby
         
				def 公共方法名(self):
          print(f'{self.name}')
        

   p1 = 类名('张无忌',18,'九阳神功')
   p2 = 类名('张三丰',68,'太极')
  
  
'''
定义在类中的功能，默认就是对象使用的，哪个对象调用，就和哪对象绑定，
'''
类名.公共方法名(123):
# 如果类调用自身功能，还是需要传参

p1.公共方法名()  # 张无忌
p1.公共方法名()  # 张三丰

# 对象可以直接调用类里面的方法，并且会把对象本身当作参数传入该方法中  self的意思就是默认对象本身




1.对象修改数据 和新增数据

p1.name = '周芷若'
#对象可以直接通过.的方式 直接对数据进行重新复制 修改
p1.password = '123'
# 如果没有该数据，则默认新增数据，类似字典 有就可以更改，没有就算新增

对象的动静态方法

class Fiction：
    name = '倚天屠龙记'
  	
    def func1(self):
      print('好看')
      
     @classmethod
     def func2(cls)：
      	print('牛逼')
 
p1 = Fiction()
p1.func1
#对象不用传参 默认对象自己本身作为传参
Fiction.func1(111)
# 类调用函数 需要传参

动态方法：
@classmethod 修饰的函数，称之为绑定给类的方法，默认是绑定给类的，用这个方法的函数 不管是类还是对象调用，都默认传参的是类

p1.func2()  # 牛逼
Fiction.func2()  # 牛逼
#结果都是一样 不管是类还是对象调用，都是默认传入了这个类

@classmethod  绑定给类专属的方法


静态方法：
@staticmethod. 默认为普通函数，不敢类点用还是对象调用，都需要根据是否需要行参，

面向对象之继承

1.继承的含义
  	在现实生活中继承表示人与人之间资源的从属关系
   		eg:儿子继承父亲 
 	在编程世界中继承表示类与类之间资源的从属关系
    	eg:类A继承类B
    
# 在编程世界中类A继承类B就拥有了类B中所有的数据和方法使用权限

class Fiction：
    name = '倚天屠龙记'
  	
    def func1(self):
      print('好看')
      
     @classmethod
     def func2(cls)：
      	print('牛逼')
        
class son(Fiction):
  pass

2.定义类时，在括号中填入其他类名，就默认新建的这个类 继承了括号中类的所有功能和数据， 
也可以同时继承多个类
class son(Fiction,Fiction2.Fiction3):
  pass


 '''
  1,继承其他类的类 叫做 子类 或者 派生类
    一般都叫子类 子类可以拥有父类的所有公共数据和方法
  2.被继承的类叫做 父类 或者 超类
    一般都叫父类
 '''

对象变量名的查找顺序

class b1:
  b = 2

class a1(b1):
  a = 1
p1 = a1()

print(p1.a)  # 1
#如果对象本身没有a 那就会用对应类中的a

p1.a = 2
print(p1.a)  # 2
# 如果对象本身有a 那优先用本身的

print(p1.b)  # 2

# 先找对象本身，然后找产生对象的类有没有，然后再找这个类的父级，以此类推 一层一层向外找， 如果整个相关的类都没有 那就报错

  ''' 对象自身 >>>> 产生对象的类 >>> 类的父类 >>> 父类的父类
      从内而外 层层寻找 优先找自身
  '''

多继承查找顺序
    class G:
        name = 'from G'
        pass
    class A:
        # name = 'from A'
        pass
    class B:
        # name = 'from B'
        pass
    class C:
        # name = 'from C'
        pass
    class D(A):
        # name = 'from D'
        pass
    class E(B):
        # name = 'from E'
        pass
    class F(C):
        # name = 'from F'
        pass

    class S1(D,E,F):
        pass
    obj = S1()
    # print(obj.name)
    
    # print(S1.mro())
    # 找名字顺序 ojb >>> S1 >>> D >>> A >>> E >>> B >>> F >>> C 
     	
'''   也可以通过关键词 mro() 方法 来查看该对象查询名称空间的顺序  
       对象自身   >>>   产生对象的类     >>>    父类(从左往右)
'''
    
 3.多继承情况下名字的查找顺序
'''
	菱形继承
    广度优先(最后才会找闭环的定点)
 非菱形继承
    深度优先(从左往右每条道走完为止)
 	ps:mro()方法可以直接获取名字的查找顺序
 	
 	
 	
！！ 也可以通过关键词 mro() 方法 来查看该对象查询名称空间的顺序 ！！

Python2 和 python3 中类的区别

经典类：python2中定义类时 没有 object 属性，需要手动定义
class P1(object):
  pass

新式类：python3中 无需手动添加，默认所有类都继承了object
class P1:
  pass

派生方法

派生方法就是子类基于父类的某个方法做扩展

关键字 super

class person:
  def __init__(self,name,age)
  	self.name = name 
    self.age = age 
    
class Student(person):
  def __init__(self,name,age,gender)
  #定义一个新的函数，但是里面的内容和父类已经又的重复 
  		super().__init__(self,name,age)
    # 通过super方法调用父类的方法。然后补充父类没有的即可
      self.gender = gender 
    # 然后加入新的内容
    
 p1 = Student('moon',17,'男')
 #这时候算添加完成了，可以直接用了，子类还是调用父类的方法，只不过可以添加内容了
  
  
 派生实战：

 class Mylist(list):
    def append(self,valuse):
      if valuse == 'moon'
      		return '输入错误'
		   super().append(valuse)
      
ojb = Mylist()
msg = ojb.append('moon')
print(ojb)
print(msg)
        
'''针对列表做了一些限制， 我们定义了一个子类 然后父类是列表， 也就相当于子类拥有父类的一切属性和方法，  然后我们对父类的方法做出了改变，我们要求在执行append方法前，先判断是否是moon 如果是就结束这个方法，如果不是就执行父类的添加方法'''


派生 可以在 父类的方法上做改善 

原文地址：http://www.cnblogs.com/moongodnnn/p/16863408.html