day20

回顾

类的三大特性

封装、继承、多态

1.类成员

类

类变量

绑定方法

类方法

静态方法

属性

实例（对象）

实例变量

1.1 实例变量

1.2 类变量

1.2.1 定义

写在类的下一级，与方法同一级。

1.2.2 访问

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

1.2.3 面试题

class Base:
    x = 1
    
obj = Base()
​
​
print(obj.x) # 先去对象中找，没有再去类中找。
obj.y = 123  # 在对象中添加了一个y=123的变量。
print(obj.y) # 123
obj.x = 123
print(obj.x)  # 123
print(Base.x) # 1

class Parent:
    x = 1
    
class Child1(Parent):
    pass
​
class Child2(Parent):
    pass
​
print(Parent.x,Child1.x,Child2.x) # 1 1 1
Child1.x = 2
print(Parent.x,Child1.x,Child2.x) # 1 2 1
Child2.x = 3
print(Parent.x,Child1.x,Child2.x) # 1 2 3

1.2.4 总结

总结：找变量优先找自己，自己没有找 类 或 基类；修改或赋值只能在自己的内部设置。

1.3 方法（绑定方法/普通方法）

1.3.1 定义

至少有一个self参数

1.3.2 执行

先创建对象，再由对象.方法()

class Foo:
    def func(self,a,b):
        print(a,b)
        
obj = Foo()
obj.func(1,2)   # 浪费资源 此处并未调用self
# ###########################
class Foo:
    def __init__(self):
        self.name = 123
​
    def func(self, a, b):
        print(self.name, a, b)
​
obj = Foo()
obj.func(1, 2) # 123 1 2

1.4 静态方法

1.4.1 定义

@staticmethod装饰器

参数无限制

1.4.2 执行

类.静态方法名()

对象.静态方法名()

class Foo:
    def __init__(self):
        self.name = 123
​
    def func(self, a, b):
        print(self.name, a, b)
​
    @staticmethod
    def f1():
        print(123)
​
obj = Foo()
obj.func(1, 2) # 123 1 2
​
Foo.f1() # 123
obj.f1() # 123 不推荐

1.5 类方法

1.5.1 定义

@classmethod装饰器

至少有cls参数，当前类

1.5.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) # 123 1 2
​
Foo.f1() # 123
Foo.f2(1,2) # Foo 1 2

1.5.3 面试题

# 问题： @classmethod和@staticmethod的区别？
"""
一个是类方法一个静态方法。 
定义：
    类方法：用@classmethod做装饰器且至少有一个cls参数。
    静态方法：用staticmethod做装饰器且参数无限制。
调用：
    类.方法直接调用。
    对象.方法也可以调用。 
"""

1.6 属性

1.6.1 定义

@property装饰器

只有一个self参数

1.6.2 执行

对象.方法 无需添加括号

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

# 属性的应用
​
class Page:
    def __init__(self, total_count, current_page, per_page_count=10):
        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 * self.per_page_count
​
​
USER_LIST = []
for i in range(321):
    USER_LIST.append('alex-%s' % (i,))
​
# 请实现分页展示：
current_page = int(input('请输入要查看的页码：'))
p = Page(321, current_page)
data_list = USER_LIST[p.start_index:p.end_index]
for item in data_list:
    print(item)

2.成员修饰符

1.公有 所有地方都能访问到

2.私有 只有自己可以访问到

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() # 可以通过类内部另外的方法调取

3.强制访问私有成员

# 强制访问私有成员
​
class Foo:
    def __init__(self,name):
        self.__x = name
​
​
obj = Foo('alex')
​
print(obj._Foo__x) # 强制访问私有实例变量

3.补充 类的嵌套

class Foo:
    def __init__(self,num):
        self.num = num
        
        
cls_list = []
for i in range(10):
    cls_list.append(Foo) # [Foo,Foo,Foo,Foo,Foo,Foo,Foo,Foo,Foo,Foo]
    
for i in range(len(cls_list)):
    obj = cls_list[i](i) # [Foo(0),Foo(1),Foo(2),Foo(3),Foo(4),Foo(5),Foo(6),Foo(7),Foo(8),Foo(9)]
    print(obj.num) #  0 1 2 3 4 5 6 7 8 9

class Foo:
    def __init__(self,num):
        self.num = num
        
B = Foo # 别名
obj = B('alex')  # alex

class Foo:
    def f1(self):
        print('f1')
    
    def f2(self):
        print('f2')
​
obj = Foo()
​
v = [ obj.f1,obj.f2 ]
for item in v:
    item() # f1 f2

class Foo:
    def f1(self):
        print('f1')
    
    def f2(self):
        print('f2')
        
    def f3(self):
        v = [self.f1 , self.f2 ]
        for item in v:
            item()
            
obj = Foo()
obj.f3() # f1 f2

class Account:
    
    def login(self):
        pass
    
    def register(self):
        pass
    
    def run(self):
        info = {'1':self.register, '2':self.login }
        choice = input('请选择:')
        method = info.get(choice)
        method()

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

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']