[PY3]——面向对象编程（1）

类[class]是抽象的模型
实例[instance]是根据类创建出来的一个个具体的“对象”

class 类名(表示该类是从哪个类继承下来的): 
　　xxx

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

# 实例化操作如下所示，赋值给一个变量，就能够创建一个实例对象
x=Myclass()
y=Myclass()

print(x.i) 
123 
print(x.f()) 
hello world 
print(x.__doc__) 
A simple example about class

# 创建的实例对象可以自由地绑定属性
x.iii="a9a"
print(x.iii)
a9a

# 创建的每个实例对象的内存地址都不一样
print(x)
<__main__.Myclass object at 0x7fbe7fa53160>
print(y)
<__main__.Myclass object at 0x7fbe7f7a8630>

# 上述的实例化操作创建了一个空的object
# 但在很多情况下，我们创建实例对象时，可能都需要有特定的初始状态。这个由__init__方法实现。
# 当一个类定义了 __init__() 方法, 类在实例化时会自动调用 __init__() 方法, 用于创建新的类实例

class Myclass(object):
    ‘‘‘A simple example about class‘‘‘
    i=123
    def f(self):
        return "hello world"

    def __init__(self,name,score):
        self.name=name
        self.score=score
        
# 关于__init__，要注意的是：  
  (1) __init__方法的第一个参数永远是self,表示创建的实例本身  
  (2) 有了__init__方法，在创建实例时就不能传入空的参数了，必须传入匹配的参数

x=Myclass()
TypeError: __init__() missing 2 required positional arguments: ‘name‘ and ‘score‘

x=Myclass("J",11)
print(x.name,x.score)
J 11

class test:
    x=7                    #类的直接下级作用域的变量，叫做类变量

    def __init__(self,name):
        self.name=name      #实例中的变量，叫实例变量


instance1=test("name1")
instance2=test(‘name2‘)

# 类变量：既是类对象可见的属性、也是实例对象可见的属性
print(test.x)
7

print(instance1.x)
7

# 下面的例子中，instance1.x+=100本质是实例对象instance1新建了一个属性，覆盖了instance1.x这个变量
# 我们要知道，类变量可以是类对象的属性也可以是实例对象的属性，但实例对象的属性变化影响不了类对象的属性，也不会影响其他的实例对象
# 反之，类对象属性的变化倒是能影响实例对象的属性
test.x=100
print(instance1.x)
100
print(test.x)
100

instance1.x+=100
print(instance1.x)
107
print(test.x)
100
print(instance2.x)
100

# 如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问
# 这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮

class Student(object):
    def __init__(self,name,score):
        self.__name=name
        self.__score=score

stu=Student(‘J‘,100)
print(stu.__score)
AttributeError: ‘Student‘ object has no attribute ‘__score‘


# 如果要允许外部访问者两个变量，可以增加get方法（get_name()和get_score()）
# 如果又要允许外部修改这两个变量，可以增加set_score,虽然显得大费周折，但我们可以顺带对参数做个检查

class Student(object):
    def __init__(self,name,score):
        self.__name=name
        self.__score=score

    def get_name(self):
        return ‘{}‘.format(self.__name)

    def get_score(self):
        return ‘{}‘.format(self.__score)

    def print_stu(self):
        print(‘%s:%s‘ % (self.__name,self.__score))

    def set_score(self,score):
        if 0<=score<=100:
            self.__score=score
        else:
            raise ValueError(‘bad score‘)


stu=Student(‘J‘,100)
print(stu.get_name())
J
print(stu.get_score())
100
stu.print_stu()
J:100


stu.set_score(99);print(stu.get_score())
99
stu.set_score(101)
ValueError: bad score

# 基类/父类/超类(base class/super class) <—— 子类(subclass)

class Animal(object):
    def run(self):
        print("Animal is running...")

    def run2(self):
        print("111")

class Dog(Animal):
    def run(self):
        print("Dog is running...")

class Cat(Animal):
    def run(self):
        print("Cat is running...")

animal=Animal()
dog=Dog()
cat=Cat()

# 子类父类存在同名方法时，子类方法覆盖父类方法
dog.run()
Dog is running...
dog.run2()
111
cat.run()
Cat is running...

# 可以通过isinstance(obj, class_or_tuple, /)，可以判断一个instance object是否属于某个类
print(isinstance(dog,Dog))
True
print(isinstance(dog,Animal))
True
print(isinstance(animal,Dog))
False

# issubclass(cls, class_or_tuple, /)class Base:

    Public_class_var=‘public class var‘     #类变量(public)
    __Private_class_var=‘private class var‘ #类变量(private)

    def __init__(self):
        self.public_instance_var=‘public instance var‘     #实例变量(public)
        self.__private_instance_var=‘private instance var‘ #实例变量(private)

    def public_instance_method(self):
        return ‘public instance method‘

    def __private_instance_method(self):
        return ‘private instance method‘

    @classmethod
    def public_class_method(cls):
        return ‘public class method‘

    @classmethod
    def __private_class_method(cls):
        return ‘private class method‘

    @staticmethod
    def public_static_method():
        return ‘public static method‘

    @staticmethod
    def __private_static_method():
        return ‘private static method‘

class Sub(Base):
   pass

sub=Sub()
print(sub.__dict__)
{‘_Base__private_instance_var‘: ‘private instance var‘, ‘public_instance_var‘: ‘public instance var‘}


# 子类可以继承类变量(public)、实例变量(public)
class Sub(Base):
    def print_public_var(self):
        print(self.Public_class_var)

    def print_public_instance_var(self):
        print(self.public_instance_var)

sub=Sub()
sub.print_public_var()
public class var

sub.print_public_instance_var()
public instance var


# 事实上凡是公有的都能继承，凡是私有的都不能继承
class Sub(Base):
    def print_public_class_method(self):
        print(self.public_class_method())

    def print_public_static_method(self):
        print(self.public_static_method())

    def print_public_instance_method(self):
        print(self.public_instance_method())


sub=Sub()
sub.print_public_class_method()
public class method
sub.print_public_static_method()
public static method
sub.print_public_instance_method()
public instance method

class A(object):
    def foo(self,x):
        print("executing foo({},{})".format(self,x))

    @classmethod
    def class_foo(cls,x):
        print("executing class_foo({},{})".format(cls,x))

    @staticmethod
    def static_foo(x):
        print("executing static_foo({})".format(x))

a=A()

a.foo(1)
executing foo(<__main__.A object at 0x7fe8619c7160>,1)

a.class_foo(1)
executing class_foo(<class ‘__main__.A‘>,1)

a.static_foo(1)
executing static_foo(1)

a.static_foo(‘hi‘)
executing static_foo(hi)

A.class_foo(1)
executing class_foo(<class ‘__main__.A‘>,1)

A.static_foo(1)
executing static_foo(1)

A.foo(1)TypeError: foo() missing 1 required positional argument: ‘x‘

print(a.foo)
<bound method A.foo of <__main__.A object at 0x7f57d0ba41d0>>

print(a.class_foo)
<bound method A.class_foo of <class ‘__main__.A‘>>

print(a.static_foo)
<function A.static_foo at 0x7f71b0c89b70>