面向对象

1、面向过程与面向对象：
面向过程：核心是过程二字，过程即解决问题的步骤，就是先干什么再干什么
基于该思想写程序就好比在设计一条流水线，是一种机械式的思维方式
优点：复杂的过程流程化，进而简单化
缺点：可扩展性差

面向对象：核心是对象二字，对象是特征和技能的结合体
基于该思想写程序就好比创造一个世界，世界是多个对象组成的，是一种上帝的思维方式
优点：可扩展性强
缺点：编程复杂程度高，容易出现过度设计

2、类：
对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体
在现实世界中：一定是先有的一个个具体存在的对象，后总结出的类
在程序中：一定保证先定义类，后产生对象

类的简单定义和使用

class Student:
        school='oldboy'
        def learn(self):
            print('learn')
        def choose_course(self):
            print('choose_course')
        # print('--->')
#查看属性：
print(Student)
print(Student.choose_course)
print(Student.school)   #类的数据属性
print(Student.learn)    #类的函数属性

print(Student.__dict__) #查看类的名称空间
#增加属性：
Student.country='china'
print(Student.country)

#修改属性：
Student.school='oldboydd'
print(Student.school)

#删除属性：
del Student.country
print(Student.country)

#类中函数的调用
#由于类中定义的函数都是需要传值的，所以在这里可以任意传入一个值就能执行类中的函数
print(Student.learn('sadf'))

类中对象的定义及其使用

class Student:
    school = 'oldboy'
    def __init__(self,name,sex,age):  #python自带的，会自动调用
        self.Name=name
        self.Sex=sex
        self.Age=age

        # stu1.Name='lqx'
        # stu1.Sex=sex
        # stu1.Age=18
    def learn(self):
        print('learn')

    def choose_course(self):
        print('choose_course')

#调用类的过程又称为实例化，stu1=Student('lqx','male','18')
#1、得到一个返回值，即对象，该对象是一个空对象stu1
#2、Student.__init__(stu1,'lqx','male','18'),
#总结：实例化，先造出一个空对象，然后把空对象和连同调用类时需要的参数一同传入init的函数，同时空对象一定在第一位

#调用类，实例化出对象：
stu1=Student('lqx','male','18')
# stu2=Student()
# stu3=Student()
#查看对象的值
print(stu1.__dict__)   #查看stu1会有自己的一个名称空间，使用__dict__就可看到对象下面的值
print(stu1.Name,stu1.Age,stu1.Sex)
#改对象的值
stu1.Name='www'
print(stu1.Name,stu1.Age,stu1.Sex)


stu2=Student('yft','male','12')
print(stu2)
print(stu1,stu2)

属性查找与绑定方法

class Student:
    school='oldbody'

    def __init__(self,name,sex,age):
        self.name=name   #给self.name赋值
        self.sex=sex
        self.age=age

    def learn(self,x,y):
        print('%s learn' %stu1.name)
        print(x,y)
    def choose_course(self):
        print('choose_course')

1、查找一个对象的属性顺序是：先找对象自己的dict,再找类的dict

stu1=Student('lqx','male',18)
stu2=Student('yft','male',20)

2、类的数据属性是所有对象共享的，所有对象都指向同一个内存地址

属性的查找，先从对象自己的名称空间去找，如果没有再去类的名称空间去找。如果再没有就会报错

#类下面应的school的名称空间和对象下面对应的school的名称空间是相同的
stu1.school='xxx'
print(Student.school,id(Student.school))
print(stu1.school,id(stu1.school))
print(stu2.school,id(stu2.school))

3、类中定义的函数是绑定给对象使用的

3.1、不同对象就是对应不同绑定方法
3.2、绑定给A，就应该由A来调用，A来调用就会把A当做第一个参数传给对应的函数

print(Student.learn)  #类去访问就是普通函数function
print(stu1.learn)   #对象去访问被称为bound method
print(stu2.learn)

