python中的list和array的不同之处

最新推荐文章于 2025-03-14 17:33:21 发布
转载 最新推荐文章于 2025-03-14 17:33:21 发布 · 175 阅读 · 0

博客介绍了Python中list和array的不同。list是内置数据类型，数据类型可不相同，保存的是数据地址，增加存储和CPU消耗；而array由numpy封装，功能强大，存放的数据类型必须相同。还提及了array的创建、元素访问和广播。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

                               python中的list和array的不同之处


       python中的list是python的内置数据类型，list中的数据类不必相同的，而array的中的类型必须全部相同。在list中的数据类型保存的是数据的存放的地址，简单的说就是指针，并非数据，这样保存一个list就太麻烦了，例如list1=[1,2,3,'a']需要4个指针和四个数据，增加了存储和消耗cpu。

      numpy中封装的array有很强大的功能，里面存放的都是相同的数据类型



 
  1. 
   
    
    
    
   
    
   
    
    
    
     list1=[
     1,
     2,
     3,
     'a']
    
    
   
  2. 
   
    
    
    
   
    
   
    
    
    
     print list1
    
    
   
  3. 
   
    
    
    
   
    
   
    
    
     
    
    
   
  4. 
   
    
    
    
   
    
   
    
    
    
     a=np.array([
     1,
     2,
     3,
     4,
     5])
    
    
   
  5. 
   
    
    
    
   
    
   
    
    
    
     b=np.array([[
     1,
     2,
     3],[
     4,
     5,
     6]])
    
    
   
  6. 
   
    
    
    
   
    
   
    
    
    
     c=list(a)   
     # array到list的转换
    
    
   
  7. 
   
    
    
    
   
    
   
    
    
    
     print a,np.shape(a)
    
    
   
  8. 
   
    
    
    
   
    
   
    
    
    
     print b,np.shape(b)
    
    
   
  9. 
   
    
    
    
   
    
   
    
    
    
     print c,np.shape(c)

运行结果：


 
  1. 
   
    
    
    
   
    
   
    
    
    
     [
     1, 
     2, 
     3, 
     'a'] 
     # 元素数据类型不同，并且用逗号隔开
    
    
   
  2. 
   
    
    
    
   
    
   
    
    
    
     [
     1 
     2 
     3 
     4 
     5] (
     5L,) 
     # 一维数组，类型用tuple表示
    
    
   
  3. 
   
    
    
    
   
    
   
    
    
    
     [[
     1 
     2 
     3]
    
    
   
  4. 
   
    
    
    
   
    
   
    
    
    
      [
     4 
     5 
     6]] (
     2L, 
     3L)
    
    
   
  5. 
   
    
    
    
   
    
   
    
    
    
     [
     1, 
     2, 
     3, 
     4, 
     5] (
     5L,)

