深度学习中的数据类型

已于 2025-04-24 14:58:02 修改
阅读量338 收藏 8
点赞数 4
文章标签： 深度学习 人工智能
于 2025-03-29 14:20:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_58970439/article/details/146677594
版权

I.python 原有数据类型

1.集合 Set = { }

        （Pandas库可替代集合）

  • 特点

    • 无序无索引：元素无顺序
    • 无重复：自动去重
    • 可变：可增删元素
    • 使用花括号 {} 或 set() 定义
my_set = {1, 2, 3, 2, "apple"}  # 自动去重 → {1, 2, 3, "apple"}
my_set.add(5)               # 添加元素 → {1, 2, 3, "apple", 5}
my_set.remove(2)            # 删除元素 → {1, 3, "apple", 5}

2. 元组 Tuple = ( )

  • 特点

    • 有序：元素按插入顺序存储
    • 不可更改：创建后不能修改
    • 允许重复：元素可重复出现
    • 使用圆括号 () 定义
my_tuple = (1, 2, "banana", False)
print(my_tuple[2])        # 访问元素 → "banana"
new_tuple = my_tuple + (5,)  # 合并元组 → (1, 2, "banana", False, 5)
one_tuple = (8,)             # 长度为1的元组这么写，（8）表示整形数字

3.列表 List = [ ]

  • 特点

    • 有序：元素按插入顺序存储
    • 可变：可修改元素（增删改）
    • 允许重复：元素可重复出现
    • 使用方括号 [] 定义

  • 基本使用

    my_list = [1, 2, 3, "apple", True]
# 添加元素 → [1, 2, 3, "apple", True, 4]
my_list.append(4)     
# 修改元素 → [100, 2, 3, "apple", True, 4]     
my_list[0] = 100
# 删除元素 → [100, 2, 3, True, 4]       
del my_list[3]

    • 列表切片

             注意切片列表赋值会修改原列表

    my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# --- 基础用法 ---
print(my_list[2:5])     # 元素取值范围为索引[2,5){或者看做[2,4]} → [2, 3, 4]
print(my_list[:3])      # 元素取值范围为索引[0,3) → [0, 1, 2]
print(my_list[5:])      # 索引5到末尾 → [5, 6, 7, 8, 9]
print(my_list[::2])     # 步长2 → [0, 2, 4, 6, 8]

# --- 负索引和逆序 ---
print(my_list[-3:])     # 最后3个元素 → [7, 8, 9]
print(my_list[::-1])    # 反转列表 → [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# --- 切片赋值（修改原列表）---
my_list[2:5] = [20, 30, 40]  # 替换索引[2,5) → [0, 1, 20, 30, 40, 5, 6, 7, 8, 9]
my_list[::2] = [0] * 5       # 替换偶数索引 → [0, 1, 0, 30, 0, 5, 0, 7, 0, 9]

    4. 字典 Dictionary = { }

    • # 创建整数型数组
arr1 = np.array( [1, 2, 3] ) # 元素若都是整数，则为整数型数组
print(arr1)

      特点

      • 无序有索引：Python 3.7+ 后有序（插入顺序）
      • 键值对结构：{key: value}
      • 键不可重复：键不可重复
      • 可变：可修改键值对
      • 使用花括号 {} 或 dict() 定义
    my_dict = {"name": "Alice", "age": 30, "city": "New York"}
my_dict["age"] = 31        # 修改值 → {"name": "Alice", "age": 31, "city": "New York"}
my_dict["job"] = "Engineer"  # 添加键值对 → {..., "job": "Engineer"}
del my_dict["city"]        # 删除键值对 → {"name": "Alice", "age": 31, "job": "Engineer"}

    II.新增数据类型

    1. NumPy 数组 (numpy.ndarray)

    import numpy as np

# 创建一维数组——向量
arr1 = np.array([1, 2, 3])
print(arr1)  # 输出: [1 2 3]

# 创建二维数组——行矩阵
arr2 = np.array([[1, 2, 3]])
print(arr2)  # 输出: [[1 2 3]]

# 创建二维数组——列矩阵
arr3 = np.array([[1], [2], [3]])
print(arr3)
# 输出:
# [[1]
#  [2]
#  [3]]

# 创建二维数组——矩阵
arr4 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr4)
# 输出:
# [[1 2 3]
#  [4 5 6]]
    •  创建随机数组
    import numpy as np

