本文介绍了Python在数据分析中的应用，包括数据类型的处理方法、数据结构如Series和DataFrame的操作技巧，以及利用Numpy实现高效的向量化运算。
Python数据分析实战之数据准备
数据类型
逻辑型
取值
True : 真
False ：假
运算规则
＆：与
一假为假，两真为真
True & True
True & False
False & False|：或
两假为假，一真为真
True | True
True | False
False | Falsenot：非
非真为假，非假为真
not True
not False数值型
加、减、乘、除
x + y
x - y
x * y
x / y取整
7 // 4
求余
10 % 4
乘方
2 ** 3
一个关于浮点数运算需要注意的地方
a = 4.2
b = 2.1
a + b
# 6.300000000000001
(a + b) == 6.3
#False可用以下步骤处理
from decimal import Decimal
a = Decimal('4.2')
b = Decimal('2.1')
a + b
# Decimal('6.3')
(a + b) == Decimal('6.3')
# True字符型
创建字符
字符串str用单引号''或双引号" "括起来
x = '我是一个字符串'
y = "我也是一个字符串"
z = """我还是一个字符串"""
转义
使用反斜杠\转义特殊字符。
s = 'Yes,he doesn\'t'如果不想让\发生转义，
可以在字符串前面添加一个r，表示原始字符串
print('C:\some\name')
# \some
#ame
print('C:\\some\\name')
# C:\some\name
print(r'C:\some\name')
# C:\some\name\反斜杠可以作为续行符，表示下一行是上一行的延续。
s = "abcd\
efg"
print(s)
# abcdefg多行字符
还可以使用"""..."""或者'''...'''跨越多行
s = """
Hello I am fine!
Thinks.
"""
print(s)
# Hello I am fine!
# Thinks.数据结构
Series系列
创建Series
from pandas import Series
x = Series(
['a', True, 1]
)修改系列索引
x = Series(
['a', True, 1],
index=['first', 'second', 'third']
)访问
x[1]
x['second']
#不能越界访问
x[3]
# KeyError: 3
追加元素
#不能追加单个元素
x.append('2')
# TypeError: cannot concatenate a non-NDFrame object
#追加一个序列
n = Series(['2'])
x.append(n)
# 0 a
# 1 True
# 2 1
# 0 2
# dtype: object
x
# 0 a
# 1 True
# 2 1
# dtype: object
#需要使用一个变量来承载变化
x = x.append(n)
'2' in x
# False
#判断值是否存在
'2' in x.values
# True切片
x[1:3]
# 1 True
# 2 1
# dtype: object删除
#根据index删除
x.drop(0)
x.drop('first')
#根据位置删除
x.drop(x.index[3])
#根据值删除
x['2'!=x.values]DataFrame数据框
数据框是用于存储多行和多列的数据集合
数据框中的概念
创建
from pandas import DataFrame
df = DataFrame({
'age': [21, 22, 23],
'name': ['KEN', 'John', 'JIMI']
})
df = DataFrame(
data={
'age': [21, 22, 23],
'name': ['KEN', 'John', 'JIMI']
},
index=['first', 'second', 'third']
)
访问
#按列访问
df['age']
df[['age', 'name']]
#按行访问
df[1:2]
#按行索引访问
df.loc[['first', 'second']]
#按行列号访问
df.iloc[0:1, 0:1]
#按行索引，列名访问
df.at['first', 'name']修改
#读取列名
df.columns
# Index(['age', 'name'], dtype='object')
#修改列名
df.columns=['age2', 'name2']
df.columns
# Index(['age2', 'name2'], dtype='object')
#读取索引
df.index
# Index(['first', 'second', 'third'], dtype='object')
# 修改行索引
df.index = range(1,4)
df.index
# RangeIndex(start=1, stop=4, step=1)删除
#根据行索引删除
#默认参数axis=0
df.drop(1, axis=0)
#根据列名进行删除
df.drop('age2', axis=1)增加
#增加列
df['newColumn'] = [2, 4, 6]
#增加行，
#注意，这种方法，
#效率非常低，
#不应该用于遍历中
df.loc[len(df)] = [24, "KENKEN"]
向量化运算
向量
一般数列只可遍历不可运算
#生成一个整数的等差序列
#局限，只能用于遍历
r1_10 = range(1, 10, 2)
for i in r1_10:
print(i)
# 1
# 3
# 5
# 7
# 9
r1_10 = range(0.1, 10, 2)
# TypeError: 'float' object cannot be interpreted as an integer创建向量
引入Numpy创建向量array
#生成一个小数的等差序列
import numpy
r = numpy.arange(0.1, 0.5, 0.01)
# array([ 0.1 , 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18,
# 0.19, 0.2 , 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27,
# 0.28, 0.29, 0.3 , 0.31, 0.32, 0.33, 0.34, 0.35, 0.36,
# 0.37, 0.38, 0.39, 0.4 , 0.41, 0.42, 0.43, 0.44, 0.45,
# 0.46, 0.47, 0.48, 0.49])向量化运算
四则运算
#向量化计算，四则运算
r + r
# array([ 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34, 0.36,
# 0.38, 0.4 , 0.42, 0.44, 0.46, 0.48, 0.5 , 0.52, 0.54,
# 0.56, 0.58, 0.6 , 0.62, 0.64, 0.66, 0.68, 0.7 , 0.72,
# 0.74, 0.76, 0.78, 0.8 , 0.82, 0.84, 0.86, 0.88, 0.9 ,
# 0.92, 0.94, 0.96, 0.98])
r - r
# array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
# 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
# 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
r * r
# array([ 0.01 , 0.0121, 0.0144, 0.0169, 0.0196, 0.0225, 0.0256,
# 0.0289, 0.0324, 0.0361, 0.04 , 0.0441, 0.0484, 0.0529,
# 0.0576, 0.0625, 0.0676, 0.0729, 0.0784, 0.0841, 0.09 ,
# 0.0961, 0.1024, 0.1089, 0.1156, 0.1225, 0.1296, 0.1369,
# 0.1444, 0.1521, 0.16 , 0.1681, 0.1764, 0.1849, 0.1936,
# 0.2025, 0.2116, 0.2209, 0.2304, 0.2401])
r / r
# array([ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
# 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
# 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])函数式运算
#函数式的向量化计算
# 5次方
numpy.power(r, 5)
# array([ 1.00000000e-05, 1.61051000e-05, 2.48832000e-05,
# 3.71293000e-05, 5.37824000e-05, 7.59375000e-05,
# 1.04857600e-04, 1.41985700e-04, 1.88956800e-04,
# 2.47609900e-04, 3.20000000e-04, 4.08410100e-04,
# 5.15363200e-04, 6.43634300e-04, 7.96262400e-04,
# 9.76562500e-04, 1.18813760e-03, 1.43489070e-03,
# 1.72103680e-03, 2.05111490e-03, 2.43000000e-03,
# 2.86291510e-03, 3.35544320e-03, 3.91353930e-03,
# 4.54354240e-03, 5.25218750e-03, 6.04661760e-03,
# 6.93439570e-03, 7.92351680e-03, 9.02241990e-03,
# 1.02400000e-02, 1.15856201e-02, 1.30691232e-02,
# 1.47008443e-02, 1.64916224e-02, 1.84528125e-02,
# 2.05962976e-02, 2.29345007e-02, 2.54803968e-02,
# 2.82475249e-02])比较运算
#向量化运算，比较运算
r>0.3
# array([False, False, False, False, False, False, False, False, False,
# False, False, False, False, False, False, False, False, False,
# False, False, False, True, True, True, True, True, True,
# True, True, True, True, True, True, True, True, True,
# True, True, True, True], dtype=bool)
#结合过滤进行使用
r[r>0.3]
# array([ 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39,
# 0.4 , 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49])矩阵运算
#矩阵运算
numpy.dot(r, r.T) # r.T为行列转换
# 4.0139999999999967
sum(r*r)
# 4.0139999999999967数据框向量化运算
生成向量数据框
from pandas import DataFrame
df = DataFrame({
'column1': numpy.random.randn(5),
'column2': numpy.random.randn(5)
})
# 按列取最小值
df.apply(min) # 默认axis=0
# column1 -1.376079
# column2 -0.922470
# dtype: float64
# 按行取最小值
df.apply(min, axis=1)
# 0 1.235722
# 1 -0.017578
# 2 -0.741343
# 3 -1.376079
# 4 0.017187
# dtype: float64比较运算
#判断每个列，值是否都大于0
df.apply(
lambda x: numpy.all(x>0),
axis=1
)
# 0 True
# 1 False
# 2 False
# 3 False
# 4 True
# dtype: bool
#结合过滤
df[df.apply(
lambda x: numpy.all(x>0), # all方法会筛选出全部复合条件的元素
axis=1
)]
# column1 column2
# 0 2.109109 1.235722
# 4 0.017187 0.460896lambda是什么？
可以这样认为,lambda作为一个表达式，定义了一个匿名函数，上例的代码x为入口参数，x+1为函数体。在这里lambda简化了函数定义的书写形式。是代码更为简洁，但是使用函数的定义方式更为直观，易理解。
func=lambda x:x+1
print(func(1))
#2
print(func(2))
#3
#以上lambda等同于以下函数
def func(x):
return(x+1)
扫一扫
1893
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
