python list转换成array_Python数据分析常用知识

python list转换成array_Python数据分析常用知识_第1张图片

此文总结了一些个人在学习python、利用python进行数据分析时用到的一些知识点,主要记录关键语句,便于日后复习与查询用,根据学习进度,持续修改更新,不足之处望见谅。

1、二元运算符

python list转换成array_Python数据分析常用知识_第2张图片

2、用tuple可以将任意序列或迭代器转换成元组

In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)

In [6]: tup = tuple('string')
In [7]: tup
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')

3、拆分元组

(1)如果你想将元组赋值给类似元组的变量,Python会试图拆分等号右边的值:

In [15]: tup = (4, 5, 6)
In [16]: a, b, c = tup
In [17]: b
Out[17]: 5

(2)Python最近新增了更多高级的元组拆分功能,允许从元组的开头“摘取”几个元素。它使用了特殊的语法*rest,这也用在函数签名中以抓取任意长度列表的位置参数:

In [29]: values = 1, 2, 3, 4, 5
In [30]: a, b, *rest = values
In [31]: a, b
Out[31]: (1, 2)
In [32]: rest
Out[32]: [3, 4, 5]

4、列表

(1)用list或[ ]生成列表

(2)添加与删除元素【append、remove、insert、pop】

append在列表末尾添加元素

insert可以在特定的位置插入元素:b_list.insert(1, 'red')

insert的逆运算是pop,它移除并返回指定位置的元素:

In [49]: b_list.pop(2)
Out[49]: 'peekaboo'
In [50]: b_list
Out[50]: ['foo', 'red', 'baz', 'dwarf']

in与not in 测试某个元素是否在列表中

(3)串联和组合列表

可以用加号将两个列表串联起来:

In [57]: [4, None, 'foo'] + [7, 8, (2, 3)]
Out[57]: [4, None, 'foo', 7, 8, (2, 3)]

如果已经定义了一个列表,用extend方法可以追加多个元素:

In [58]: x = [4, None, 'foo']
In [59]: x.extend([7, 8, (2, 3)])
In [60]: x
Out[60]: [4, None, 'foo', 7, 8, (2, 3)]

通过加法将列表串联的计算量较大,因为要新建一个列表,并且要复制对象。用extend追加元素,尤其是到一个大列表中,更为可取。

(4)排序

sort函数将一个列表原地排序

In [61]: a = [7, 2, 5, 1, 3]
In [62]: a.sort()
In [63]: a
Out[63]: [1, 2, 3, 5, 7] 

sort有一些选项,有时会很好用。其中之一是二级排序key,可以用这个key进行排序。例如,我们可以按长度对字符串进行排序:

In [64]: b = ['saw', 'small', 'He', 'foxes', 'six'] 
In [65]: b.sort(key=len)
In [66]: b
Out[66]: ['He', 'saw', 'six', 'small', 'foxes']

(5)切片

用切边可以选取大多数序列类型的一部分,切片的基本形式是在方括号中使用start:stop

In [73]: seq = [7, 2, 3, 7, 5, 6, 0, 1]
In [74]: seq[1:5]
Out[74]: [2, 3, 7, 5]

切片也可以被序列赋值

In [75]: seq[3:4] = [6, 3]
In [76]: seq
Out[76]: [7, 2, 3, 6, 3, 5, 6, 0, 1]

5、序列函数

(1)enumerate

Python内建了一个enumerate函数,可以返回(i, value)元组序列

for i, value in enumerate(collection):

(2)zip函数

In [89]: seq1 = ['foo', 'bar', 'baz']
In [90]: seq2 = ['one', 'two', 'three']
In [91]: zipped = zip(seq1, seq2)
In [92]: list(zipped)
Out[92]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

(3)reversed函数

reversed可以从后向前迭代一个序列

In [100]: list(reversed(range(10)))
Out[100]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

(4)可以用del关键字或pop方法(返回值的同时删除键)删除值:

6、用序列创建字典

常常,你可能想将两个序列配对组合成字典。

mapping = {}
for key, value in zip(key_list, value_list):
mapping[key] = value

7、集合

集合是无序的不可重复的元素的集合。你可以把它当做字典,但是只有键没有值。可以用两种方式创建集合:通过set函数或使用尖括号set语句:

In [133]: set([2, 2, 2, 1, 3, 3])
Out[133]: {1, 2, 3}
 
In [134]: {2, 2, 2, 1, 3, 3}
Out[134]: {1, 2, 3}

集合支持合并、交集、差分和对称差等数学集合运算。考虑两个示例集合:

In [135]: a = {1, 2, 3, 4, 5}
In [136]: b = {3, 4, 5, 6, 7, 8}

合并是取两个集合中不重复的元素。可以用union方法,或者|运算符:

In [137]: a.union(b)
Out[137]: {1, 2, 3, 4, 5, 6, 7, 8}
 
In [138]: a | b
Out[138]: {1, 2, 3, 4, 5, 6, 7, 8}

交集的元素包含在两个集合中。可以用intersection或&运算符:

