本文已参加「新人创造礼」活动，一同敞开创造之路。

python创立类

1.创立类

如下界说一个动物类Animal为基类，它基本两个实例特点name和age、一个办法call。

class people:
  #界说基本特点
  name = ''
  age = 0
  #界说私有特点,私有特点在类外部无法直接进行访问
  __weight = 0
  #界说结构办法
  def __init__(self,n,a,w):
    self.name = n
    self.age = a
    self.__weight = w
  def speak(self):
    print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

2.承继

class Animal(object): #  python3中所有类都能够承继于object基类
  def __init__(self, name, age):
    self.name = name
    self.age = age
​
  def call(self):
    print(self.name, '会叫')
​
######
# 现在咱们需求界说一个Cat 猫类承继于Animal，猫类比动物类多一个sex特点。 
######
class Cat(Animal):
  def __init__(self,name,age,sex):
    super(Cat, self).__init__(name,age) # 不要忘掉从Animal类引入特点
    self.sex=sex
​
if __name__ == '__main__': # 单模块被引用时下面代码不会受影响，用于调试
  c = Cat('喵喵', 2, '男') #  Cat承继了父类Animal的特点
  c.call() # 输出 喵喵 会叫 ，Cat承继了父类Animal的办法 

留意：留意： 一定要用 super(Cat, self).init(name,age) 去初始化父类，否则，承继自 Animal的 Cat子类将没有 name和age两个特点。 函数super(Cat, self)将返回当时类承继的父类，即 Animal，然后调用init()办法，留意self参数已在super()中传入，在init()中将隐式传递，不能再写出self。

3.重构

class Cat(Animal):
  def __init__(self, name, age, sex):
    super(Cat, self).__init__(name,age)
    self.sex = sex
​
  def call(self):
    print(self.name,'会“喵喵”叫')
​
if __name__ == '__main__':
  c = Cat('喵喵', 2, '男')
  c.call() # 输出：喵喵 会“喵喵”叫

留意：类办法的调用次序，当咱们在子类中重构父类的办法后，Cat子类的实例先会在自己的类 Cat 中查找该办法，当找不到该办法时才会去父类 Animal 中查找对应的办法。

4.Python中子类与父类的联系

class Animal(object):
  pass
​
class Cat(Animal):
  pass
​
A= Animal()
C = Cat()

子类与父类的联系是 “is” 的联系，如上 Cat 承继于 Animal 类，咱们能够说：

“A”是 Animal 类的实例，但，“A”不是 Cat 类的实例。

“C”是 Animal 类的实例，“C”也是 Cat 类的实例。

判别目标之间的联系，咱们能够经过 isinstance (变量,类型) 来进行判别：

print('"A" IS Animal?', isinstance(A, Animal))
print('"A" IS Cat?', isinstance(A, Cat))
print('"C" IS Animal?', isinstance(C, Animal))
print('"C" IS Cat?', isinstance(C, Cat))

输出结果：

"A" IS Animal? True
"A" IS Cat? False
"C" IS Animal? True
"C" IS Cat? True

拓展： isinstance() 判别变量类型

函数 isinstance() 不止能够用在咱们自界说的类，也能够判别一个变量的类型，如判别数据类型是否为 int、str、list、dict 等。

print(isinstance(100, int))
print(isinstance('100', int))
print(isinstance(100, str))
print(isinstance('100', str))

输出：

True
False
False
True

5.python 中多态

类具有承继联系，并且子类类型能够向上转型看做父类类型，假如咱们从 Animal 派生出 Cat和 Dog，并都写了一个 call() 办法，如下示例：

class Animal(object):
   def __init__(self, name, age):
       self.name = name
       self.age = age
   def call(self):
       print(self.name, '会叫')
class Cat(Animal):
   def __init__(self, name, age, sex):
       super(Cat, self).__init__(name, age)
       self.sex = sex
   def call(self):
       print(self.name, '会“喵喵”叫')
class Dog(Animal):
   def __init__(self, name, age, sex):
       super(Dog, self).__init__(name, age)
       self.sex = sex
   def call(self):
       print(self.name, '会“汪汪”叫')

咱们界说一个 do 函数，接收一个变量 ‘all’,如下：

def do(all):
   all.call()
A = Animal('小黑',4)
C = Cat('喵喵', 2, '男')
D = Dog('旺财', 5, '女')
for x in (A,C,D):
   do(x)

输出结果：

小黑 会叫
喵喵 会“喵喵”叫
旺财 会“汪汪”叫

小常识：多态

这种行为称为多态。也就是说，办法调用将作用在 all 的实践类型上。C 是 Cat 类型，它实践上具有自己的 call() 办法以及从 Animal 承继的 call 办法，但调用 C .call() 总是先查找它本身的界说，假如没有界说，则顺着承继链向上查找，直到在某个父类中找到停止。

传递给函数 do(all) 的参数 all 纷歧定是 Animal 或 Animal 的子类型。任何数据类型的实例都能够，只要它有一个 call() 的办法即可。其他类不承继于 Animal，具备 call 办法也能够运用 do 函数。这就是动态言语，动态言语调用实例办法，不检查类型，只要办法存在，参数正确，就能够调用。

python批量树立目标

办法一：

class Blog:
   def __init__(self,num):
       print("a new object num is",num)
       self.value = num
   def __str__(self):
       return str(self.value+3)
# 循环树立四个目标，locals()函数能够将字符串转换为变量名！
#详细的操作和含义我并不清楚，大家能够自行百度～
for i in range(1,5):
    locals()['blog_'+str(i)] = Blog(i)
#验证是否有blo_3这个目标变量
print(blog_3)

作用：

('a new object num is', 1)
('a new object num is', 2)
('a new object num is', 3)
('a new object num is', 4)
3

办法二：

class bianyuan(custom):
    cj = 430080
    def __init__(self, name, data, cj):
        super(bianyuan, self).__init__(name)
        self.cj = cj
        self.data = data
    def distribute(self, slip):
        self.data = self.data + slip
flag = 1  ##设置flag，用于批量命名目标
for name in m_qos_suit_keys:
    # for i in range(1,101):
    if flag<101:
        locals()["bianyuan_"+str(flag)] = bianyuan(name, 0, m_limit.get(name))  ##批量命名目标
        flag += 1
bianyuan_1.distribute(slip)
bianyuan_2.distribute(slip)
bianyuan_3.distribute(slip)
print(bianyuan_1.data)
print(bianyuan_1.name)
print(bianyuan_2.data)
print(bianyuan_2.name)

\