版权声明：本文为博主非原创文章，未经博主允许可以转载。

 
 

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. a=np.array([1,2,3,4,5])
  4. b=np.array([[1,2,3],[4,5,6]])
  5. c=list(a)   # array到list的转换
  6. print a,np.shape(a)
  7. print b,np.shape(b)
  8. print c,np.shape(c)
list1=[1,2,3,'a']

print list1

a=np.array([1,2,3,4,5])

b=np.array([[1,2,3],[4,5,6]])

c=list(a)   # array到list的转换

print a,np.shape(a)

print b,np.shape(b)

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,)
[1, 2, 3, 'a'] # 元素数据类型不同，并且用逗号隔开

[1 2 3 4 5] (5L,) # 一维数组，类型用tuple表示

[[1 2 3]

 [4 5 6]] (2L, 3L)

[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()
a=np.array((1,2,3,4,5))# 参数是元组

b=np.array([6,7,8,9,0])# 参数是list

c=np.array([[1,2,3],[4,5,6]])# 参数二维数组

print a,b,

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
c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])

c.shape # (3L, 4L)

c.shape=4,-1   //c.reshape((2,-1))

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; rgb(255, 255, 255);">array([[ 1,  2,  3],
  2. [ 4,  4,  5],
  3. [ 6,  7,  7],
  4. [ 8,  9, 10]])
<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; ">array([[ 1,  2,  3],

       [ 4,  4,  5],

       [ 6,  7,  7],

       [ 8,  9, 10]])
   
   这里的reshape最终相当于是一个浅拷贝，也就是说还是和原来的书c使用相同的内存空间
  1. d=c.reshape((2,-1))
  2. d[1:2]=100
  3. c
d=c.reshape((2,-1))

d[1:2]=100

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; rgb(255, 255, 255);">
a1=np.array([[1,2,3],[4,5,6]],dtype=np.float64)

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; ">

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







  1. arr1=np.arange(1,10,1) #
    2. 

  2. arr2=np.linspace(1,10,10)
    3. 

  3. print arr1,arr1.dtype
    4. 

  4. print arr2,arr2.dtype






arr1=np.arange(1,10,1) #

arr2=np.linspace(1,10,10)

print arr1,arr1.dtype

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. 

  2. return i%4+2
    3. 

  3. np.fromfunction(fun,(10,))






def fun(i):

    return i%4+2

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. 

  2. return (i+1)*(j+1)
    3. 

  3. np.fromfunction(fun2,(9,9))






def fun2(i,j):

    return (i+1)*(j+1)

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. 

  2. file=open(fileName)
    3. 

  3. dataMat=[]  //
    4. 

  4. for line in file.readlines():
    5. 

  5. curLine=line.strip().split('\t')
    6. 

  6. floatLine=map(float,curLine)//这里使用的是map函数直接把数据转化成为float类型
    7. 

  7. dataMat.append(floatLine)
    8. 

  8. return dataMat






def loaddataSet(fileName):

    file=open(fileName)

    dataMat=[]  //

    for line in file.readlines():

        curLine=line.strip().split('\t')

        floatLine=map(float,curLine)//这里使用的是map函数直接把数据转化成为float类型

        dataMat.append(floatLine)

    return dataMat  


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






元素访问：


 






  1. arr[5] #5
    2. 

  2. arr[3:5] #array([3, 4])
    3. 

  3. arr[:5] #array([0, 1, 2, 3, 4])
    4. 

  4. arr[:-1]# array([0, 1, 2, 3, 4, 5, 6, 7, 8])
    5. 

  5. arr[:] #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    6. 

  6. arr[2:4]=100 # array([  0,   1, 100, 100,   4,   5,   6,   7,   8,   9])
    7. 

  7. arr[1:-1:2] #array([  1, 100,   5,   7]) 2 是间隔
    8. 

  8. arr[::-1] #array([  9,   8,   7,   6,   5,   4, 100, 100,   1,   0])
    9. 

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






arr[5] #5

arr[3:5] #array([3, 4])