In [139]: a.intersection(b)
Out[139]: {3, 4, 5}
 
In [140]: a & b
Out[140]: {3, 4, 5}

集合常用方法

python list转换成array_Python数据分析常用知识_第3张图片

你还可以检测一个集合是否是另一个集合的子集或父集:

In [150]: a_set = {1, 2, 3, 4, 5}
In [151]: {1, 2, 3}.issubset(a_set)
Out[151]: True
 
In [152]: a_set.issuperset({1, 2, 3})
Out[152]: True

集合的内容相同时,集合才对等:

In [153]: {1, 2, 3} == {3, 2, 1}
Out[153]: True

8、列表、集合和字典推导式

列表推导式是Python最受喜爱的特性之一。它允许用户方便的从一个集合过滤元素,形成列表,在传递参数的过程中还可以修改元素。形式如下:

[expr for val in collection if condition]
dict_comp = {key-expr : value-expr for value in collection if condition}
set_comp = {expr for value in collection if condition}
 
In [154]: strings = ['a', 'as', 'bat', 'car', 'dove', 'python']
In [155]: [x.upper() for x in strings if len(x) > 2]
Out[155]: ['BAT', 'CAR', 'DOVE', 'PYTHON']

9、生成器表达式

(1)生成器

生成器(generator)是构造新的可迭代对象的一种简单方式。一般的函数执行之后只会返回单个值,而生成器则是以延迟的方式返回一个值序列,即每返回一个值之后暂停,直到下一个值被请求时再继续。要创建一个生成器,只需将函数中的return替换为yeild即可:

def squares(n=10):
    print('Generating squares from 1 to {0}'.format(n ** 2))
    for i in range(1, n + 1):
    yield i ** 2

(2)生成器表达式

其创建方式为,把列表推导式两端的方括号改成圆括号:

In [189]: gen = (x ** 2 for x in range(100))
In [190]: gen
Out[190]:  at 0x7fbbd5ab29e8>

10、NumPy的ndarray:一种多维数组对象

创建数组最简单的办法就是使用array函数。它接受一切序列型的对象(包括其他数组),然后产生一个新的含有传入数据的NumPy数组。以一个列表的转换为例:

In [19]: data1 = [6, 7.5, 8, 0, 1]
In [20]: arr1 = np.array(data1)
In [21]: arr1
Out[21]: array([ 6. , 7.5, 8. , 0. , 1. ])

11、NumPy数组的运算

数组很重要,因为它使你不用编写循环即可对数据执行批量运算。NumPy用户称其为矢量化(vectorization)。大小相等的数组之间的任何算术运算都会将运算应用到元素级:

(1)一元ufunc

python list转换成array_Python数据分析常用知识_第4张图片

python list转换成array_Python数据分析常用知识_第5张图片

(2)二元ufunc

python list转换成array_Python数据分析常用知识_第6张图片

python list转换成array_Python数据分析常用知识_第7张图片

(3)将条件逻辑表述为数组运算

numpy.where函数是三元表达式x if condition else y的矢量化版本

In [165]: xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
In [166]: yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
In [167]: cond = np.array([True, False, True, True, False])

假设我们想要根据cond中的值选取xarr和yarr的值:当cond中的值为True时,选取xarr的值,否则从yarr中选取。列表推导式的写法应该如下所示:

In [168]: result = [(x if c else y)
 .....: for x, y, c in zip(xarr, yarr, cond)]

这有几个问题。第一,它对大数组的处理速度不是很快(因为所有工作都是由纯Python完成的)。第二,无法用于多维数组。若使用np.where,则可以将该功能写得非常简洁:

In [170]: result = np.where(cond, xarr, yarr)
In [171]: result
Out[171]: array([ 1.1, 2.2, 1.3, 1.4, 2.5])

(4)基本数组统计方法

python list转换成array_Python数据分析常用知识_第8张图片

python list转换成array_Python数据分析常用知识_第9张图片

(5)数组的集合运算

python list转换成array_Python数据分析常用知识_第10张图片

(6)线性代数

python list转换成array_Python数据分析常用知识_第11张图片

(7)numpy.random中的部分函数

python list转换成array_Python数据分析常用知识_第12张图片

python list转换成array_Python数据分析常用知识_第13张图片

12、pandas的数据结构介绍

要使用pandas,你首先就得熟悉它的两个主要数据结构:Series和DataFrame。虽然它们并不能解决所有问题,但它们为大多数应用提供了一种可靠的、易于使用的基础。

eries是一种类似于一维数组的对象,它由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据即可产生最简单的Series:

DataFrame是一个表格型的数据结构,它含有一组有序的列,每列可以是不同的值类型(数值、字符串、布尔值等)。DataFrame既有行索引也有列索引,它可以被看做由Series组成的字典(共用同一个索引)。DataFrame中的数据是以一个或多个二维块存放的(而不是列表、字典或别的一维数据结构)。有关DataFrame内部的技术细节远远超出了本书所讨论的范围。

