Python之面向对象类和对象

Python之面向对象类和对象

　　定义一个类：class

　　定义类的语法：

class Test(object):
    """
    类里定义一类事物共同的技能。
    可以是变量，也可是函数。
    """
    camp = "Demacia"
    def attack(self):
        print("attack")

　　如何使用类：类的用法----实例化和引用自己的属性

　　　　一、内置类

　　　　　　　　例如int（） 加参数就能用。

　　　　　　　　x=int(10)

　　　　　　　　print(x)

　　　　二、实例化

　　　　　　　定义的Test类，加括号。就是将Test类 变成一个具体的对象 Test（）。

　　　　　　　所以，obj = Test（）是将一个抽象的类Test，变成一个具体的对象的过程。这个过程就叫实例化。

　　　　三、引用类的方法，类的特征（类的变量），类的技能（类的函数）

　　　　　　print（Test.camp） 引用Test类里camp变量的值。demacia

　　　　　　Test.attack（5578）

#一：实例化
# x=int(10)
# print(x)

# obj=Garen() #实例化
# print(obj)

#二：引用类的特征（类的变量）和技能（类的函数）
# print(Garen.camp)
# print(Garen.attack)
# Garen.attack(1231231) 

　　如何使用实例：

　　g1 = Test() 这样就是一个实例。将Test类实例了。对于g1来说，就是一个具体的存在对象。

#如何使用实例
class Test:
    camp='Demacia'                                                                 

    def __init__(self,nickname):
        """
        init的作用：self.nick是给自己定义了一个别名，叫nickname
        实例化Test(),就会自动触发__init__方法的执行。
        :param nickname:
        """
        self.nick=nickname  #g1.nick='草丛伦'
    def attack(self,enemy):
        # print('---------->',self.nick) #g1.nick
        print('%s attack %s' %(self.nick,enemy))                                   

g1=Test('草丛伦') #Test.__init___(g1,'草丛伦')
g2=Test('猥琐轮')
print(g1.nick)
g1.attack('George')                                                                

print(g1.nick)
print(g1.camp)
print(g1.attack)
print(Test.attack)                                                                 

Test.attack() #调用的是函数，
g1.attack() #self=g1     g1.attack是一种以绑定方法，调用attack的方式
Test.attack(g1)                                                                    

# print(g2.nick)
# print(g2.camp)
                                                                                   

　　　　Test.attack() 和g1.attack() 的区别：

　　　　　　　　　Test.attack（）是调用的attack的函数。由类去调用就没有对象那种自动传值的功能

　　　　　　　　　g1.attack（） 是g1绑定attack函数这个方法，会将g1自己作为第一个参数，传给后面的方法 (自动传值)。

　　self的作用：

　　　　由对象触发的，就有自动传值的功能。

　　　　self就是对象自己。

　　　　

#总结：
#类：一：实例化，二：引用名字（类名.变量名，类名.函数名）
#实例：引用名字（实例名.类的变量，实例名.绑定方法，实例名.实例自己的变量名）

class Garen:
    camp='Demacia'

    def __init__(self,nickname):
        self.nick=nickname  #g1.nick='草丛伦'
    def attack(self,enemy):
        # print('---------->',self.nick) #g1.nick
        print('%s attack %s' %(self.nick,enemy))

# print(Garen.camp) #查
# Garen.camp='aaaaaa' #改
# print(Garen.camp)
#
# # del Garen.camp #删除
# # print(Garen.camp)
#
# Garen.x=1
# print(Garen.x)

g1=Garen('George')
# print(g1.nick)
# g1.nick='asb'
# print(g1.nick)
# del g1.nick
# print(g1.nick)

# g1.sex='female'
# print(g1.sex)

　　面向对象的程序设计OOD

　　　　　找对象 ----》找类（归纳对象共同的特征与技能，还有每个对象独有的特征）

　　 面向对象编程OOP

　　　　　先定义类 ---》实例化出对象

　　 面向对象分析OOA

　　 面向对象测试OOT

　　 面向对象维护OOSM

　　 定义学生类：
　　　　特征：共同国籍（China）
　　　　技能：查看成绩

　　独有的特征：ID，名字，性别，省。

# #OOD
# #定义学生类：
# #特征：共同国籍（China）
# #技能：查看成绩
# #独有的特征：ID，名字，性别，省。

