标签：数据分析 输出 grouped Python df tm names print 网约车
目录
变量赋值
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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。