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

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

class ClassName:

    <statement-1>

    .

    .

    .

    <statement-N>

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

x=Myclass()
y=Myclass()

print(x.i) 

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)

print(instance1.x)

# 下面的例子中，instance1.x+=100本质是实例对象instance1新建了一个属性，覆盖了instance1.x这个变量

# 我们要知道，类变量可以是类对象的属性也可以是实例对象的属性，但实例对象的属性变化影响不了类对象的属性，也不会影响其他的实例对象

# 反之，类对象属性的变化倒是能影响实例对象的属性

test.x=100

print(instance1.x)

print(test.x)

instance1.x+=100

print(instance1.x)

print(test.x)

print(instance2.x)

# 如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在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())

stu.print_stu()

J:100

stu.set_score(99);print(stu.get_score())

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

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

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>