python--类的实例化

1、类的定义和语法

class dog(object):   #用class定义类
    "dog class"     #对类的说明
 
    def __init__(self,name):   #构造函数或者是构造方法，也可以叫初始化方法
        self.name = name
 
 
    def sayhi(self):    #类方法
        "sayhi funcation"    #对类方法的说明
        print("hello,i am a dog,my name is ",self.name)
 
 
d = dog("AAAA")   #定义一个d的对象，叫实例
d.sayhi()    #调用实例的方法

2、self关键字

self 这个关键字相当于实例化对象本身(self相当于d)，在实例化过程中，把自己传进去了

3、函数__init__() 、__del__()

在类中__init__()函数叫构造函数，又叫构造方法，也可以叫初始化函数。它的作用就是初始化实例时，初始化传入实例的的默认值。如果不写__init__(),就会调用的默认为空的__init__(),说白了，这个方法不管你写不写，都会调用，而且，一旦实例化就会调用。

class dog(object):
    "dog class"
 
    def __init__(self,name):  #构造方法，不写调用默认的构造方法
        self.name = name 
 
    def eat(self,food):
        print("the dog name is {0},it like food is {1}".format(self.name,food))
 
d = dog("AAAA")
d.eat("hotdog")

#输出结果
the dog name is alex,it like food is hotdog

在类中__del__()函数叫做析构函数，是在实例销毁的时候调用的函数

class dog(object):
    "dog class"
 
    def __init__(self,name):
        self.name = name
 
    def sayhi(self):
        print("the dog {0} is sayhi".format(self.name))
 
    def __del__(self):     #定义析构函数
        print("del.....run...")
 
d = dog("alex")
del d
import time
time.sleep(5)
 
#输出
del.....run...

①析构函数说明时候调用呢？

其实每一个对象都是一个应用，就像每一个房间都有门牌号一样， 只要这个对象的引用被清空时，就会自动执行，就像上面的del d,其实python中有自动垃圾回收机制，会定时去的去回收一些被清空的应用，而析构函数就是在引用被清空之后会自动执行

②析构函数的作用？

比如说server端接受很多客户端的连接，当你手动屏蔽你的sever端的时候，这个时候客户端还在正常的连接，如果sever端用类写的，你就可以delete server端的同时，在__del__()写一些东西，说去close掉很多客户端的连接。说白了，析构函数就是做一些程序的收尾工作。

4、类的实例化过程图解:

小结：

• 其实self,就是实例本身！你实例化时python会自动把这个实例本身通过self参数传进去。
• 定义类（class dog(object)）-> 实例化(d = dog()) -> 实例化对象(d)
• __init__()构造函数
• self.name = name 被称为属性、成员变量、字段
• def sayhi(self)  被称为方法、动态属性

5、访问类属性

class dog(object):
    "dog class"

    def __init__(self, name):
        self.name = name  # 类的成员变量

    def sayhi(self):
        print("the dog {0} is sayhi".format(self.name))

    def eat(self, food):  # 传入一个参数,参数名：food
        print("the dog name is {0},it like food is {1}".format(self.name, food))


d = dog("AAAA")  # 实例化对象
d.sayhi()  # 调sayhi方法
d.eat("hotdog")  # 调eat方法

# 输出结果
the dog AAAA is sayhi
the dog name is AAAA,it like food is hotdog

①为什么eat方法里面会传入一个food的参数名呢？而这个为什么不能再其他方法里面用呢？而self.name就可以呢？

因为food它只是作为eat方法的一个参数，不是类的成员变量，只能在自己的方法里面使用，而self.name是类的成员变量，它是类的属性，所以可以被调用。

②为什么类的每一个方法第一个参数都是self呢？

是因为类在实例化的时候，需要把实例对象本身传进来，好去调用对象本身的属性和方法

6、修改类属性

class dog(object):
    "dog class"
 
    def __init__(self,name,age):
        self.name = name  
        self.age = age
 
    def sayhi(self,update_age):  #传入一个update_age参数
        self.age = update_age   #修改对象的age属性
 
d = dog("AAAA",18)
d.sayhi(22)  #第1次在类的方法中修改
print(d.age)  
d.age = 19   #第2次在类外面修改
print(d.age)
 
#输出
22
19

