数据分析应用 | Python实现网约车语义数据分析
作者：互联网
目录
变量赋值
Python是一种动态编程语言，无需提前定义数据类型，本次运行环境配置在Anaconda的Spyder的Python3.8之中。
- Spyder清楚变量：在IPython中输入reset命令，提示输入y确认即可；
- Spyder清空历史：清空IPthon中的输入历史记录，在控制台输入clear即可，使用快捷键Ctrl + L。
print('a' * 4) #输出为：aaaa
s = "abc"
print('a' in s) #输出为：True
print('d' in s) #输出为：False
# （2）字符串处理常用函数
s = 'transport BIG DATA'
len(s) #返回字符串长度，结果为18
s.lower() #将字符串转为小写字母，结果为'transport big data'
s.upper() #将字符串转为大写字母，结果为'TRANSPORT BIG DATA'
s.capitalize() #首字母大写，结果为'Transport big data'
s.strip('t') #去除字符串开头或结尾的指定字符，无参数时则去除空格、回车。结果为'ransport BIG DATA'
s.split(' ') #以空格将字符串分割为列表，结果为['transport', 'BIG', 'DATA']
s.count('a') #统计字符串中'a'出现的次数，结果为1
s.find('a') #找到指定字符第一次出现的位置，结果为2
'+'.join(['1', '2', '3']) #用指定字符将列表中字符连接，结果为'1+2+3'
变量字段
列表字段
网约车字段列表的定义、取值和切片，元素的增删，列表的生成。
#（1）列表的定义
station_names = ['a1', 'a2', 'a3', 'a4']
len(station_names) #len()为计算列表长度的函数，输出结果为4
#（2）列表的取值和切片
station_names[1] #第1个元素，结果为'a2'
station_names[1:3] #第1-2个元素，结果为['a2', 'a3']
station_names[:3] #第0-2个元素，结果为['a1', 'a2', 'a3']
station_names[2:] #第2至最后一个元素，结果为['a3', a4']
station_names[-1] #最后一个元素，结果为'a4'
station_names[:-2] #第0个至倒数第3个元素，结果为['a1', 'a2']
#（3）元素的增删
station_names.append('a4') #添加到末尾，结果为 ['a1', 'a2', 'a3', 'a4', 'a4']
station_names.insert(1, 'a4') #插入到指定位置，结果为['a1', 'a4', 'a2', 'a3', 'a4']
station_names.pop() #删除末尾元素，处理后列表为['a1', 'a2', 'a3']，返回值为末尾元素
station_names.pop(2) #删除指定索引处元素，处理后列表为['a1', 'a2', 'a4']，返回指定索引处元素
#（4）列表的生成
a = [1, 2, 3]
b = [x + 2 for x in a] #b的返回值为[3, 4, 5]
c = {'a':1, 'b':3, 'c':7}
d = [(x, y+1) for x, y in c.items()] #返回[('b', 4), ('c', 8), ('a', 2)]
字典字段
字典的取值元素的增删，取出字典的键值
#（1）字典的定义
lon_dict = {'a1': 118.773, 'a2': 118.778, 'a3': 118.781, 'a4':118.783}
#（2）字典的取值
lon_dict['a2'] #结果为118.778
lon_dict.get('a5', 0) #第一个参数为所需要查找的键，第二个参数为查找不到时返回的值，此处返回0
#（3）字典元素的增删
lon_dict.pop('a2') #删除键为'a2'的条目
lon_dict['a5'] = 118.797 #直接增加一个条目
#（4）取出字典的键值
lon_dict.keys() #取出字典的键
lon_dict.values() #取出字典的值
lon_dict.items() #取出字典的键值对
集合运算
集合的产生，增删，交集、并集、差集等。
#（1）集合
s = set([1, 2, 2, 3]) #输出为{1, 2, 3}
#（2）集合元素的增删
s.add(4) #输出为{1, 2, 3, 4}
s.remove(3) #输出为{1, 2, 4}
#（3）集合的运算
s = set([1, 2, 3])
p = set([3, 4, 5])
s & p #交集，输出为{3}
s | p #并集，输出为{1, 2, 3, 4, 5}
s - p #等价于s-s∩p，输出为{1, 2}
p - s #等价于p-s∩p，输出为{4, 5}
异常处理
语义异常分析测试
try:
a = 1 / 0
except ZeroDivisionError as e: # 此处e为ZeroDivisionError的别名，可通过它获得更详细的信息
a = 1
print(e) # 输出为 division by zero
finally:
print(a)
匿名函数
匿名函数能够避免臃肿
def add(x): #定义加1函数
return x + 1
num = [1, 2, 3]
list(map(add, num)) #返回[2, 3, 4]，由于map函数返回的是map对象，需要使用list函数转换为list
num = [1, 2, 3]
list(map(lambda x: x+1, num)) #返回[2, 3, 4]
时间数据
时间类型数据处理与转换，将时间戳或者字符串时间转换为标准时间格式。
import time
start = time.time() #记录代码开始运行时间，time.time()用于获取当前时间戳
a = 1566897866 #类型1：时间戳数据，常见的时间输入格式
c = time.localtime(a) #将时间戳转换为时间格式
print(c)
# 输出结果如下：time.struct_time(tm_year=2019, tm_mon=8, tm_mday=27, tm_hour=17, tm_min=24, tm_sec=26, tm_wday=1, tm_yday=239, tm_isdst=0)
a = "2017-6-11 17:51:30" #类型2：字符型时间数据
c=time.strptime(a,"%Y-%m-%d %H:%M:%S")
print(c)
# 输出结果如下：
# time.struct_time(tm_year=2017, tm_mon=6, tm_mday=11, tm_hour=17, tm_min=51, tm_sec=30, tm_wday=6, tm_yday=162, tm_isdst=-1)
c.tm_year #年
c.tm_mon #月
c.tm_mday #日
c.tm_hour #小时
c.tm_min #分钟
c.tm_sec #秒
c.tm_wday #星期几
c.tm_yday #到当年1月1日的天数
end = time.time() #运行结束时间
timeSpent = end - start #计算运行时间
print("Time spent: {0} s".format(timeSpent))
# random模块
import random
a=1
b=2
s=[1,2,3]
k=1
random.random() #生成0-1之间均匀分布的随机浮点数
random.normalvariate(0, 1) #生成1个符合均值为0，方差为1正态分布的随机数
[random.normalvariate(0, 1) for x in range(10)] #生成长度为10的正态分布序列
random.uniform(a, b) #生成[a, b]区间内的随机浮点数
random.randint(a, b) #生成[a, b]区间内的随机整数
random.choice(s) #从序列s中随机获取一个值
random.shuffle(s) #将序列s中元素打乱
random.sample(s, k) #从序列s中获取长度为k的片段
Numpy应用
Numpy数组处理、存取及条件选择。
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) #定义一个ndarray对象
# [[1, 2, 3],
# [4, 5, 6],
# [7, 8, 9]]
a.ndim #ndarray的维数(阶)，输出为2
a.shape #ndarray的形状，输出为(3, 3)，对应（行数，列数）
a.size #ndarray的元素个数，输出为9
# 深复制浅复制
b = a # 引用
print(id(a)== id(b)) # id()能够输出对象的内存地址，输出为True
c = a.view() # 浅复制
print(id(a)==id(c)) # 输出为False
d = a.copy() # 深复制
# 多维数组的下标存取
a[0, 1] #输出2 (行、列的索引都是由0开始)
a[[0, 2], [1, 2]] #输出为array([2, 9])，等价于np.array([a[0, 1], a[2, 2]])
a[:2, 1:3] #第0至1行，第1至2列array([[2, 3], [5, 6]])
a[2, 1:] #第2行，第1至最后1列
a[:-1] #第0至倒数第2行
a[1, :] #第1行，shape为(3,)，一维，array([4, 5, 6])
a[1:2, :] #第1行，shape为(1,3), 二维，array([[4, 5, 6]])
a[:,1] #第1列，shape为(3, ), 一维，array([2, 5, 8])
a[:,1:2] #第1列，shape为(3, 1), 二维，array([[2], [5], [8]])
# Numpy中还能直接用判断条件（布尔矩阵）取出符合某些条件的元素：
a>2 #输出为array([[False, False, True],
# [True, True, True],
# [True, True, True]])
a[a>2] #输出数组中大于2的值，为一个一维数组
a[(a>2) & (a<6)] #使用逻辑运算符连接多个条件，注意不能使用and,or之类的关键词进行连接，否则会报错
# 数组运算
#逐元素运算
a + b
a * b
a/b
a ** 2
np.sin(a)
# 矩阵运算
a.dot(b) #a与b矩阵相乘
a = np.mat(a) #转换为矩阵对象
a.I #逆矩阵
a.T #转置
a.trace() #迹
np.linalg.det(a) #矩阵a的行列式
np.linalg.norm(a,ord=None) #矩阵a的范数
np.linalg.eig(a) #矩阵a的特征值和特征向量
np.linalg.cond(a,p=None) #矩阵a的条件数
# 随机数生成
np.random.norm(0, 1, 100) #生成均值为0，方差为1（不是标准差），长度为100的正态分布样本
np.random.poisson(5, 100) #生成均值为5，长度为100的泊松分布样本
np.random.negative_binomial(1, 0.1, 100) #生成n=1, p=0.1，长度为100的负二项分布样本
Pandas应用
Pandas应用
import pandas as pd
df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
df.columns = ['A', 'B', 'C'] #定义表头
df['A']
df[['A', 'B']]
df[1:3] #取1到2行，输出为
df.iloc[1:3, 2] #多维索引，输出为
df[df['A']>1] #根据条件选择，输出为
print(type(df.A)) # 输出<class 'pandas.core.series.Series'>
tmp = pd.Series([1, 2, 3], name='tmp') # 创建一个名为tmp的Series
# 文件的读取与写入
df = pd.read_csv('file.csv') #读取csv格式文件，自动识别第一行为表头
df = pd.read_csv('file.csv', names=['A','B','C']) #指定表头
df = pd.read_csv('file.csv', index_col=0) #指定索引列
df.to_csv('newfile.csv') #在工作目录下新建csv文件
# 对列进行操作
#（1）创建新列
df['new'] = 1 #新建一列（添加为最后一列），赋值为1
df['new1'] = range(len(df)) #新建一列，赋值为由0开始的递增序列
df['date'] = ['20190801', '20190702', '20190601'] #新建一列存储日期
#（2）基于已有列进行计算
df['new'] = df['A'] + 1 #新建一列，赋值为列A加1
df['new'] = df['A'] + df['B'] #新建一列，赋值为列A与列B的和
#新建一列，赋值为列A与列B的商，转换为numpy数组进行计算，能提升性能
df['new'] = df['A'].values / df['B'].values
# 在其他计算较为复杂的情况下，需要利用apply语句，传入自定义函数进行列的运算，通常来说，此种用法更为通用。
#任务：新建一列，将date字段的月份取出，并转换为int类型，此处使用了匿名函数，参见3.7.1，也可直接传入已有函数的函数名
df['new'] = df['date'].apply(lambda x: int(x[4:6]))
#任务：新建一列，对两列进行apply操作，获得列A与列B的和
df['new'] = df[['A','B']].apply(lambda x: x[0]+x[1], axis=1)
# 分组操作
#划分
grouped = df.groupby(by=[ 'A']) #按列A进行分组
grouped['C'] #取分组后的C列
df['C'].groupby(df['A']) #等价于上面两行语句
for name, group in grouped:
print(name)
print(group)
grouped.get_group('xx') #直接获取列A的值为’xx’的组，例如：grouped.get_group(1)
grouped.sum() #对各组进行单独求和
grouped.size() #获取各组的大小
grouped.mean() #获取各组的均值
grouped.min() #获取各组最小值
grouped.max() #获取各组最大值
grouped.std() #获取各组标准差
grouped.var() #获取各组方差
#使用自定义函数
grouped.aggregate(f) #f也可采用匿名函数的形式
df = pd.DataFrame({'VehicleType': ['Car', 'Truck', 'Car', 'Truck'], 'Speed': [67., 43., 72., 49.]})
df.groupby(['VehicleType']).mean()
df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
df.append(df2)
df1 = pd.DataFrame([['a', 1], ['b', 2]], columns=['letter', 'number'])
df2 = pd.DataFrame([['c', 3], ['d', 4]], columns=['letter', 'number'])
参考资料
[1]https://blog.csdn.net/weicao1990/article/details/52334336
[2]https://zhuanlan.zhihu.com/p/45237245
[3]https://www.kaggle.com/
致谢
- 感谢大家关注，感谢订阅，谢谢！
- 欢迎一起学习，一起进步！
标签：数据分析,输出,grouped,Python,df,tm,names,print,网约车 来源： https://blog.csdn.net/m0_57362105/article/details/118273377