# #OOP
class Student():
    country = "China"
    def __init__(self,ID,NAME,SEX,PROVINCE):
        self.id = ID
        self.name = NAME
        self.sex = SEX
        self.province = PROVINCE

    def search_score(self):
        """
        查询分数技能
        :return:
        """
        print("tell score")
    def study(self):
        """
        学习技能
        :return:
        """
        print('study')

##类的用法：
##类的实例化，属性引用
s1 = Student("",'george','man','neimeng')
s2 = Student("",'wang','man','neimeng')

##类的属性： 特征（变量）和技能（函数，绑定方法）
s1.search_score()
s2.search_score()
s1.study()
print(Student.country)
print(Student.__init__)
print(Student.study)

Student.__init__(s1,2,3,4,5)    #这样是调函数

Student.study(s1)   #类查看自己的属性。

Student.x =1 #给类增加一个属性。

　　什么是对象，什么是类：

　　　　 在一个游戏中，每个玩家选一个英雄，每个英雄都有自己的特征和技能，特征既是数据属性，技能既是方法属性。特征与技能的结合就是一个对象。

　　　　从一组对象中提取相似的部分就是类，类所有对象都具有的特征和技能的结合体。

　　在Python中，用变量表示特征，用函数表示技能，因而类是变量与函数的结合体，对象是变量与方法（指向类的函数）的结合体。

　　在Python3中，统一了类与类型的概念。类型和类就是一个。class。

在Python2中，分为新式类和经典类。在Python3中，都是统一的新式类。

　　新式类和经典类声明的最大不同在于，所有新式类必须继承至少一个父类。

　　所有类不管是不是显示声明父类，都有一个默认继承的object父类。父类也叫基类，基础的意思。

　　可用 类名.__bases__ 来查看类都继承了那些父类。

　　在Python2中的类的区别：

　　经典类：

　　class 类名：

　　　　pass

　　新式类：

　　class 类名(父类)：

　　　　pass

　　　

在类的 __init__ 函数里不能有return的返回值。  在元类里详细说明。

对象的使用：

　　　对象也成为实例，

class Test(object)：
    pass

T = Test()    #对象T就是类Test的实例。

　　对象的用法：　

　　　 只有属性引用。

　　对象的属性：

　　　对象本身就只有特征（变量）

class Test（object）：
    def __init__(self,id,name):
        self.id = id
        self.name = name

    def A(self):
        pass

T = Test()
print(T.id,T.name)   #对象可以引用类的变量。  

查看类的名称空间和对象的名称空间：

　　类的名称空间：

　　　　类名.__dict__

　　对象的名称空间：

　　　　对象.__dict__

　　在 Test.A 和 T.A 是不一样的内存地址。

　　绑定方法的核心在于“绑定”，唯一绑定一个确定的对象。

基于面向对象开发：

#应用场景
#找不到共同特征和技能不用强求

#对象：学校----->归类
    #共有的特征：商标为etiantian
    #共有的技能：招生
    #独有的特征：地址不一样，老师们，课程

class School:
    tag='etiantian'
    def __init__(self,addr):
        self.addr=addr
        self.teacher_list=[]
        self.course_list=[]

    def zhaosheng(self):
        pass

#对象：老师---->归类
    #共同的技能：教课
    #独有的特征：名字，性别，level，课程

class Teacher:

    def __init__(self,name,sex,level):
        self.name=name
        self.sex=sex
        self.level=level
        self.course_list=[]

    def teach(self):
        pass

#对象：学生---->归类
    #共同的特征：
    #共同的技能：search_score,handin
    #独有的特征：学号，名字，性别，课程
class Student:
    def __init__(self,ID,name,sex):
        self.id=ID
        self.name=name
        self.sex=sex
        self.course_list=[]
    def search_score(self):
        pass

    def handin(self):
        pass

class Course:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

s1=Student('','sun','female')
# print(s1.id,s1.name,s1.sex)
# print(s1.course_list)
# s1.course_list.append('python')
# s1.course_list.append('linux')
# print(s1.course_list)

python_obj=Course('python',15800,'7m')
linux_obj=Course('linux',19800,'2m')

s1.course_list.append(python_obj)
s1.course_list.append(linux_obj)
# print(s1.course_list)

print('''student name is:%s
    course name is ：%s
    course price is :%s
    ''' %(s1.name,s1.course_list[0].name,s1.course_list[0].price))