• python 中各类型介绍及相互转换 - list, array, tensor, dict, tuple, DataFrame

    目录

    1 python 各类封装包数据类型

    1.1 list类型

    1.2 dict类型

    1.3 tuple类型

    1.4 array 数组对象

    1.5 tensor 对象

    1.6 DataFrame对象

    2 python内数据类型之间转换

    2.1 list, tuple转numpy

    2.2 numpy 转 list

    2.3 numpy 转 tensor

    2.4 numpy 转 tensor

    2.5 list 转 tensor

    2.6 tensor转list

    2.7 list 转 DataFrame

    1 python 各类封装包数据类型

    1.1 list类型

    列表，是python中最基本的数据结构；

            1. 每个元素都可以通过索引获取，索引就是index = 0, 1, ...；

            2. 列表的数据项不需要有相同的数据类型，其写法就是： 使用逗号将不同的数据项分割，使用方括号扩起来就可以；

    例子：

    1. list1 = ['physics', 'chemistry', 1997, 2000]
    2. list2 = [1, 2, 3, 4, 5 ]

            3. 使用索引获取列表数据：

    例子：

    1. >>> list1 = ['physics', 'chemistry', 1997, 2000]
    2. >>> list1[0]
    3. 'physics'
    4. >>> list1[2:4]
    5. [1997, 2000]

            4. 使用索引修改列表值：

    例子：

    1. >>> list1 = ['physics', 'chemistry', 1997, 2000]
    2. >>> list1[3] = 2345
    3. >>> list1
    4. ['physics', 'chemistry', 1997, 2345]

            5. 向列表添加元素：

    例子：

    1. >>> list1.append('qiqiqi')
    2. >>> list1
    3. ['physics', 'chemistry', 1997, 2345, 'qiqiqi']

            6. 删除列表元素

    例子：

    1. >>> list1
    2. ['physics', 'chemistry', 1997, 2345, 'qiqiqi']
    3. >>> del list1[1]
    4. >>> list1
    5. ['physics', 1997, 2345, 'qiqiqi']
    6.  
    7.  
    8. >>> list1.remove(1997)
    9. >>> list1
    10. ['physics', 2345, 'qiqiqi']

            7. 合并两个列表

    例子：

    1. >>> list1
    2. ['physics', 1997, 2345, 'qiqiqi']
    3. >>> list2 = [1,1,3]
    4. >>> list1+list2
    5. ['physics', 1997, 2345, 'qiqiqi', 1, 1, 3]

            8. 获取某元素在列表中出现的次数

    例子：

    1. >>> list1+list2
    2. ['physics', 1997, 2345, 'qiqiqi', 1, 1, 3]
    3. >>> (list1+list2).count(1)
    4. 2

            9. 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

    例子：

    1. >>> list1
    2. ['physics', 2345, 'qiqiqi']
    3. >>> list1.extend(list2)
    4. >>> list1
    5. ['physics', 2345, 'qiqiqi', 1, 1, 3]

    1.2 dict类型

    字典是python另一种可变容器模型，可以存储任意类型对象；

            字典的每个键值对（ key:value ）用冒号 : 分割，每个键值对之间用逗号 （, ）分割，整个字典包括在花括号 {} 中；

            字典的键是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一；

            值可以取任意的数据类型；

            1. 通过键来访问值：

    例子：

    1. >>> tinydict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
    2. >>> tinydict['Beth']
    3. '9102'

            2. 使用键修改字典对应的值：
    例子：

    1. >>> tinydict['Beth'] = 6666
    2. >>> tinydict
    3. {'Alice': '2341', 'Beth': 6666, 'Cecil': '3258'}

            3. 删除某一元素, 清空字典，删除字典：

    例子：

    1. >>> del tinydict['Beth']
    2. >>> tinydict
    3. {'Alice': '2341', 'Cecil': '3258'}
    4.  
    5. >>> tinydict
    6. {'Alice': '2341', 'Cecil': '3258'}
    7. >>> tinydict.clear() # 清空字典
    8. >>> tinydict
    9. {}
    10. >>> del tinydict # 删除字典
    11. >>> tinydict
    12. Traceback (most recent call last):
    13.   File "", line 1, in 
    14. NameError: name 'tinydict' is not defined

            4. 以列表返回一个字典所有的键

    例子：

    1. >>> tinydict.keys()
    2. dict_keys(['Alice', 'Beth', 'Cecil'])

    1.3 tuple类型

            与列表类型不同之处在于，其使用小括号，且值不能被修改；

                    1. 使用索引访问元素（与list相同）

    例子：

    1. >>> tup1 = ('physics', 'chemistry', 1997, 2000)
    2. >>> tup1[0]
    3. 'physics'

                    2. 对元组进行连接：
    例子：

    1. >>> tup1 = ('physics', 'chemistry', 1997, 2000)
    2. >>> tup1[0]
    3. 'physics'
    4. >>> tup2 = ('1','cs')
    5. >>> tup3 = tup1 + tup2
    6. >>> tup3
    7. ('physics', 'chemistry', 1997, 2000, '1', 'cs')

    1.4 array 数组对象

    Numpy 支持大量的维度数组与矩阵运算，且针对数组运算提供了大量的数学函数库；

            NumPy 通常与 SciPy（Scientific Python， SciPy 是一个开源的 Python 算法库和数学工具包）和 Matplotlib（绘图库，是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习；

            1. NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合；

            2. ndarray 是用于存放同类型元素的多维数组，每个元素占有相同大小的内存区域；

            3. 创建n维数组；

    例子：

    1. >>> import numpy as np
    2. >>> a = np.array([1,2,3])  # 一维数组
    3. >>> a
    4. array([1, 2, 3])
    5. >>> a = np.array([[1,  2],  [3,  4]])
    6. >>> a
    7. array([[1, 2],
    8.        [3, 4]]) # 多维数组

            4. numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未赋值的数组

    例子：

    1. >>> x = np.empty([3,2], dtype = int)
    2. >>> x
    3. array([[ 7290888465049002104,  3184989590875566189],
    4.        [ 8104636977815248178,  2987133850644979813],
    5.        [-5764607523034234870, -5764607523034234880]])
    6. >>> x.shape
    7. (3, 2)
    8. >>> x.dtype
    9. dtype('int64')

            5. 创建值全为0的数组：

    例子：

    1. >>> x = np.zeros(5) # 默认是浮点数类型
    2. >>> x
    3. array([0., 0., 0., 0., 0.])
    4. >>> y = np.zeros((5,), dtype = int) 
    5. >>> y
    6. array([0, 0, 0, 0, 0])
    7. >>> y.shape
    8. (5,)
    9. >>> y.dtype
    10. dtype('int64')
    11. >>> n = np.zeros((3,2))
    12. >>> n
    13. array([[0., 0.],
    14.        [0., 0.],
    15.        [0., 0.]])
    16.

            6.  从数值范围创建数组(np.arange):

    例子：

    1. numpy.arange(start, stop, step, dtype)
    2. # start 起始值，默认为0
    3. # stop 终止值（不包含）
    4. # step 步长，默认为1
    5. # dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型
    6.  
    7. >>> x = np.arange(1,5,2) 
    8. >>> x
    9. array([1, 3])

            7. 修改数组形状：

    例子：

    1. numpy.reshape(arr, newshape, order='C') # 不改变数据的条件下修改形状
    2. # arr：要修改形状的数组
    3. # newshape：整数或者整数数组，新的形状应当兼容原有形状
    4.  
    5. >>> a = np.arange(8)
    6. >>> a
    7. array([0, 1, 2, 3, 4, 5, 6, 7])
    8. >>> b = a.reshape(4,2)
    9. >>> b
    10. array([[0, 1],
    11.        [2, 3],
    12.        [4, 5],
    13.        [6, 7]])
    14. ndarray.flatten(order='C') # 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
    15. # order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。
    16.  
    17. >>> b.flatten(order = 'F')
    18. array([0, 2, 4, 6, 1, 3, 5, 7])

    1.5 tensor 对象

            torch.Tensor是一种包含单一数据类型元素的多维矩阵；torch.Tensor是默认的tensor类型（torch.FlaotTensor）的简称；

                    1. 张量可以从python的list构成；

    例子：

    1. >>> import torch
    2. >>> a = torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
    3. >>> a
    4. tensor([[1., 2., 3.],
    5.         [4., 5., 6.]])

                    2. 创建未初始化的张量

    例子：

    1. >>> x = torch.empty(5,3)
    2. >>> x
    3. tensor([[0.0000e+00, 1.4013e-45, 0.0000e+00],
    4.         [0.0000e+00, 0.0000e+00, 0.0000e+00],
    5.         [0.0000e+00, 0.0000e+00, 0.0000e+00],
    6.         [1.1704e-41, 0.0000e+00, 2.2369e+08],
    7.         [0.0000e+00, 0.0000e+00, 0.0000e+00]])

                    3. 创建随机初始化的张量：

    例子：

    1. >>> y = torch.rand(2,2) # 包含了从区间[0,1)的均匀分布中抽取一组随机数，形状由可变参数size定义
    2. >>> y
    3. tensor([[0.7967, 0.0257],
    4.         [0.0560, 0.9289]])
    5. >>> y.size
    6. in method size of Tensor object at 0x7fa945882e50>
    7. >>> y.size()
    8. torch.Size([2, 2])
    9. >>> y.shape
    10. torch.Size([2, 2])

                    4. 创建全为0的张量

    例子：

    1. >>> z = torch.zeros(2,2)
    2. >>> z
    3. tensor([[0., 0.],
    4.         [0., 0.]])

                    5. 随机生成张量

    例子：

    1. >>> q = torch.arange(8)
    2. >>> q
    3. tensor([0, 1, 2, 3, 4, 5, 6, 7])

                    6. 张量数据类型转换：

    例子：

    1. # 使用独立的函数如 int(),float()等进行转换
    2. >>> q = q.float()
    3. >>> q
    4. tensor([0., 1., 2., 3., 4., 5., 6., 7.])
    5.  
    6. # 使用torch.type()函数
    7. >>> q = q.type(torch.FloatTensor)
    8. >>> q
    9. tensor([0., 1., 2., 3., 4., 5., 6., 7.])
    10.  
    11. # 使用type_as()函数
    12. >>> y = torch.arange(2)
    13. >>> y = y.type_as(q)
    14. >>> y
    15. tensor([0., 1.])

                    7. 张量形状改变

    例子：

    1. >>> q.view(4,-1)
    2. tensor([[0., 1.],
    3.         [2., 3.],
    4.         [4., 5.],
    5.         [6., 7.]])

                    8. 张量压缩维度：

    例子：

    1. >>> q = q.view(4,1,-1)
    2. >>> q.shape
    3. torch.Size([4, 1, 2])
    4. >>> q = q.squeeze(1)
    5. >>> q
    6. tensor([[0., 1.],
    7.         [2., 3.],
    8.         [4., 5.],
    9.         [6., 7.]])
    10. >>> q.shape
    11. torch.Size([4, 2])

                    9. 张量扩张维度

    例子：

    1. >>> q = q.unsqueeze(1)
    2. >>> q.shape
    3. torch.Size([4, 1, 2])

    1.6 DataFrame对象

    DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。

            DataFrame既有行索引，也有列索引，可以看作由 Series 组成的字典（共同用一个索引）；

            1. DataFrame构造方法

    例子：

    1. pandas.DataFrame( data, index, columns, dtype, copy)
    2. # data：一组数据(ndarray、series, map, lists, dict 等类型)
    3. # index：索引值，或者可以称为行标签
    4. # columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 
    5. # dtype：数据类型
    6. >>> import pandas as pd
    7. >>> data = [['Google',10],['Runoob',12],['Wiki',13]]
    8. >>> df = pd.DataFrame(data,columns=['Site','Age'],dtype=float)
    9. >>> df
    10.      Site   Age
    11. 0  Google  10.0
    12. 1  Runoob  12.0
    13. 2    Wiki  13.0

            2. 使用 nparray (ndarray 的长度必须相同)创建DataFrame

    例子：

    1. >>> data = {'Site':['Google', 'Runoob', 'Wiki'], 'Age':[10, 12, 13]}
    2. >>> data
    3. {'Site': ['Google', 'Runoob', 'Wiki'], 'Age': [10, 12, 13]}
    4. >>> type(data)
    5. <class 'dict'>
    6. >>> data = pd.DataFrame(data)
    7. >>> data
    8.      Site  Age
    9. 0  Google   10
    10. 1  Runoob   12
    11. 2    Wiki   13

             3. 使用dict创建DataFrame，没有对应的部分数据为 NaN

    例子：

    1. >>> data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
    2. >>> df = pd.DataFrame(data)
    3. >>> df
    4.    a   b     c
    5. 0  1   2   NaN
    6. 1  5  10  20.0

             4. 使用 loc 属性返回指定行的数据，如果没有设置索引，第一行索引为 0，第二行索引为 1

    例子：

    1. >>> df
    2.    a   b     c
    3. 0  1   2   NaN
    4. 1  5  10  20.0
    5. >>> df.loc[0]
    6. a    1.0
    7. b    2.0
    8. c    NaN
    9. Name: 0, dtype: float64

            5. 返回指定列的数据

    例子：

    1. >>> df['a']
    2. 0    1
    3. 1    5
    4. Name: a, dtype: int64

    2 python内数据类型之间转换

    2.1 list, tuple转numpy

    使用： numpy = np.array(list)

    例子：

    1. >>> list1
    2. ['physics', 2345, 'qiqiqi', 1, 1, 3]
    3. >>> numpy1 = np.array(list1)
    4. >>> numpy1
    5. array(['physics', '2345', 'qiqiqi', '1', '1', '3'], dtype=')
    6.  
    7. >>> tup1 = (1,3,'ds')
    8. >>> numpy3 = np.array(tup1)
    9. >>> numpy3
    10. array(['1', '3', 'ds'], dtype=') # 可以看到元素是同一数据类型
    11. # 这个array不能转化为tensor类型，因为 tensor内元素不支持string类型

    2.2 numpy 转 list

    使用： list = numpy.tolist()

    例子：

    1. >>> numpy2 = np.arange(4)
    2. >>> numpy2
    3. array([0, 1, 2, 3])
    4. >>> list2 = numpy2.tolist()
    5. >>> list2
    6. [0, 1, 2, 3]

    2.3 numpy 转 tensor

    使用： tensor = torch.tensor(numpy ) 或者 tensor = torch.from_numpy(numpy)

    例子：

    1. >>> numpy4 = np.empty((3,2))
    2. >>> numpy4
    3. array([[0., 0.],
    4.        [0., 0.],
    5.        [0., 0.]])
    6. >>> tensor1 = torch.tensor(numpy4)
    7. >>> tensor1
    8. tensor([[0., 0.],
    9.         [0., 0.],
    10.         [0., 0.]], dtype=torch.float64)
    11.  
    12. # from_numpy形式
    13. >>> numpy5 = np.arange(4)
    14. >>> numpy5
    15. array([0, 1, 2, 3])
    16. >>> tensor2 = torch.from_numpy(numpy5)
    17. >>> tensor2
    18. tensor([0, 1, 2, 3])

    2.4 numpy 转 tensor

    使用： numpy = tensor.numpy() 或者 numpy = tensor.detach().numpy()

            主要区别在于是否使用detach()，也就是返回的新变量是否需要计算梯度。【用了detach()，不需要计算梯度了】

    例子：

    1. >>> numpy6 = tensor2.numpy()
    2. >>> numpy6
    3. array([0, 1, 2, 3])
    4.  
    5.  
    6. >>> numpy7 = tensor2.detach().numpy()
    7. >>> numpy7
    8. array([0, 1, 2, 3])

    2.5 list 转 tensor

            先转为numpy， 再转为tensor，包装list内的元素是tensor内元素要求的类型（float64, float32, float16, complex64, complex128, int64, int32, int16, int8, uint8, and bool.） 且list内元素维度一致；

    例子：

            当list内元素包含list，和其他类型时,不能转化：

    1. >>> list3 = [1,2,[2,3]]
    2. >>> numpy8 = np.array(list3)
    3. array([1, 2, list([2, 3])], dtype=object)
    4. >>> tensor4 = torch.tensor(numpy8)
    5. Traceback (most recent call last):
    6.   File "", line 1, in 
    7. TypeError: can't convert np.ndarray of type numpy.object_. The only supported types are: float64, float32, float16, complex64, complex128, int64, int32, int16, int8, uint8, and bool.
    8.  # 因为numpy中元素是list类型的

            正常情况：

    1. >>> list4 = [[1,2],[2,3]]
    2. >>> numpy9 = np.array(list4)
    3. >>> numpy9
    4. array([[1, 2],
    5.        [2, 3]])
    6. >>> tensor5 = torch.tensor(numpy9)
    7. >>> tensor5
    8. tensor([[1, 2],
    9.         [2, 3]])

            list转tensor 也可以直接转化

    例子：

    1. >>> tensor6 = torch.tensor(list4)
    2. >>> tensor6
    3. tensor([[1, 2],
    4.         [2, 3]])

            当list中的每个元素都是tensor类型时：

    转化方法：

    val = torch.tensor([item.cpu().detach().numpy() for item in val]).cuda()

    2.6 tensor转list

    Tensor不可直接转换为list ， 需要先转换为numpy，然后在转换为list

            使用： list = tensor.numpy().tolist()

    例子：

    1. >>> list5 = tensor6.numpy().tolist()
    2. >>> list5
    3. [[1, 2], [2, 3]]

    2.7 list 转 DataFrame

    两个不同列表转换成为DataFrame:

    使用： DataFrame = pd.DataFrame(list)

    例子：

    1. >>> a=[1,2,3,4]#列表a
    2. >>> b=[5,6,7,8]#列表b
    3. >>> c={"a" : a,"b":b}
    4. >>> data = pd.DataFrame(c)
    5. >>> data
    6.    a  b
    7. 0  1  5
    8. 1  2  6
    9. 2  3  7
    10. 3  4  8

  • 相关阅读:
    JAVA每日小知识（关于excel下载时插入和stream流遍历优化）
    Flink代码单词统计 ---批处理
    Springboot中上一个定时任务没执行完，是否会影响下一个定时任务执行分析及结论
    Web 后端的一生之敌：分页器
    倾向得分匹配PSM案例分析
    TiKV+SPDK，探索存储的性能极限
    代码随想录Day29 贪心04 LeetCode T860 柠檬水找零 T406 根据身高重建队列 T452 用最少得箭引爆气球
    【云原生 | Docker】腾讯云部署Django项目 （服务器选型、git配置、docker三分钟部署）
    非线性参数的精英学习灰狼优化算法-附代码
    论文常见拉丁术语
  • 原文地址：https://blog.csdn.net/qq_40671063/article/details/126891592