Python-系列-[基础学习]-[面向对象学习]

Python-面向对象

"""
    Python-->面向对象
    1.类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
    2.类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
    3.数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
    4.方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
    5.局部变量：定义在方法中的变量，只作用于当前实例的类。
    6.实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
    7.继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
    8.实例化：创建一个类的实例，类的具体对象。
    9.方法：类中定义的函数。
    10.对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
"""

# python -- 创建类 
class Human:
    # 定义类的属性
    yanjing ="眼睛"
    bizi = "鼻子"
    zuiba = "嘴巴"
    name = "姓名"
    
    # 定义类的方法/行为
    def xingzou(self):
        print("站着往前走")
    
    def chifan(self):
        print("人类喜欢吃肉肉")
    
    def chuanyifu(self):
        print("人类喜欢穿衣服")
    
    def peopleQiguan(self):
        print("人的器官有:",self.bizi,self.name)
'''
    empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。

    第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

    self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
'''
   
p1 = Human()
p1.peopleQiguan()
    
class Test:
    def prt(self):
        print(self)
        print(self.__class__)

t=Test()
t.prt()
    
class YuanGong:
    '所有员工的基类'
    empCount = 0
    
    # 添加构造方法
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary
        YuanGong.empCount += 1
    '展示员工的数量'
    def displayCount(self):
        print("员工的数量是:",YuanGong.empCount)
        
    def displayEmployee(self):
        print("姓名:",self.name,"薪水:",self.salary)

# 实例化一个 类的对象

zhangsan = YuanGong("张涛",2000)

koubi = YuanGong("抠鼻",400)


# 访问属性
# 访问对象的属性
zhangsan.displayEmployee()
koubi.displayEmployee()

# 属性的添加,删除,修改
zhangsan.age = 7
zhangsanAge = getattr(zhangsan,'age')
print("张三的年龄是:",zhangsanAge)

'''
    getattr(obj, name[, default]) : 访问对象的属性。
    hasattr(obj,name) : 检查是否存在一个属性。
    setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
    delattr(obj, name) : 删除属性。
'''

# Python内置类属性
'''
    __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
    __doc__ :类的文档字符串
    __name__: 类名
    __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
    __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
'''

print("显示YuanGongLei的注释:YuanGong._doc_:",YuanGong.__doc__)
print("显示员工类的名称:",YuanGong.__name__)

# Python 对象垃圾回收
'''
    Python 使用了引用计数这一简单技术来跟踪和回收垃圾。

    在 Python 内部记录着所有使用中的对象各有多少引用。
    一个内部跟踪变量，称为一个引用计数器。

    当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。
    a = 40      # 创建对象  <40>
    b = a       # 增加引用， <40> 的计数
    c = [b]     # 增加引用.  <40> 的计数

    del a       # 减少引用 <40> 的计数
    b = 100     # 减少引用 <40> 的计数
    c[0] = -1   # 减少引用 <40> 的计数
'''

a = 8
b = a
c = [b]

del a
# print("对象a的值是:",a)
print("对象b的值是:",b)
print("对象c的值是:",c)

# 析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：

# 实例测试

class Point:
    def __init__(self,x=0,y=0):
        self.x = x
        self.y = y
    def __del__(self):
        class__name = self.__class__.__name__
        print (class__name,"销毁")
        
p1 = Point()
p2 = p1
p3 = p1

print(id(p1),id(p2),id(p3))

# 注意：通常你需要在单独的文件中定义一个类，
        
# 类的继承
'''
    面向对象的编程带来的主要好处之一是代码的重用，
    实现这种重用的方法之一是通过继承机制。

    通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
'''

class Parent:
    parentAttr = 100
    def __init__(self):
        print("调用父类构造函数")
    
    def parentMethod(self):
        print("调用父类的构造方法")
        
    # 设置父类的set get 方法 通过set 方法可以设置属性的值
    # 通过get 方法可以获取属性的值
    
    def setAttr(self,attr):
        Parent.parentAttr = attr;
    
    def getAttr(self):
        print("父类属性:",Parent.parentAttr)


# 定义子类

class Child(Parent):
    def __init__(self):
        print("调用子类的构造方法")
        
    def childMethod(self):
        print("调用子类方法")
        
c = Child()  # 实例化一个子类对象
c.childMethod()  # 调用子类的方法

c.parentMethod() # 调用父类的方法

c.setAttr(200)
c.getAttr()

"""
    方法重写
    如果你的父类方法的功能不能满足你的需求，
    你可以在子类重写你父类的方法：

    实例：
"""

class Parent1:        # 定义父类
   def myMethod(self):
      print("'调用父类方法'")
 
class Child1(Parent1): # 定义子类
   def myMethod(self):
      print (",我是你爸爸调用子类方法")
 
c = Child1()          # 子类实例
c.myMethod()         # 子类调用重写方法

'''
类属性与方法
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，
不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，
类方法必须包含参数 self,且为第一个参数

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，
不能在类的外部调用。在类的内部调用 self.__private_methods
'''

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
# print counter.__secretCount  # 报错，实例不能访问私有变量

print(counter._JustCounter__secretCount)

"""
单下划线、双下划线、头尾双下划线说明：
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
"""