Python-开发之路-面向对象-初阶

PS：由于时间原因，今天先只列提纲

概述：

面向过程式编程：根据业务逻辑从上到下进行垒代码

面向对象式编程：对函数进行封装分类

两种方式各有长处，应因地制宜(函数式的应用场景 –> 各个函数之间是独立且无共用的数据)

函数式编程是面向过程式编程

函数式、面向对象简要对比

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7
#函数式：
def fetch(host,username,password,sql):
pass

def create(host,username,password,sql):
pass

def remove(host,username,password,sql):
pass

def modify(host,username,password,sql):
pass

"""
面向对象
首先通过‘class’这个关键字告诉python，这里开始创建一个类，当在这个类后面加上括号，就变成这个模板建的一个实例，这个实例就是这个类的一个对象
类中的函数第一个参数必须是self（详细见：类的三大特性之封装）
类中定义的函数叫做 “方法”
"""
class sqlhelper:

def fetch(self,sql):
pass
def create(self,sql):
pass
def remove(self,sql):
pass
def modify(self,sql):
pass

obj = sqlhelper()
obj.hhost = "c1.salt.com"
obj.uusername = 'alex'
obj.pwd = '123'

obj.fetch("select * from A")
#面向对象三大特点：封装、继承、多态

面向对象三个特性：封装、继承、多态

1、封装

将内容封装在某处，以后再去调用被封装在某处的内容

使用封装的步骤： 1.封装， 2.调用

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7

##封装
class SQLHelper:
#构造方法，创建一个类的对象后，自动首先执行的是就__init__
def __init__(self,a1,a2,a3):
print('autorun')
self.hhost = a1
self.uusername = a2
self.pwd = a3

def fetch(self,sql):
pass
def create(self,sql):
pass
def remove(self,sql):
pass
def modify(self,sql):
pass

obj1 = SQLHelper('c1.salt.com','alex',123)
obj1.fetch("sel * from A")

class c1:
def __init__(self,name,obj):
self.name = name
self.obj = obj

class c2:
def __init__(self,name,age):
self.name = name
self.age = age
def show(self):
print(self.name)

class c3:
def __init__(self,aaa):
self.money = 123
self.a1 = aaa

c2_obj = c2('aa',11)
c1_obj = c1('alex',c2_obj)
c3_obj = c3(c1_obj)
print(c1_obj.obj.age,c3_obj.a1.obj.age)

2、继承：

继承，即为把父集的方法拷贝到子集中，但是优先级低于子集的本地方法

单继承

同名的方法（比如：show），子类优先级高于父类

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7

class F1:#父类，基类
def show(self):
print('show')
def foo(self):
print(self.name)

class F2(F1):#F2:子类，派生类
def __init__(self,name):
self.name = name
def bar(self):
print('bar')
def show(self):
print('F2.show')

obj = F2('alex')
obj.show()
obj.foo()

多继承

子集按照从左到右的先后顺序，并遵循深度优先、宽度优先的原则，来对多个父集进行继承，由于self以为创建的对象本身，因此每次遇见#self.XXX,则返回子集重头开始解读（3.*版本）

多说一下2.7和3.5的多继承区别：

2.7，支持两种继承法：

新类继承法：在创建类时，如果继承了object类，则继承的原则与3.*版本一致；

经典类继承法：如果没有继承object类，则当左右两个父类的顶层父类是同一个时，在子类去左边父类寻找方法时，会一路寻找到顶级父类，然后才去右边父类寻找；

3.*，继承方法：

新建类时，默认隐式继承object类，子类在寻找方法时，当遇到左右父类的顶级父类是同一个时，在遵循深度优先是，不去顶级父类寻找，而是转而去右边父类，遵循宽度优先，并在找到最后一个父类时，才寻找到顶层。

3、多态

多态(对于参数 多种形态、多种类型 都适应)

#python，在参数声明这里，不管什么参数的类型都全适应，优点：方便灵活，缺点：代码可读性差
def func(arg):
print(arg)

func(1)
func("meta")
func([11,22,3])

# C#/Java,在参数声明这里，需要明确指定参数的数据类型，优点：方便排查，可读性高；缺点：刻板
def func(list arg):
print(arg)

func(123)
func("meta") # 报错