1、创建一个类就创建了一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性。而类中可以定义两种属性：

静态属性：就是直接在类中定义的变量。

动态属性：就是定义在类中的方法。

class Course:
    language = 'Chinese'

    def __init__(self, name, teacher, period, price):
        self.name = name
        self.teacher = teacher
        self.period = period
        self.price = price

    def getname(self):
        return self.name

    def getteacher(self):
        return self.teacher


python = Course('Python', 'Chang', '6 month', 20000)
ret = python.getname()
print('The python course name is: ', ret)

linux = Course('Linux', 'Shen', '3 month', 10000)
ret = linux.getteacher()
print('The teacher of linux course is: ', ret)

总结一点：我们通过类，其实是规范了一些对象，让这些对象有规律可循。

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性。

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

a = 1

class A:
    # a
    # A.a

2、类中是不能通过__dict__来修改静态属性。

而对象属性是可以通过“对象名.__dict__['属性名'] = 新属性值”来进行修改的。

class Course:
    language = 'Chinese'

    def __init__(self, name, teacher, period, price):
        self.name = name
        self.teacher = teacher
        self.period = period
        self.price = price

    def getname(self):
        return self.name

    def getteacher(self):
        return self.teacher

# 创建一个python课程对象
python = Course('Python', 'Chang', '6 month', 20000)

# 修改静态属性
Course.language = 'English'
print(Course.language)

# 检查是否可以使用__dict__来修改
Course.__dict__['language'] = 'English'

# 通过__dict__来修改对象属性
python.__dict__['name'] = 'BigPython'
print(python.getname())

3、通过对象名来调用静态属性：

class Course:
    language = 'Chinese'
    # 打印language属性的内存地址
    print(id(language))

    def __init__(self, name, teacher, period, price):
        self.name = name
        self.teacher = teacher
        self.period = period
        self.price = price

    def getname(self):
        return self.name

    def getteacher(self):
        return self.teacher


# 创建一个python课程对象
python = Course('Python', 'Chang', '6 month', 20000)
ret = python.getname()
print('The python course name is: ', ret)


# 通过对象名来调用静态属性：
print(python.language)    # 返回值Chinese

# 打印python对象中的language的内存地址
print(id(python.language))   # 从结果可以看出两者是一样

通过id来打印类的language的内存地址和python对象的language属性的内存地址，可以看到是同一个。

 

总结下：类中的静态对象，类和对象两者都可以来调用。静态属性应该是类共性的一个东西，每个实例化对象都拥有这个共性的属性。

4、对象之间是平行关系，没有交集。两个对象可以共用同一个静态变量。

5、通过某个对象修改类变量，检查类变量和其他对象的同变量是否发生变化。

class Course:
    language = 'Chinese'

    def __init__(self, name, teacher, period, price):
        self.name = name
        self.teacher = teacher
        self.period = period
        self.price = price

    def getname(self):
        return self.name

    def getteacher(self):
        return self.teacher


# 创建一个python课程对象
python = Course('Python', 'Chang', '6 month', 20000)
ret = python.getname()
print('The python course name is: ', ret)

# 创建一个linux课程对象
linux = Course('Linux', 'Shen', '3 month', 10000)
ret = linux.getteacher()
print('The teacher of linux course is: ', ret)

# 通过对象来修改类变量
python.language = 'Spalish'

# 该python对象可以看到language变量发生了修改
print(python.language)

# 再检查其他对象，还是language还是Chinese
print(linux.language)

# 再检查类变量language，还是Chinese
print(Course.language)

结论：对于不可变数据类型来说，类变量最好用类名操作。

6、对可变数据类型：

class Course:
    language = ['Chinese']

    def __init__(self, name, teacher, period, price):
        self.name = name
        self.teacher = teacher
        self.period = period
        self.price = price

    def getname(self):
        return self.name

    def getteacher(self):
        return self.teacher


# 创建一个python课程对象
python = Course('Python', 'Chang', '6 month', 20000)
# ret = python.getname()
# print('The python course name is: ', ret)

# 创建一个linux课程对象
linux = Course('Linux', 'Shen', '3 month', 10000)
# ret = linux.getteacher()
# print('The teacher of linux course is: ', ret)

# 通过对象来修改类变量列表中的元素
python.language[0] = 'English'

# 该python对象可以看到language变量发生了修改
print(python.language)

# 再检查其他对象，还是language还是Chinese
print(linux.language)

# 再检查类变量language，还是Chinese
print(Course.language)

在类中开辟了一个language的内存地址，这个内存地址指向一个列表，但是列表里的元素发生了变化。所以都发生了变化。

那我们再修改下程序：

class Course:
    language = ['Chinese']

    def __init__(self, name, teacher, period, price):
        self.name = name
        self.teacher = teacher
        self.period = period
        self.price = price

    def getname(self):
        return self.name

    def getteacher(self):
        return self.teacher


# 创建一个python课程对象
python = Course('Python', 'Chang', '6 month', 20000)
# ret = python.getname()
# print('The python course name is: ', ret)

# 创建一个linux课程对象
linux = Course('Linux', 'Shen', '3 month', 10000)
# ret = linux.getteacher()
# print('The teacher of linux course is: ', ret)

# 通过对象来修改类变量，指向了另外一个列表对象
python.language = ['English']

# 该python对象可以看到language变量发生了修改
print(python.language)

# 再检查其他对象，还是language还是Chinese
print(linux.language)

# 再检查类变量language，还是Chinese
print(Course.language)

对于可变数据类型来说，通过对象名的静态对象元素进行修改是共享的，重新赋值是独立的。

7、创建一个类，每实例化一个对象就记录下来，最终所有对象都共享这个数据。

class Foo:
    count = 0

    def __init__(self):
        Foo.count += 1


f1 = Foo()
f2 = Foo()

print(f1.count)
print(f2.count)

print(Foo.count)

这个类变量记录下实例化对象的数量。这个就是利用了类变量的一个例子。

8、函数的名字跟静态属性的名字不要重名。

class Foo:
    count = 0
    def count(self):
        pass

count函数名其实也有一个内存空间。

9、绑定方法：

def func(): pass


print(func)


class Foo:
    def func(self):
        print('func')


f1 = Foo()
print(Foo.func)
print(f1.func)
print(f1)

当对象名调用类中定义的方法时，才有绑定方法，就是把对象的值通过self参数给了这个方法。

10、包package和__init__的关系：

import time

time.time()     # 导入一个time包，然后就可以使用time对象中的方法time(), 就有一个实例化的过程。

 import time，就相当于类的实例化的过程。