arr[:5] #array([0, 1, 2, 3, 4])

arr[:-1]# array([0, 1, 2, 3, 4, 5, 6, 7, 8])

arr[:] #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

arr[2:4]=100 # array([  0,   1, 100, 100,   4,   5,   6,   7,   8,   9])

arr[1:-1:2] #array([  1, 100,   5,   7]) 2 是间隔

arr[::-1] #array([  9,   8,   7,   6,   5,   4, 100, 100,   1,   0])

arr[5:2:-1]# -1的间隔表示从右向左所以5>2  #array([  5,   4, 100])




 


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




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

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






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

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


[[4 4 5]]

[4 4 5]




  1. print c[1]
    2. 

  2. print c[1:2]






print c[1]

print c[1:2]


[4 4 5]

[[4 4 5]]




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

  2. print c[1:4]
    3. 

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






print c[1][2]

print c[1:4]

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. 

  2. b[:3]=0
    3. 

  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; rgb(255, 255, 255);">array([0, 0, 0, 0, 4, 5, 6, 7, 8, 9])






b=arr[1:6]

b[:3]=0

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; ">array([0, 0, 0, 0, 4, 5, 6, 7, 8, 9])


    


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




  1. list1=list(c)
    2. 

  2. list1[1]=0
    3. 

  3. list1  #上面修改的0并没有被改变






list1=list(c)

list1[1]=0

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. 

  2. a>5
    3. 

  3. a[a>5]  #






a=np.array(a*2)

a>5

a[a>5]  # 


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




   2)列表索引




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




  1. x=np.arange(10)
    2. 

  2. index=[1,2,3,4,5]
    3. 

  3. arr_index=np.array(index)
    4. 

  4. print x
    5. 

  5. print x[index]  # list索引
    6. 

  6. print x[arr_index]  # array索引






x=np.arange(10)

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

arr_index=np.array(index)

print x

print x[index]  # list索引

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. 

  2. lista=list(a)
    3. 

  3. print a*2
    4. 

  4. print lista*2






a=np.arange(10)

lista=list(a)

print a*2

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. 

  2. b = np.arange(0, 5)
    3. 

  3. print a
    4. 

  4. print b






a = np.arange(0, 60, 10).reshape(-1, 1)

b = np.arange(0, 5)

print a

print b


[[ 0]

 [10]

 [20]

 [30]

 [40]

 [50]]

[0 1 2 3 4]




  1. print np.add(a,b,c)


 




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]]






												


											
python中的list和array的不同之处 2的更多相关文章
	

    
						
  1. python中的list和array的不同之处 及转换
		
    python中的list和array的不同之处list是列表,可以通过索引查找数值,但是不能对整个列表进行数值运算 In [96]: b=[1,2] In [97]: b[1]Out[97]: 2In ...
    
		
    2. 
								
  2. python中的list和array的不同之处
		
    原文地址:  http://blog.csdn.net/liyaohhh/article/details/51055147#reply python中的list是python的内置数据类型,list中 ...
    
		
    3. 
						
  3. 关于python中的矩阵乘法（array和mat类型）
		
    关于python中的矩阵乘法,我们一般有两种数据格式可以实现:np.array()类型和np.mat()类型: 对于这两种数据类型均有三种操作方式: (1)乘号 * (2)np.dot() (3)np ...
    
		
    4. 
						
  4. python中的list以及list与array相互转换
		
    python中的list是一种有序集合,可以随时增删元素: # -*- coding: utf-8 -*- frameID = 1 frameID_list = [] frameID_list.app ...
    
		
    5. 
						
  5. python学习笔记——多进程中共享内存Value & Array
		
    1 共享内存 基本特点: (1)共享内存是一种最为高效的进程间通信方式,进程可以直接读写内存,而不需要任何数据的拷贝. (2)为了在多个进程间交换信息,内核专门留出了一块内存区,可以由需要访问的进程将 ...
    
		
    6. 
						
  6. python中几个常见的“黑盒子”之 列表list
		
    python常见的数据类型有:字符串,布尔类型,整数,浮点数,数字,日期,列表,元祖,字典.相信前面6个大家都非常的熟悉,但是对于python的列表,元祖,字典我有时候一直在想其内部的实现是怎么样子的 ...
    
		
    7. 
						
  7. python中的迭代与递归
		
    遇到一个情况,需要进行递归操作,但是呢递归次数非常大,有一万多次.先不说一万多次递归,原来的测试代码是java的,没装jdk和编译环境,还是用python吧 先看下原本的java代码: public  ...
    
		
    8. 
						
  8. python中的进程、线程（threading、multiprocessing、Queue、subprocess）
		
    Python中的进程与线程 学习知识,我们不但要知其然,还是知其所以然.你做到了你就比别人NB. 我们先了解一下什么是进程和线程. 进程与线程的历史 我们都知道计算机是由硬件和软件组成的.硬件中的CP ...
    
		
    9. 
						
  9. Python中利用LSTM模型进行时间序列预测分析
		
    时间序列模型 时间序列预测分析就是利用过去一段时间内某事件时间的特征来预测未来一段时间内该事件的特征.这是一类相对比较复杂的预测建模问题,和回归分析模型的预测不同,时间序列模型是依赖于事件发生的先后顺 ...
    
		
    10. 
		

	


