python面向对象一

1.1三种编程方法论

1.面向过程：把复杂的任务一步一步分解成简单的任务。

2.函数式编程：思想上接近于数学运算，根据某种方式，根据方式得出的结果。

3.面向对象编程:一种编程方式，需要使用“类”和“对象”来实现，其实就是对“类”和“对象的”使用

 

1.1.1  面向对象设计和面向对象编程

1.面向对象设计(Object-oriented design)：将一类的具体的事物的属性和方法整合到一起，即面向对象设计。

注：面向对象(OO)，是一种程序设计思想，不一定只有class定义类才是面向对象，def定义函数的就不是面向对象了，这是一种错误的判断，面向对象是一种思想。

def person(name,age,gender):  #理解一个人种类    
    def play(name):     #人的方法
        print("[%s],正在玩python" %(name['name']))
    def eat(name):      #人的方法
        print("[%s]正在吃饭"%(name["name"]))
    def init(name,age,gender):  #初始化人的属性，以及方法。
        person1 = {
            "name":name,
            "age":age,
            "gender":gender,
            "play":play,
            "eat":eat
        }
        return person1
    return  init(name,age,gender)
aa = person("xixi",18,"male")  #可以简单理解为生成了一个人的实例
aa["play"](aa) #调用人的方法
aa["eat"](aa)
bb = person("xiaoxi",19,"female") #有创建了一个人的实例
bb["play"](bb)

#这就是一个简单的面向对象的设计

2.面向对象编程(Object-oriented programming):用定义类+实例/对象的方式去实现面向对象的设计。

类(class):用来描述具有相同的属性和方法的集合，它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

对象(object):通过类定义(或创建)的数据结构实例。实例就是对象

实例化：由类产生对象的过程叫实例化

 

一.初始类

定义类的格式

class ClassName:    #注：定义关键字(类名)单词首字母要大写，这是一种规范
    #关于类的的注释文档
    类体

#ClassName类名

#创建一个类Data
class Data:
    "这是一个测试的数据"
    pass

#实例化类
d1 = Data()   # Data()类实例化的过程  ，利用Data是实例化一个对象d1

 

python2中的类和python3中的类

前提：
1.在python2中分新式类和经典类，python3中统一都是新式类。
2.新式类和经典类声明的最大不同在于，所有新式类必须继承至少一个父类。
3.所有类不管是否显示声明父类，都有一个默认继承object父类(类的继承，下面会写)

经典类：
class 类名:
     pass
 
新式类：
class 类名(父类):
     pass

注：在python3中上面这两种方式都是新式类

 

1.2属性

类是用来描述某一个类的事物，类的对象是这一类事物中一个个体

是事物就要有属性，(类)属性分为：

1.数据属性：就是变量

2.函数属性：就是函数，在面向对象中通常称为方法。

注意：类和对象都用点(.)来访问自已的属性

class.属性

object.属性

 

1.2.1类相关认识

一.类的数据属性

#定义了一个中国的类，在类中定义了一个属性person
#类属性又称为静态变量，或者静态数据，这些属性是类对象绑定在一起的，不依赖实例。
(不同的类，都有不同的属性，只有自已的类，才能访问自已的属性)


class China:
    person = "Chinese"
print(China.person)   #查看类的属性

 

二.类的方法

class China:
    person = "Chinese"
    def create(self):  #这个self 是把类实例本身传进去
        print("%s 是个发展中国家" %self)

country = "china"
China.create(country)  #调用类的方法create

 

三.查看类属性和方法

有两种方式查看：

1.dir(类名):查出的是类的属性名的列表

2.类名.__dict__:查出的是一个字母，key为属性名，value为属性值

print(dir(China))
# ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'create', 'person']


print(China.__dict__)
# {'__dict__': <attribute '__dict__' of 'China' objects>, '__module__': '__main__', 'create': <function China.create at 0x000000F0DBB8E2F0>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'China' objects>, 'person': 'Chinese'}

 查看特定属性的内容

class China:
    person = "Chinese"
    def create(self):  #现在在这里只是一个参数的形式
        print("%s 是个发展中国家" %self)

# 可以根据字典取key的方式，查看该属性的内容
print(China.__dict__["person"])  #Chinese
print(China.__dict__["create"])   #<function China.create at 0x000000569A2CE2F0>

 

1.2.2对象相关认识

 对象是有类实例化而来的，类实例的结果就是一个对象。

由于类可以起到模块的作用，因此创建实例的时候，我们可以把共有的数据属性，可以给强制填写进去，通过定义一个特殊的__init__的方法，把共有的属性绑定到上去。

class China:
    "我们是中国人"
    person = "Chinese"
    def create(self):  #现在在这里只是一个参数的形式
        print("%s 是个发展中国家" %self)