创建：

    array的创建：参数既可以是list，也可以是元组.使用对应的属性shape直接得到形状 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      a=np.array((
      1,
      2,
      3,
      4,
      5))
      # 参数是元组
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      b=np.array([
      6,
      7,
      8,
      9,
      0])
      # 参数是list
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      c=np.array([[
      1,
      2,
      3],[
      4,
      5,
      6]])
      # 参数二维数组
     
    
    
  4. 
    
    
     
    
    
    
    
    
     
    
      print a,b,
     
    
    
  5. 
    
    
     
    
    
    
    
    
     
    
      c.shape()

   也可以直接改变属性array的形状，-1代表的是自己推算。这里并不是T, reshape(())也可以 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      c = np.array([[
      1, 
      2, 
      3, 
      4],[
      4, 
      5, 
      6, 
      7], [
      7, 
      8, 
      9, 
      10]])
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      c.shape 
      # (3L, 4L)
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      c.shape=
      4,
      -1   //c.reshape((
      2,
      -1))
     
    
    
  4. 
    
    
     
    
    
    
    
    
     
    
      c  
     
    
    

  

  
  1. 
    
    
     
    
    
    
    
    
     
    
      <pre style=
      "box-sizing: border-box; overflow: auto; font-size: 14px; padding: 0px; margin-top: 0px; margin-bottom: 0px; line-height: 17.0001px; word-break: break-all; word-wrap: break-word; border: 0px; border-radius: 0px; white-space: pre-wrap; vertical-align: baseline; background-color: rgb(255, 255, 255);">array([[ 
      1,  
      2,  
      3],
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
             [ 
      4,  
      4,  
      5],
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
             [ 
      6,  
      7,  
      7],
     
    
    
  4. 
    
    
     
    
    
    
    
    
     
    
             [ 
      8,  
      9, 
      10]])
     
    
    

  
   
   这里的reshape最终相当于是一个浅拷贝，也就是说还是和原来的书c使用相同的内存空间

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      d=c.reshape((
      2,
      -1))
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      d[
      1:
      2]=
      100
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      c
     
    
    

  

 

 
array([[  1,   2,   3],
       [  4,   4,   5],
       [100, 100, 100],
       [100, 100, 100]])

 
 
 
   前面在创建数组的时候并没有使用数据类型，这里我们也可以使用数据类型。默认的是int32.
 
 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      a1=np.array([[
      1,
      2,
      3],[
      4,
      5,
      6]],dtype=np.float64)
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      print a1.dtype,a.dtype  
      #float64 int32<pre style="margin-top: 0px; margin-bottom: 0px; line-height: 17.0001px; box-sizing: border-box; overflow: auto; font-size: 14px; padding: 0px; word-break: break-all; word-wrap: break-word; border: 0px; border-radius: 0px; white-space: pre-wrap; vertical-align: baseline; background-color: rgb(255, 255, 255);">
     
    
    

  

 
 前面在创建的时候我们都是使用的np.array()方法从tuple或者list转换成为array，感觉很是费劲，numpy自己提供了很多的方法让我们自己直接创建一个array. 
 
 
 
 
 
 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      arr1=np.arange(
      1,
      10,
      1) 
      # 
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      arr2=np.linspace(
      1,
      10,
      10)
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      print arr1,arr1.dtype
     
    
    
  4. 
    
    
     
    
    
    
    
    
     
    
      print arr2,arr2.dtype
     
    
    

  

 
[1 2 3 4 5 6 7 8 9] int32
[  1.   2.   3.   4.   5.   6.   7.   8.   9.  10.] float64

 
 np.arange(a,b,c)表示产生从a-b不包括b，间隔为c的一个array，数据类型默认是int32。但是linspace(a,b,c)表示的是把a-b平均分成c分，它包括b。
 

 
   有时候我们需要对于每一个元素的坐标进行赋予不同的数值，可以使用fromfunction函数

 

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      def fun(i):
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
        
      return i%
      4+
      2
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      np.fromfunction(fun,(
      10,))
     
    
    

  

 

 
array([ 2.,  3.,  4.,  5.,  2.,  3.,  4.,  5.,  2.,  3.])
 
 
   fromfunction必须支持多维数组，所以他的第二个参数必须是一个tuple，只能是(10,),(10)是错误的。

 

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      def fun2(i,j):
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
        
      return (i+
      1)*(j+
      1)
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      np.fromfunction(fun2,(
      9,
      9))
     
    
    

  

 

 
array([[  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.],
       [  2.,   4.,   6.,   8.,  10.,  12.,  14.,  16.,  18.],
       [  3.,   6.,   9.,  12.,  15.,  18.,  21.,  24.,  27.],
       [  4.,   8.,  12.,  16.,  20.,  24.,  28.,  32.,  36.],
       [  5.,  10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.],
       [  6.,  12.,  18.,  24.,  30.,  36.,  42.,  48.,  54.],
       [  7.,  14.,  21.,  28.,  35.,  42.,  49.,  56.,  63.],
       [  8.,  16.,  24.,  32.,  40.,  48.,  56.,  64.,  72.],
       [  9.,  18.,  27.,  36.,  45.,  54.,  63.,  72.,  81.]])
 
 
    虽然说，这里提供了很多的直接产生array的方式，但是大部分情况我们都是会从list进行转换，因为在实际的处理中，我们需要从txt加载文件，那样直接读入的数据显示存放到list中，需要处理的时候我们转换到array,因为

 