# 0 - 1 均匀分布的浮点型随机数组，形状为 5 的向量
arr1 = np.random.random(5)
print(arr1)
# 示例输出: [0.59699399 0.89113584 0.00695752 0.49089431 0.32050609]

# 创建 60 - 100 范围内均匀分布的 3 行 3 列随机数组
arr_custom = (100 - 60) * np.random.random((3, 3)) + 60
print(arr_custom)
# 示例输出（每次运行结果不同）: 
# [[75.456789  82.345678  63.234567]
#  [92.123456  68.987654  77.654321]
#  [88.432109  61.234567  95.678901]]

# 整数型随机数组，形状为(1, 15)的矩阵
arr2 = np.random.randint(10, 100, (1, 15))
print(arr2)
# 示例输出: [[17 65 54 48 82 57 52 26 28 27 53 36 61 92 13]]

# 服从正态分布的随机数组，形状为(2, 3)的二维矩阵
arr3 = np.random.normal(0, 1, (2, 3))
print(arr3)
# 示例输出: 
# [[-0.43163964 -1.56817412  0.5460523 ]
#  [-2.93093358  0.42577899 -1.69842077]]

    • 一个 NumPy 数组只容纳一种数据类型， NumPy 数组分为整数型数组与浮点型数组

    import numpy as np

# 创建整数型数组
arr1 = np.array( [1, 2, 3] ) # 元素若都是整数，则为整数型数组
print(arr1)
# 创建浮点型数组
arr2 = np.array( [1.0, 2, 3] ) # 内含浮点数，则为浮点型数组
print(arr2)

    类型转化——>.astype( ) 方法

    import numpy as np
 # 整数型数组
arr1 = np.array( [1, 2, 3] )
print(arr1)
# [1 2 3]
 # 整数型数组 ——> 浮点型数组
arr2 = arr1.astype(float)
print(arr2)
# [1. 2. 3.]
# 浮点型数组 ——> 整数型数组
arr3 = arr2.astype(int)
print(arr3)
# [1 2 3]
    import numpy as np

# 整数型数组
arr = np.array([1, 2, 3])
print(arr)  # 输出: [1 2 3]

# 整数型数组与浮点数做运算
print(arr + 0.0)  # 输出: [1. 2. 3.]
print(arr * 1.0)  # 输出: [1. 2. 3.]

# 整数型数组遇到除法（即便是除以整数）
print(arr / 1)  # 输出: [1. 2. 3.]

# 整数型数组与浮点型数组做运算
int_arr = np.array([1, 2, 3])
float_arr = np.array([1.0, 2, 3])
print(int_arr + float_arr)  # 输出: [2. 4. 6.]

    数组维度

            当数组有 1 层中括号，如[1 2 3]，则其为一维数组，其形状是 3 或 (3,) ；

            当数组有 2 层中括号，如[[1 2 3]]，则其为二维数组，其形状是 (1,3) ；

            当数组有 3 层中括号，如[[[1 2 3]]]，则其为三维数组，其形状是 (1,1,3) ；

            将一维数组称为向量，二维数组称为矩阵。

    import numpy as np

# 传入形状 3，造出一维数组
arr1 = np.ones(3)
print(arr1)  # 输出: [1. 1. 1.]

# 传入形状(1, 3)，造出二维数组
arr2 = np.ones((1, 3))
print(arr2)  # 输出: [[1. 1. 1.]]

# 传入形状(1, 1, 3)，造出三维数组
arr3 = np.ones((1, 1, 3))
print(arr3)  # 输出: [[[1. 1. 1.]]]

# 使用数组的 .shape 属性查看 arr1 的形状
print(arr1.shape)  # 输出: (3,)

# 使用数组的 .shape 属性查看 arr2 的形状
print(arr2.shape)  # 输出: (1, 3)

# 使用数组的 .shape 属性查看 arr3 的形状
print(arr3.shape)  # 输出: (1, 1, 3)

    数组维度转换——>.reshape( )

    import numpy as np

# 创建一维数组
arr1 = np.arange(10)
print(arr1)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 升级为二维数组
arr2 = arr1.reshape((1, -1))
print(arr2)  # 输出: [[0 1 2 3 4 5 6 7 8 9]]
    import numpy as np

# 创建二维数组
arr2 = np.arange(10).reshape(2, 5)
print(arr2)
# 输出:
# [[0 1 2 3 4]
#  [5 6 7 8 9]]

