import  torch as t
from sympy.printing.pytorch import torch

#1.创建一个空的张量
x=t.empty(4,4)
print(x)
#2.创建一个随机数
y=t.randn(4,4)
print(y)
# 3.创建一个全部元素为0的张量
z=t.zeros(4,4)
print(z)
# 5.通过元素初始化张量
u=t.tensor([0,1,2,3,4,5,6,7,8,9])
print(u,u.dtype)
# 6.通过元素初始化张量，类型推导,python 会根据初始化元素推导数据类型
u1=t.tensor([0.0,1,2,3,4,5,6,7,8,9])
print(u1,u1.dtype)
# 7.相同维度的tensor的加 减 乘 除
t1=t.tensor([0.0,1,2,3,4,5,6,7,8,9])
t2=t.tensor([1,2,3,4,5,6,7,8,9,10.0])

t3=t.add(t1,t2)
print(t3)
t4=t.sub(t1,t2)
print(t4)
t5=t.mul(t1,t2)
print(t5)
t6=t.div(t1,t2)
print(t6)

# 不同维度加会出现问题吗? ,不同维度加法出现问题
# t7=t.tensor([1,2,3,4,5,6,7,8,9])
# t8=t.add(t1,t7)
# print(t8)

# 8 维度转换 view 不会改变内存的分布
v1=t.tensor([0,1,2,3,4,5,6,7,8,9])
v=v1.view(-1,5)
print(v)
v2=v.view(-1,10)
print(v2)
#9.转置矩阵
trans1=t.permute(v,(1,0))
print(trans1)

# 9与numpy数组的转换
na=t1.numpy()
print(na)
nb=t2.numpy()
print(nb)
#使用tensor.add 直接调用numpy 不报错，但是无结果输出
#nc=t.add(na,nb)
nd=t.add(t.from_numpy(na),t.from_numpy(nb))
print(nd)

#10 从内存到显存 从显存到内存 从tensor到numpy
if torch.cuda.is_available():
    #从内存转到显存
    result =t1.cuda()+t2.cuda()
    print(result)
    #从显存到内存到
    dd=result.cpu()
    print(dd)
    #从tensor到numpy
    ee=dd.numpy()
    print(ee)


#10 计算元素中最大值
t1_idex_max=t1.argmax()
t2_idex_max=t2.argmax()
print(t1_idex_max,t2_idex_max)
print(t1[t1_idex_max],t2[t2_idex_max])


#11.生成全部为0或者全为1的tensror
zeros_tensor=torch.zeros(2,3,4)
print(zeros_tensor)

ones_tensor=torch.ones(2,3,4)
print(ones_tensor)

#12 运算符号 + -  * /  **    (加减乘除以及幂指数运算）为按照元素运算
x_11=torch.tensor([1.0,2,4,8])
y_11=torch.tensor([2,2,2,2])
print(x_11+y_11)
print(x_11-y_11)
print(x_11*y_11)
print(x_11/y_11)
print(x_11**y_11)
print(torch.exp(x_11)) #自然对数

# 13多个tensor的连接
x_22=torch.arange(12,dtype=torch.float32).reshape(3,4)
y_22=torch.tensor([[2.0,1,4,3],[1,2,3,4],[4,3,2,1]])
Z_22=torch.cat((x_22,y_22),dim=0)#维度1上进行连接，3+3.第一个维度为6
U_22=torch.cat((x_22,y_22),dim=1)
print(x_22)
print(y_22)
print(Z_22)
print(U_22)

# 14.对于tensor 中所有的元素求和，产生一个单元素张量
w_22=U_22.sum()
print(w_22)


# 15.广播机制
# 对于维度不同的元素进行按照元素操作时候
# 我们看到了如何在相同形状的两个张量上执行按元素操作。
# 在某些情况下，[**即使形状不同，我们仍然可以通过调用
# *广播机制*（broadcasting mechanism）来执行按元素操作**]。
# 这种机制的工作方式如下：
# 1. 通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
# 2. 对生成的数组执行按元素操作。

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
print(a)
print(b)
print(a+b)
print(a-b)
print(a**b)

# 16.切片与索引

a_12=torch.arange(12).reshape((4,3))
print(a_12)
print(a_12[-1]) # 输出第一个维度的最后一行
print(a_12[1:3]) # 输出第一个维度的2到3行 第一个索引包含，第二个索引不包含
#根据索引修改元素值
a_12[1,2]=9  #注意是中括号
print(a_12)

a_13=torch.arange(24).reshape((4,3,2))
print(a_13)
a_13[1,2,1]=-1  #注意是中括号
print(a_13)

#17 使用 ：表示轴上的全部的元素的索引
# 如果我们想[**为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值。**]
# 例如，`[0:2, :]`访问第1行和第2行，其中“:”代表沿轴1（列）的所有元素。
# 虽然我们讨论的是矩阵的索引，但这也适用于向量和超过2个维度的张量。

a_14=torch.arange(12).reshape((4,3))
print(a_14)
a_14[0:2,:]=-2
print(a_14)

a_15=torch.arange(12).reshape((4,3))
print(a_15)
a_15[:,0:2]=-2
print(a_15)

a_16=torch.arange(24).reshape((4,3,2))
print(a_16)
a_16[:,0:2,0:1]=-2
print(a_16)

# a_17=torch.arange(24).reshape((4,3,2))
# print(a_17)
# a_17[:,0:1]=-2
# print(a_17)

#18 .节约内存

# 在 Python 中，id() 函数用于返回一个对象的“标识符”（identity），通常表示为该对象所在内存中的地址。具体来说：
# 返回值：id() 返回一个整数，这个整数是对象在 Python 内部的唯一标识符。对于同一时刻的同一个对象而言，id() 函数始终会返回相同的结果。
# 内存地址：虽然 id() 返回的值通常与对象在内存中的地址相关联，但它并不直接等同于 C 语言意义上的“地址”。
# Python 的内存管理是抽象化的，
# 并且不保证id() 直接对应实际物理内存地址。特别是在对象被垃圾回收或者其他操作导致重用时，
# 相同的 ID 可能会再次分配给新的对象。
# 类型：id() 返回的整数通常是 CPython 实现中 Py_ssize_t 类型的值。这个类型在不同平台上可能有所不同（例如，
# 在 32-bit 系统上，它通常是一个 32 位整数；而在 64-bit 系统上，则可能是一个 64 位整数）。
# 使用场景：
# **检查两个变量是否引用了同一个对象**。
# **在调试和内存管理时，追踪对象的生命周期和重用情况**。
Y=torch.arange(12).reshape((4,3))
X=torch.randn(4,3)
before = id(Y)
print(before)
Y = Y + X
print(id(Y))
print(id(Y) == before)

# 19 tensor对象与python中对象转换
A = X.numpy()
B = torch.tensor(A)
print(type(A), type(B))


# 要(**将大小为1的张量转换为Python标量**)，我们可以调用`item`函数或Python的内置函数。
a = torch.tensor([3.5])
print(a, a.item(), float(a), int(a))