注：就是说在类的方法中或者类的外面都可以修改类的属性

7、私有属性

 定义私有属性

class dog(object):
    "dog class"

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__sex = "man"  # 定义私有属性__sex

    def sayhi(self, update_age):
        self.age = update_age


d = dog("AAAA", 18)
print(d.__sex)  # 访问私有属性__sex

# 输出
Traceback (most recent call last):
    print(d.__sex)  # 访问私有属性__sex
AttributeError: 'dog' object has no attribute '__sex' # 报错，说没有__sex这个属性

上面的例子可以看出，私有属性是不可以访问的，更不可以修改。但是我们就想访问，但是不去修改，我们怎么办呢？

get方法访问私有属性

class dog(object):
    "dog class"

    def __init__(self, name):
        self.name = name
        self.__sex = "man"  # 定义私有属性sex

    def get_sex(self):  # 定义get方法
        return self.__sex  # 返回私有属性sex值


d = dog("AAAA")
d_sex = d.get_sex()  # 调用实例对象d的get_sex()方法获取私有属性sex
print(d_sex)

# 输出结果
man

注：这种方法只能访问私有属性，但是不能更改私有属性

强制访问私有属性

class dog(object):
    "dog class"
 
    def __init__(self,name):
        self.name = name
        self.__sex = "man"  #定义私有方法sex
 
d = dog("AAAA")
print(d._dog__sex)  #访问私有属性sex
d._dog__sex = "woman"  #修改私有属性sex
print(d._dog__sex) #打印修改后的值

#输出结果
man
woman

注：这种方法就更为暴力，可以访问也可以修改，就是：对象名._类名__属性名

8、公有属性

定义公有属性：在类中直接定义的，可以提供这个类所属的所有对象都可以访问的属性

class dog(object):
    "dog class"

    nationality = "JP"  # 定义公有属性nationality

    def __init__(self, name):
        self.name = name


d1 = dog("AAAA")
d2 = dog("sanjiang")
print(d1.nationality, d2.nationality)  # 所有的成员变量都可以访问

# 输出结果
JP JP

d1.name,d2.name也可以访问，也可以修改， 为什么不能叫公有属性呢？

class dog(object):
    "dog class"

    nationality = "JP"

    def __init__(self, name):
        self.name = name


d1 = dog("AAAA")
d2 = dog("sanjiang")
print(d1.name, d2.name)

# 输出结果
AAAA sanjiang

注：上面的name是每个对象的属性，并不是共享，而是独立的 ，所以不能叫做公有属性

访问/修改公有属性

class dog(object):
    "dog class"

    nationality = "JP"  # 定义公有属性

    def __init__(self, name):
        self.name = name


d1 = dog("AAAA")
d2 = dog("sanjiang")
print(dog.nationality)  # 访问公有属性
dog.nationality = "US"  # 修改公有属性
print(dog.nationality)

# 输出
JP
US

注 ：公有属性不仅可以通过所属类的所有对象访问，还可以通过类本身直接访问和修改

公有属性特性

公有属性不是私有属性，它提供所有对象访问和修改，那我们其中有一个对象正在修改公共属性发生什么变化呢？

class dog(object):
    "dog class"

    nationality = "JP"

    def __init__(self, name):
        self.name = name


d1 = dog("AAAA")
d2 = dog("sanjiang")
print("firsthand change...")
print(d1.nationality, d2.nationality)
print("brfore change ...")
d1.nationality = "CN"  # 对象的d1修改公共属性得值
print(d1.nationality, d2.nationality)
print("after change ....")
dog.nationality = "US"  # dog类本省修改公共属性的值
print(d1.nationality, d2.nationality)

#输出结果
firsthand change...
JP JP
brfore change ...
CN JP          #d1对象的公共属性被修改了
after change ....
US US    #d1对象的公共属性值没有随着类本身的公共属性值修改而修改

解疑：

1. 对象d1去访问nationality属性时，如果在成员属性中找不到，就会找公共属性，也就是说自己的属性找不到就去找父亲的属性
2. d1.nationality="CN" 相当于在自己对象内部又重新创建了一个新的局部变量，这个局部变量已经脱离了class本身，跟这个类已经没有半毛钱关系了，只是名字一样而已，如果不改，还是找全局的。