类的成员,组合

时间 2019-12-12

标签成员组合繁體版

原文原文链接

一.成员

　　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()

有必要写实例方法python

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)

建立三个学校