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或其它第三方包,它们定义了很多方法,足够让你头晕的.

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的转置
标题URL：http://6mz.cn/article/hdohcc.html

网站建设知识

python转置函数,python的转置

python中怎样让数据列转置

Python实现矩阵转置的方法分析

pandas常用函数汇总

python transpose函数怎么用

python中transpose是什么意思

python自带及pandas、numpy数据结构(一)

其他资讯