Python----类的方法

1、以单下划线开头的变量，是被隐藏的变量(_ab) 但这只是一种约定，并不会真正限制访问，是一个受保护的变量

class People:
    _ab = 15

    def test(self):
        print('单下划线变量')

p = People()
print(p._ab)

>>> 15

2、双下划线开头的变量,python都会自动的重命名为:__变量名----> _类名__变量名, 并不是真正的私有变量，外部仍可以

class People:
 
    __ab = 15


p = People()
print(p._People__ab)

>>> 15

3、双下划线开头的属性继承给子类时，子类无法覆盖（原理也是基于python自动做了双下划线开头重命名的工作）

class People:
    __a = 15

class Test(People):
    __a = 16


t = Test()
print(t._Test__a)
print(t._People__a)

>>> 16
>>> 15

4、当不加self等其他参数时只有类自己可以调用该方法，是绑定该类的方法

class People:
    def hit():
        print('2333')


People.hit()

>>> 2333

5、实例对象传参

class fine:
	def la():  # 如果没有self就是绑定的方法
		pass
	def __init__(self,name):
p1 = finie(name)   这个参数传给__init__函数

6、在子类中调用父类的方法：1、父类名.父类方法(需要加self)

class People:

    def see(self):
        print('father')


class Test(People):
    def see(self):
        People.see(self)

t = Test()
t.see()

>>> father

2、super().父类方法(不需要加self)

class People:

    def see(self):
        print('father')


class Test(People):
    def see(self):
        super().see()

t = Test()
t.see()

7、先打印函数属性，后打印数据属性

class People:
    ab = 'Jax'

    def see(self):
        print('2333')

    def msg(self):
        print('{}{}'.format(self.ab, self.see()))

p = People()
p.msg()

>>> 2333
    JaxNone

8、在类的方法前加上@property 装饰器，在调用该函数时不需要加括号，该函数以成为类的一个属性，静态属性，和实例绑定有self

class People:
    @property
    def see(self):
        return '2333'

p = People()
print(p.see)

>>> 2333

9、在类的方法前加上@classmethod 装饰器，表示是类方法。括号里面不再是self而是cls，cls相当遇类本身。但是实例对象仍然可以调用类方法。和类绑定，通过类调用

class People:
    @classmethod
    def see(cls):
        print('2333')

People.see()

>>> 2333

10、在类的方法前加上@staticmethod 装饰器，不能使用类变量和实例变量，表示是静态方法叫类的工具包。和谁都不绑定，所以只能做一些和类都不相关的操作,不加self

class People:
    @staticmethod
    def see():
        print('和类无关')

People.see()

11、类的组合：一个类在初始化的时候，可以引用其他的类，用来做类和类之间的关联

class People:
    def __init__(self,name):
        self.name = name
        self.eat = Eat()
        self.look = Look()

    def speak(self):
        print(self.eat.eat(),self.look.Look())

class Eat:
    def eat(self):
        return 'eating'

class Look:
    def Look(self):
        return 'I am Looking'

t = People('Jax')
t.speak()

>>> eating I am Looking

一个小例子：选课系统

import pickle


class School:
    def __init__(self, address):
        self.address = address


class Student:
    def __init__(self, school, grade):
        self.grade = Course(grade, name='jax')
        self.school = School(school)


class Course:
    def __init__(self, subject, name, time=40, price=400):
        self.subject = subject
        self.price = price
        self.time = time
        self.teacher = Teacher(name)
        if subject == 'go':
            self.address = School('shanghai')
        else:
            self.address = School('beijing')

    # 新姿势，把类写进去了,其实就是写进去self
    def save(self):
        with open('lab.db', 'wb') as f:
            # pickle.dump(self,f)
            a = pickle.dumps(self)
            f.write(a)


class Teacher:
    def __init__(self, name):
        self.name = name
        self.school = School('shanghai')

course_obj = pickle.load(open('lab.db', 'rb'))
print(course_obj)

猜你喜欢