# 降级为一维数组
arr1 = arr2.reshape(-1)
print(arr1)  # 输出: [0 1 2 3 4 5 6 7 8 9]

    访问元素

    import numpy as np

# 创建向量
arr1 = np.arange(1, 10)
print(arr1)  # 输出: [1 2 3 4 5 6 7 8 9]

# 访问元素
print(arr1[3])  # 正着访问，输出: 4
print(arr1[-1])  # 倒着访问，输出: 9

# 修改数组元素
arr1[3] = 100
print(arr1)  # 输出: [1 2 3 100 5 6 7 8 9]

# 创建矩阵
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2)
# 输出:
# [[1 2 3]
#  [4 5 6]]

# 访问元素
print(arr2[0, 2])  # 输出: 3
print(arr2[1, -2])  # 输出: 5

# 修改元素
arr2[1, 1] = 100.9
print(arr2)
# 输出:
# [[1 2 3]
#  [4 100 6]]

    花式索引

            访问单个元素时，向量用 arr1[x]，矩阵用 arr2[x,y]。 普通索引用一层中括号，花式索引用两层中括号。

    （1）向量的花式索引：

    import numpy as np

# 创建向量
arr1 = np.arange(0, 90, 10)
print(arr1)  # 输出: [ 0 10 20 30 40 50 60 70 80]

# 花式索引
print(arr1[[0, 2]])  # 输出: [0 20]

     （2）矩阵的花式索引

    import numpy as np

# 创建矩阵
arr2 = np.arange(1, 17).reshape(4, 4)
print(arr2)
# 输出:
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]
#  [13 14 15 16]]

# 花式索引
print(arr2[[0, 1], [0, 1]])  
# 0行0列，1行1列，输出: [1 6]
print(arr2[[0, 1, 2], [2, 1, 0]])  
# 0行2列，1行1列，2行0,列，输出: [3  6  9]

# 修改数组元素
arr2[[0, 1, 2, 3], [3, 2, 1, 0]] = 100
print(arr2)
# 输出:
# [[  1   2   3 100]
#  [  5   6 100   8]
#  [  9 100  11  12]
#  [100  14  15  16]]

    数组切片

    import numpy as np

arr1 = np.arange(10)

# 当明确知道从第 x 个元素切到第 y 个元素
print(arr1)  # 输出: [0 1 2 3 4 5 6 7 8 9]
print(arr1[1:4])  # 从索引[1]开始，切到索引[4]之前，输出: [1 2 3]
print(arr1[1:])  # 从索引[1]开始，切到结尾，输出: [1 2 3 4 5 6 7 8 9]
print(arr1[:4])  # 从数组开头开始，切到索引[4]之前，输出: [0 1 2 3]

# 当明确切除数组的开头与结尾
print(arr1)  # 输出: [0 1 2 3 4 5 6 7 8 9]
print(arr1[2:-2])  # 切除开头 2 个和结尾 2 个，输出: [2 3 4 5 6 7]
print(arr1[2:])  # 切除开头 2 个，输出: [2 3 4 5 6 7 8 9]
print(arr1[:-2])  # 切除结尾 2 个，输出: [0 1 2 3 4 5 6 7]

# 当明确隔几个元素采样一次时
print(arr1)  # 输出: [0 1 2 3 4 5 6 7 8 9]
print(arr1[::2])  # 每 2 个元素采样一次，输出: [0 2 4 6 8]
print(arr1[::3])  # 每 3 个元素采样一次，输出: [0 3 6 9]
print(arr1[1:-1:2])  # 切除一头一尾后，每 2 个元素采样一次，输出: [1 3 5 7]

    矩阵切片

    import numpy as np

# 创建 4 行 5 列的矩阵
arr2 = np.arange(1, 21).reshape(4, 5)
print(arr2)
# 输出:
# [[ 1  2  3  4  5]
#  [ 6  7  8  9 10]
#  [11 12 13 14 15]
#  [16 17 18 19 20]]

# 矩阵切片初体验
print(arr2[1:3, 1:-1])
# 输出:
# [[ 7  8  9]
#  [12 13 14]]

# 跳跃采样
print(arr2[::3, ::2])
# 输出:
# [[ 1  3  5]
#  [16 18 20]]

    提取矩阵的行、列

    import numpy as np

