数据分析应用 | Python实现网约车语义数据分析

本文主要是介绍数据分析应用 | 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/

致谢

感谢大家关注，感谢订阅，谢谢！
欢迎一起学习，一起进步！

这篇关于数据分析应用 | Python实现网约车语义数据分析的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Python教程

数据分析应用 | Python实现网约车语义数据分析

目录

变量赋值

变量字段

列表字段

字典字段

集合运算

异常处理

匿名函数

时间数据

Numpy应用

Pandas应用

参考资料

致谢

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