slowfast官方代码阅读过程中的Python基础补充（一）

torch.clamp()

clamp是夹紧的意思。函数的功能是将input Tensor，夹紧到[min,max]区间中，输出同样为Tensor。

torch.clamp(input, min, max, out=None) → Tensor

实现过程：

      | min, if x_i < min
y_i = | x_i, if min <= x_i <= max
      | max, if x_i > max

示例：

torch.linspace()

PyTorch的官方网站上找到了这个函数的详细说明

torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

函数的作用是，返回一个一维的tensor（张量），这个张量包含了从start到end，分成steps个线段得到的向量。常用的几个变量:

start： 开始值
end： 结束值
steps：分割的点数，默认是100
dtype：返回值（张量）的数据类型

import torch
print(torch.linspace(3,10,5))
#tensor([ 3.0000,  4.7500,  6.5000,  8.2500, 10.0000])
 
 
type=torch.float
print(torch.linspace(-10,10,steps=6,dtype=type))
#tensor([-10.,  -6.,  -2.,   2.,   6.,  10.])

frame.shape()

frame.shape[0]：图像的垂直尺寸（高度）
frame.shape[1]：图像的水平尺寸（宽度）
frame.shape[2]：图像的通道数。

.long()

long() 函数将数字或字符串转换为一个长整型

torch.index_select()

index_select(
    dim,
    index
)

dim：表示从第几维挑选数据，类型为int值；
index：表示从第一个参数维度中的哪个位置挑选数据，类型为torch.Tensor类的实例；

seek()

seek() 方法用于移动文件读取指针到指定位置。
参数

• offset – 开始的偏移量，也就是代表需要移动偏移的字节数
• whence – 可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。

返回值
如果操作成功，则返回新的文件位置，如果操作失败，则函数返回 -1。

numpy.frombuffer(buffer, dtype=float, count=_1, offset=0)

Interpret a buffer as a 1-dimensional array.

参数
buffer : buffer_like

An object that exposes the buffer interface.  

dtype : data-type, optional

Data-type of the returned array; default: float.  

count : int, optional

Number of items to read. `-1` means all data in the buffer.  

offset : int, optional

Start reading the buffer from this offset (in bytes); default: 0.  

Notes
If the buffer has data that is not in machine byte-order, this should be specified as part of the data-type, e.g.:

  dt = np.dtype(int)  
  dt = dt.newbyteorder(' ')  
  np.frombuffer(buf, dtype=dt)  

The data of the resulting array will not be byteswapped, but will be interpreted correctly.

Examples

s = 'hello world' np.frombuffer(s, dtype='S1', count=5, offset=6) array(['w', 'o', 'r', 'l', 'd'],
 dtype='|S1')  
np.frombuffer(b'\x01\x02', dtype=np.uint8) array([1, 2], dtype=uint8) np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3) array([1, 2, 3], dtype=uint8)

math.inf

浮点正无限。（对于负无限，使用 -math.inf。）等于输出float(‘inf’)。

ndarray与tensor的相互转换

import numpy as np
import tensorflow as tf

#  函数法
# 先找出一个ndarray的数据，这里我直接定义一个
a = np.ndarray([3,4]) # 3x4形状的ndarray数据

b = tf.convert_to_tensor(a)
print(b) # out:Tensor("Const:0", shape=(3, 4), dtype=float64)


#  通过调用启动会话进行转换
op = tf.constant([1, 2, 3, 4])
print(op) # out:Tensor("Const_1:0", shape=(4,), dtype=int32)

sess = tf.InteractiveSession()
op_ndarray = op.eval() # 这里等效于op_ndarray = sess.run(op)
print(op_ndarray) # out:<class 'numpy.ndarray'>

Python @函数装饰器及用法

假设用 funA() 函数装饰器去装饰 funB() 函数，如下所示：

#funA 作为装饰器函数
def funA(fn):
    #...
    fn() # 执行传入的fn参数
    #...
    return '...'
@funA
def funB():
    #...

实际上，上面程序完全等价于下面的程序：

def funA(fn):
    #...
    fn() # 执行传入的fn参数
    #...
    return '...'
def funB():
    #...
funB = funA(funB)

通过比对以上 2 段程序不难发现，使用函数装饰器 A() 去装饰另一个函数 B()，其底层执行了如下 2 步操作：

1. 将 B 作为参数传给 A() 函数；

2. 将 A() 函数执行完成的返回值反馈回 B。

举个例子：