(1)创建DataFrame

最常用的一种是直接传入一个由等长列表或NumPy数组组成的字典:

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
 'year': [2000, 2001, 2002, 2001, 2002, 2003],
 'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)

如果指定了列序列,则DataFrame的列就会按照指定顺序进行排列:

In [47]: pd.DataFrame(data, columns=['year', 'state', 'pop'])

你也可以使用类似NumPy数组的方法,对DataFrame进行转置(交换行和列):

In [68]: frame3.T
Out[68]: 
 2000 2001 2002
Nevada NaN 2.4 2.9
Ohio 1.5 1.7 3.6

(2)dataframe索引

python list转换成array_Python数据分析常用知识_第14张图片

(3)描述和汇总统计

python list转换成array_Python数据分析常用知识_第15张图片

(4)相关系数与协方差

(5)唯一值、值计数以及成员资格

python list转换成array_Python数据分析常用知识_第16张图片

13、数据清洗和准备

在数据分析和建模的过程中,相当多的时间要用在数据准备上:加载、清理、转换以及重塑。这些工作会占到分析师时间的80%或更多。

(1)缺失数据

python list转换成array_Python数据分析常用知识_第17张图片

14、利用函数或映射进行数据转化

对于许多数据集,你可能希望根据数组、Series或DataFrame列中的值来实现转换工作

data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon',
 ....: 'Pastrami', 'corned beef', 'Bacon',
 ....: 'pastrami', 'honey ham', 'nova lox'],
 ....:  'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})

假设你想要添加一列表示该肉类食物来源的动物类型。我们先编写一个不同肉类到动物的映射:

meat_to_animal = {
 'bacon': 'pig',
 'pulled pork': 'pig',
 'pastrami': 'cow',
 'corned beef': 'cow',
 'honey ham': 'pig',
 'nova lox': 'salmon'
}

Series的map方法可以接受一个函数或含有映射关系的字典型对象,但是这里有一个小问题,即有些肉类的首字母大写了,而另一些则没有。因此,我们还需要使用Series的str.lower方法,将各个值转换为小写:

(1)food列转换为小写

lowercased = data['food'].str.lower()

(2)新生成animal列

data['animal'] = lowercased.map(meat_to_animal)

(3)对原有food列进行修改

data['food'].map(lambda x: meat_to_animal[x.lower()])

使用map是一种实现元素级转换以及其他数据清理工作的便捷方式。

15、替换值(fillna、replace)

利用fillna方法填充缺失数据可以看做值替换的一种特殊情况。前面已经看到,map可用于修改对象的数据子集,而replace则提供了一种实现该功能的更简单、更灵活的方式

data = pd.Series([1., -999., 2., -999., -1000., 3.])
data.replace(-999, np.nan)

如果你希望一次性替换多个值,可以传入一个由待替换值组成的列表以及一个替换值:

data.replace([-999, -1000], np.nan)

要让每个值有不同的替换值,可以传递一个替换列表:

data.replace([-999, -1000], [np.nan, 0])

传入的参数也可以是字典:

data.replace({-999: np.nan, -1000: 0})

16、轴索引重命名

跟Series中的值一样,轴标签也可以通过函数或映射进行转换,从而得到一个新的不同标签的对象。轴还可以被就地修改,而无需新建一个数据结构。

In [66]: data = pd.DataFrame(np.arange(12).reshape((3, 4)),
 ....: index=['Ohio', 'Colorado', 'New York'],
 ....: columns=['one', 'two', 'three', 'four'])

如果想要创建数据集的转换版(而不是修改原始数据),比较实用的方法是rename:

data.rename(index=str.title, columns=str.upper)

17、离散化和面元划分

为了便于分析,连续数据常常被离散化或拆分为“面元”(bin)。假设有一组人员数据,而你希望将它们划分为不同的年龄组:

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]

接下来将这些数据划分为“18到25”、“26到35”、“35到60”以及“60以上”几个面元。要实现该功能,你需要使用pandas的cut函数:

bins = [18, 25, 35, 60, 100]
cats = pd.cut(ages, bins)
pd.value_counts(cats)
Out[81]: 
(18, 25] 5
(35, 60] 3
(25, 35] 3
(60, 100] 1
dtype: int64

跟“区间”的数学符号一样,圆括号表示开端,而方括号则表示闭端(包括)。哪边是闭端可以通过right=False进行修改:

pd.cut(ages, [18, 26, 36, 61, 100], right=False)

你可 以通过传递一个列表或数组到labels,设置自己的面元名称:

In [83]: group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
In [84]: pd.cut(ages, bins, labels=group_names)
Out[84]: 
[Youth, Youth, Youth, YoungAdult, Youth, ..., YoungAdult, Senior, MiddleAged, Mid
dleAged, YoungAdult]
Length: 12
Categories (4, object): [Youth < YoungAdult < MiddleAged < Senior]

18、检测和过滤异常值