array的设计更加符合我们的使用，涉及到矩阵的运算在使用mat，那么list主要就是用进行元素的索取。

 

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      def loaddataSet(fileName):  
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
          file=open(fileName)  
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
          dataMat=[]  //
     
    
    
  4. 
    
    
     
    
    
    
    
    
     
        
      for line 
      in file.readlines():  
     
    
    
  5. 
    
    
     
    
    
    
    
    
     
    
              curLine=line.strip().split(
      '\t')  
     
    
    
  6. 
    
    
     
    
    
    
    
    
     
    
              floatLine=map(float,curLine)//这里使用的是map函数直接把数据转化成为float类型  
     
    
    
  7. 
    
    
     
    
    
    
    
    
     
    
              dataMat.append(floatLine)  
     
    
    
  8. 
    
    
     
    
    
    
    
    
     
        
      return dataMat  
     
    
    

  

 
 上面的韩顺返回最终的数据就是最初的list数据集，再根据不同的处理需求是转化到array还是mat。其实array是mat的父类，能用mat的地方，array理论上都能传入。
 

 

 
 元素访问：

 

   
 

 

  
  

   
  1. 
     
    
      
    
     
    
     
    
      
    
       arr[
       5] 
       #5
      
    
     
  2. 
     
    
      
    
     
    
     
    
      
    
       arr[
       3:
       5] 
       #array([3, 4])
      
    
     
  3. 
     
    
      
    
     
    
     
    
      
    
       arr[:
       5] 
       #array([0, 1, 2, 3, 4])
      
    
     
  4. 
     
    
      
    
     
    
     
    
      
    
       arr[:
       -1]
       # array([0, 1, 2, 3, 4, 5, 6, 7, 8])
      
    
     
  5. 
     
    
      
    
     
    
     
    
      
    
       arr[:] 
       #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
      
    
     
  6. 
     
    
      
    
     
    
     
    
      
    
       arr[
       2:
       4]=
       100 
       # array([  0,   1, 100, 100,   4,   5,   6,   7,   8,   9])
      
    
     
  7. 
     
    
      
    
     
    
     
    
      
    
       arr[
       1:
       -1:
       2] 
       #array([  1, 100,   5,   7]) 2 是间隔
      
    
     
  8. 
     
    
      
    
     
    
     
    
      
    
       arr[::
       -1] 
       #array([  9,   8,   7,   6,   5,   4, 100, 100,   1,   0]) 
      
    
     
  9. 
     
    
      
    
     
    
     
    
      
    
       arr[
       5:
       2:
       -1]
       # -1的间隔表示从右向左所以5>2  #array([  5,   4, 100])
      
    
     

   

  

 

 

   
 

 
   上面是array的一维数组的访问方式，我们再来看看二维的处理方式

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      print c[
      1:
      2]
      #  c[1:2].shape-->(1L, 3L)
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      print c[
      1:
      2][
      0]  
      # shape-->(3L,)
     
    
    

  

 

 
[[4 4 5]]
[4 4 5]

 

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      print c[
      1]
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      print c[
      1:
      2]
     
    
    

  

 

 
[4 4 5]
[[4 4 5]]

 

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      print c[
      1][
      2]
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      print c[
      1:
      4]
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      print c[
      1:
      4][
      0][
      2]
     
    
    

  

 

 
5
[[  4   4   5]
 [100 100 100]
 [100 100 100]]
5

 

 
   可以看出对于有:的表达最终的结果外面还嵌套一层list的[]，。访问的一定要注意，python最bug的就是，语法

 
灵活，不管怎样写索引语法都是正确的，但是最终的书结果却让你大跌眼镜。

 

 

 
    还有array的索引最终产生的是一个一个原始数据的浅拷贝，还和原来的数据共用一块儿内存

 

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      b=arr[
      1:
      6]
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      b[:
      3]=
      0
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      arr  
      #<pre style="box-sizing: border-box; overflow: auto; font-size: 14px; padding: 0px; margin-top: 0px; margin-bottom: 0px; line-height: 17.0001px; word-break: break-all; word-wrap: break-word; border: 0px; border-radius: 0px; white-space: pre-wrap; vertical-align: baseline; background-color: rgb(255, 255, 255);">array([0, 0, 0, 0, 4, 5, 6, 7, 8, 9])
     
    
    

  

 
    

 
    产生上面的原因是因为array中直接存放的数据，拷贝的话直接拿走的是pointer，没有取走数据，但是list却会直接发生深拷贝，数据指针全部带走

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      list1=list(c)
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      list1[
      1]=
      0
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      list1  
      #上面修改的0并没有被改变
     
    
    

  

 

 
