类的成员,组合

一.成员

　　1.变量

  　　实例变量(字段)
      　　公有实例变量(字段)

      　　私有实例变量(字段)

 　　 类变量(静态字段)
      　　公有类变量(静态字段)

      　　私有类变量(静态字段)

class Foo:

    country='中国'  #
    # 类变量,静态字段(以下的方法都可以调用公共的变量可以拿出来放到类变量中)

    # 方法
    def __ini__(self,name):
        self.name=name
        # 实例变量,对象变量,字段

    # 方法
    def fnc(self):
        pass

obj=Foo('lisa')
# Foo类的对象
# Foo类的实例

class Foo:

    country='中国'
    # 类变量,静态字段(以下的方法都可以调用公共的变量可以拿出来放到类变量中)

    # 方法
    def __init__(self,name):
        self.name=name
        # 实例变量,对象变量,字段

    # 方法
    def func(self):
        pass

obj1=Foo('lisa')
obj2=Foo('sushan')
print(obj1.country)
print(obj2.country)

class Foo:

    country='中国'

    def __init__(self,name):
        self.name=name

    def func(self):
        pass

obj1=Foo('lisa')
obj2=Foo('sushan')

可以通过类名访问类变量,也可以通过类的对象访问 
obj1.country='美国'   #此时只有obj1里的country改成了美国
Foo.country='美国'   #此时Foo里的所有country改成了美国

print(obj1.country)
print(obj2.country)

准则:
　　实例变量(字段)访问时,使用对象访问,即:obj.name
　　类变量(静态字段)访问时,使用类方法,即:Foo.country(实在不方便时,采用对象)

class Foo:

    country='中国'

    def __init__(self,name):
        self.name=name

    def func(self):
        pass
obj1=Foo('lisa')
obj2=Foo('sushan')

练习一:
obj1.name='amy'
print(obj1.name)  #amy
print(obj2.name)  #sushan

练习二:
obj1.country='美国'
print(obj1.country)  #美国
print(obj2.country)  #中国

练习三:
Foo.country='美国'
print(obj1.country)  #美国
print(obj2.country)  ##美国

什么时候用类变量
　　所有对象中有共同的字段且要改都改要删都删时,将实例变量提取成静态字段

字段成员修饰符:

class Foo:
    def __init__(self,name):
        self.name=name
        self.age=123
        #此时的self.name,self.age是共有的,内部能调用,外部也能调用

    def func(self):
        print(self.name)  #内部能调用

obj=Foo('lisa')
print(obj.name)  #外部也能调用
print(obj.age)
obj.func()

class Foo:
#     def __init__(self,name):
#         #私有的实例变量
#         self.__name=name
#         self.age=123
#
#     def func(self):
#         print(self.__name) #内部可以调用
#
# obj=Foo('Lisa')
# print(obj.age)
# print(obj.__name)  # 'Foo' object has no attribute '__name'  Foo里没有这个属性 外部不能调用
# obj.func()  #间接访问

公有:
class Foo:
    country='中国'
    def __init__(self):
        pass

    def func(self):
        print(self.country)  #内部调用
        print(Foo.country)

obj=Foo()
print(obj.country)  #外部调用
obj.func()

class Foo:
    __country='中国'
    def __init__(self):
        pass

    def func(self):
        print(self.__country)  #内部可以执行

obj=Foo()
print(obj.__country)   #外部无法调用私有变量
obj.func()

class Foo:
    def __init__(self,name):
        #私有的实例变量
        self.__name=name
obj=Foo('Lisa')
print(obj._Foo__name)  #硬上也可以出来 但是不建议

python 中创建一个类,将自动继承object,可以帮助我们开辟内存

class Base(object):
    __secret='受贿'
    def __init__(self):

class Foo(Base):
    def func(self):
        print(self.__secret)   #找不到
        print(Foo.__secret)

print(Foo.__secret)  #找不到


class Base(object):
    __secret='受贿'
    def zt(self):
        print('Base.__secret')

class Foo(Base):
    def func(self):
        print(self.__secret)
        print(Foo.__secret)

obj=Foo()
obj.zt()  #子类访问父类的函数是可以访问的

2.方法:

  实例方法
  静态方法
  类方法
没必要写实例化方法,可以用静态方法

class Foo(object):
    def __init__(self,name):
        self.name=name

    def func(self):
        print('实例方法')
obj=Foo()
obj.func()

有必要写实例方法

class Foo(object):
    def __init__(self, name):
        self.name = name

    def func(self):
        print(self.name)