data = pd.DataFrame(np.random.randn(1000, 4))
data.describe() #查勘数据的概要统计指标
col = data[2]
col[np.abs(col) > 3]
data[(np.abs(data) > 3).any(1)]

根据数据的值是正还是负,np.sign(data)可以生成1和-1:

data[np.abs(data) > 3] = np.sign(data) * 3

any&all扩展补充知识:

一个总的原则就是“any”意味着一行或者一列有一个为真(这里一般指不为0)则返回真,一行或者一列全部为假(一般指0)才为假,”all“意味着一行或者一列所有为真才为真(均不等于0),一行或者一列有一个为假则为假。

DataFrame.all(axis=None, bool_only=None, skipna=None, level=None, **kwargs) 

返回的是在给定的轴上,是否有元素为真

参数:

1、axis,0/1,默认为0轴

2、skipna,布尔值,默认为True,若整行或整列为NA则返回NA

3、level,整数,默认为空,当层次化索引时使用

4、bool_only,只考虑布尔值,默认为False

19、排列和随机采样

利用numpy.random.permutation函数可以轻松实现对Series或DataFrame的列的排列工作(permuting,随机重排序)。通过需要排列的轴的长度调用permutation,可产生一个表示新顺序的整数数组:

20、计算指标、哑变量

另一种常用于统计建模或机器学习的转换方式是:将分类变量(categorical variable)转换为“哑变量”或“指标矩阵”。

如果DataFrame的某一列中含有k个不同的值,则可以派生出一个k列矩阵或DataFrame(其值全为1和0)。pandas有一个get_dummies函数可以实现该功能(其实自己动手做一个也不难)。使用之前的一个DataFrame例子:

In [109]: df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
 .....: 'data1': range(6)})
In [110]: pd.get_dummies(df['key'])
Out[110]: 
      a    b    c
0    0    1    0
1    0    1    0
2    1    0    0
3    0    0    1
4    1    0    0
5    0    1    0

21、字符串操作

(1)以逗号分隔的字符串可以用split拆分成数段

In [134]: val = 'a,b, guido'
In [135]: val.split(',')
Out[135]: ['a', 'b', 'guido']

(2)split常常与strip一起使用,以去除空白符(包括换行符)

(3)Python内置字符串方法

python list转换成array_Python数据分析常用知识_第18张图片

python list转换成array_Python数据分析常用知识_第19张图片

22、python矢量化字符串函数

python list转换成array_Python数据分析常用知识_第20张图片

23、层次化索引

层次化索引(hierarchical indexing)是pandas的一项重要功能,它使你能在一个轴上拥有多个(两个以上)索引级别。抽象点说,它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子:创建一个Series,并用一个由列表或数组组成的列表作为索引:

data = pd.Series(np.random.randn(9),
                index=[['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'], 
                      [1, 2, 3, 1, 3, 1, 2, 2, 3]])

In [10]: data
Out[10]: 
a  1   -0.204708
   2    0.478943
   3   -0.519439
b  1   -0.555730
   3    1.965781
c  1    1.393406
   2    0.092908
d  2    0.281746
   3    0.769023
dtype: float64

对于一个层次化索引的对象,可以使用所谓的部分索引,使用它选取数据子集的操作更简单:

In [12]: data['b']
Out[12]: 
1 -0.555730
3 1.965781
dtype: float64
 
In [13]: data['b':'c']
Out[13]: 
b 1 -0.555730
 3 1.965781
c 1 1.393406
 2 0.092908
dtype: float64
 
In [14]: data.loc[['b', 'd']]
Out[14]: 
b 1 -0.555730
 3 1.965781
d 2 0.281746
 3 0.769023
dtype: float64

有时甚至还可以在“内层”中进行选取:

In [15]: data.loc[:, 2]
Out[15]: 
a 0.478943
c 0.092908
d 0.281746
dtype: float64

层次化索引在数据重塑和基于分组的操作(如透视表生成)中扮演着重要的角色。例如,可以通过unstack方法将这段数据重新安排到一个DataFrame中:

data.unstack()
Out[16]: 
 1 2 3
a -0.204708 0.478943 -0.519439
b -0.555730 NaN 1.965781
c 1.393406 0.092908 NaN
d NaN 0.281746 0.769023

unstack的逆运算是stack:

In [17]: data.unstack().stack()
Out[17]: 
a 1 -0.204708
 2 0.478943
 3 -0.519439
b 1 -0.555730
 3 1.965781
c 1 1.393406
 2 0.092908
d 2 0.281746
 3 0.769023
dtype: float64

对于一个DataFrame,每条轴都可以有分层索引:

In [18]: frame = pd.DataFrame(np.arange(12).reshape((4, 3)),
 ....: index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
 ....: columns=[['Ohio', 'Ohio', 'Colorado'],
 ....:  ['Green', 'Red', 'Green']])
In [19]: frame
Out[19]: 
 Ohio Colorado
 Green Red Green
a 1 0 1 2
 2 3 4 5
b 1 6 7 8
 2 9 10 11

24、创建DataFrame的几种方式

(1)使用numpy创建