[array([1, 2, 3]), 0, array([100, 100, 100]), array([100, 100, 100])]

 

 

 
   除了这些之外还有自己的更加牛掰的方式（只能用array)

 
   1）使用布尔数组.感觉甚是强大，就不要自己写什么判断语句啦，注意这种方式得到结果不和原始数组共享空间。布尔索引仅仅适用于数组array，list没资格用。布尔索引最终得到下标索引为true的数据。索引只能是布尔数组

 

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      a=np.array(a*
      2)
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      a>
      5
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      a[a>
      5]  
      # 
     
    
    

  

 
array([16, 32, 48, 64, 80, 16, 32, 48, 64, 80])

 

 
   

 
   2)列表索引

 

 
      列表索引可以是数组和list。返回的数据不和原来的数据共享内存。索引可以是list和array

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      x=np.arange(
      10)
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      index=[
      1,
      2,
      3,
      4,
      5]
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      arr_index=np.array(index)
     
    
    
  4. 
    
    
     
    
    
    
    
    
     
    
      print x
     
    
    
  5. 
    
    
     
    
    
    
    
    
     
    
      print x[index]  
      # list索引
     
    
    
  6. 
    
    
     
    
    
    
    
    
     
    
      print x[arr_index]  
      # array索引
     
    
    

  

 

 

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

 

 
  array和list区别*2

 

 

  
  1. 
    
    
     
    
    
    
    
    
     
    
      a=np.arange(
      10)
     
    
    
  2. 
    
    
     
    
    
    
    
    
     
    
      lista=list(a)
     
    
    
  3. 
    
    
     
    
    
    
    
    
     
    
      print a*
      2
     
    
    
  4. 
    
    
     
    
    
    
    
    
     
    
      print lista*
      2
     
    
    

  

 

 
[ 0  2  4  6  8 10 12 14 16 18]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

 

 
 array的广播

 

  

 

 

  
  

   
  1. 
     
    
      
    
     
    
     
    
      
    
       a = np.arange(
       0, 
       60, 
       10).reshape(
       -1, 
       1)
      
    
     
  2. 
     
    
      
    
     
    
     
    
      
    
       b = np.arange(
       0, 
       5)
      
    
     
  3. 
     
    
      
    
     
    
     
    
      
    
       print a
      
    
     
  4. 
     
    
      
    
     
    
     
    
      
    
       print b
      
    
     

   

  
[[ 0]
 [10]
 [20]
 [30]
 [40]
 [50]]
[0 1 2 3 4]

  

  
print np.add(a,b,c)
   

  

  
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]
 [50 51 52 53 54]]

  

 

 

 
 
 
 
 
 

 

转自博客：https://blog.youkuaiyun.com/liyaohhh/article/details/51055147#reply

                

                
                
        

    

    
  



    



                



	

		

			

				
					
python中的array函数作用_Python中的Array | 数组2(简介和功能)

				
			

			

				

					weixin_39755853的博客
				

				

					12-04
					
					5160
					
				

			

		

		

			
				
相关文章：Python中的数组Array | 1(简介和功能)以下是更多函数。1. typecode：此函数返回初始化数组所用的数据类型。2. itemsize：此函数返回单个数组元素的大小(以字节为单位)。3. buffer_info()：返回一个元组，表示存储数组的地址和数组中的元素数。# Python代码，展示如何使用函数：typecode, itemsize, buffer_info()#...

			
		

	



                

            
              



	

		

			

				
					
python 中的list和array的不同之处及转换问题

				
			

			

				

					12-23
				

			

		

		

			
				
python中的list是python的内置数据类型，list中的数据类不必相同的，而array的中的类型必须全部相同。在list中的数据类型保存的是数据的存放的地址，简单的说就是指针，并非数据，这样保存一个list就太麻烦了，例如...

			
		

	



              


  
              

                


	

		

			

				
					
python list 与 array 的区别

				
			

			

				

					weixin_39087379的博客
				

				

					05-27
					
					160
					
				

			

		

		

			
				
