Python入门记录六

目录

仅为入门记录！

#面向对象：Object Oriented

#组合：把多个没有纵向关系(继承关系)的类加入到一个类中(横向关系)

#类，类对象和实例对象：三个不同的概念

#类属性和实例属性

#类的静态方法和抽象方法

#一些相关的BIF

---

---

仅为入门记录！

#--------------------------------------------------------------------

#面向对象：Object Oriented

#封装：对外部隐藏对象的工作细节
#继承：子类自动共享父类之间的数据和方法
#多态：可以对不同类的对象调用相同的方法，产生不同的结果
#Python的类名约定用大写字母开头
'''
class Person:
    #python的成员方法不用定义也可以使用
    def __init__(self, name):
        self.name = name
    
    def setName(self, name):
        self.name = name
    
    #self 相当于this指针
    def getName(self):
        return self.name
'''
#构造函数：__init__(self[,])，默认为无参构造
#共有和私有
#定义时在变量名前加__(两个下划线)，变为私有，和private一样，私有只能在本类中使用
'''
class Person:
    __name = 'python'

    def getName(self):
        return self.__name

p = Person()
print(p.__name)#打印不出来
print(p.getName())#打印出来
'''
#实际可以通过p._Person__name来访问，所以python为伪私有！！
#继承
#--class DerivedClassName(BaseClassName):
#--在子类继承父类的同时，可以重新定义某些属性，并重新某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。另外，为子类追加新的属性和方法也是常见的作法。
#--如果默认构造被子类覆盖，则在子类默认构造函数中要加入
#--1：ClassFather.__init__(self)或者
#--2：super().__init__()：使用super()函数
'''
class Person:
    def __init__(self):
        self.name = 'python'
        self.no = 666

class Student(Person):
    def __init__(self):
        super().__init__()
        print(self.name,self.no)
'''
#super函数的'超级'地方：
#--super函数会自动帮你找出所有基类以及对应的方法。由于你不用给出基类的名字，这就意味着
#--你如果需要改变了类继承关系，你只要改变class语句中的父类即可，而不必在大量代码中去修改所有被继承的地方
#如果没有super().__init__()，会报错，因为子类的构造函数覆盖了父类的，父类的构造函数没有实现，便没有name，no两个变量，所以报错！
#python还允许多继承，java单继承多接口
#--class DerivedClassName(BaseClassName,BaseClassName2,...):
#--------------------------------------------------------------------

#组合：把多个没有纵向关系(继承关系)的类加入到一个类中(横向关系)

'''
class Bird:
    def __init__(self, x):
        self.x = x

class Pigeon:
    def __init__(self, x):
        self.x = x

class Sky:
    def __init__(self, x, y):
        self.bird = x
        self.pigeon = y

    def print_num(self):
        print('共有小鸟%d只，鸽子多少%d只' % (self.bird, self.pigeon))
'''
#--------------------------------------------------------------------

#类，类对象和实例对象：三个不同的概念

'''
class A:
    cnt = 1

a = A()
b = A()
c = A()#A成为类对象，a、b、c称为实例对象
a.cnt += 10
print(a.cnt) -> 11
print(b.cnt) -> 1：c也一样
#现在改变类对象A的cnt
A.cnt += 100
print(a.cnt) -> 11
print(b.cnt) -> 101
print(b.cnt) -> 101
'''
#上面是为什么呢？
#第一个就是因为实例对象a的成员变量改变了，而其他两个没有改变
#第二个是因为a.cnt += 10的操作，在a的类中重新生成了一个变量cnt覆盖了之前的cnt变量
#所有当类对象的cnt改变时，a的cnt是重新生成的，要改变的已经被覆盖了(python会自动释放其空间)，所有a.cnt没有改变
#以上例子：
#类定义        A
#类对象        A
#实例对象    a b c
#在类定义结束后，类定义就变为了类对象

#类的静态方法：在普通方法前加上@staticmethod即可
'''
class Test:
    @staticmethod:
    def static(): #不用要self参数
        pass
    def nostatic(self):
        pass
#静态方法的最大优点就是：不会绑定到实例对象上，换而言之就是节省开销
t1 = Test()
t2 = Test()
#静态方法在内存中之生成一个，节省开销
print(t1.static) -> <function D.static at 0x000001D01EB1A400>
print(t2.static) -> <function D.static at 0x000001D01EB1A400>
#非静态每个实例对象都有一个
print(t1.nostatic) -> <bound method D.nostatic of <__main__.D object at 0x000001D01EAF0DA0>>
print(t2.nostatic) -> <bound method D.nostatic of <__main__.D object at 0x000001D01EAF05C0>>

'''

#------------------------------------------------------------------

#类属性和实例属性

#1：实例属性：
#--在__init__(self,…)中初始化
#--内部调用时都需要加上self.
#--外部调用时用实例化对象.属性名
#2:类属性：

