编程语言
首页 > 编程语言> > 数据分析应用 | Python实现网约车语义数据分析

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

作者:互联网

目录

变量赋值

Python是一种动态编程语言,无需提前定义数据类型,本次运行环境配置在Anaconda的Spyder的Python3.8之中。

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