doraemon的python 类成员与对象成员

7.5 成员

7.5.1 对象成员

• 实例变量

class Abc:
    def __init__(self,name):
        self.name = name
       
obj = Abc(liujia)
?
#在对象中添加了一个变量name
        

7.5.2类成员

• 类变量

class Abc:
    name = ‘liujia‘
    def func(self):
        pass
    def bar(self):
        pass
#name就是类变量

定义：写在类的下一级和方法是同一级

访问、调用：

#类.类变量名称
#对象.类变量名称

总结：找变量有限找自己的，自己没有就找类或者基类；修改或者复制只能在自己的内部设置

• 绑定方法

定义：至少有一个self参数

执行：先创建对象，又对象.方法()

class FOO:
    def func(self,a,b):
        print(a,b)
        
obj = FOO()
obj.func(1,2)

• 类方法

定义：

1. @classmethon装饰器

2. 至少有cls参数，当前类

执行：

1. 类.类方法()

2. 对象.类方法()(不推荐)

class Foo:
    def __init__(self):
        self.name = 123
?
    def func(self, a, b):
        print(self.name, a, b)
?
    @staticmethod
    def f1():
        print(123)
?
    @classmethod
    def f2(cls,a,b):
        print(‘cls是当前类‘,cls)
        print(a,b)
?
obj = Foo()
obj.func(1, 2)
?
Foo.f1()
Foo.f2(1,2)

• 静态方法

定义：

1. @staticmethod装饰器

2. 参数没有限制，可以不传，也可以传多个

执行：

1. 类.静态方法名()

2. 对象.静态方法名()(不推荐)

class Foo:
    def __init__(self):
        self.name = 123
        
    def func(self):
        print(self.name,a,b)
        
    @staticmethod
    def f1():
        print(123)
        
obj = Foo()
obj.func()
FOO.f1()
#可以直接用类调用方法，也可以用对象调用方法

• 属性

定义：

1. @property装饰器

2. 只有一个self参数

执行：

对象.方法 不用加括号

class Foo:
    
    
    @property
    def func(self):
        print(123)
        return 999
    
obj = Foo()
result = obj.func
print(result)

#属性的应用
class Page:
    def __init__(self,total_count,current_page,per_page_count=10):
        self
        self.total_count = total_count
        self.per_page_count = per_page_count
        self.current_page = current_page
    @property   
    def start_index(self):
        return (self.current_page - 1)*self.per_page_count
    @property
    def end_index(self)
        return self.current_page*per_page_count
    
user_list = []
for i in range(250):
    user_list.append(‘alex-----%s‘ %(i,)) 
    
    
current_page = int(input(‘请输入想要查看的页码：‘))
p = Page(250,current_page)
data_list = user_list[p.start_index:p.end_index]
for item in data_list:
    print(item)

7.5.3 成员修饰符

• 公有，所有地方都能访问到

• 私有，自能自己访问,前面加__

class Foo:
    def __init__(self, name):
        self.__name = name
?
    def func(self):
        print(self.__name)
?
?
obj = Foo(‘alex‘)
# print(obj.__name)
obj.func()

class Foo:
    __x = 1
?
    @staticmethod
    def func():
        print(Foo.__x)
?
?
# print(Foo.__x)
Foo.func()

class Foo:
?
    def __fun(self):
        print(‘msg‘)
?
    def show(self):
        self.__fun()
?
obj = Foo()
# obj.__fun()
obj.show()

7.5.4 嵌套

class School(object):
    def __init__(self,title,addr):
        self.title = title
        self.address = addr
        
class ClassRoom(object):
    
    def __init__(self,name,school_object):
        self.name = name
        self.school = school_object
        
s1 = School(‘北京‘,‘沙河‘)
s2 = School(‘上海‘,‘浦东‘)
s3 = School(‘深圳‘,‘南山‘)
?
c1 = ClassRoom(‘全栈21期‘,s1)
c1.name
c1.school.title
c1.school.address
# ############################################
v = [11,22,33,{‘name‘:‘山海‘,‘addr‘:‘浦东‘}]
?
v[0]
v[3][‘name‘]

class Foo:
    def __init__(self,num):
        self.num = num
        
        
cls_list = []
for i in range(10):
    cls_list.append(Foo)
    
for i in range(len(cls_list)):
    obj = cls_list[i](i)
    print(obj.num)

class Foo:
    def f1(self):
        print(‘f1‘)
    
    def f2(self):
        print(‘f2‘)
?
obj = Foo()
?
v = [ obj.f1,obj.f2 ]
for item in v:
    item()
#当做参数传递

class Foo:
    pass
?
class Foo(object):
    pass
?
# 在python3中这俩的写法是一样，因为所有的类默认都会继承object类，全部都是新式类。
?
?
# 如果在python2中这样定义，则称其为：经典类
class Foo:
    pass 
# 如果在python2中这样定义，则称其为：新式类
class Foo(object):
    pass 
?
class Base(object):
    pass
class Bar(Base):
    pass

doraemon的python 类成员与对象成员

原文：https://www.cnblogs.com/doraemon548542/p/11255480.html