类的成员,组合-CSDN博客

一.成员

　　1.变量

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

      　　私有实例变量(字段)

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

      　　私有类变量(静态字段)

 1 class Foo:
 2 
 3     country='中国'  #
 4     # 类变量,静态字段(以下的方法都可以调用公共的变量可以拿出来放到类变量中)
 5 
 6     # 方法
 7     def __ini__(self,name):
 8         self.name=name
 9         # 实例变量,对象变量,字段
10 
11     # 方法
12     def fnc(self):
13         pass
14 
15 obj=Foo('lisa')
16 # Foo类的对象
17 # 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)

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

 1 class Foo:
 2 
 3     country='中国'
 4 
 5     def __init__(self,name):
 6         self.name=name
 7 
 8     def func(self):
 9         pass
10 
11 obj1=Foo('lisa')
12 obj2=Foo('sushan')
13 
14 可以通过类名访问类变量,也可以通过类的对象访问 
15 obj1.country='美国'   #此时只有obj1里的country改成了美国
16 Foo.country='美国'   #此时Foo里的所有country改成了美国
17 
18 print(obj1.country)
19 print(obj2.country)

类变量,静态字段的改变

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

 1 class Foo:
 2 
 3     country='中国'
 4 
 5     def __init__(self,name):
 6         self.name=name
 7 
 8     def func(self):
 9         pass
10 obj1=Foo('lisa')
11 obj2=Foo('sushan')
12 
13 练习一:
14 obj1.name='amy'
15 print(obj1.name)  #amy
16 print(obj2.name)  #sushan
17 
18 练习二:
19 obj1.country='美国'
20 print(obj1.country)  #美国
21 print(obj2.country)  #中国
22 
23 练习三:
24 Foo.country='美国'
25 print(obj1.country)  #美国
26 print(obj2.country)  ##美国

易错点:

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

字段成员修饰符:

 1 class Foo:
 2     def __init__(self,name):
 3         self.name=name
 4         self.age=123
 5         #此时的self.name,self.age是共有的,内部能调用,外部也能调用
 6 
 7     def func(self):
 8         print(self.name)  #内部能调用
 9 
10 obj=Foo('lisa')
11 print(obj.name)  #外部也能调用
12 print(obj.age)
13 obj.func()

实例变量(字段)公有

 1 class Foo:
 2 #     def __init__(self,name):
 3 #         #私有的实例变量
 4 #         self.__name=name
 5 #         self.age=123
 6 #
 7 #     def func(self):
 8 #         print(self.__name) #内部可以调用
 9 #
10 # obj=Foo('Lisa')
11 # print(obj.age)
12 # print(obj.__name)  # 'Foo' object has no attribute '__name'  Foo里没有这个属性 外部不能调用
13 # obj.func()  #间接访问

实例变量(字段)私有

 1 公有:
 2 class Foo:
 3     country='中国'
 4     def __init__(self):
 5         pass
 6 
 7     def func(self):
 8         print(self.country)  #内部调用
 9         print(Foo.country)
10 
11 obj=Foo()
12 print(obj.country)  #外部调用
13 obj.func()

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

 1 class Foo:
 2     __country='中国'
 3     def __init__(self):
 4         pass
 5 
 6     def func(self):
 7         print(self.__country)  #内部可以执行
 8 
 9 obj=Foo()
10 print(obj.__country)   #外部无法调用私有变量
11 obj.func()

类变量(静态字段)私有:

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

特殊情况:

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

 1 class Base(object):
 2     __secret='受贿'
 3     def __init__(self):
 4 
 5 class Foo(Base):
 6     def func(self):
 7         print(self.__secret)   #找不到
 8         print(Foo.__secret)
 9 
10 print(Foo.__secret)  #找不到
11 
12 
13 class Base(object):
14     __secret='受贿'
15     def zt(self):
16         print('Base.__secret')
17 
18 class Foo(Base):
19     def func(self):
20         print(self.__secret)
21         print(Foo.__secret)
22 
23 obj=Foo()
24 obj.zt()  #子类访问父类的函数是可以访问的