#funA 作为装饰器函数
def funA(fn):
    print("啦啦啦")
    fn() # 执行传入的fn参数
    print("嘻嘻嘻")
    return "装饰器函数的返回值"
@funA
def funB():
    print("学习 Python")
print(funB)

执行出来：

啦啦啦
学习 Python
嘻嘻嘻
装饰器函数的返回值

显然，被“＠函数”修饰的函数不再是原来的函数，而是被替换成一个新的东西（取决于装饰器的返回值），即如果装饰器函数的返回值为普通变量，那么被修饰的函数名就变成了变量名；同样，如果装饰器返回的是一个函数的名称，怎么被修饰的函数名依然表示一个函数。实际上，所谓函数装饰器，就是通过装饰器函数，在不修改原函数的前提下，来对函数的功能进行合理的扩充。

带参数的函数装饰器

当 funB() 函数无参数时，可以直接将 funB 作为 funA() 的参数传入。但是，如果被修饰的函数本身带有参数，那应该如何传值呢？
比较简单的解决方法就是在函数装饰器中嵌套一个函数，该函数带有的参数个数和被装饰器修饰的函数相同。例如：

def funA(fn):
    # 定义一个嵌套函数
    def say(arc):
        print("Python教程:",arc)
    return say
@funA
def funB(arc):
    print("funB():", a)
funB("http://c.biancheng.net/python")

程序执行结果为：

Python教程: http://c.biancheng.net/python

等价于：

def funA(fn):
    # 定义一个嵌套函数
    def say(arc):
        print("Python教程:",arc)
    return say
def funB(arc):
    print("funB():", a)
   
funB = funA(funB)
funB("http://c.biancheng.net/python")

显然，通过 funB() 函数被装饰器 funA() 修饰，funB 就被赋值为 say。这意味着，虽然我们在程序显式调用的是 funB() 函数，但其实执行的是装饰器嵌套的 say() 函数。

但还有一个问题需要解决，即如果当前程序中，有多个（≥ 2）函数被同一个装饰器函数修饰，这些函数带有的参数个数并不相等，怎么办呢？

最简单的解决方式是用 *args 和 **kwargs 作为装饰器内部嵌套函数的参数，*args 和 **kwargs 表示接受任意数量和类型的参数。举个例子：

def funA(fn):
    # 定义一个嵌套函数
    def say(*args,**kwargs):
        fn(*args,**kwargs)
    return say
@funA
def funB(arc):
    print("C语言中文网：",arc)
@funA
def other_funB(name,arc):
    print(name,arc)
funB("http://c.biancheng.net")
other_funB("Python教程：","http://c.biancheng.net/python")

运行结果为：

C语言中文网： http://c.biancheng.net
Python教程： http://c.biancheng.net/python

函数装饰器可以嵌套

上面示例中，都是使用一个装饰器的情况，但实际上，Python 也支持多个装饰器，比如：

@funA
@funB
@funC
def fun():
    #...

上面程序的执行顺序是里到外，所以它等效于下面这行代码：

fun = funA( funB ( funC (fun) ) )

class

需求:
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和占地面积，其中
床：占地4平米
衣柜：占地2平米
餐具：占地1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要输出：户型，总面积，剩余面积，家具名称列表

class house:
    def __init__(self, houseType, houseArea):
        self.houseType = houseType
        self.area = houseArea
        self.fire_area = houseArea
        self.fitment = []

    def __str__(self):
        return '户型：%s\n总面积:%s平米\n剩余面积:%s平米\n家具：%s' % (self.houseType, self.area, self.fire_area, ','.join(self.fitment))

    def add_fitment(self, fitmentname):
        if fitmentname.area < self.fire_area:
            self.fitment.append(fitmentname.name)
            self.fire_area -= fitmentname.area
        else:
            print('%s的占地%s平米太大了，房子剩余面积%s平米太小了' % (fitmentname.name, fitmentname.area, self.fire_area))


class fitment:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return '%s占地%s平米' % (self.name, self.area)


bed = fitment('架子床', 4)
bureau = fitment('折叠衣柜', 2)
cutlery = fitment('餐桌', 1.5)
# print(bed)
# print(bureau)
# print(cutlery)

xiaoming_house = house('两室一厅', 100)
xiaoming_house.add_fitment(bed)
xiaoming_house.add_fitment(cutlery)
print(xiaoming_house)

仍不懂的：

frames = [frame.to_rgb().to_ndarray() for frame in video_frames]
frames = torch.as_tensor(np.stack(frames))