初识面向对象：类

定义一个类：

    class 类名(大写开头)
    静态变量            
    函数 ： 方法       #动态属性  # 类中可以定义方法，方法都有一个必须传的参数self
    变量 ： 类属性    #静态属性  # 类中可以定义静态属性         

例：

class Tst:
    nationality = '中国' #静态变量，不能通过双下dict方法修改，不能在外部通过对象调用修改，可以查看，可以在外部通过类名调用修改，
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        print(id(self))#self与t1的内存地址一样

    def way(self):#方法，一般情况下必须传self参数，且必须写在第一个；后面还可以传其他参数，是自由的
        pass

t1 = Tst('aike','25','男')                   #所以t1接收的是self的内存地址
print(Tst.nationality)                          #查看静态变量
print(Tst.__dict__['nationality'])              #同样可以使用双下dict方法查看静态变量值
# Tst.__dict__['nationality'] = '美国'            #报错，所以静态变量不能通过双下dict方法修改
Tst.nationality = '美国'
print(Tst.nationality)                       #通过类直接调用可以修改
print(t1)                                       #返回的是一个内存地址，与self一样
print(id(t1))                                   #self与t1的内存地址一样
print(t1.name)                                  #查看属性值
print(t1.__dict__)                              #通过双下dict方法能够查到里面的数据，内存地址与一致，所以数据也是一致
print(t1.__dict__['name'])                      #同样可以使用双下dict方法查看属性值
t1.__dict__['name'] = '艾克'                      #使用双下dict方法可以修改属性值
print(t1.__dict__['name'])

t1.way()                                        #可以用对象直接调用方法，等同于Tst.way(t1)，如果方法不止接收一个参数，在括号内部依次传入即可            

 

过程：
    类名() 首先 会创造出一个对象，创建了一个self变量
    调用init方法，类名括号里的参数会被这里接收
    执行init方法
    返回self

__init__方法：初始化方法
    python帮我们创建了一个对象self
    每当我们调用类的时候就会自动触发这个方法。默认传self
    在init方法里面可以对self进行赋值

对象能做的事：
    查看属性
    调用方法
    __dict__ 对于对象的增删改查操作都可以通过字典的语法进行

类名能做的事：
    实例化
    调用方法 : 只不过要自己传递self参数
    调用类中的属性和对象,也就是调用静态属性和对象
    __dict__ 对于类中的名字只能看 不能操作

总结： 

　　1、实例化的过程就是类——>对象的过程，创建的对象就是一个实例化的东西

　　2、self在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字，但是正常人都不会这么做。self拥有属性都属于对象，在类的内部，self就是一个对象

　　3、对象通过双下dict方法能够查到这个对象的数据，内存地址与self一致，所以数据也是一致

　　4、静态变量可以在类的外部通过双下dict方法查看，但不能修改，可以通过类名调用修改

　　5、对象调用方法的方式需要细心

补充：关于类和对象的命名空间

#静态属性为不可变数据类型
class Person:
    state = 'chinese'
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

aike = Person('aike',25,'男')
chenfan = Person('chenfan',25,'男')
print(aike.state) #chinese
print(chenfan.state) #chinese
aike.state = 'US'
print(aike.state)#US
print(Person.state)#chinese
print(chenfan.state)#chinese
Person.state = 'UK'
print(Person.state)#UK
print(aike.state)#US 上面的aike.state = 'US'是在给aike赋值，因为对象找变量优先找自己的，没有就找类的，类没有则报错，不会找全局的
print(chenfan.state)#UK

#当静态变量为可变数据类型时
class Person:
    state = ['chinese'] #列表
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

aike = Person('aike',25,'男')
chenfan = Person('chenfan',25,'男')
print(aike.state)#['chinese']
print(chenfan.state)#['chinese']
aike.state[0] = 'US'
print(aike.state)#['US']
print(chenfan.state)#['US']
chenfan.state = 'UK' #重新赋值
print(chenfan.state)#UK
print(aike.state)['US']

结论：

1、对象调用类中的静态变量时，会优先找自己的，如果自身没有，则找类的，类没有不再向全局找，直接报错

2、当类的静态变量为不可变数据类型时，对象调用静态变量对其值进行修改，不会影响到静态变量的原始值，而是直接在对象自身的内存创建一个新的变量赋值

3、当类的静态变量为可变数据类型时，对象调用静态变量对其值进行修改，修改时共享的，会影响原始值，其他对象调用也会被影响，重新赋值又是独立的，与不可变数量类型一样。

4、类变量最好用类名操作