df=pd.DataFrame(np.arange(16).reshape((4,4)),
 index=list('abcd'),
 columns=['one','two','three','four'])

(2)由Series组成的字典

df3 = pd.DataFrame({'one':pd.Series([0,1,2,3]),
 'two':pd.Series([4,5,6,7]),
 'three':pd.Series([8,9,10,11]),
 'four':pd.Series([12,13,14,15])},
 columns=['one','two','three','four'])

自定义行索引

df4 = pd.DataFrame({'one':pd.Series([0,1,2,3],index=list('abcd')),
 'two':pd.Series([4,5,6,7],index=list('abcd')),
 'three':pd.Series([8,9,10,11],index=list('abcd')),
 'four':pd.Series([12,13,14,15],index=list('fjkg'))},
 columns=['one','two','three','four'])

由Series组成的字典,创建Dataframe, columns为字典key, index为Series的标签(如果

Series没有指定标签,则默认数字标签)

(3)由字典或series组成的列表

data = [{"one":1,"two":2},{"one":5,"two":10,"three":15}]
df6 = pd.DataFrame(data)

指定行索引列名

df4 = pd.DataFrame(data, columns = ["one", "two", "three"],index=['a','b'])

(4)由字典组成字典

data = {
 "Jack":{"math":90, "english":89, "art":78},
 "Marry":{"math":82, "english":95, "art":96},
 "Tom":{"math":85, "english":94}
}
 
df4 = pd.DataFrame(data, index = ["art", "math", "english"], columns = ["Jack", "Tom", "Bob"])

(5)数组、列表、元祖、组成的字典

df2 = pd.DataFrame({
      'one':[0,1,2,3],
 'two':[4,5,6,7],
 'three':[8,9,10,11],
 'four':[12,13,14,15]},
 index=list('abcd'),
 columns=['one','two','three','four'])

25、drop函数

(1)drop() 删除行和列

 df.drop([ ],axis=0,inplace=True)

drop([]),默认情况下删除某一行;

如果要删除某列,需要axis=1;

参数inplace 默认情况下为False,表示保持原来的数据不变,True 则表示在原来的数据上改变。

(2)drop_duplicates()去重

DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)

subset : column label or sequence of labels, optional 
用来指定特定的列,默认所有列
keep : {‘first’, ‘last’, False}, default ‘first’ 
删除重复项并保留第一次出现的项
inplace : boolean, default False 
是直接在原来数据上修改还是保留一个副本

26、python取整的几种方法

(1)向下取整

>>> a = 3.75
>>> int(a)
3

(2)四舍五入

>>> round(3.25); round(4.85)
3.0
5.0

(3)向上取整

>>> import math
>>> math.ceil(3.25)
4.0
>>> math.ceil(3.75)
4.0
>>> math.ceil(4.85)
5.0

27、删除 DataFrame表的最后一行的正确方法

df.drop([len(df)-1],inplace=True)

注意不要用df.drop([-1],inplace=True),这个写法不对

28、删除与增减行列

(1)删除某行某列

df.drop(index=['Bob', 'Dave', 'Frank'],
              columns=['state', 'point'])

(2)增加某列

df['new']='12'#向 DataFrame 添加一列,该列为同一值

(3)增加某行

loc方法:直接改变原来行的值

df.loc[0] = ['羊', 9]

不改变原来行的值,新增一行

df = pd.DataFrame({
 '动物' : ['狗','猫','兔'],
 '数量' : [ 3, 4, 6]
 })
df1 = df.loc[:0]
df2 = df.loc[1:]
df3 = pd.DataFrame({
 '动物' : ['羊'],
 '数量' : [ 9 ]
 })
df = df1.append(df3, ignore_index = True).append(df2, ignore_index = True)

(4)列表分块与df分块

列表分块

list[a:b] 根据列表元素索引在相应的位置进行拆分

df分块

按索引进行拆分

df1 = df.loc[:10,:] 拆分成前10行

df2 = df.loc[10:,:] 拆分成除df1外的其他数据

按特征进行拆分

columns=df.columns[:5] #前5列特征

df3=df[columns]

columns1=df.columns[5:] #第六列及以后特征

df4=df[columns1]

总结:列表切片形式为list[a:b];dataframe切片形式为df[a:b,c:d]

29、pivot_table

(1)pd.pivot_table(df,index=["Manager","Rep"],values=["Price"],aggfunc=np.sum)

index指定了两个行索引;

values:用于计算的指标值

aggfunc:指标值的计算汇总方式

(2)我认为pivot_table中一个令人困惑的地方是“columns(列)”和“values(值)”的使用。记住,变量“columns(列)”是可选的,它提供一种额外的方法来分割你所关心的实际值。然而,聚合函数aggfunc最后是被应用到了变量“values”中你所列举的项目上。

pd.pivot_table(df,index=["Manager","Rep"],values=["Price"],

columns=["Product"],aggfunc=[np.sum])

python list转换成array_Python数据分析常用知识_第21张图片

(3)非数值NaN的处理