list 列表，可以包含不同的元素，可以使用 append 在末尾添加元素
array 矩阵，内部的元素类型相同



			
		

	





	

		

			

				
					
numpy数组和矢量运算03

				
			

			

				

					AIHUBEI的博客
				

				

					06-13
					
					737
					
				

			

		

		

			
				
numpy 基础：数组和矢量运算
xiaoyao
NumPy是在⼀个连续的内存块中存储数据，独⽴于其他Python内置对象。NumPy的C语⾔编写的算法库可以操作内存，⽽不必进⾏类型检查或其它前期⼯作。⽐起Python的内置序列，NumPy数组使⽤的内存更少。NumPy可以在整个数组上执⾏复杂的计算，⽽不需要Python的for循环。
# 导入packages
import numpy as np

np.random.seed(12345)

import matplotlib.pyplot as plt

			
		

	



		

			
		



	

		

			

				
					
python中的array函数_NumPy的数组对象

				
			

			

				

					weixin_39947306的博客
				

				

					12-03
					
					3372
					
				

			

		

		

			
				
NumPy的主要操作对象是同类型的多维数组，数组中的所有元素类型都是相同的，数组对象名是ndarray，别名是array。一、创建数组可以有多种方式创建NumPy数组：(1)使用NumPy的array函数从Python列表中创建数组，数组类型由列表中的数据类型确定；(2)使用NumPy的zeros函数创建数组元素全部为0的数组，默认情况下数组元素的类型为float64；(3)使用NumPy的one...

			
		

	





	

		

			

				
					
详解Python list和numpy array的存储和读取方法

				
			

			

				

					09-18
				

			

		

		

			
				
`list`和`numpy array`是两种常见的数据结构，分别用于不同场景。这篇文章将详细介绍这两种结构的存储和读取方法。  首先，我们来看`list`。`list`是Python内置的数据类型，它允许存储任意类型的元素，并且是动态...

			
		

	





	

		

			

				
					
Python列表list数组array用法实例解析

				
			

			

				

					12-24
				

			

		

		

			
				
本文以实例形式详细讲述了Python列表list数组array用法。分享给大家供大家参考。具体如下： Python中的列表(list)类似于C#中的可变数组（ArrayList），用于顺序存储结构。   创建列表   复制代码 代码如下:sample_...

			
		

	





	

		

			

				
					
(numpy)python中Array的常用函数

				
			

			

				

					weixin_43760295的博客
				

				

					06-24
					
					1万+
					
				

			

		

		

			
				