# 创建 4 行 5 列的矩阵
arr3 = np.arange(1, 21).reshape(4, 5)
print(arr3)
# 输出:
# [[ 1  2  3  4  5]
#  [ 6  7  8  9 10]
#  [11 12 13 14 15]
#  [16 17 18 19 20]]

# 提取第 2 行
print(arr3[2, :])  # 输出: [11 12 13 14 15]

# 提取 1 至 2 行
print(arr3[1:3, :])
# 输出:
# [[ 6  7  8  9 10]
#  [11 12 13 14 15]]

# 规范的提取行
print(arr3[2, :])  # 输出: [11 12 13 14 15]
# 简便的提取行
print(arr3[2])  # 输出: [11 12 13 14 15]
    import numpy as np

# 创建一个 4 行 5 列的矩阵
arr4 = np.arange(1, 21).reshape(4, 5)
print(arr4)
# 输出:
# [[ 1  2  3  4  5]
#  [ 6  7  8  9 10]
#  [11 12 13 14 15]
#  [16 17 18 19 20]]

# 提取第 2 列（注意，输出的是向量）
print(arr4[:, 2])  # 输出: [ 3  8 13 18]

# 提取 1 至 2 列
print(arr4[:, 1:3])
# 输出:
# [[ 2  3]
#  [ 7  8]
#  [12 13]
#  [17 18]]
            值得注意的是，提取某一个单独的列时，出来的结果是一个向量。如果你真的想要提取一个列矩阵出来，示例如下。 
    import numpy as np

# 创建 3 行 5 列的矩阵
arr5 = np.arange(1, 16).reshape(3, 5)
print(arr5)
# 输出:
# [[ 1  2  3  4  5]
#  [ 6  7  8  9 10]
#  [11 12 13 14 15]]

# 提取第 2 列为向量
cut = arr5[:, 2]
print(cut)  # 输出: [ 3  8 13]

# 升级为列矩阵
cut = cut.reshape((-1, 1))
print(cut)
# 输出:
# [[ 3]
#  [ 8]
#  [13]]

    数组切片仅是视图

            与 Python 列表和 Matlab 不同，NumPy 数组的切片仅仅是原数组的一个视图。换言之，NumPy 切片并不会创建新的变量。

            深度学习中为节省内存，将多次使用 arr[:] =<表达式> 来替代 arr = <表达式>。

    import numpy as np

# 创建原数组 arr
arr = np.arange(10)
print(arr)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 创建 arr 的切片 cut
cut = arr[:3]
print(cut)  # 输出: [0 1 2]

# 对切片的数值进行修改
cut[0] = 100
print(cut)  # 输出: [100 1 2]

# 原数组也被修改
print(arr)  # 输出: [100 1 2 3 4 5 6 7 8 9]
            如果真的需要为切片创建新变量（这种情况很稀少），使用 .copy( ) 方法。 
    import numpy as np

# 创建一个 0 到 10 的向量 arr
arr = np.arange(10)
print(arr)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 创建 arr 的拷贝切片
copy = arr[:3].copy()
print(copy)  # 输出: [0 1 2]

# 对拷贝切片的数值进行修改
copy[0] = 100
print(copy)  # 输出: [100 1 2]

# 原数组不为所动
print(arr)  # 输出: [0 1 2 3 4 5 6 7 8 9]

    数组赋值仅是绑定

            与 NumPy 数组的切片一样，NumPy 数组完整的赋值给另一个数组，也只是绑定。换言之，NumPy 数组之间的赋值并不会创建新的变量，示例如下：

    import numpy as np

# 创建一个 0 到 9 的数组变量 arr1
arr1 = np.arange(10)
print(arr1)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 把数组 1 赋值给另一个数组 2
arr2 = arr1
print(arr2)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 修改数组 2
arr2[0] = 100
print(arr2)  # 输出: [100 1 2 3 4 5 6 7 8 9]

# 原数组也被修改
print(arr1)  # 输出: [100 1 2 3 4 5 6 7 8 9]
    如果真的需要赋给一个新数组，使用 .copy( ) 方法。 
    import numpy as np

# 创建一个 0 到 9 的数组变量 arr1
arr1 = np.arange(10)
print(arr1)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 把数组 1 的拷贝赋值给另一个数组 2
arr2 = arr1.copy()
print(arr2)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 修改数组 2
arr2[0] = 100
print(arr2)  # 输出: [100 1 2 3 4 5 6 7 8 9]

