list array解析(總算清楚一點了)

# -*- coding: utf-8 -*-
"""
Created on Tue Aug 09 23:04:51 2016

@author: Administrator
"""

import numpy as np

'''
 python中的list是python的內置數據類型，list中的數據類不必相同的，而array的中的類型必須全部相同。
 在list中的數據類型保存的是數據的存放的地址，簡單的說就是指針，並非數據，這樣保存一個list就太麻煩了，例如list1=[1,2,3,'a']需要4個指針和四個數據，增加了存儲和消耗cpu。
 numpy中封裝的array有很強大的功能，里面存放的都是相同的數據類型
'''
#模塊1 array list 基本展示 
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, 2, 3, 'a']
[1 2 3 4 5] (5L,)
[[1 2 3]
 [4 5 6]] (2L, 3L)
[1, 2, 3, 4, 5] (5L,)
'''

'''
whos
Variable   Type       Data/Info
-------------------------------
a          ndarray    5L: 5 elems, type `int32`, 20 bytes
b          ndarray    2Lx3L: 6 elems, type `int32`, 24 bytes
c          list       n=5
list1      list       n=4
np         module     <module 'numpy' from 'C:\<...>ages\numpy\__init__.pyc'>
'''

#模塊2 
#創建：array的創建：參數既可以是list，也可以是元組.使用對應的屬性shape直接得到形狀
print '222222222222222222222222222222222222222222\n'
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  
print c.shape  
#[1 2 3 4 5] [6 7 8 9 0] (2L, 3L) #print a,b,
#[1 2 3 4 5] [6 7 8 9 0]
#(2L, 3L) 注意：print 后面加上 \n 換行；注意：print a,b b后面沒有,換行了，如果有,不換行

#模塊3 也可以直接改變屬性array的形狀，-1代表的是自己推算
print '33333333333333333333333333333333333333333333\n'
c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])  
print c.shape # (3L, 4L)  
c.shape=4,-1
print c
c.reshape(2,-1)  
print c
print 'reshape產生新的變量'
x = c.reshape(2,-1)  
print x
'''
33333333333333333333333333333333333333333333

(3L, 4L)
[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
reshape產生新的變量
[[ 1  2  3  4  4  5]
 [ 6  7  7  8  9 10]]
'''
'''
里的reshape最終相當於是一個淺拷貝，也就是說還是和原來的書c使用相同的內存空間
'''
x[0]=1000
print x
print c
'''
33333333333333333333333333333333333333333333

(3L, 4L)
[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
reshape產生新的變量
[[ 1  2  3  4  4  5]
 [ 6  7  7  8  9 10]]
[[1000 1000 1000 1000 1000 1000]
 [   6    7    7    8    9   10]]
[[1000 1000 1000]
 [1000 1000 1000]
 [   6    7    7]
 [   8    9   10]]
'''



#模塊4 前面在創建數組的時候並沒有使用數據類型，這里我們也可以使用數據類型。默認的是int32.
a1=np.array([[1,2,3],[4,5,6]],dtype=np.float64)  
print a1.dtype,a.dtype 
#float64 int32


#模塊5 前面在創建的時候我們都是使用的np.array()方法從tuple或者list轉換成為array，感覺很是費勁，numpy自己提供了很多的方法讓我們自己直接創建一個array. 
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。
'''


#模塊6  有時候我們需要對於每一個元素的坐標進行賦予不同的數值，可以使用fromfunction函數
print '666666666666666666\n'
def fun(i):  
    return i%4+2  
print np.fromfunction(fun,(10,)) 

#[ 2.  3.  4.  5.  2.  3.  4.  5.  2.  3.]
def fun2(i,j):
    return (i+1)*(j+1) 
print np.fromfunction(fun2,(9,9))  

'''
雖然說，這里提供了很多的直接產生array的方式，但是大部分情況我們都是會從list進行轉換，因為在實際的處理中，我們需要從txt加載文件，那樣直接讀入的數據顯示存放到list中，
需要處理的時候我們轉換到array,因為array的設計更加符合我們的使用，涉及到矩陣的運算在使用mat，那么list主要就是用進行元素的索取。
'''
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理論上都能傳入。



#模塊7 元素訪問：
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print '77777777777777777'
'''

     一維數組方法   
    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])  
'''

#我們再來看看二維的處理方式
c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])  
print c[1]  
print c[1:2] 
print c[1][2]  
print c[1:4]  
print c[1:4][0][2] 

'''
[4 5 6 7]
[[4 5 6 7]]
6
[[ 4  5  6  7]
 [ 7  8  9 10]]
6
可以看出對於有:的表達最終的結果外面還嵌套一層list的[]，。訪問的一定要注意，python最bug的就是，語法
靈活，不管怎樣寫索引語法都是正確的，但是最終的書結果卻讓你大跌眼鏡。
還有array的索引最終產生的是一個一個原始數據的淺拷貝，還和原來的數據共用一塊兒內存
'''
b=arr[1:6]  
b[:3]=0 
print b
 
#產生上面的原因是因為array中直接存放的數據，拷貝的話直接拿走的是pointer，沒有取走數據，但是list卻會直接發生深拷貝，數據指針全部帶
list1=list(c)  
list1[1]=0  
print list1  #上面修改的0並沒有被改變 
print c
#[array([1, 2, 3, 4]), 0, array([ 7,  8,  9, 10])]


#模塊8 

'''
除了這些之外還有自己的更加牛掰的方式（只能用array)
1）使用布爾數組.感覺甚是強大，就不要自己寫什么判斷語句啦，注意這種方式得到結果不和原始數組共享空間。
布爾索引僅僅適用於數組array，list沒資格用。布爾索引最終得到下標索引為true的數據。索引只能是布爾數組
'''
print '888888888888\n'
a=np.array((1,2,3,4,5))# 參數是元組  
a=np.array(a*2)  
print a[a>5] #[ 6  8 10]
print a>5 # [False False  True  True  True]

#列表索引可以是數組和list。返回的數據不和原來的數據共享內存。索引可以是list和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索引 

print '8-1'
a=np.arange(10)  
lista=list(a)  
print a*2  
print lista*2     #大跌眼鏡，數組和list的乘積很嚇人

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

#模塊9 array的廣播
print '9\n'
a = np.arange(0, 60, 10).reshape(-1, 1)  
b = np.arange(0, 5)  
print a  
print b  
print np.add(a,b)