python基础操作（三）--面向对象

这篇是我即将写python基础操作的最后一篇–面向对象。
这里补充讲一下python的定义：
python是面向对象、解释型计算机程序的动态类型的一种语言。
什么是面向对象？
python中一切皆为对象，对象务的描述和方法系统的定义为一个类，这个类的具体实例就是一个对象
我对面向对象的理解：
面向对象是相对于面向过程而言的。
面向过程语言是一种基于功能分析的、以算法为中心的程序设计方法；而面向对象是一种基于结构分析的、以数据为中心的程序设计思想。
在面向对象语言中有一个有很重要东西，叫做类。
面向对象有三大特性：封装、继承、多态。
什么是解释型？
程序执行时无需进行编译成二进制代码，直接在执行过程中对语句一条条进行编译
什么是动态类型？
指程序在运行是可以改变其结构：新的函数可以被引进，已有的函数可以被删除等结构上的变化（随意更改变量）
原来CSDN还可以修改原来之前写的博客的，突然发现了一个‘新大陆’一样开心。恩，我只是修改了之前写过的标题，现在看起来就一目了然了，哈哈。
然后我有发觉自己没写python入门基本操作–索引。。。后面在补上一篇吧
ok，回到原题，上篇python基础操作–模块入口https://blog.csdn.net/weixin_46341320/article/details/105520832

# coding=utf8
# 面向对象程序设计：
# 1、面向对象程序设计基础
# 1）对象（object）：可以将一组数据与这组数据有关操作组装在一起，形成一个实体，这个实体就是对象。
#也可以这样说，通过类定义的数据结构的实例称之为对象
#实例化：在类中定义一个对象的过程，称之为实例化，创建一个类的实例，类的具体对象
#在python中对象包括：2个数据成员（类变量和实例变量）和方法
如：yy='duoduo'+'666' #这里yy就是对象

# 2）类：（class）：用来描述具有相同或相似性质的对象的集合就是类。
定义了该集合每个对象所共有的属性和方法：
对象的抽象就是类，类的具体化就是对象。
# 例：如果人类是一个类，则一个具体的人就是一个对象。
# 类一般包含属性和方法（也可以不包含属性和方法）
#类的划分的标准：写代码的人来定

# 3）封装：将数据和操作捆绑在一起，定义一个新类的过程就是封装。
# 4）继承:类之间的关系，在这种关系中，一个类共享了一个或多个其他类定义的结构的行为
# 5）方法：也称为成员函数，值对象上的操作，作为类声明的一部分来定义，方法定义了对一个对象可以执行的操作
# 6）构造函数：一种成员函数，来在创建对象时初始化对象，构造函数一般与它所属的类完全同名

# 2、定义和使用类
#类是如何定义的：
#在python中类的变量为属性，类的方法/函数是行为
#a、通过关键字：class，写法的结构：class+类名
#1）经典类：class+类名
#2）新式类：class+类名（object）
#如果类名括号里面有object，则表示为新式类，否则为经典类
#b、类名的规范：数字字母下划线组成，不能以数字开头，首字母大写驼峰命名，如：Name_Xiao
#c、类属性，如：a=1 放在类里面的变量值
#d、类方法/类函数：就是写在类里面的函数/方法：函数以def开头
#写法结构：def+函数名（参数）

# 3、类的继承和多态

class Person(object):#object是一切类的基类，父类，超类
    hand=13          #定义一个类变量
    def __init__(self,name,age):#self就是实例本身
# 构造函数作用：用来初始化对象（创建对象）
#什么时候用初始化函数？想用就用，不想用就不用
#使用规则：如果某个属性值是多个函数共用的，就可以用初始化函数
        #self.name实例变量
        self.name=name#把形式参数name赋值给实例变量
        self.__age=age#定义一个私有变量，用2个（下划线）__开头
    def shopping(self):  #实例方法
        return self.name+'买东西'

    # 定义一个类方法在方法名上需要加装饰器 @classmethod
    # 类方法中默认参数cls；
    # 装饰器：是一个函数或叫类，在不影响原有方法的基础上给方法添加新的功能
    # 类方法
    @classmethod
    def work(cls):
        return '我是一个类方法'

    # 静态方法
    @staticmethod
    def study():
        return '我是一个静态方法'

    # 通过创建一个实例方法来访问私有变量
    def fun(self):
        return self.__age

    # 定义一个私有方法：
    def __fun1(self):
        return '我是一个私有方法'

    # 通过创建一个实例方法来访问私有方法
    def fun2(self):
        return self.__fun1()
#私有的都需要创建实例来访问
p=Person('老表',18) #创建一个对象p就是一个具体对象或实例

# 1、调用类变量和实例变量
print p.hand      #通过对象调用类变量     #13
print p.name      #通过对象调用实例变量   #老表
print Person.hand #类调用类变量           #13
print Person.name #类不能调用实例变量     #会报错
#实例变量是每个实例或对象所独有的

# 2、对象调用实例方法、类方法、静态方法
print p.shopping()      #对象调用实例方法  #老表买东西
print p.work()          #对象调用类方法    #我是一个类方法
print p.study()         #对象调用静态方法  #我是一个静态方法