思考题:如何验证子类都不知道私有字段的存在

2.方法:

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

1 class Foo(object):
2     def __init__(self,name):
3         self.name=name
4 
5     def func(self):
6         print('实例方法')
7 obj=Foo()
8 obj.func()

有必要写实例方法

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

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

obj = Foo()
obj.func()

静态方法

 1 class Foo():
 2     def __init__(self, name):
 3         self.name = name
 4 
 5     @staticmethod   #静态方法  :如果方法中不用对象中的封装的值,就可以用静态方法
 6     def func():   #不用写self
 7         print('222')
 8 
 9 obj = Foo('更好')
10 obj.func()
11 Foo.func()

静态方法

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

 1 class Foo():
 2     def __init__(self, name):
 3         self.name = name
 4 
 5     @staticmethod
 6     def func():
 7         print('222')
 8     # 类方法(用当前类的时候就用类方法)
 9     @classmethod
10     def show(cls,x1,x2):  #cls,自动传递当前类
11         print(cls,x1,x2)

类方法

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

View Code

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

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

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

1 class Foo:
2     def __init__(self):
3         pass
4     def __display(self):
5         print('666')
6     def func(self):
7         self.__display()
8 obj=Foo()
9 obj.func()

私有成员无法再外部直接访问,但是可以在外部间接访问(私有的实例方法)

 1 class Foo:
 2     def __init__(self):
 3         pass
 4     @staticmethod
 5     def __display():
 6         print('666')
 7     def func(self):
 8         Foo.__display()
 9 obj=Foo()
10 obj.func()

私有成员无法再外部直接访问,但是可以在外部间接访问(私有的静态方法)

 1 class Foo:
 2     def __init__(self):
 3         pass
 4     @classmethod
 5     def __display(cls):
 6         print('666')
 7     def func(self):
 8         Foo.__display()
 9 obj=Foo()
10 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
  属性也有公有私有之分,与上面相同

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

练习题(翻页)从前

 1 class Pagenation():
 2     def __init__(self,num_list,page,per_page_num=10):
 3         '''
 4         初始化
 5         :param num_list: 所有的数据
 6         :param page: 要看的页数
 7         :param per_page_num: 每页有几个
 8         '''
 9         self.num_list=num_list
10         self.page=page
11         self.per_page_num=per_page_num
12     @property
13     def start(self):
14         '''
15         每页的开始
16         :return:
17         '''
18         return (page-1)*self.per_page_num
19 
20     @property
21     def end(self):
22         '''
23         每页的结束
24         :return:
25         '''
26         return page*10
27     def show(self):
28         '''
29         主函数
30         :return:
31         '''
32         result=self.num_list[self.start:self.end]
33         for el in result:
34             print(el)
35 
36 num_list=[]
37 for i in range(0,901):
38     res='num-%s' % i
39     num_list.append(res)
40 
41 page=int(input('请输入要查看的页码:'))
42 
43 obj=Pagenation(num_list,page)
44 obj.show()

练习题(翻页)现在

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

 1 class ch:
 2     def __init__(self,name,address):
 3         self.name=name
 4         self.address=address
 5     def speech(self):
 6         pass
 7 obj1=ch('北京','沙河')
 8 obj2=ch('上海','浦东')
 9 obj3=ch('深圳','南山')
10 class Teacher:
11     def __init__(self,name,age,salary):
12         self.name=name
13         self.age=age
14         self.salary=salary
15         self.school=None
16 obj4=Teacher('王华','25','10000')
17 obj5=Teacher('刘敏','26','12000')
18 obj6=Teacher('李青','27','14000')
19 
20 obj4.school=obj1
21 obj5.school=obj2
22 obj6.school=obj1
23 
24 print(obj4.school.name)
25 print(obj5.school.name)
26 print(obj6.school.name)