python轉置函數,python的轉置

python中怎樣讓數據列轉置

需求:

站在用戶的角度思考問題，與客戶深入溝通，找到永修網站設計與永修網站推廣的解決方案，憑借多年的經驗，讓設計與互聯網技術結合，創造個性化、用戶體驗好的作品，建站類型包括：成都做網站、網站建設、企業官網、英文網站、手機端網站、網站推廣、域名注冊、雅安服務器托管、企業郵箱。業務覆蓋永修地區。

你需要轉置一個二維數組,將行列互換.

討論:

你需要確保該數組的行列數都是相同的.比如:

arr = [[1, 2, 3], [4, 5, 6], [7,8, 9], [10, 11, 12]]

列表遞推式提供了一個簡便的矩陣轉置的方法:

print [[r[col] for r in arr] for col in range(len(arr[0]))]

[[1, 4, 7, 10], [2, 5, 8, 11],[3, 6, 9, 12]]

另一個更快和高級一些的方法,可以使用zip函數:

print map(list,

zip(*arr))

本節提供了關于矩陣轉置的兩個方法,一個比較清晰簡單,另一個比較快速但有些隱晦.

有時候,數據到來的時候使用錯誤的方式,比如,你使用微軟的ADO接口訪問數據庫,由于Python和MS在語言實現上的差別.

Getrows方法在Python中可能返回的是列值,和方法的名稱不同.本節給的出的方法就是這個問題常見的解決方案,一個更清晰,一個更快速.

在列表遞推式版本中,內層遞推式表示選則什么(行),外層遞推式表示選擇者(列).這個過程完成后就實現了轉置.

在zip版本中,我們使用*arr語法將一維數組傳遞給zip做為參數,接著,zip返回一個元組做為結果.然后我們對每一個元組使用list方法,產生了列表的列表(即矩陣).因為我們沒有直接將zip的結果表示為list,

所以我們可以我們可以使用itertools.izip來稍微的提高效率(因為izip并沒有將數據在內存中組織為列表).

import itertools

print map(list,

itertools.izip(*arr))

但是,在特定的情況下,上面的方法對效率的微弱提升不能彌補對復雜度的增加.

關于*args和**kwds語法:

*args(實際上,*號后面跟著變量名)語法在Python中表示傳遞任意的位置變量,當你使用這個語法的時候(比如,你在定義函數時使用),Python將這個變量和一個元組綁定,并保留所有的位置信息,

而不是具體的變量.當你使用這個方法傳遞參數時,變量可以是任意的可迭代對象(其實可以是任何表達式,只要返回值是迭代器).

**kwds語法在Python中用于接收命名參數.當你用這個方式傳遞參數時,Python將變量和一個dict綁定,保留所有命名參數,而不是具體的變量值.當你傳遞參數時,變量必須是dict類型(或者是返回值為dict類型的表達式).

如果你要轉置很大的數組,使用Numeric Python或其它第三方包,它們定義了很多方法,足夠讓你頭暈的.

相關說明:

zip(...)

zip(seq1 [,

seq2 [...]]) - [(seq1[0], seq2[0] ...),

(...)]

Return a

list of tuples, where each tuple contains the i-th element

from each of

the argument sequences. The returned list is truncated

in length to

the length of the shortest argument sequence.

Python實現矩陣轉置的方法分析

Python實現矩陣轉置的方法分析

本文實例講述了Python實現矩陣轉置的方法。分享給大家供大家參考，具體如下：

前幾天群里有同學提出了一個問題：手頭現在有個列表，列表里面兩個元素，比如[1, 2]，之后不斷的添加新的列表，往原來相應位置添加。例如添加[3, 4]使原列表擴充為[[1, 3], [2, 4]]，再添加[5, 6]擴充為[[1, 3, 5], [2, 4, 6]]等等。

其實不動腦筋的話，用個二重循環很容易寫出來：

def trans(m):

a = [[] for i in m[0]]

for i in m:

for j in range(len(i)):

a[j].append(i[j])

return a

m = [[1, 2], [3, 4], [5, 6]] # 想象第一個列表是原始的，后面的是往里添加的