随机推荐
	

    
									
  1. <..................> 哈佛大学哲学系 && 历史哲学笔记文献集
			
    哈佛大学哲学系课程表            (一)概况    (1)哈佛大学哲学系现有教师21人,其中访问教授7人,教师流动性较大,每年有一定的变化.以下为现任教师:Richard Moran(系主任 ...
    
			
    2. 
						
  2. python错误笔记
			
    1.print "hello world!";SyntaxError:Missing parentheses in call to ‘paint’ . Did you mean p ...
    
			
    3. 
						
  3. Map.Entry<K,V>分析
			
    一.好处 你是否已经对每次从Map中取得关键字然后再取得相应的值感觉厌倦? Set keys = map.keySet( ); if(keys != null) { Iterator iterator ...
    
			
    4. 
						
  4. spring boot 2.0添加对fastjson的支持
			
    首先引入fastjson的maven依赖: <dependency> <groupId>com.alibaba</groupId> <artifactId&g ...
    
			
    5. 
						
  5. Android Studio的快捷键
			
    Android Studio可以在setting的keymaps设置快捷键,但最好使用该默认的快捷键. 生成TAG: logt 控制台打印带参的log:logm 代码提示:ctrl + alt + s ...
    
			
    6. 
						
  6. django目录下的路由系统和视图函数
			
    一.Django路由系统(url) 1.什么是路由系统 路由系统的本质是URL模式以及要为该URL模式调用的视图函数之间的一个映射表即不同的url路径对应的不同的函数,该路由系统是存放在全局配置文件u ...
    
			
    7. 
						
  7. Nginx反向代理+负载均衡简单实现
			
    一.基础环境: 负   载  机:A机器: 192.168.71.223后端机器1:B机器:192.168.71.224后端机器2:C机器:192.168.71.226 需求: 1)访问A机器的808 ...
    
			
    8. 
						
  8. python基础深入(元组、字符串、列表、字典)
			
    python基础深入(元组.字符串.列表.字典) 一.列表 1.追加 >>>list = [1,2,3,4] #用于在列表末尾添加新的对象,只能单个添加,该方法无返回值,但是会修改原 ...
    
			
    9. 
						
  9. sql两张表关联更新字段
			
    记录,推荐使用第三种,个人觉得比较好 --第一种写法,之前一直用,没有在意 UPDATE sr_t_TCodeUserReciveCfg SET fUserID=a.fUserID,fImportFl ...
    
			
    10. 
						
  10. P4271 [USACO18FEB]New Barns
			
    题目 P4271 [USACO18FEB]New Barns 做法 这题很长见识啊!! 知识点:两棵树\((A,B)\)联通后,新树的径端点为\(A\)的径端点与\(B\)的径端点的两点 不断加边,那 ...
    
			
    11.