如果想移除它们,我们可以使用“fill_value”将其设置为0

pd.pivot_table(df,index=["Manager","Rep"],values=["Price"],

columns=["Product"],aggfunc=[np.sum],fill_value=0)

python list转换成array_Python数据分析常用知识_第22张图片

(4)values 包括两个值

pd.pivot_table(df,index=["Manager","Rep"],values=["Price","Quantity"],
 columns=["Product"],aggfunc=[np.sum],fill_value=0)

有趣的是,你可以将几个项目设置为索引来获得不同的可视化表示。下面的代码中,我们将“Product”从“columns”中移除,并添加到“index”变量中。

pd.pivot_table(df,index=["Manager","Rep","Product"],
 values=["Price","Quantity"],aggfunc=[np.sum],fill_value=0)

python list转换成array_Python数据分析常用知识_第23张图片

(5)看总和数据

pd.pivot_table(df,index=["Manager","Rep","Product"],
 values=["Price","Quantity"],
 aggfunc=[np.sum,np.mean],fill_value=0,margins=True)

python list转换成array_Python数据分析常用知识_第24张图片

(6)高级透视表过滤

一旦你生成了需要的数据,那么数据将存在于数据帧中。所以,你可以使用自定义的标准数据帧函数来对其进行过滤。

如果你只想查看一个管理者(例如Debra Henley)的数据,可以这样:

table.query('Manager == ["Debra Henley"]')

我们可以查看所有的暂停(pending)和成功(won)的交易,代码如下所示:

table.query('Status == ["pending","won"]')

图示pivot_table

python list转换成array_Python数据分析常用知识_第25张图片

30、pandas的axis=0或1

使用0值表示沿着每一列或行标签索引值向下执行方法

使用1值表示沿着每一行或者列标签模向执行对应的方法

python list转换成array_Python数据分析常用知识_第26张图片

31、X[:,0]和X[:,1]

X[:,0]就是取所有行的第0个数据, X[:,1] 就是取所有行的第1个数据。

x[:] 冒号左侧表示开始位置,右侧表示结束位置

32、在cmd中查看python版本和安装路径

版本

python -V

安装路径

where python

33、index()方法

index() 函数用于从列表中找出某个值第一个匹配项的索引位置

34、字典及其基本操作

由于字典中的 key 是非常关键的数据,而且程序需要通过 key 来访问 value,因此字典中的 key 不允许重复

(1)创建key-value

scores = {}

scores['数学'] = 93

(2)删除键值对

del scores['数学']

(3)字典方法

clear() 用于清空字典中所有的 key-value 对

get() 方法其实就是根据 key 来获取 value

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}

# 获取'BMW'对应的value

print(cars.get('BMW')) # 8.5

update()方法

update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典. 在执行 update() 方法时,如果被更新的字典中己包含对应的 key-value 对,那么原 value 会被覆盖;如果被更新的字典中不包含对应的 key-value 对,则该 key-value 对被添加进去。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
cars.update({'BMW':4.5, 'PORSCHE': 9.3})
print(cars)

items()、keys()、values()

items()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。

(4)使用字典格式化字符串

# 字符串模板中使用key

temp = '教程是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s'

book = {'name':'Python基础教程', 'price': 99, 'publish': 'C语言中文网'}

# 使用字典为字符串模板中的key传入值

print(temp % book)

教程是:Python基础教程, 价格是:0000099.00, 出版社是:C语言中文网

35、Pandas中更改列的数据类型

(1)如果想要将这个操作应用到多个列,依次处理每一列是非常繁琐的,所以可以使用DataFrame.apply处理每一列。

df[['col2','col3']] = df[['col2','col3']].apply(pd.to_numeric)

(2)软转换——类型自动推断

版本0.21.0引入了infer_objects()方法,用于将具有对象数据类型的DataFrame的列转换为更具体的类型。

df = df.infer_objects()

(3)astype强制转换

df[['two', 'three']] = df[['two', 'three']].astype(float)

36、merge、join、concat比较

(1)concat:沿着一条轴,将多个对象堆叠到一起

concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, 
       keys=None, levels=None, names=None, verify_integrity=False, copy=True)

objs:需要连接的对象集合,一般是列表或字典;
axis:连接轴向;
join:参数为‘outer’或‘inner’;
join_axes=[]:指定自定义的索引;
keys=[]:创建层次化索引;
ignore_index=True:重建索引

pd.concat()只是单纯的把两个表拼接在一起,参数axis是关键,它用于指定是行还是列,axis默认是0。

当axis=0时,pd.concat([obj1, obj2])的效果与obj1.append(obj2)是相同的;

当axis=1时,pd.concat([obj1, obj2], axis=1)的效果与pd.merge(obj1, obj2, left_index=True, right_index=True, how='outer')是相同的。

concat方法不会去重,但是可以使用drop_duplicates方法达到去重的效果。

