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中上面这两种方式都是新式类

2.x的类和3.x的类

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>

view

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.通过实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部实现的的细节。