print Person.shopping(p)#类名调用实例方法需要一个实例作为入参    #老表买东西
print Person.work()     #类名调用类方法						   #我是一个类方法
print Person.study()    #类名调用静态方法					   #我是一个静态方法

# 3、私有方法和私有变量
print p.fun()           #对象调用私有变量   #18
print p.fun2()          #对象调用私有方法   #我是一个私有方法

# 类名调用私有方法和私有变量都需要一个实例作为入参
print Person.fun(p)     #类名调用私有变量   #18
print Person.fun2(p)    #类名调用私有方法   #我是一个私有方法

这里看得会有点懵，但认真看几遍之后，也就那么一回事，洒洒水啦

小结

#1、实例具有类里面的所有属性和方法的使用权限
#2、实例可以调用类里面任意属性，实例可以调用类里面的任意函数和方法
#3、调用属性：实例名.属性名
#4、调用方法/函数:实例名.方法名（）/实例名.函数名（）
#5、普通函数和类函数的区别:类函数有self

#类中的3种方法
# 1、实例方法：只能实例来调用
# 2、类方法：类方法的调用不创建实例或者创建实例都可以调用
# 3、静态方法：普通的函数
#总结：
#实例方法self，类方法cls，静态方法就是普通方法
#共同点：三种方法都可以通过实例和类名调用
#不同点：类方法和静态方法不可以调用类里面的属性值；
# 如果他们需要参数，请自己给自己传参

#什么时候去定义静态方法和类方法？
#当某个函数与其他函数没有任何关系的时候，就可以定义为静态方法或类方法，静态方和类方法只是为了方便调用，不需要创建实例，直接类名.函数名就可以完成调用

#继承
#编写的类是另一个现在（已存在）类的特殊的版本，可以使用继承一个类继承另一个类时，它会自动获取另一个类的所有属性和方法
#原有的类称为父类，而新类称为子类。
# 子类继承其父类的所有属性和方法同时还可以定义自己的属性。
# 1.子类的方法__init__()
#创建子类的实例时，python需要完成的任务是给父类的所有属性赋值，子类的方法__init__（）需要父类的帮助
# 2.创建子类时，父类必须包含在当前文件夹中，且位于子类的前面；定义子类时，在括号里面必须指定父类的名称
# 3.重写父类的方法
#对父类的方法，只要不符合子类模拟的实际的行为，都可以对其进行重写，可以在子类中定义一个与需要重写的父类方法同名：
#python中将不会考虑这个父类方法，而只是关注子类中定义的相应的方法

class Father(object):#父类也称为超类
    def __init__(self):
        pass
    def aiwan(self):
        print '老王爱玩'
    def rich(self):
        print '老王家里有钱'
class Son(Father):#子类继承父类
    def __init__(self):
        super(Father).__init__(Son)#继承父类的构造函数
        # super（）是一个特殊函数，帮助python将父类和子类关联起来
    def aimeinv(self):
        print '喜欢美女'
    def car(self):
        print '喜欢跑车'
s=Son()
#子类调用自己的函数
s.aimeinv()    #喜欢美女
s.car()        #喜欢跑车
#调用父类的方法（继承方法）
s.aiwan()      #老王爱玩
s.rich()       #老王家里有钱

#判断s对象是否为Son类的实例对象
print isinstance(s,Son)      #True
#判断Son类是否为Father类的子类
print issubclass(Son,Father) #True

# 定义父类：
class duoduo():
    def run(self):
        pass
#定义子类,并重新写入方法：
class sport_A(duoduo):
    def run(self):
        print '去打球'
class sport_B(duoduo):
    def run(self):
        print '去唱K'
class gz(object):
    def fun(self,dog):#只要能接收父类对象，就能接收子类对象
         dog.run()    #只要父类对象能工作，子类对象就能工作,
                      #并且不同子类会产生不同的执行效果。
pp=gz()
pp.fun(sport_A())   #去打球
pp.fun(sport_B())   #去唱K

# 封装
#1、数据放在列表里（数据层面）
#2、常用代码段打包成一个函数（语句层面）
#3、对象是模拟真实事件，把数据和代码都封装在一起
class A:
    def __init__(self):
        pass
    def setname(self,name):
        self.name=name
    def getname(self):
        return self.name
a=A()
a.setname('班长')
print a.getname()   #班长

#多态：可以对不同类的对象调用相同的方法，产生不同的结构
class A():
    def fun(self):
        print '我毕业了'
class B:
    def fun(self):
        print '我毕业于广州大学'
aa=A()
bb=B()
#调用fun（）函数，名字一样，实现不一样，这就是多态
aa.fun()
bb.fun()

class Animal():
    def __init__(self):
        pass
    def eat(self,x,y):
        return x+y
dog=Animal()
person=Animal()
print dog.eat('骨头','肉')  #骨头肉
print person.eat(2,3)    	#5     

写到这，python算是告上一段落了，除去还没写索引，但是并不是就此结束学习之旅，越是学习，越是觉得python魅力所在，有空还是会逛一下大佬写的博文，学习借鉴来此充实自己。因为我突然有种很‘可怕’的想法，规划未来的职业生涯，我想着要从测试转开发，当然，这几年还是从测试开始，一步步做起。未来的未知的东西太多了，很可能想法也会被遗忘。
小白上路，请保护好这颗幼苗~嘻嘻