# 查看数组 1
print(arr1)  # 输出: [0 1 2 3 4 5 6 7 8 9]

    2. Pandas  (DataFrame/Series)

    一维pandas对象Series的创建

    import numpy as np
import pandas as pd

# 数组创建法
d = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
s1 = pd.Series(d)
print(s1)
# 输出:
# a    1
# b    2
# c    3
# d    4
# e    5
# dtype: int64

# 直接创建法
value = [0, 0.2, 0.4, 0.6, 0.8, 1.0]
# value可以是 列表 数组 张量tenser
key = ['a', 'b', 'c', 'd', 'e', 'f']
s2 = pd.Series(value, index=key)
print(s2)
# 输出:
# a    0.0
# b    0.2
# c    0.4
# d    0.6
# e    0.8
# f    1.0
# dtype: float64
s3 = pd.Series(value)

     Series类型有两个属性，即value和index。

    无论是用列表、数组还是张量来创建对象，最终 values 均为numpy数组。

    import pandas as pd

# 用列表创建sr
v = [53, 64, 72, 82]
k = ['1号', '2号', '3号', '4号']
sr = pd.Series(v, index=k)
# 输出:
# 1号    53
# 2号    64
# 3号    72
# 4号    82
# dtype: int64

# 查看values属性
print(sr.values)
# 输出: array([53, 64, 72, 82], dtype=int64)

# 查看index属性
print(sr.index)
# 输出: Index(['1号', '2号', '3号', '4号'], dtype='object')

     二维pandas数据DataFrame的创建

    字典法创建二维pandas数据，必须基于多个一维series做拼接，一列一列做拼接

    import pandas as pd

# 创建sr1：各个病人的年龄
v1 = [53, 64, 72, 82]
i = ['1号', '2号', '3号', '4号']
sr1 = pd.Series(v1, index=i)
# 输出:
# 1号    53
# 2号    64
# 3号    72
# 4号    82
# dtype: int64

# 创建sr2：各个病人的性别
v2 = ['女', '男', '男', '女']
i = ['1号', '2号', '3号', '4号']
sr2 = pd.Series(v2, index=i)
# 输出:
# 1号    女
# 2号    男
# 3号    男
# 4号    女
# dtype: object

# 创建df对象
df = pd.DataFrame({'年龄': sr1, '性别': sr2})
# 输出:
#      年龄 性别
# 1号  53  女
# 2号  64  男
# 3号  72  男
# 4号  82  女

     DataFrame属性：value，index，column

    import pandas as pd

# 设定键值
v = [[53, '女'], [64, '男'], [72, '男'], [82, '女']]
i = ['1号', '2号', '3号', '4号']
c = ['年龄', '性别']

# 数组创建法
df = pd.DataFrame(v, index=i, columns=c)
print(df)
# 输出:
#      年龄 性别
# 1号  53  女
# 2号  64  男
# 3号  72  男
# 4号  82  女

# 查看values属性
print(df.values)
# 输出: array([[53, '女'],
#            [64, '男'],
#            [72, '男'],
#            [82, '女']], dtype=object)

# 查看index属性
print(df.index)
# 输出: Index(['1号', '2号', '3号', '4号'], dtype='object')

# 查看columns属性
print(df.columns)
# 输出: Index(['年龄', '性别'], dtype='object')

     退化为numpy数组

    import pandas as pd

# 设定键值
v = [[53, '女'], [64, '男'], [72, '男'], [82, '女']]
i = ['1号', '2号', '3号', '4号']
c = ['年龄', '性别']

# 数组创建法
df = pd.DataFrame(v, index=i, columns=c)

# 提取完整的数组
arr = df.values
print(arr)
# 输出:
# [['53' '女']
#  ['64' '男']
#  ['72' '男']
#  ['82' '女']]

# 提取第[0]列，并转化为一个整数型数组
arr = arr[:, 0].astype(int)
print(arr)
# 输出:
# [53 64 72 82]

     显示索引和隐式索引

    import pandas as pd

# 创建sr
v = [53, 64, 72, 82]
k = ['1号', '2号', '3号', '4号']
sr = pd.Series(v, index=k)
# 输出:
# 1号    53
# 2号    64
# 3号    72
# 4号    82
# dtype: int64

# 访问元素 - 使用loc
print(sr.loc['3号']) 
# 输出: 72

# 访问元素 - 使用iloc
print(sr.iloc[2]) 
# 输出: 72