stu1.learn(1,2)  #自动把stu1传入函数 等同于 student.learn(stu1,1,2)

4、小练习：统计被实例化的次数

class Teacher:
    shool='oldbody'
    count=0
    def __init__(self,name,sex,age,level,salary):
        self.name=name
        self.sex=sex
        self.age=age
        self.level=level
        self.salary=salary
        Teacher.count+=1   #count的属性应该是Teacher 类的属性（全局的），才能让全部的对象都能使用

    def teach(self):
        print('%s teach' %self.name)

stu1=Teacher('egon','male','23','10','2000')
stu2=Teacher('www','male','25','30','4000')
print(stu1.count)
# print(stu2.count)

类与类之间的相互调用

class Garen:
    camp='demacia'
    def __init__(self,nickname,life_value,aggresivity):
        self.nickname=nickname
        self.life_value=life_value
        self.aggresivity=aggresivity

    def attack(self,enemy):
        enemy.life_value-=self.aggresivity


class Riven:
    camp = 'Noxus'

    def __init__(self, nickname, life_value, aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity

    def attack(self, enemy):
        enemy.life_value -= self.aggresivity

g1=Garen('盖伦',1000,100)
r1=Riven('瑞文',200,500)

print(g1.life_value)
r1.attack(g1)
print(g1.life_value)

类即类型

#类型dict就是类dict
>>> list
<class 'list'>

#实例化的到3个对象l1,l2,l3
>>> l1=list()
>>> l2=list()
>>> l3=list()

#三个对象都有绑定方法append,是相同的功能,但内存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>

#操作绑定方法l1.append(3),就是在往l1添加3,绝对不会将3添加到l2或l3
>>> l1.append(3)
>>> l1
[3]
>>> l2
[]
>>> l3
[]
#调用类list.append(l3,111)等同于l3.append(111)
>>> list.append(l3,111) #l3.append(111)
>>> l3
[111] 

从代码级别看面向对象

# Author:lqx

#1、在没有学习类的这一概念，数据与功能是分离的
def connect(host,port,db,charset):
    conn=0
    pass
    return conn
def exc1(host,port,db,charset,sql):
    conn=connect(host,port,db,charset)
    return  conn.execcute(sql)

def exc2(host, port, db, charset,proc_name):
    conn = connect(host, port, db, charset)
    return   conn.call_proc(proc_name)
exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')


#2、我们想到的解决办法是，把相同的变量都定义为全局变量
HOST=‘127.0.0.1’
PORT=3306
DB=‘db1’
CHARSET=‘utf8’
x=1
y=2

def exc1(sql):
    conn=connect(host,port,db,charset)
    conn.execute(sql)
    return xxx


def exc2(proc_name):
    conn=connect(host,port,db,charset)
    conn.call_proc(proc_name)
    return xxx

exc1(HOST,PORT,DB,CHARSET,'select * from tb1;')
exc2(HOST,PORT,DB,CHARSET,'存储过程的名字')


def func1():
    print(x)
    print(y)

def func2():
    print(x)
    print(y)
#每次调用都需要重复传入一堆参数
exc1('select * from tb1;')
exc2('utf8','存储过程的名字')

exc1('select * from tb2;')

func()




#使用类以后，定义一个类
class Mysqlhandle():
    def __init__(self,host,port,db,charset='utf-8'):
        self.host=host
        self.port=port
        self.db=db
        self.charset=charset
        self.conn=conntect(host,port,db,charset)

    def exc1(self,sql):
        return self.conn.execute(sql)
    def exc2(self,proc_name):
        return self.conn.call_proc(proc_name)
obj1=Mysqlhandle('127.0.0.1','3306','db1')
obj1.exc1('select * from db1')
obj1.exc1('select * from db2')

obj2=Mysqlhandle('10.10.10.9','3306','db2')
obj2.exc2('select * from t1 where id > 3')