obj = Foo()
obj.func()

静态方法

class Foo():
    def __init__(self, name):
        self.name = name

    @staticmethod   #静态方法  :如果方法中不用对象中的封装的值,就可以用静态方法
    def func():   #不用写self
        print('222')

obj = Foo('更好')
obj.func()
Foo.func()

静态方法可以通过类调用,也可以通过对象调用 但是推荐使用类调用
总结:
  1.编写时
    编写是方法上方写@staticmethod
    方法参数可有可无
  2.调用时
      类.方法名()   推荐
      对象.方法名()

class Foo():
    def __init__(self, name):
        self.name = name

    @staticmethod
    def func():
        print('222')
    # 类方法(用当前类的时候就用类方法)
    @classmethod
    def show(cls,x1,x2):  #cls,自动传递当前类
        print(cls,x1,x2)

执行类方法
Foo.show(1,8)  #<class '__main__.Foo'> 1 8

总结:
    1.定义时
        在方法上方写:@classmethod
        参数:至少有一个cls参数
    2.执行时
        类名.方法名()   默认会将当前类传到参数中
    3.什么时候用
        如果在方法中会使用到当前类,就可以使用(看代码的时候用,原码)

静态方法/类方法和实例方法的区别
　　方法中没有用到封装的对象中的内容时,就可以用静态方法或类方法,否则用实例方法
　　静态方法或类方法的选择,方法中用到了当前类就用类方法
　　定义时:静态方法上要写@staticmethod;类方法上要写@classmethod
　　执行时:前者是类名.方法名 后者是对象.方法名

★以上方法想要变成私有的前面要加上下划线

class Foo:
    def __init__(self):
        pass
    def __display(self):
        print('666')
    def func(self):
        self.__display()
obj=Foo()
obj.func()

class Foo:
    def __init__(self):
        pass
    @staticmethod
    def __display():
        print('666')
    def func(self):
        Foo.__display()
obj=Foo()
obj.func()

class Foo:
    def __init__(self):
        pass
    @classmethod
    def __display(cls):
        print('666')
    def func(self):
        Foo.__display()
obj=Foo()
obj.func()

3.属性(通过方法改造出来的)

class Foo:
    def __init__(self):
        pass
    @property  #在方法上加上property
    def start(self):  #括号里不可以加其他参数
        return 1
    @property
    def end(self):
        return 10
obj=Foo()
print(obj.start)  #调用的时候不加括号
print(obj.end)

总结:
  1.编写时
      方法的上方写property
      方法的参数只有一个self
  2.调用时:不用加括号   对象.方法
  3.对于简单的方法,无序传参且有返回值时可以使用@property
  属性也有公有私有之分,与上面相同

while 1:
    data_list=[]
    for i in range(1,901):
        data_list.append('num_%s' % i)
    page=int(input('请输入要查看的页码'))
    # per_page_num=10
    start=(page-1)*10
    end=page*10
    num_list=data_list[start:end]
    for item in num_list:
        print(item)

class Pagenation():
    def __init__(self,num_list,page,per_page_num=10):
        '''
        初始化
        :param num_list: 所有的数据
        :param page: 要看的页数
        :param per_page_num: 每页有几个
        '''
        self.num_list=num_list
        self.page=page
        self.per_page_num=per_page_num
    @property
    def start(self):
        '''
        每页的开始
        :return:
        '''
        return (page-1)*self.per_page_num

    @property
    def end(self):
        '''
        每页的结束
        :return:
        '''
        return page*10
    def show(self):
        '''
        主函数
        :return:
        '''
        result=self.num_list[self.start:self.end]
        for el in result:
            print(el)

num_list=[]
for i in range(0,901):
    res='num-%s' % i
    num_list.append(res)

page=int(input('请输入要查看的页码:'))

obj=Pagenation(num_list,page)
obj.show()

二.组合(嵌套)(建模)

class ch:
    def __init__(self,name,address):
        self.name=name
        self.address=address
    def speech(self):
        pass
obj1=ch('北京','沙河')
obj2=ch('上海','浦东')
obj3=ch('深圳','南山')
class Teacher:
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary
        self.school=None
obj4=Teacher('王华','25','10000')
obj5=Teacher('刘敏','26','12000')
obj6=Teacher('李青','27','14000')

obj4.school=obj1
obj5.school=obj2
obj6.school=obj1

print(obj4.school.name)
print(obj5.school.name)
print(obj6.school.name)