print trans(m) # result:[[1, 3, 5], [ 2, 4, 6]]

然而不管怎么看這種代碼都很丑。

仔細看了一下m這種結構。等等，這不是字典的iteritems()的結果么？如果dict(m)，那么結果——不就是keys()和values()么？

于是利用字典轉換一下：

def trans(m):

d = dict(m)

return [d.keys(), d.values()]

可是再仔細想想，這里面有bug。如果添加列表的第一個元素相同，也就是轉化之后dict的key相同，那肯定就不行了呀！況且，如果原始列表不是兩個，而是多個，肯定不能用字典的呀！于是這種方法作罷，還是好好看看列表的形狀。

然后又是一個不小心的發現：

這種轉置矩陣的即時感是怎么回事？

沒錯，這個問題的本質就是求解轉置矩陣。于是就簡單了，還是用個不動腦筋的辦法：

def trans(m):

for i in range(len(m)):

for j in range(i):

m[i][j], m[j][i] = m[j][i], m[i][j]

return m

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

print trans(m)

其實還是有點bug的，看起來是好用的，然而這個矩陣要求行列長度相同才行。

最后，群里某大神說：如果只是轉置矩陣的話，直接zip就好了。這才想起來zip的本質就是這樣的，取出列表中的對應位置的元素，組成新列表，正是這個題目要做的。

所以最終，這個題目（轉置矩陣）的python解法就相當奇妙了：

def trans(m):

return zip(*d)

沒錯，就這么簡單。python的魅力。

pandas常用函數匯總

pandas官方文檔:

對常用函數做了匯總，每個函數的參數可能不是全的，但是常用的，不常用的沒總結，如有問題，請不吝賜教，謝謝！

1、創建Series

? 通用函數：pd.Series(values,index)

1)pd.Series([1,2,3],index=[‘a’,‘b’,‘c‘])

2)pd.Series(np.array([1,2,3]),index=[‘a’,‘b’,‘c‘])

3)pd.Series({ 'a'：1,? 'b'：2,? 'c'：3})

? ? Series轉字典：Series.to_dict()

說明：Series的values參數是python中常見的一維數據類型。

2、屬性

1）Series.values ---array([1,2,3])

? ? ?? Series的values是array類型

2）Series.index---index([‘a’,‘b’,‘c‘])

? ? ?? 未指定index時，自動生成 0-（N-1）的整數索引，

? ? ?? 指定 index時，使用指定索引。

3、Series的索引與切片

?? Series[0] / Series['a']? : Sereis可以位置索引或標簽索引，也可以進行切片操作

1、創建DataFrame

1) 創建DataFrame的通用函數：

df = pd.DataFrame(values,index,columns)

pd.dataFrame([[1,2,3],[4,5,6],[7,8,9]],index=['a','b','c'],columns=['bj','sh','sz'])

pd.dataFrame(np.arange(1,10).reshape(3,3),index=['a','b','c'],columns=['bj','sh','sz'])

pd.dataFrame('bj':[1,4,7],'sh':[2,5,8],'sz':[3,6,9],index=['a','b','c'])

說明：創建方法與Sries類似，Series的values參數是python中常見的一維數據類型，DataFrame的values參數是python中常見的二維數據類型。

2) 通過網頁中復制數據快捷創建

? ? import webbrowser

? ? link = ''

? ? webbrowser.open(link)

? ? 打開界面進行復制，將數據復制到粘貼板中

? ? df = pd.read_clipboard() ? #從粘貼板中讀取數據

3）通過Series創建DataFrame

? ? df = pd.DataFrame([s1,s2,s3],columns=['bj','sh','sz'])

? ? 注意：單獨的s1,s2,s3是縱向排列的的Series，但是在DataFrame中是橫向排列的。

? ? 自己總結：Series除了打印出來是Series格式外，其他時候可以直接當作list來操作。

2、屬性

1)df.columns

? ? 通過columns生成新的DataFrame

? ? df_new = pd.DataFrame(df,columns=['x1','x2'])

? ? 或者df_new = df[['x1','x2']]

2)df.shape? 顯示行列數

