美文网首页
Python学习第八天——《A Byte of Python》笔

Python学习第八天——《A Byte of Python》笔

作者: 蓝色公爵 | 来源:发表于2018-03-26 19:17 被阅读0次
    Let it be

    继续面向对象编程的学习

    classes(类)

    class Person:
        pass  #An empty block
    p=Person()
    print(p)
    

    Outport:

    <main.Person object at 0x00000203E858F8D0>

    这是类的一个最简单的例子。说明main 模块中有了一个Person 类的实例,“0x00000203E858F8D0”是对象在计算机内存的地址。

    Methods(方法)

    类的方法和函数类似,区别只是一个额外的self变量。

    class Fans:
        def sayHi(self):
            print("I'm a basketball fan. I like Jordan.")
    bf=Fans()
    bf.sayHi()
    

    Outport:

    I'm a basketball fan. I like Jordan.

    注意sayHi 方法没有任何参数,但仍然在函数定义时有self。

    The __ init __ Method(__init __方法)

    Python 的类中有很多方法的名字有特殊的重要意义。init 方法在类的一个对象被建立时马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意,这个名称的开始和结尾都是双下划线。

    class Person:
        def __init__(self,name):
            self.name=name
        def say_hi(self):
            print("I'm a basketball fun, I like ",self.name)
    #p=Person('Mike Jordan')
    #p.say_hi()
    p=Person('Mike Jordan').say_hi()
    

    Output

    I'm a basketball fun, I like Mike Jordan

    Class And Object Variables(类和对象变量)

    有两种类型的域—— 类的变量和对象的变量,它们根据是类还是对象拥有这个变量而区分。
    类的变量由一个类的所有对象(实例)共享使用。只有一个类变量的拷贝,所以当某个对象对类的变量做了改动的时候,这个改动会反映到所有其他的实例上。
    对象的变量由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝,即它们不是共享的,在同一个类的不同实例中,虽然对象的变量有相同的名称,但是是互不相关的。

    class Robot:
        """Represents a robot, with a name."""
    
        # A class variable, counting the number of robots
        population = 0
    
        def __init__(self, name):
            """Initializes the data."""
            self.name = name
            print("(Initializing {})".format(self.name))
    
            # When this person is created, the robot
            # adds to the population
            Robot.population += 1
    
        def die(self):
            """I am dying."""
            print("{} is being destroyed!".format(self.name))
    
            Robot.population -= 1
    
            if Robot.population == 0:
                print("{} was the last one.".format(self.name))
            else:
                print("There are still {:d} robots working.".format(
                    Robot.population))
    
        def say_hi(self):
            """Greeting by the robot.
    
            Yeah, they can do that."""
            print("Greetings, my masters call me {}.".format(self.name))
    
        @classmethod
        def how_many(cls):
            """Prints the current population."""
            print("We have {:d} robots.".format(cls.population))
    
    
    droid1 = Robot("R2-D2")
    droid1.say_hi()
    Robot.how_many()
    
    droid2 = Robot("C-3PO")
    droid2.say_hi()
    Robot.how_many()
    
    print("\nRobots can do some work here.\n")
    
    print("Robots have finished their work. So let's destroy them.")
    droid1.die()
    droid2.die()
    
    Robot.how_many()
    

    Outport:

    (Initializing R2-D2)
    Greetings, my masters call me R2-D2.
    We have 1 robots.
    (Initializing C-3PO)
    Greetings, my masters call me C-3PO.
    We have 2 robots.

    Robots can do some work here.

    Robots have finished their work. So let's destroy them.
    R2-D2 is being destroyed!
    There are still 1 robots working.
    C-3PO is being destroyed!
    C-3PO was the last one.
    We have 0 robots.

    Inheritance(继承)

    面向对象的编程带来的主要好处之一是代码的重用,途径之一是通过继承机制。继承完全可以理解成执行类之间的类型和子类型关系。
    假设你想要写一个程序来记录学校之中的教师和学生情况。他们有一些共同属性,比如姓名、年龄和地址。他们也有专有的属性,比如教师的薪水、课程和假期,学生的成绩和学费。你可以为教师和学生建立两个独立的类来处理它们,但是这样做的话,如果要增加一个新的共有属性,就意味着要在这两个独立的类中都增加这个属性。
    一个比较好的方法是创建一个共同的类称为SchoolMember, 然后让教师和学生的类继承这个共同的类。即它们都是这个类型(类)的子类型,然后我们再为这些子类型添加专有的属性。
    使用这种方法有很多优点。如果我们增加/改变了SchoolMember 中的任何功能,它会自动地反映到子类型之中。例如,你要为教师和学生都增加一个新的身份证域,那么你只需简单地把它加到SchoolMember 类中。然而,在一个子类型之中做的改动不会影响到别的子类型。另外一个优点是你可以把教师和学生对象都作为SchoolMember 对象来使用,这在某些场合特别有用,比如统计学校成员的人数。一个子类型在任何需要父类型的场合可以被替换成父类型,即对象可以被视作是父类的实例,这种现象被称为多态现象
    另外,我们会发现在重用父类的代码的时候,我们无需在不同的类中重复它。而如果我们使用独立的类的话,我们就不得不这么做了。
    在上述的场合中,SchoolMember 类被称为基本类超类。而Teacher 和Student类被称为导出类子类

    class SchoolMember:
        '''Represents any school member.'''
        def __init__(self, name, age):
            self.name = name
            self.age = age
            print('(Initialized SchoolMember: {})'.format(self.name))
    
        def tell(self):
            '''Tell my details.'''
            print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")
    
    
    class Teacher(SchoolMember):
        '''Represents a teacher.'''
        def __init__(self, name, age, salary):
            SchoolMember.__init__(self, name, age)
            self.salary = salary
            print('(Initialized Teacher: {})'.format(self.name))
    
        def tell(self):
            SchoolMember.tell(self)
            print('Salary: "{:d}"'.format(self.salary))
    
    
    class Student(SchoolMember):
        '''Represents a student.'''
        def __init__(self, name, age, marks):
            SchoolMember.__init__(self, name, age)
            self.marks = marks
            print('(Initialized Student: {})'.format(self.name))
    
        def tell(self):
            SchoolMember.tell(self)
            print('Marks: "{:d}"'.format(self.marks))
    
    t = Teacher('Mrs. Shrividya', 40, 30000)
    s = Student('Swaroop', 25, 75)
    
    # prints a blank line
    print()
    
    members = [t, s]
    for member in members:
        # Works for both Teachers and Students
        member.tell()
    

    OutPort:

    (Initialized SchoolMember: Mrs. Shrividya)
    (Initialized Teacher: Mrs. Shrividya)
    (Initialized SchoolMember: Swaroop)
    (Initialized Student: Swaroop)

    Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
    Name:"Swaroop" Age:"25" Marks: "75"


    summary

    面向对象对我而言,理解总是有点问题,这个在学习C#时就存在,因此花了两天看完这一章,也算无奈之举。即使多花了一天,觉得现在也只是理解了80%,而不是百分百贯通,要在以后的学习中进一步巩固加强。

    相关文章

      网友评论

          本文标题:Python学习第八天——《A Byte of Python》笔

          本文链接:https://www.haomeiwen.com/subject/obnrcftx.html