>>> df1=DataFrame(np.random.randn(3,4),columns=['a','b','c','d']) 
>>> df2=DataFrame(np.random.randn(2,3),columns=['b','d','a']) 
>>> pd.concat([df1,df2],ignore_index=True)    #ignore_index=True  重新生成行索引

python list转换成array_Python数据分析常用知识_第27张图片

(2)merge:通过键拼接列

类似于关系型数据库的连接方式,可以根据一个或多个键将不同的DatFrame连接起来。该函数的典型应用场景是,针对同一个主键存在两张不同字段的表,根据主键整合到一张表里面。

merge(left, right, how='inner', on=None, left_on=None, right_on=None,  
      left_index=False, right_index=False, sort=True,  
      suffixes=('_x', '_y'), copy=True, indicator=False)

left和right:两个不同的DataFrame;
how:连接方式,有inner、left、right、outer,默认为inner;
on:指的是用于连接的列索引名称,必须存在于左右两个DataFrame中,如果没有指定且其他参数也没有指定,
则以两个DataFrame列名交集作为连接键;
left_on:左侧DataFrame中用于连接键的列名,这个参数左右列名不同但代表的含义相同时非常的有用;
right_on:右侧DataFrame中用于连接键的列名;
left_index:使用左侧DataFrame中的行索引作为连接键;
right_index:使用右侧DataFrame中的行索引作为连接键;
sort:默认为True,将合并的数据进行排序,设置为False可以提高性能;
suffixes:字符串值组成的元组,用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称,
默认为('_x', '_y');
copy:默认为True,总是将数据复制到数据结构中,设置为False可以提高性能;
indicator:显示合并数据中数据的来源情况

具体例子省略

(3)join:主要用于索引上的合并

(略)

小结:

(1)concat主要用于结构相同的两张或多张表进行合并,可横向、纵向进行;

(2)merge则相当于excel的vlookup函数,以两张表的各自的某列为基准,进行跨表格的数据查找匹配。

37、代码运行时间

import time
start =time.process_time()
代码块
end = time.process_time()
print('Running time: %s Seconds'%(end-start))

38、格式化字符串

转换说明符

%d、%i 转换为带符号的十进制整数

%o 转换为带符号的八进制整数

%x、%X 转换为带符号的十六进制整数

%e 转化为科学计数法表示的浮点数(e 小写)

%E 转化为科学计数法表示的浮点数(E 大写)

%f、%F 转化为十进制浮点数

%g 智能选择使用 %f 或 %e 格式

%G 智能选择使用 %F 或 %E 格式

%c 格式化字符及其 ASCII 码

%r 使用 repr() 函数将表达式转换为字符串

%s 使用 str() 函数将表达式转换为字符串

例1

01.age = 8
02.print("C语言中文网已经%d岁了!" % age)

例2

01.name = "C语言中文网"
02.age = 8
03.url = "http://c.biancheng.net/"
04.print("%s已经%d岁了,它的网址是%s。" % (name, age, url))

例3

%m.nf
 %.nf
01.f = 3.141592653
02.# 最小宽度为8,小数点后保留3位
03.print("%8.3f" % f)
04.# 最小宽度为8,小数点后保留3位,左边补0
05.print("%08.3f" % f)
06.# 最小宽度为8,小数点后保留3位,左边补0,带符号
07.print("%+08.3f" % f)

39、join函数

 >>> seq1 = ['hello','good','boy','doiido']
 >>> print (' '.join(seq1))
 hello good boy doiido
 >>> print ':'.join(seq1)
 hello:good:boy:doiido
#对字符串进行操作
>>> seq2 = "hello good boy doiido"
>>> print ':'.join(seq2)
h:e:l:l:o: :g:o:o:d: :b:o:y: :d:o:i:i:d:o 
#对元组进行操作
>>> seq3 = ('hello','good','boy','doiido')
>>> print ':'.join(seq3)
hello:good:boy:doiido
#对字典进行操作
>>> seq4 = {
      'hello':1,'good':2,'boy':3,'doiido':4}
>>> print ':'.join(seq4)
boy:good:doiido:hello
#合并目录
>>> import os
>>> os.path.join('/hello/','good/boy/','doiido')
'/hello/good/boy/doiido'

40、确实数据处理函数

(1)传入how='all'将只丢弃全为NA的那些行

data.dropna(how='all')

(2)用这种方式丢弃列,只需传入axis=1即可

data.dropna(axis=1, how='all')

41、将一列由小数转化为百分数

data['人员利用率'] = data['人员利用率'].apply(lambda x: format(x, '.2%'))

42、apply函数应用

df['day_change_rate']=df.apply(lambda x:
(x['close_price_1']-x['close_price'])/x['close_price'],axis=1)

当axis=1,表示传入的x为行

43、排序

