面向对象

Posted 2020-10-21 uulinux

01 类的定义与使用

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

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

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

3、站在老男孩学校的角度
现实中的对象：

对象1：
    特征
        学校=老男孩
        名字=李三炮
        性别=男
        年龄=18
    技能
        学习
        选课

对象2：
    特征
        学校=老男孩
        名字=张铁蛋
        性别=女
        年龄=38
    技能
        学习
        选课

对象3：
    特征
        学校=老男孩
        名字=武大郎
        性别=男
        年龄=28
    技能
        学习
        选课

对象4：
    特征
        学校=老男孩
        名字=egon
        性别=男
        年龄=18
    技能
        教学

现实中的老男孩学生类：
老男孩学生类
相似的特征
学校=老男孩
相似的技能
学习
选课

# 类体代码在类的定义阶段就会立刻执行，
class Student:
    school=‘oldboy‘

    def learn(self):
        print(‘is learning‘)

    def choose_course(self):
        print(‘choose course‘)

    # print(‘====run‘)


# print(Student)
# print(Student.__dict__)

#查看
# print(Student.school) #数据属性
# print(Student.learn) #函数属性

#增加
# Student.country=‘China‘
# print(Student.country)

#修改
# Student.school=‘Oldboy‘
# print(Student.school)

#删除
# del Student.country
# print(Student.country)

# print(Student.learn)
# Student.learn(‘xxxxx‘)

02 对象的定义与使用

class Student:
    school=‘oldboy‘

    #stu1,‘李三炮‘,‘男‘,18
    def __init__(self,name,sex,age): #在调用类时会自动触发执行
        self.Name=name
        self.Sex=sex
        self.Age = age

        #stu1.Name=‘李三炮‘
        #stu1.Sex=‘男‘
        #stu1.Age=18

    def learn(self):
        print(‘is learning‘)

    def choose_course(self):
        print(‘choose course‘)

#调用类的过程又称之为实例化:stu1=Student(‘李三炮‘,‘男‘,18)
#1、得到一个返回值，即对象，该对象是一个空对象stu1
#2、Student.__init__(stu1,‘李三炮‘,‘男‘,18)

stu1=Student(‘李三炮‘,‘男‘,18)
# print(stu1.__dict__)
# print(stu1.Name,stu1.Age,stu1.Sex)

stu2=Student(‘张铁蛋‘,‘女‘,38)
stu3=Student(‘武大郎‘,‘男‘,28)
# print(stu2.__dict__)
# print(stu3.__dict__)

# print(stu1,stu2,stu3)

# print(stu2.Name)

03 属性查找与绑定方法

x=1
class Student:
    school=‘oldboy‘
    # Name=‘xxx‘

    def __init__(self,name,sex,age): #在调用类时会自动触发执行
        self.Name = name
        self.Sex = sex
        self.Age = age


        #stu1.Name=‘李三炮‘
        #stu1.Sex=‘男‘
        #stu1.Age=18

    def learn(self,x,y):
        print(‘%s is learning‘ %self.Name)
        print(x,y)

    def choose_course(self):
        print(‘choose course‘)

    def commit_hw():
        print(‘commit homework‘)

#1、查找一个对象的属性顺序是：先找对象自己的__dict__,再找类的__dict__
# stu1=Student(‘李三炮‘,‘男‘,18)
# # print(stu1.__dict__)
#
# # print(stu1.Name)
# # print(stu1.school)
# # print(stu1.x)

stu1=Student(‘李三炮‘,‘男‘,18)
stu2=Student(‘张铁蛋‘,‘女‘,38)
stu3=Student(‘武大郎‘,‘男‘,28)


# 2、类的数据属性是所有对象共享，所有对象都指向同一个内存地址
# stu1.school=‘xxx‘
# Student.school=‘Oldgirl‘
# print(Student.school,id(Student.school))
# print(stu1.school,id(stu1.school))
# print(stu2.school,id(stu2.school))
# print(stu3.school,id(stu3.school))

# 3、类中定义的函数是绑定给对象使用：
# 3.1：不同对象就是不同绑定方法
# 3.2：绑定给谁，就应该由谁来调用,谁来调用就会把谁当做第一个参数传给对应的函数
# print(Student.learn)
# print(stu1.learn)
# print(stu2.learn)
# print(stu3.learn)

# stu1.learn(1,2) #Student.learn(stu1,1,2)
# stu2.learn(1,3)
# stu3.learn(1,4)
# print(Student.learn)

# stu1.commit_hw()

类即类型

# class Teacher:
#     school=‘oldboy‘
#     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
#
#     def teach(self):
#         print(‘%s is teaching‘ %self.name)
#
# t1=Teacher(‘egon‘,‘male‘,18,10,3000)
# print(type(t1))


# l=[1,2,3,4] #l=list([1,2,3,4])
# print(type(l))

l1=list([1,2,3,4])
l2=list([1,2,3,4])
# print(id(l1))
# print(id(l2))

# print(l1.append)
# l1.append(5) #list.appent(l1,5)
# list.append(l1,5)
# print(l1)

l1.append(‘a‘)
l2.append(‘b‘)

06 从代码级别看面向对象

1、在没有学习类这个概念时，数据与功能是分离的

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

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

#每次调用都需要重复传入一堆参数
exc1(‘127.0.0.1‘,3306,‘db1‘,‘utf8‘,‘select * from tb1;‘)
exc2(‘127.0.0.1‘,3306,‘db1‘,‘utf8‘,‘存储过程的名字‘)

exc1(‘127.0.0.1‘,3306,‘db1‘,‘utf8‘,‘select * from tb2;‘)

2、在没有学习类这个概念时，数据与功能是分离的

host=‘127.0.0.1‘
port=3306
db=‘db1‘
charset=‘utf-8‘

x=1
y=2

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

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

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=connect(host,port,db,charset)
#
#     def exc1(self,sql):
#         return self.conn.execute(sql)
#
#     def exc2(self,proc_name)
#         return self.conn.call_proc(prco_name)
#
# obj1=Mysqlhandle(‘127.0.0.1‘,3306,‘db1‘)
#
# obj1.exc1(‘select * from t1‘)
# obj1.exc1(‘select * from t2‘)
# obj1.exc1(‘select * from t3‘)

# obj2=Mysqlhandle(‘10.10.10.9‘,3306,‘db2‘)
# obj2.exc1(‘select * from t1 where id > 3‘)