3)df.head() ? 默認顯示前5行

4)df.tail() ? ? 默認顯示后5行

3、獲取DataFrame的列

1）獲取DataFrame某一列

? ? ? df.x1或df['x1']:返回值是Series,可以理解為一個DataFrame是由多個Series組成的。

? 2) 獲取DataFrame某幾列

? ? ? df_new = df[['x1','x2','x3']]

4、為某列賦值

? 1) df['x1'] = range(10)

? 2) df['x1'] = numpy.arange(10)

? 3) df['x1'] = pd.Series(np.arange(10))

? 說明：類似于創建Series

5、為某列對應的特定行重新賦值

? ? df['x1'] = pd.Series([2,3],index=[0,1])

? ? 將列為x1,行索引為0和1的值改為2,3

6、獲取DadaFrame的行

? for row in DataFrame.iterrows():

? ? ? ? ? print(row[0],row[1])

? #每個row是一個元祖，包含2個元素，row[0]是整型索引，row[1]是Series,所以從行的角度也可以看出，一個DataFrame是由多個Series組成的。

7、DataFrame的轉置

? df_new = df.T

1、粘貼板的io

? df = pd.read_clipboard()

? df.to_clipboard()

2、csv的io

?? df.to_csv('xxx.csv')

?? df = pd.read_csv('xxx.csv')

3、json的io

?? df.to_json()

?? pd.read_json(df.to_json())

4、excel的io

? ? df.to_excel('xx.xlsx')

? ? df = pd.read_excel('xx.xlsx')

5、df = pd.read_sql('')

? ? df.to_sql('')

1、iloc

? sub_df = df.iloc[10:20,:]? 選取DataFrame的10-20行，所有列數據

? sub_df = df.iloc[10:20,0:2]

? 說明：iloc函數是位置索引，與索引的名字無關。

2、loc

? sub_df = df.loc[10:20,:'movie_name']

? 說明：loc是標簽索引，10,20，'movie_name'? 都是索引名字，與位置無關。

1、Series.reindex(index=['x1','x2','x3'],fill_value=10)

? 將df重新索引，并且將NaN空值用10進行填充

2、Series.reindex(index=range(15),method='ffill')

前項填充，后面的值用前面的值進行填充

通過reindex想到，如果想新增一個空列或者空行，可以用reindex方法,同樣地，想減少某些行或者某些列，也可以用reindex方法。

? 繼reindex之后刪除行列的函數操作

? Series.drop('A') ? #刪除'A'所對應的值

? DataFrame.drop(label,axis)?

? label可以是行名也可以是列名，label是行的話axis是0，label是列的話axis是1。

** 刪除行還可以用 del df['A']

nan是numpy的一種數據類型，np.nan,float類型

任何數據與nan的運算結果都是nan

1、nan in Series

? Series.isnull()? --返回value為True或者False的Series

? Series.notnull()? --返回value為True或者False的Series

? Series.dropna()? --返回刪除nan值后的Series

? Series.fillna(method='ffill')? --前項插值，按照前面的值填充后面的空值

2、nan in DataFrame

? df.isnull()? --返回value為True或者False的DataFrame

? df.notnull()? --返回value為True或者False的DataFrame

? df.dropna(axis=0/1,how='any/all'，thresh=None)

? 說明：axis表示刪除行為nan或者列為nan；

? ? ? ? ? ? any表示只要有一個為空，all表示行中的每個元素或者列中的每個元素為空；

? ? ? ? ? ? thresh是閾值的意思，表示某行或者某列nan的個數達到閾值的個數時才刪除該行或該列。

? df.fillna(value=1)? ---所有的空值都填充為1

? df.fillna(value={0:0,1:1,2:2}) ---將0列的空值填為0,1列的空值填為1,2列的空值填為2，默認為填充列

? 注意：fillna和dropna的特點，生成新的DataFrame,原來的DataFrame不變。

1、多重索引介紹

Series = pd.Series(np.random.randn(6),index=[['1','1','1','2','2','2'],['a','b','c','a','b','c']])

'1','2'為一級索引，'a','b','c'為二級索引