df.sort_values(by=['col2','col3'],ascending=False)
ascending=False表示降序排序
## 参数
sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)
#### 参数说明
axis:0按照行名排序;1按照列名排序
level:默认None,否则按照给定的level顺序排列---貌似并不是,文档
ascending:默认True升序排列;False降序排列
inplace:默认False,否则排序之后的数据直接替换原来的数据框
kind:默认quicksort,排序的方法
na_position:缺失值默认排在最后{"first","last"}
by:按照那一列数据进行排序,但是by参数貌似不建议使用
## 对x1列升序排列,x2列升序。处理x1有相同值的情况 
import pandas as pd 
x = pd.DataFrame({"x1":[1,2,2,3],"x2":[4,3,2,1]}) 
x.sort_index(by = ["x1","x2"],ascending = [False,True]) 

44、保留特定位数小数

x = 3.142222
y = 3.147777
z = 3.2
round(x, 2)
 3.14
round(y, 2)
 3.15
round(z, 2)
 3.2

45、pandas 排序

df.sort_values(by=['col2','col3'],ascending=False)

46、字符串转化为时间

sh_index['日期']=pd.to_datetime(sh_index['日期'], format ='%Y-%m-%d')

47、删除list某个值

python中关于删除list中的某个元素,一般有三种方法:remove、pop、del

48、删除包含空值的行

df=df.dropna(axis=0,subset = ['签单保费','支付金额','总保额','保单性质'])
备注:axis=0表示行,axis=1表示列

49、对列表中某一类值进行修改

profession.loc[profession['职业']=='无','职业'] ='无业'
前为条件,后为选择字段
职业:列名,无:表格原内容,无业:替换无的新内容 

df.replace('A',0.1,inplace=True)

50、在list中确定某个值的索引

list.index('2020-01-02') #在列表中查找某个值的索引

51、用numpy生成时间列表

np.arange('2020-01-01','2020-07-14',dtype=np.datetime64)

52、numpy数组差分

>>> x = np.array([1, 2, 4, 7, 0])
>>> np.diff(x)
array([ 1, 2, 3, -7])
>>> np.diff(x, n=2)
array([ 1, 1, -10])
>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
>>> np.diff(x)
array([[2, 3, 4],
 [5, 1, 2]])
>>> np.diff(x, axis=0)
array([[-1, 2, 0, -2]])
>>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)
>>> np.diff(x)
array([1, 1], dtype='timedelta64[D]')

53、dataframe中根据某个值求该值的行索引

index = df[df['date']=='2019-12-02'].index.tolist()[0]

54、字符串&时间类型相互转化

对dataframe中的整列进行操作

(1)字符串转时间

df['date']中的日期以字符串类型存储;'date'为列名

df['date'] = pd.to_datetime(df['date'], format ='%Y-%m-%d') 

(2)时间转字符串

df['date']中的日期以时间类型存储;'date'为列名

df['date'] = df['date'].astype(np.str)

55、DataFrame修改列名

(1)部分列名修改

df.rename(columns={'原列名' : '新列名'}, inplace=True)

(2)全部列重命名

df.columns = new_columns,可以是列表或元组, 但新旧列名的长度必须一致,否者会不匹配报错。这种改变方式是直接改变了原始数据。

df.columns =['a1','b1','c1','d1'] #'a1','b1','c1','d1'为新的列名

(3)读取文件时重命名

df = pd.read_csv('xxx.csv', names=new_columns, header=0)

56、两列合并成一列

df_20['去重项']=df_20['报案号'].map(str) + df_20['申请调查项目'].map(str)

57、从时间序列提取年月日

data['AnalogWriteTime']=pd.to_datetime(data['AnalogWriteTime'])
data['year']=data['AnalogWriteTime'].dt.year
data['day']=data['AnalogWriteTime'].dt.day
data['hour']=data['AnalogWriteTime'].dt.hour
data['minute']=data['AnalogWriteTime'].dt.minute

58、判断数据中是否有空值

(1)pandas isnull()函数

df.isnull()    #返回df中各元素是否为空的同df大小的数据框
df["A"].isnull()  #判断A列中空值情况
df[["A","B"]].isnull()  # 指定多列进行空值判断,对于本文实例,下述代码效果同df.isnull() 

(2)pandas notnull()函数

df.notnull()    #判断df中各元素是否 不是 空值
df["A"].notnull()  #判断A列中非空值情况
df[["A","B"]].notnull()  # 指定多列进行非空值判断,对于本文实例,下述代码效果同df.notnull() 

(3)numpy np.isnan() 函数

np.isnan(df)   # 等同于df.isnull()
np.isnan(df["A"])   # 等同于 df["A"].isnull()
np.isnan(df[["A","B"]])  # 等同于 df[["A","B"]].isnull()

(4)根据空值筛选数据

# 筛选出A列为空的所有行
df[df.A.isnull()]    
df[df["A"].isnull()]

# 筛选出A列非空的所有行
df[df.A.notnull()]   
df[df["A"].notnull()]        

# 筛选出df中存在空值的行
df[df.isnull().values==True] 

(5)查找空值索引

np.where(np.isnan(df))   # df中空值所在的行索引及列索引
np.where(np.isnan(df.A))    # df中A列空值所在的行索引

59、jupyter查看历史操作命令

%history

你可能感兴趣的:(python,list转换成array)