面向对象之类的成员

类的成员

　　

class A:
    company_name='静态变量'  # 静态变量(静态字段)
    __iphone='1235412'        # 私有静态变量
​
    def __init__(self,name,age):    # 双下方法
        self.name=name  # 对象属性
        self.__age=age  # 私有对象属性
​
    def func(self):  # 普通方法
        pass
​
    def __func(self): # 私有方法
        print(666)
​
    @classmethod  # 类方法
    def class_func(cls):
        """定义类方法，至少有一个cls参数"""
        print('类方法')
​
    @staticmethod  # 静态方法
    def static_func():
        print('静态方法')
​
    @property  # 属性
    def prop(self):
        pass

　　对于类的共有静态属性，类的外部，类的内部，派生类都可以访问到

　　类的私有静态属性

 

　　

class B:
    school_name='共有静态属性'
    __consc_edu='私有静态属性'

class A(B):
    class_name='python'
    __girlnum='一个'

    def func(self):
        print(self.__girlnum)
        # print(self.__consc_edu)


obj=A()
# 私有静态属性类的外部不可以访问
# print(obj.__girlnum)
# 私有静态属性类的内部可以访问
obj.func()
# 私有静态属性派生类不可以访问

 

 

　　对象的私有静态属性

　　　如果想设定一些私有的或者是不行让类外面用到，密码加密等设置私有成员

　　　

class B:
    school_name='共有静态属性'
    __consc_edu='私有静态属性'
​
    def __init__(self, weight):
        self.__weight = weight
​
class A(B):
    class_name='python'
    __girlnum='一个'
​
    def __init__(self,name,age,weight):
        super().__init__(weight)
        self.name=name
        self.__age=age
​
    def func(self):
        print(self.__age)     # 类的内部可以使用
        print(self.__weight)  # 派生类中也可以访问
​
obj=A('如花',18,180)
print(obj.__age) # 类的外部不能访问
obj.func()

　　扩展：

　　　　　私有成员除了在类的内部，当真访问不到了吗

 

　　　　

class A:
    __girlnum='1个'

print(A.__dict__)

# python中所有的私有成员：就是在私有成员的前面加上_类名而已
print(A._A__girlnum)

 

　　　　总结： 对于这些私有成员来说，他们只能在类的内部使用，不能在类的外部，及派生类中使用

　　类的其他成员：

　　　　这里的其他成员主要就是类方法，静态方法，普通方法三种方法在内存中都归属于类，区别在于调用的方式不同

　　　　　实例方法

　　　　　　定义：一个参数必须是实例对象，该参数名一般约定为self，通过他来传递属性和方法 调用必须是实例对象调用

　　　 类方法：

　　　　类方法：用类名直接调用的方法，他会自动的将类名传递给cls

　　　　定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法); 调用：实例对象和类对象都可以调用。

　　　　

class A:
    num = 1
​
    def func(self):
        print('实例方法')
​
    @classmethod  #
    def a_fun(cls):
        print(cls)
        print('这是类方法')
​
​
obj = A()
A.func(obj)
print(A)
A.a_fun()
obj.a_fun()  # 对象也调用类方法，但是也会自动的将其从属的类名传给self

　　　静态方法

　　　　　　静态方法：不依赖与类，也依赖于对象，，他就是一个普通的函数放置于类中,使结构更加清晰与合理 静态方法与类相关，但是不用类里面的属性和方法

定义一个学生类Student，没实例化一个，实现自加1，统计学生数量

　　　　

class Student:
    num = 0
​
    def __init__(self, name):
        self.name = name
        self.count()
​
    @classmethod
    def count(cls):
        cls.num += 1
​
    @classmethod
    def get_num(cls):
        return cls.num
​
m1=Student('妹子1')
m2=Student('妹子1')
m3=Student('妹子1')
sq1=Student('妹子1')
sq3=Student('妹子1')
sq2=Student('妹子1')
print(Student.get_num())
class A:
    def func(self):
        print(111)
    @classmethod
    def a_func(cls):
        print('这是类方法')
    @staticmethod
    def static_func():
        print('这是静态方法')
​
​
obj=A()
obj.static_func()
A.static_func()  # 对象和类名都可以调用

　　　属性

　　　　　将一个类方法伪装成一个属性

　　　　   为什么要用property

　　　　   将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

　　　　   由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

　　　　

bmi值测试人体体脂：
class Bmi:
    def __init__(self,weight,height):
        self.weight=weight
        self.height=height
​
    def bmi(self):
        return self.weight/self.height**2
​
tb=Bmi(60,1.7)
print(tb.bmi())
​
我们要让bmi方法伪装成属性，虽然在代码级别没有提升，但看起来更加合理
​
class Bmi:
    def __init__(self,weight,height):
        self.weight=weight
        self.height=height
​
    @property  # 调用得时候不按照方法的调用规则，按照属性的调用规则，不需要加括号
    def bmi(self):
        return self.weight/self.height**2
​
tb=Bmi(60,1.7)
print(tb.bmi)
class Foo:
    def __init__(self,name):
        self.name=name
​
    @property  # 调用得时候不按照方法的调用规则，按照属性的调用规则，不需要加括号
    def aaa(self):
        print('get的时候调用我')
​
    @aaa.setter
    def aaa(self,v):
        print('修改的时候调用我')
​
    @aaa.deleter
    def aaa(self):
        print('删除的时候执行我')
​
obj=Foo('alex')
print(obj.name)
obj.aaa='dsb'
del obj.aaa
print(obj.name)
obj.aaa
​
设置属性的另外一种属性：
​
class Foo:
​
    def get_AAA(self):
        print('get的时候运行我啊')
​
    def set_AAA(self,value):
        print('set的时候运行我啊')
​
    def delete_AAA(self):
        print('delete的时候运行我啊')
​
    bbb = property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应
​
f1=Foo()
f1.bbb
f1.bbb='aaa'
del f1.bbb

其他方法

　　isinstance(obj,N): 判断 obj对象 是由N类(N的派生类)实例化出来的对象，是返回True

　　对象与类之间的关系

　　

class A:
    pass
​
class B(A):
    pass
​
class C(B):
    pass
​
obj=B()
print(isinstance(obj,B))    # True
print(isinstance(obj,A))    # True
print(isinstance(obj,C))    # False

　　issubclass(M,N) 判断是M类是N类的子孙.

　　类与类之间的关系　　　　

　　

class A:
    pass
​
class B(A):
    pass
​
class C(B):
    pass
    
print(issubclass(C, B))
print(issubclass(C, A))
​

　　type

　　　　type 到底是什么 type 元类 python中一切皆对象，一个趔也是一个对象 那么这个类对象肯定是由类实例化出来的 python中你创建的所有的类，以及大部分list str等等这些类，都是从type元类实例化出来的 object 也是有type元类实例化出来的

　　 　　

from collections import Iterable
from collections import Iterator
​
s1='hjdfhad'
​
l1=[45,65,8,9]
​
print(type(s1))  # 判断的是对象从属那个类
print(type(l1))
​
print('__iter__' is dir(s1))
print(isinstance(s1,Iterable))