df 可以看做是索引的'1','2'的Series

Series['1']? --Series

Series['1']['a']? --value

Series[:,'a'] --選擇'1'和'2'中的'a'對應的值

2、多重索引格式轉為二維DataFrame

df = Series.unstack() --轉為二維DataFrame

3、多重索引在DataFrame中的操作

1、 map函數與apply函數、applymap函數的區別：

? 1）map函數對Series中的每個元素作用；

? 2）applymap函數對DataFrame中的每個元素作用；

? 3）apply函數對對DataFrame和Series的一列做整體運算。

2、Series.replace(to_replace=[2,3,4],values=[20,30,40])? 替換Series中多個值

Series.replace({1:10,2:20})? 將索引為1的值替換為10，將索引為2的值替換為20

df.sum()? --默認按照列進行求和,nan的值被忽略

df.min()? --默認按照列求最小值

df.max()? --默認按照列求最大值

df.mean()? --默認按照列求平均值

df.describe()? --默認按照列進行描述

df.sum(axis=1)? --按行求和，nan的值被忽略

#axis=0表示對橫軸進行操作，但是運算中表現為縱軸操作

#axis=1表示對縱軸進行操作，但是運算中表現為橫軸操作

bins = [0,59,70,80,100],bins是分割范圍

score_cat = pd.cut(Series,bins)? ---得到catgory類型的數據

DataFrame的分箱技術很棒啊！

pd['catgory'] = pd.cut(df['a'],bins=[0,59,70,80,100],labels=['low','ok','good','great'])

--新增一列，將a列的值按照labels進行分類標記，good!!!

#生成長度為3的隨機字符串? pd.util.testing.rands(3)

1、按照一列分組

? g = df.groupby('city')

? g是分組類型數據，打印不出來，所以看不到，但是有屬性和方法可以間接的了解

1） g.groups? --得到分的幾個組，和每個組包含的索引

2）g.get_group('BJ')? --得到'BJ'所對應的組

3）groupby = split +apply +combine

? ? ?? g.mean()? --求每組的平均值

? ? ?? g.max() ? --求每組的最大值

? ? ?? g.min() ? --求每組的最小值

? ? ?? g.count()

? ? ?? g.describe()

? 4）g是一個可迭代對象，可以用list函數將其轉化為list

? ? ? list(g) -- [('組名1',DataFrame1),('組名2',DataFrame2),(),()]

? ? ? dict(list(g))? --將其轉化為字典

? 同時可以通過for循環進行遍歷操作：for item,desc in g:print(item,desc)

? #怪不得分組后不是DataFrame，因為元組的第一個元素是'分組名'。

2、按照多列分組

? g_new = df.groupby(['city','wind'])

? 得到生成器((('分組1','分組2'),DataFrame),(),()...)

? g_new.get_group(('分組1','分組2'))

? for (name_1,name_2),group in g_new:

? ? ? ? ? print((name_1,name_2),group)

g.mean()? --求每組的平均值

與g.agg('mean')方法一樣

pd.pivot_table(df,index=['',''],aggfuc='sum',values=['',''])

index是分組的組名，values是透視表呈現結果的列，columns是values下的分解

#感覺透視表呈現的結果就是groupby+agg后的結果

#分析者需要對數據結構有一定的了解

df.sort_values(by='',ascending=True/False)[:10]? df可以索引

df.value_counts()? --按值計數

df.['a'] = df['b'].apply(lambda x:x0)? --DataFrame中的True/False

通過g.size()可以看到被groupby之后的數據，得到的是一個Series

1、Series的排序：

1）對值進行排序

Series.sort_values()? ---直接對Series的值進行排序

2）通過索引進行排序

Series.sort_index()?

#默認都是升序排列

2、DataFrame的排序

df.sort_values(by='')? --按照某列的順序進行排序

df['a'].sort_values()? --返回對a列數據的排序結果，只返回a列

1、df.index = Series(['a','b','c'])? 直接對index賦予新值

2、df.index = df.index.map(str.upper)

map函數中只傳入新的函數名即可

3、df.rename(index=str.upper,columns=str.lower)