# 花式索引 - 使用loc
print(sr.loc[['1号', '3号']]) 
# 输出:
# 1号    53
# 3号    72
# dtype: int64

# 花式索引 - 使用iloc
print(sr.iloc[[0, 2]]) 
# 输出:
# 1号    53
# 3号    72
# dtype: int64

# 修改元素 - 使用loc
sr.loc['3号'] = 100
print(sr)
# 输出:
# 1号    53
# 2号    64
# 3号    100
# 4号    82
# dtype: int64

# 修改元素 - 使用iloc
sr.iloc[2] = 100
print(sr)
# 输出:
# 1号    53
# 2号    64
# 3号    100
# 4号    82
# dtype: int64

    一维对象的索引 

    index显示索引，如['1号':'3号']，包含3号；但是隐式索引[1:3]和之前的numpy一样，不包含3

    import pandas as pd

# 创建sr
v = [53, 64, 72, 82]
k = ['1号', '2号', '3号', '4号']
sr = pd.Series(v, index=k)
# 输出:
# 1号    53
# 2号    64
# 3号    72
# 4号    82
# dtype: int64

# 访问切片 - 使用loc
print(sr.loc['1号':'3号'])
# 输出:
# 1号    53
# 2号    64
# 3号    72
# dtype: int64

# 访问切片 - 使用iloc
print(sr.iloc[0:3])
# 输出:
# 1号    53
# 2号    64
# 3号    72
# dtype: int64

# 切片仅是视图 - 使用loc
cut = sr.loc['1号':'3号']
cut.loc['1号'] = 100
print(sr)
# 输出:
# 1号    100
# 2号    64
# 3号    72
# 4号    82
# dtype: int64

# 切片仅是视图 - 使用iloc
cut = sr.iloc[0:3]
cut.iloc[0] = 100
print(sr)
# 输出:
# 1号    100
# 2号    64
# 3号    72
# 4号    82
# dtype: int64

# 对象赋值仅是绑定 - 使用loc
cut = sr
cut.loc['3号'] = 200
print(sr)
# 输出:
# 1号    100
# 2号    64
# 3号    200
# 4号    82
# dtype: int64

# 对象赋值仅是绑定 - 使用iloc
cut = sr
cut.iloc[2] = 200
print(sr)
# 输出:
# 1号    100
# 2号    64
# 3号    200
# 4号    82
# dtype: int64

    二维对象的索引 

    import pandas as pd

# 创建 DataFrame 对象
i = ['1号', '2号', '3号', '4号']
v1 = [53, 64, 72, 82]
v2 = ['女', '男', '男', '女']
sr1 = pd.Series(v1, index=i)
sr2 = pd.Series(v2, index=i)
df = pd.DataFrame({'年龄': sr1, '性别': sr2})

# 访问元素 - 使用 loc
print(df.loc['1号', '年龄'])
# 输出: 53

# 访问元素 - 使用 iloc
print(df.iloc[0, 0])
# 输出: 53

# 花式索引 - 使用 loc
print(df.loc[['1号', '3号'], ['性别', '年龄']])
# 输出:
#      性别  年龄
# 1号  女  53
# 3号  男  72

# 花式索引 - 使用 iloc
print(df.iloc[[0, 2], [1, 0]])
# 输出:
#      性别  年龄
# 1号  女  53
# 3号  男  72

# 修改元素 - 使用 loc
df.loc['3号', '年龄'] = 100
print(df)
# 输出:
#      年龄  性别
# 1号  53  女
# 2号  64  男
# 3号  100  男
# 4号  82  女

# 修改元素 - 使用 iloc
df.iloc[2, 0] = 100
print(df)
# 输出:
#      年龄  性别
# 1号  53  女
# 2号  64  男
# 3号  100  男
# 4号  82  女

     访问切片

    import pandas as pd

# 数组创建法
v = [[53, '女'], [64, '男'], [72, '男'], [82, '女']]
i = ['1号', '2号', '3号', '4号']
c = ['年龄', '性别']
df = pd.DataFrame(v, index=i, columns=c)

# 输出:
#      年龄 性别
# 1号  53  女
# 2号  64  男
# 3号  72  男
# 4号  82  女

# 切片 - 使用loc
print(df.loc['1号':'3号', '年龄'])
# 输出:
# 1号    53
# 2号    64
# 3号    72
# Name: 年龄, dtype: int64