python中Array的常用函数1.unique2.sum3.max
1.unique
a = np.random.randint(10, size=20).reshape(4,5)
a
>>>array([[0, 8, 1, 9, 2],
          [9, 4, 3, 6, 5],
          [7, 3, 4, 5, 1],
          [2, 0...

			
		

	





	

		

			

				
					
List集合和数组的区别以及三种转换方式

				
			

			

				

					ProGram_Java521的博客
				

				

					09-21
					
					4236
					
				

			

		

		

			
				
List集合和数组的区别以及三种转换方式   Java数组转List的三种方式及对比

			
		

	





	

		

			

				
					
浅述一下list和数组的区别

				
			

			

				

					youcanreally的博客
				

				

					04-19
					
					739
					
				

			

		

		

			
				
总的来说，List 提供了更多的灵活性和方便性，但在性能上可能略逊于数组，特别是在大量元素的情况下。因此，在选择使用数组还是 List 时，需要根据具体情况来权衡性能和灵活性的需求。list在访问元素时需要额外的间接寻址开销，因为他是根据链表或动态数组实现的，需要根据索引遍历到相应的位置。list是泛型集合，list的大小是可以动态调整的，可以根据需要增加或减少元素，不需要建新的数据结构。数组的大小是固定的，不能直接增加或删除元素，需要额外的操作来重新分配内存空间。1、动态大小和静态大小。

			
		

	





	

		

			

				
					
数组和List之间的区别及转换

				
			

			

				

					cxbtdd的博客
				

				

					11-03
					
					672
					
				

			

		

		

			
				
附上arraylist扩充机制：newCapacity=oldCapacity+(oldCapacity>>1)(注：>>1:右移1位，相当于除以2)，但由于源码里传过来的minCapcatiy的值是size+1，能够实现grow方法调用就肯定是(size+1)>elementData.length的情况，所以size就是初始最大容量或上一次扩容后达到的最大容量，才会进行扩容。而且，每次添加新的元素的时候都会检查内部数组的空间是否足够，效率比数组低(这是比较麻烦的地方)。

			
		

	





	

		

			

				
					
list和array的区别 --- python

					
热门推荐

				
			

			

				

					kakazai.cn
				

				

					08-07
					
					1万+
					
				

			

		

		

			
				
list和array的区别

list和array都可以根据索引来取其中的元素。

list是列表，list中的元素的数据类型可以不一样。array是数组，数组中的元素的数据类型必须一样。

list不可以进行四则运算，array可以进行四则运算。


code




x = [1,2,'a']   #x是一个list，list里面的元素的数据类型可以不同
print(x[0])     #可以...

			
		

	





	

		

			

				
					
数组跟列表有什么区别

				
			

			

				

					再来一下！
				

				

					06-01
					
					1528
					
				

			

		

		

			
				
灵活性：列表更灵活，可以包含任意类型的元素，适用于通用的数据存储和处理。效率：NumPy 数组在内存和计算效率上更优，适用于需要大量数值计算和科学计算的场景。根据具体需求选择合适的数据结构是关键。对于需要高效数值计算和处理多维数据的任务，NumPy 数组是更好的选择；而对于一般用途的数据存储和处理，列表则更为合适。

			
		

	





	

		

			

				
					
地基Python中​列表（List）​ 和 ​数组（Array）​ 区别

					
最新发布

				
			

			

				

					qq_37679639的博客
				

				

					03-14
					
					934
					
				

			

		

		

			
				
Python 中，​列表（List）​ 和 ​数组（Array）​ 是两种不同的数据结构，主要区别简易介绍

			
		

	





	

		

			

				
					
java中Array（数组）、List（列表）、Set（集合）、Map（映射）、Queue（队列）详解

				
			

			

				

					2301_79858914的博客
				

				

					06-16
					
					3598
					
				

			

		

		

			
				
数据结构特点适用场景数组（Array）固定大小，索引访问，类型一致固定大小数据集，快速访问列表（List）动态大小，有序，允许重复需要频繁添加、删除元素的数据集集合（Set）无序，不允许重复元素快速查找，去重映射（Map）键值对，键唯一映射关系的数据集，快速访问键对应的值队列（Queue）FIFO顺序处理元素按顺序处理元素的场景掌握这些基本数据结构及其应用场景，能够帮助你更有效地处理和管理数据，从而编写更高效的Java程序。

			
		

	





	

		

			

				
					
python中list和array的区别

				
			

			

				

					开飞机的小毛驴儿
				

				

					12-02
					
					237
					
				

			

		

		

			
				
简单地说，list是python中的基本数据类型，其中的元素类型可以不同，例如：

[1,'a','b',3]

而array是numpy包中的一种类型，它里面的元素类型必须完全相同，例如

[1,2,3,4]

一个最直观的相似点就是二者都用中括号[]来表示。
...

			
		

	





	

		

			

				
					
Array和List的区别

				
			

			

				

					xuanzeticai的专栏
				

				

					10-30
					
					559
					
				

			

		

		

			
				
Array和List都属于顺序表。

			
		

	





	

		

			

				
					
【C#】C#中的Array数组,List集合和ArrayList集合

				
			

			

				

					冰茶的博客
				

				

					01-10
					
					1562
					
				

			

		

		

			
				
类型安全性:Array和List提供类型安全,而ArrayList不提供。
大小调整:Array大小固定,List和 ArrayList大小可动态调整。
性能:Array通常性能最好,List次之,ArrayList由于装箱和拆箱可能性能最差。
使用场景:Array适合固定大小的集合,List适合动态大小且类型一致的集合，ArrayList适合需要存储不同类型对象的旧代码。

			
		

	





	

		

			

				
					
python中list和array

				
			

			

				

					07-28
				

			

		

		

			
				
在Python中，list和array是两种不同的数据类型。list是Python的内置数据类型，而array是numpy库中定义的数据类型。在使用array之前，需要先下载和安装numpy库\[2\]。  list和array在一些方面有相同之处，比如它们都...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值