? 或者傳遞字典，進行一一轉換

pd.merge(df1,df2,on=None,how='left/right/inner/outer')

pd.merge(df1,df2)? --沒有on參數默認先找相同的columns,然后在columns下找相同的values

pd.merge(df1,df2,on='columns')? --on參數是指按照指定列進行merge

left:表示以左邊的數據表為基準，進行填充右面的數據

right:表示以右邊的數據表為基準，填充左邊的數據

outer:以on的指定列的所有值為基準，填充兩邊的數據

inner:默認inner,相同on指定的columns下的相同values對應的左右兩邊的數據

1、concat拼接

pd.concat([Series1,Series2])

pd.concat([df1,df2])? -- 上下疊加，將沒有的列進行填充

2、combine組合

Series1.combine_first(Series2)? --用Series2的值去填充Series1中為空的值

df1.combine_first(df2)? ---用df2將df1中的空值填充

df['A'] = df['A'].apply(str.upper)? ---apply函數中也只輸入函數名

len(df)? --求df的長度

len(df['a'].unique())? --查看a列中不重復數據的多少

Series.duplicated()? --返回一列True/False的Series

Series.drop_duplicates()? --刪除重復值

df.drop_duplicates('a',keep='first/last')

df.drop_duplicates()? --刪除完全重復的行

參數：'a'表示以a列為基準，刪除重復值

? ? ? ? ? first表示保留第一個，last表示保留最后一個

data_list = pd.date_range(start,end,period='D',freq)

period='D',以天為單位

freq = 'W' 以周為單位

freq = 'W-Mon'以每周一位單位

freq = '5H'? 以5h為單位

以data_range作為索引提取數據比較簡單

df[datetime(2017,9,1)]

df['2017-09-01']

df['20170901']

df['201709']

對時間序列數據進行分組聚合操作：

s1.resample('M').mean()? --以月為單位進行采樣，然后求每組的平均值

s1.resample('H').ffill()? --前項填充

s1.resample('H').bfill()? --后項填充

補充：1）jupyter中可以執行linux命令，太棒了！

? ? ? ? ? ? !ls

? ? ? ? ? ? !more xxx.csv

? ? ? ? ? ? !pwd? 等等

? ? ?? 2）jupyter 查看函數幫助的快捷鍵：摁住shift + tab? 棒！！！

python transpose函數怎么用

比如，將A1:E1轉置到A3:A7

首先選定A3:A7然后輸入

=TRANSPOSE($A$1:$E$1)

最后按【組合鍵】確認。

python中transpose是什么意思

我先來一個舉例：

arr = np.arange(16).reshape((2, 2, 4))

arr的array是這樣的

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

[ 4, 5, 6, 7]],

[[ 8, 9, 10, 11],

[12, 13, 14, 15]]])

我們對arr進行transpose轉置，arr2 = arr.transpose((1,0,2))，結果是這樣：

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

[ 8, 9, 10, 11]],

[[ 4, 5, 6, 7],

[12, 13, 14, 15]]])

這是怎么來的呢。

arr.transpose((1,0,2))的1,0,2三個數分別代表shape()的三個數的順序，初始的shape是（2,2,4），也就是2維的2 x 4矩陣，索引分別是shape的[0],[1],[2]，arr.transpose((1,0,2))之后，我們的索引就變成了shape[1][0][2],對應shape值是shape(2,2,4)，所以矩陣形狀不變。

與此同時，我們矩陣的索引也發生了類似變化，如arr中的4，索引是arr[0,1,0],arr中的5是arr[0,1,1]，變成arr2后，4的位置應該是在[1,0,0]，5的位置變成[1,0,1]，同理8的索引從[1,0,0]變成[0,1,0]。

python自帶及pandas、numpy數據結構(一)

1.python自帶數據結構：序列（如list）、映射（如字典）、集合（set）。

以下只介紹序列中的list：

創建list：

list1 = []

list1 = [1,2,3,4,5,6,7,8,9] #逗號隔開

list2 = [[1,2],[3,4],[5,6],[7,8]] #list2長度(len(list2))為2,list2[0] = [1,2]

