一，基本的语法

 变量初始化
name = "gaolingrengongzhinneng"
print(name)

 列表

list = [1,2,3,4,5]
print(list)
print(list[2])
print(list[-1])   # -1在list中表示最后一个

 字典 - 哈希表  dict 字典中要用到字符串来作为索引#key - value  根据key找value，

dict1 = {"name":"RUC", "age":18, 18:"去ruc读书"}
print(dict1["name"])
print(dict1[29])

二 分支语句

 判断

a=3
if a==3:
    print("正确的")
    print("我也是属于a==3")

if a==4:
    print("错误的")
else:
    print("你知道a为几吗？")

A = None

if A==None:
    print("A是空的")

三 循环

 循环
for i in 范围  !!一定注意这里是范围，不能直接给数字

list1 = [1,2,3,4,5]

for i in list1:
    print(i)

for i in range(10):  #[0,10)
    print(i)

for i in range(1, 10):
    print(i)

for i in range(1,10,2):  # 1是开头， 10是结尾， 2是步长
    print(i)

dict1 = {"name":"RUCchenli", "age":29, 29:"2026年9月必去ruc读书"}
print(dict1)  #单纯输出整个字典

 分别输出key 和 value

for each in dict1:
    print(each)
    print(dict1[each])

 while循环

i = 2
while i < 10:
    print(i)
    i+=1

四 列表（数组）

# 列表   -  切片 和插入 和删除

list1 =[0, 1, 2, 3, 4, 5]
for each in list1:
    print(each)

 切片
print(list1[1:4])   # 左开右闭的区间，找的是第二个到第四个
print(list1[0:4])  # 从第一个元素（下标0）到第四个元素 输出
print(list1[1: -1])  #从下标1的开始，输出到  倒数第二个

 如果想从下标1的开始，输出到最后一个
print(list1[1:])
dict1 = {"name":"RUCchenli", "age":29, 29:"2026年9月必去ruc读书"}
list2 = [1, 2, dict1]

for each in dict1:
    print(each)

 删除
 根据值删除
list2 = [0, 1, 2, 3, 4, 5]
print(list2)
list2.remove(3)     删除值为3的元素
print(list2)

 根据下标删除
del list2[3]   删除下标为3的值 ，此时删除的应该是值为4的，因为刚刚3被删掉了
print(list2)


# 插入
list2.append(2)   在最后加上一个值为7的元素
print(list2)

list2.extend([8, 9, 10])  在最后直接插入一个新的列表
print(list2)

 在list初始化的时候，有种方便的操作是 循环后置
list2 = [i for i in range(10)]
print(list2)

五 数值运算及函数定义

 加减乘除 传入 格式

a = 3
b = 2
print(a+b)
print(a//b) # 地板除，两个整型除完后向下取整
print(a**b)  # a的b次方

 返回a的平方
def myfun(A) :
    C=A**2
    return C

a = 3
print(myfun(a))

 这里可以默认一个值为固定值，但是一定放后面
def myfun2(A, B=2):
    C=A**B
    return C

六 类的使用

 类，模型

 初始化
 __init__ 一般会用这个函数初始化
 通过self传播各个属性
class person():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def print_name(self):
        print(self.name)

ali = person("li",29) #实例化
print(ali.name)
ali.print_name()
print(ali.print_name())  # 没有返回值，会输出None

 继承
class superman(person):  # 直接继承前者的属性
    def __init__(self, name, age):
        super().__init__(name, age)
        self.fly_ = True;

    def fly(self):
        if self.fly_ == True:
            print("我会飞~")

superli = superman("li~",29)

superli.fly()

七、矩阵的使用

#矩阵

import numpy as np
import torch
# tensor 张量
 
list1 =[
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15]
]

print(list1)
 转化为矩阵
array1 = np.array(list1)
print(array1)  # 输出方式不一样

array2 = np.array(list1)
print(array2)

 矩阵拼接
array3 = np.concatenate((array1, array2), axis=1)  # 矩阵拼接 水平拼接 ，如果axis=0 是上下拼接
print(array3)

 矩阵切片
print(array3[1:3, 1:3])  # 取下标1到下标3的行， 下标1到下标3的列
print(array3[:, :])


 跳着切
idx = [1, 3]
print(array3[:, idx])  # 切片所有行， 下标1的列和 下标3的列

八、张量

import torch
import numpy as np
# 张量
list1 =[
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15]
]

# print(list1)
#
# tensor1 = torch.tensor(list1)
# print(tensor1)
#
# array1 = np.array(list1)
# print(array1)
w = 3

# ========== 第一部分：创建【张量A】 ==========
x = torch.tensor(3.0)  # 1. 在内存中创建了一个「值=3.0」的张量，命名为【张量A】
                       # 2. 把标签 x 贴到【张量A】身上
x.requires_grad_(True) # 给【张量A】开启梯度追踪 ✔️
w = torch.tensor(3.0, requires_grad=True) # 创建一个新的 值=3.0」的张量，赋值给w
y = x**2 + w
y.backward()           # 对张量 x , w 求梯度，计算出 x.grad = 6.0 , w.grad =1.0
print(x.grad)          # 打印的是【张量A】的梯度 → 6.0 ✔
print(w.grad)

# ========== 第二部分：创建【张量B】 ==========
x.grad = torch.tensor(0.0)  # 1. 在内存中创建了一个「值=0.0」的全新张量，
                       # 2. 把标签 x 从【张量A】身上撕下来，重新贴到【张量B】身上
                       # 3. 【张量A】依然存在于内存中，它的梯度值6.0也依然存在！
y2 = x**2
# y2.backward()
print(x.grad)


# 直接创建张量
tensor1 = torch.ones((100,4)) # 创建一个全是1的张量
tensor2 = torch.zeros((10, 4)) # 10行4列的全是0的张量
tensor3 = torch.normal(0, 0.01, (10, 4)) # 平均数 ，标准差 ，(行数，列数)

# 张量求和
tensor4 = torch.ones((10,4))
sum1 = torch.sum(tensor4)  # 求所有的和

sum2 = torch.sum(tensor4, dim=0) # 从上到下 行相加
sum3 = torch.sum(tensor4, dim=1) # 从左到右 列相加
sum4 = torch.sum(tensor4, dim=1, keepdim=True) # 从左到下 列相加 ，保持形状
print(tensor4)
print(sum4)

# 想知道张量的形状

print(tensor4.shape)