# country = "china"
# China.create(country)

# 可以根据字典取key的方式，查看该属性的内容
# print(China.__dict__["person"])  #Chinese
# print(China.__dict__["create"])   #<function China.create at 0x000000569A2CE2F0>


class Student:
    def __init__(self,name,age,gender):#这里的self 就相当于得到把对象本身自已
        self.name = name
        self.age = age
        self.gender = gender
    def score(self):
        print("%s 的成绩是99 "%self.name)
    def play(self):
        print("%s 的喜欢玩球，年龄是 %s" %(self.name,self.age))


one = Student("xiaoxi",12,"male") #通过实例化的得到了一个对象one
print(one.name)  #该对象的共有的数据属性  ，得到该对象的名字
one.score() #该对象的方法score
one.play()  #该对象的方法play
two = Student("xixi",11,"male")#又创建了个对象
print(two.name)

 

注意上面的代码：__init__方法的第一个参数永远是self，表示创建的实例本身，因此在__init__方法内部，就可以把各种属性绑定到self上，因为self就指向了创建的实例本身。

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，python解释器会把自已实例变量传进去。

和普通函数相比，在类中定义的函数只有一点不同，就是第一参数永远是实际变量，并且，调用时不用传递该参数。除此之外的类的方法和普通函数没什么区别。我们任然可以用函数的其他参数。

 

实例属性：

实例化的过程就是执行__init__的过程，这个函数内部只是为实例本身即self设定了一些变量，所有实例只有数据属性。

class Teacher:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def teach(self):
        print("%s 老师正在教书，他现在已近 %s 岁了 ，是一位 %s 老师" %(self.name,self.age,self.gender))

one_teacher = Teacher("小林",48,"male")
print(one_teacher.__dict__) #查看实例属性
print(one_teacher.name,one_teacher.age,one_teacher.gender) #访问实例的数据属性

 

现在访问实例的函数属性(方法,其实就是类的函数属性)

class Teacher:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def teach(self):
        print("%s 老师正在教书，他现在已近 %s 岁了 ，是一位 %s 老师" %(self.name,self.age,self.gender))

one_teacher = Teacher("小林",48,"male")
print(one_teacher.__dict__) #查看实例属性
print(one_teacher.name,one_teacher.age,one_teacher.gender) #访问实例的数据属性
#新加的下面3行内容
print(Teacher.__dict__) #函数属性只存在于类中
Teacher.teach(one_teacher) #我们只能通过类去调用类的函数属性，然后把实例当做变量传递给self
one_teacher.teach() #注其实就是Teacher.teach(one_teacher)

 

查看实例的属性同样是用dir和内置__dict__两种方式。

 

警告：类和对象虽然调用__dict__返回时一个字典结构，但是千万不要直接修改该字典，会导致你原来oop不稳定。

 

1.3类属性与对象(实例)属性

类属性的增删改查

class Teacher:
    country = "China"
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def teach(self):
        print("%s 老师正在教书，他现在已近 %s 岁了 ，是一位 %s 老师" %(self.name,self.age,self.gender))

#查看类的属性
print(Teacher.country)
#修改类的属性
Teacher.country = "中国"
print("修改后类的属性》》",Teacher.country)
#删除类属性
del Teacher.country
print(Teacher.__dict__)
# print(Teacher.country)  #在打印会报错，提示没有country 属性
Teacher.location = "Beijing"
print("添加类属性>>",Teacher.location)
print(Teacher.__dict__)



#给类在添加一个函数属性（方法），
def do(self,homework):
    print("%s 正在修改 %s" %(self.name,homework))

Teacher.do = do  #把do函数，添加到类里面去
print(Teacher.__dict__)
one = Teacher("xiaoli",30,"female")
Teacher.do(one,"homework") #把one实例传进去

 

 

 

 

实例属性的增删改查

class Teacher:
    country = "China"
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def teach(self):
        print("%s 老师正在教书，他现在已近 %s 岁了 ，是一位 %s 老师" %(self.name,self.age,self.gender))



two = Teacher("dav",32,"male")
#查看实例属性
print(two.name)
print(two.__dict__)
print(two.country) #这里country不存在two的属性字典中，

#删除实例属性
# del two.country  #报错
del two.name
print(two.__dict__)
# 增加实例属性
two.name = "xixi" #又重新添加一个name属性
two.test = "data test"
print(two.__dict__)
#修改实例属性
two.age = 35
print(two.__dict__)

注：上面虽然这样写，但是一般最好不要修改原来oop。

 

总结:

1.类是创建实例的模块，而实例则是一个一个具体的对象，各个实例拥有的数据都相互独立，互不影响。

2.方法就是实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据。

3.通过实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部实现的的细节。