liststring = list(“thisisalist”) #只用于創建字符串列表

索引list：

e = list1[0] #下標從零開始，用中括號

分片list：

es = list1[0:3]

es = list1[0:9:2] #步長在第二個冒號后

list拼接（list1.append(obj)、加運算及乘運算）：

list長度：

list每個元素乘一個數值：

list2 = numpy.dot(list2,2)

list類似矩陣相乘（每個元素對應相乘取和）：

list3 = numpy.dot(list1,list1)

#要求相乘的兩個list長度相同

list3 = numpy.dot(list2,list22)

#要求numpy.shape(list2)和numpy.shape(list22)滿足“左行等于右列”的矩陣相乘條件，相乘結果numpy.shape(list3)滿足“左列右行”

2.numpy數據結構：

Array：

產生array：

data=np.array([[1, 9, 6], [2, 8, 5], [3, 7, 4]])

data=np.array(list1)

data1 = np.zeros(5) #data1.shape = (5,),5列

data1 = np.eye(5)

索引array:

datacut = data[0,2] #取第零行第二列，此處是6

切片array：

datacut = data[0:2,2] # array([6, 5])

array長度：

data.shape

data.size

np.shape(data)

np.size(data)

len(data)

array拼接：

#括號內也有一個括號（中括號或者小括號）！

d = np.concatenate((data,data))

d = np.concatenate((data,data),axis = 1) #對應行拼接

array加法：逐個相加

array乘法：

d = data data #逐個相乘

d = np.dot(data,data) #矩陣相乘

d = data 3 #每個元素乘3

d = np.dot(data,3) #每個元素乘3

array矩陣運算：

取逆 : np.linalg.inv(data)

轉置：data.T

所有元素求和 : np.sum(data)

生成隨機數：np.random.normal(loc=0, scale=10, size=None)

生成標準正態分布隨機數組：np.random.normal(size=(4,4))

生成二維隨機數組：

np.random.multivariate_normal([0,0],np.eye(2))

生成范圍在0到1之間的隨機矩陣(M,N)：

np.random.randint(0,2,(M,N))

Matrix:

創建matrix：

mat1 = np.mat([[1, 2, 3], [4, 5, 6]])

mat1 = np.mat(list)

mat1 = np.mat(data)

matrix是二維的，所有+，-，*都是矩陣操作。

matrix索引和分列：

mat1[0:2，1]

matrix轉置：

np.transpose(mat1)

mat1.transpose()

matrix拼接：

np.concatenate([mat1,mat1])

np.concatenate([mat1,mat1],axis = 1)

numpy數據結構總結：對于numpy中的數據結構的操作方法基本相同：

創建：np.mat(list),np.array(list)

矩陣乘：np.dot(x,y)

轉置：x.T or np.transpose(x)

拼接：np.concatenate([x,y],axis = 1)

索引：mat[0:1,4],ary[0:1,4]

3.pandas數據結構:

Series:

創建series：

s = pd.Series([[1,2,3],[4,5,6]],index = [‘a’,‘b’])

索引series：

s1 = s[‘b’]

拼接series：

pd.concat([s1,s1],axis = 1) #也可使用s.append(s)

DataFrame:

創建DaraFrame:

df = pd.DataFrame([[1,2,3],[1,2,3]],index = ['a','b'],columns = ['x','y','z'])

df取某一列：

dfc1 =df.x

dfc1 = df[‘x’]

dfc2 = df.iloc[:,0] #用.iloc方括號里是數字而不是column名！

dfc2 = df.iloc[:,0:3]

df取某一行：

dfr1 = df.iloc[0]

df1 = df.iloc[0:2]

df1 = df[0:2] #這種方法只能用于取一個區間

df取某個值：

dfc2 = df.iloc[0,0]

dfc2 = df.iloc[0:2,0:3]

當前標題：python轉置函數,python的轉置
當前鏈接：http://m.kartarina.com/article22/hdohcc.html

成都網站建設公司_創新互聯，為您提供服務器托管、營銷型網站建設、軟件開發、搜索引擎優化、電子商務、Google

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