#--为静态属性
#--在__init__()外初始化
#--在内部用类名.类属性名调用
#--外部既可以用类名.类属性名又可以用实例化对象.类属性名来调用
#--大多情况下应该考虑使用实例变量(类变量通常仅用来跟踪与类相关的值)
#--类对象和实例对象对同一个类属性有相同的地址
'''
class Test:
    list1 = []

a = Test()
a.list1.append(1)
print(a.list1) -> [1]
print(Test.list1) -> [1]
'''
#什么是绑定
'''
class BB:
    def printBB():
        print('no no!')

bb = BB()
bb.printBB()

#错误，python严格要求方法需要有实例才能够被调用，这种限制其实就是python所谓的绑定概念。
#所有python会自动把bb对象作为第一个参数传入！！
'''
#--类中的变量为静态变量，相当于static，只要程序结束才会被释放
#例：
'''
class A:
    def __init__(self, x):
        self.x = x

    def print(self):
        print(self.x)

a = A(1)
del A
a.print() -> 1
'''
#因为实例对象内的变量为静态变量，尽管类对象被释放，但是实例属性依然完好无损，存在内存中

#--------------------------------------------------------------------

#类的静态方法和抽象方法

#类的静态方法：在普通方法前加上@staticmethod即可
'''
class Test:
    @staticmethod:
    def static(): #不用要self参数
        pass
    def nostatic(self):
        pass
#静态方法的最大优点就是：不会绑定到实例对象上，换而言之就是节省开销
t1 = Test()
t2 = Test()
#静态方法在内存中之生成一个，节省开销
print(t1.static) -> <function D.static at 0x000001D01EB1A400>
print(t2.static) -> <function D.static at 0x000001D01EB1A400>
#非静态每个实例对象都有一个
print(t1.nostatic) -> <bound method D.nostatic of <__main__.D object at 0x000001D01EAF0DA0>>
print(t2.nostatic) -> <bound method D.nostatic of <__main__.D object at 0x000001D01EAF05C0>>
'''
#类的抽象方法
# 抽象方法在一个基类中定义，但是可能不会有任何的实现。在 Java 中，这被描述为一个接口的方法。
#1：最简单的抽象方法：
'''
class Pizza(object):
    def get(self):
        raise NotImplenmentedError
'''
#任何继承自 Pizza 的类将实现和重载 get_radius 方法，否则会出现异常。这种独特的实现抽象方法的方式也有其缺点。如果你写一个继承自 Pizza 的类，忘记实现 get_radius，错误将会在你使用这个方法的时候才会出现。
#2：使用abc模板
'''
import abc
class SuperClass(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def get(self):
        pass  
#使用 abc 和它的特类，一旦你试着实例化 BasePizza 或者其他继承自它的类，就会得到 TypeError：

clas SubClass(SuperClass):
    pass

sub = SubClass()

异常：TypeError: Can't instantiate abstract class SubClass with abstract methods display
'''
#--------------------------------------------------------------------

#一些相关的BIF

#--issubclass(class, classinfo)：判断父子类关系 classinfo可以是类对象组成的元组，只要class与其中热河一个候选类的子类，则返回true
#--isintance(object, classinfo)：检查一个实例对象是否属于一个类，如果第一个不是object类型的话，永远返回false，同样第二个参数也可以是元组
#--hasattr(object, name)：检查一个对象中是否有某个属性(name)，第二个参数为字符串类型
#--注意实例对象可以拥有类属性，而类对象不拥有实例属性
'''
class A:
    count = 0
    def __init__(self):
        self.cnt = 0
    def show(self):
        print(self.cnt)

hasattr(A, show),(A, count),(a, count),(a, cnt)为true
hasattr(A, cnt)为false
'''
#--getattr(object, name[, default])：返回属性指定的属性值。
#--第三个有可选参数，当无此参数时，如对象内没有该属性，会抛出异常，否则返回第三个参数指定的内容
#--setattr(object, name, value)：设置对象中指定属性的值，如果指定属性不存在，则会创建该属性
#如类对象设定则为类属性，都可以访问，实例对象设定为实例对象，类对象无法调用。
#--delattr(object, name)：删除类对象中的属性，如不存在则引出异常。
#归属问题：实例对象无法删除类属性，类对象无法删除实例属性
#--property(fget=None, fset=None, fdel=None, doc=None)：通过属性来设置属性
#--参数均为方法：第一个获得属性，第二个设置属性，第三个为删除属性
'''
class A:
    def __init__(self, size = 0):
        self.size = size
    def getSize(self):
        return self.size
    def setSize(self, size):
        self.size = size
    def delSize(self):
        del self.size

    x = property(getSize, setSize, delSize)

a = A()
a.x -> 0 #获得属性
a.x = 5  #设置属性
ax. -> 5
del a.x  #删除size属性
'''