# 切片 - 使用iloc
print(df.iloc[0:3, 0])
# 输出:
# 1号    53
# 2号    64
# 3号    72
# Name: 年龄, dtype: int64

# 提取二维对象的行 - 使用loc
print(df.loc['3号', :])
# 输出:
# 年龄    72
# 性别    男
# Name: 3号, dtype: object

# 提取二维对象的行 - 使用iloc
print(df.iloc[2, :])
# 输出:
# 年龄    72
# 性别    男
# Name: 3号, dtype: object

# 提取矩阵对象的列 - 使用loc
print(df.loc[:, '年龄'])
# 输出:
# 1号    53
# 2号    64
# 3号    72
# 4号    82
# Name: 年龄, dtype: int64

# 提取矩阵对象的列 - 使用iloc
print(df.iloc[:, 0])
# 输出:
# 1号    53
# 2号    64
# 3号    72
# 4号    82
# Name: 年龄, dtype: int64

     数据转置

    import pandas as pd

# 创建畸形df
v = [[53, 64, 72, 82], ['女', '男', '男', '女']]
i = ['年龄', '性别']
c = ['1号', '2号', '3号', '4号']
df = pd.DataFrame(v, index=i, columns=c)
# 输出:
#       1号  2号  3号  4号
# 年龄  53  64  72  82
# 性别  女  男  男  女

# 转置
df = df.T
print(df)
# 输出:
#       年龄 性别
# 1号  53  女
# 2号  64  男
# 3号  72  男
# 4号  82  女

     数据反转

    import pandas as pd

# 创建 DataFrame
v = [[53, 64, 72, 82], ['女', '男', '男', '女']]
i = ['年龄', '性别']
c = ['1号', '2号', '3号', '4号']
df = pd.DataFrame(v, index=i, columns=c)
df = df.T
# 输出:
#       年龄 性别
# 1号    53  女
# 2号    64  男
# 3号    72  男
# 4号    82  女

# 左右翻转
df = df.iloc[:, ::-1]
print(df)
# 输出:
#       性别  年龄
# 1号    女   53
# 2号    男   64
# 3号    男   72
# 4号    女   82

# 上下翻转
df = df.iloc[::-1, :]
print(df)
# 输出:
#       性别  年龄
# 4号    女   82
# 3号    男   72
# 2号    男   64
# 1号    女   53

     导入csv

    import pandas as pd

# 导入Pandas对象，假设Data.csv文件存在且格式正确，将第一列设为索引列
df = pd.read_csv('Data.csv', index_col=0)
# 输出：显示读取Data.csv文件后创建的DataFrame对象内容，因未提供文件内容，无法确切给出
print(df) 

# 提取纯数组，将DataFrame对象中的数据以二维数组形式提取出来
arr = df.values
# 输出：显示提取出的二维数组内容，因原DataFrame内容未知，无法确切给出
print(arr)

     数据分析——>.describe()函数

    3. Tensor（PyTorch/TensorFlow 张量）

    课件位置NumPy 的函数PyTorch 的函数用法区别
    1.1 数据类型.astype().type()无
    2.4 随机数组np.random.random()torch.rand()无
    2.4 随机数组np.random.randint()torch.randint()不接纳一维张量
    2.4 随机数组np.random.normal()torch.normal()不接纳一维张量
    2.4 随机数组np.random.randn()torch.randn()无
    3.4 数组切片.copy().clone()无
    4.4 数组拼接np.concatenate()torch.cat()无
    4.5 数组分裂np.split()torch.split()参数含义优化
    6.1 矩阵乘积np.dot()torch.matmul()无
    6.1 矩阵乘积np.dot(v,v)torch.dot()无
    6.1 矩阵乘积np.dot(m,v)torch.mv()无
    6.1 矩阵乘积np.dot(m,m)torch.mm()无
    6.2 数学函数np.exp()torch.exp()必须传入张量
    6.2 数学函数np.log()torch.log()必须传入张量
    6.3 聚合函数np.mean()torch.mean()必须传入浮点型张量
    6.3 聚合函数np.std()torch.std()必须传入浮点型张量

    Plan-C-
    关注
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

    当前余额3.43元 前往充值 >
    需支付：10.00元
    成就一亿技术人!
    领取后你会自动成为博主和红包主的粉丝 规则
    hope_wisdom
    发出的红包
    实付元
    使用余额支付
    点击重新获取
    扫码支付
    钱包余额 0

    抵扣说明：

    1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
    2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

    余额充值