Pytorch学习——TORCH.AUTOGRAD

1. Pytorch中backward（）函数

backward(gradient=None, retain_variables=False)[source]

2.Python中的类

（1）属性+方法=类

属性：静态特征
方法：动态特征
在python约定首字母大写为“类”，小写为函数

(2)面向对象的特征

• 封装
• 继承

class Mylist(list):
    pass
list2=Mylist()
list2.append(5)
list2.append(8)
list2.append(8)
list2
[5, 8, 8]
list2.sort()
list
<class 'list'>
list2
[5, 8, 8]

-多态

class A:
    def fun(self):
        print("AA")
        
class B:
    def fun(self):
        print("BB")
        
a=A()
b=B()

a.fun()
AA
b.fun()
BB

(3) init(self)

init(self)只要实例化一个对象的时候，这个方法就会被调用

class ball:
    def __init__(self,name):
        self.name=name
    def kick(self):
        print("我是%s,"%self.name)
b=ball('haha')
b.kick()
我是haha,

（4）super（）

super()函数是用于调用父类（超类）的一个方法;

super()是解决多重继承类问题，直接用名调用父类方法在使用单继承的时候没有问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等常见问题。

当子类中出现与父类相同名的方法，子类中的方法就会覆盖父类中的方法，但是如果也想用父类的方法时候，可以使用super（）函数

class Fish:
    def __init__(self):
        self.x=random.randint(0,10)
        self.y=random.randint(0,10)

    def move(self):
        self.x-=1
        print("我的位置是： ",self.x,self.y)

class Goldfish(Fish):
    pass

class Carp(Fish):
    pass

class Salmon(Fish):
    pass

class Shark(Fish):
    def __init__(self):
        # Fish.__init__(self)
        # super().__init__()
        self.hungry=True

    def eat(self):
        if self.hungry:
            print("吃货，天天吃")
            self.hungry=False
        else:
            print("吃饱了")

selmon=Salmon()
selmon.move()
shark=Shark()
shark.move()
shark.eat()

运行结果：

出错的原因是Shark（）子类中的__init__(self)覆盖了父类的__init__(self)，所以shark.move的时候就会出现没有"x",所以可以使用super()函数，调用父类。代码改动结果如下：

class Shark(Fish):
    def __init__(self):
        # Fish.__init__(self)
        super().__init__()
        self.hungry=True

    def eat(self):
        if self.hungry:
            print("吃货，天天吃")
            self.hungry=False
        else:
            print("吃饱了")

fish=Fish()
fish.move()
goldfish=Goldfish()
goldfish.move()
carp=Carp()
carp.move()
selmon=Salmon()
selmon.move()
shark=Shark()
shark.move()
shark.eat()

运行结果：

（5）多重继承

一个子类可以继承多个父类

class Base1:
    def foo1(self):
        print("我是foo1,为Base1代言,")
        
class Base2:
    def foo2(self):
        print("我是foo2,为Base2代言")
        
class C(Base1,Base2):
    pass

运行结果:

c=C()
c.foo1()
我是foo1,为Base1代言,
c.foo2()
我是foo2,为Base2代言

(6)组合

当几个类之间没有关系的时候，但是需要将它们放到一块，用继承就会显得很突兀，所以需要另外一种方法。比如一个池塘里里有x只乌龟，y条鱼。

class Turtle:
    def __init__(self,x):
        self.num=x

class Fish:
    def __init__(self,x):
        self.num=x

class Pool:
    def __init__(self,x,y):
        self.turtle=Turtle(x)
        self.fish=Fish(y)

    def print_num(self):
        print("水池里有%d只乌龟，%d条鱼"%(self.turtle.num,self.fish.num))

pool=Pool(1,10)
pool.print_num()

运行结果：

也可以这样简写：

class Pool:
    def __init__(self,x,y):
        self.turtle=x
        self.fish=y

    def print_num(self):
        print("水池里有%d只乌龟，%d条鱼"%( self.turtle,self.fish))

pool=Pool(1,10)
pool.print_num()

（7）绑定

Python严格要求方法需要实例才能被调用，这种限定其实就是Python所谓的绑定。

class CC:
    def setXY(self,x,y):
        self.x=x
        self.y=y
    def print(self):
        print(self.x,self.y)
        

从运行结果可以看出当类CC被删除的时候，但是dd.print()还可以运行。