第三周环境安装，pandas学习

python搭建环境(按照腾讯云实验室安装)

1. 准备工作
   Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。首先我们来看看系统中是否已经存在 Python ，并安装一些开发工具包:

安装前准备

查看当前系统中的 Python 版本，可以看到实验室的这台服务器已经安装了 Python 2.6.6

python --version

检查 CentOS 版本，我们可以看到这台服务器的 CentOS的版本是 CentOS release 6.8

cat /etc/redhat-release

为了避免后续安装出错，我们先来安装开发工具包
先安装 Development Tools

yum groupinstall -y "Development tools"

然后安装其它的工具包

yum install -y zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel

安装 Python

下载、编译和安装 Python 2.7.13
yum 源中没有新版 Python ，我们到官网中下载 Python 2.7.13

wget https://mc.qcloudimg.com/static/archive/b577469e4ed03782eb1f62e8fd6125a5/Python-2.7.13.tar.gz

下载完成后，解压这个安装包

tar zxvf Python-2.7.13.tar.gz

进入文件夹 Python-2.7.13

cd Python-2.7.13

执行 configure 文件预编译

./configure

编译和安装

make && make install

配置 Python

更新系统默认 Python 版本

先把系统默认的旧版 Python 重命名

mv /usr/bin/python /usr/bin/python.old

再删除系统默认的 python-config 软链接

rm -f /usr/bin/python-config

最后创建新版本的 Python 软链接

ln -s /usr/local/bin/python /usr/bin/python

ln -s /usr/local/bin/python-config /usr/bin/python-config

ln -s /usr/local/include/python2.7/ /usr/include/python2.7

编辑 /usr/bin/yum 文件，把代码第一行的 python 改为指向老的 python2.6 版本，修改内容参考以下：

#!/usr/bin/python2.6
import sys
try:
    import yum
except ImportError:
    print >> sys.stderr, """\nThere was a problem importing one of the Python modules
required to run yum. The error leading to this problem was:

   %s

Please install a package which provides this module, or
verify that the module is installed correctly.

It's possible that the above module doesn't match the
current version of Python, which is:
%s

If you cannot solve this problem yourself, please go to
the yum faq at:
  http://yum.baseurl.org/wiki/Faq

""" % (sys.exc_value, sys.version)
    sys.exit(1)

sys.path.insert(0, '/usr/share/yum-cli')
try:
    import yummain
    yummain.user_main(sys.argv[1:], exit_code=True)
except KeyboardInterrupt, e:
    print >> sys.stderr, "Exiting on user cancel."

    sys.exit(1)

再查看 Python 版本，现在我们看到的已经是最新版了

python --version

为新版 Python 安装一些工具

为新版 Python 安装 pip

curl https://bootstrap.pypa.io/get-pip.py | python

使用 pip 安装第三方库 requests

pip install requests

python env安装

概要

在开发Python程序的时候，有时候可能需要在不同版本的Python上进行测试。pyenv就是这么一个管理多版本Python的工具。由于在Windows中我们可以同时安装多个版本的Python，所以这里是在Linux下介绍该工具。

环境

python3.6.4
CentOS Linux release 7.7.1908

linux安装pyenv

• 查看python版本：python -V，若python版本3.x，则不需要准备python3.6.4环境。
• 执行pyenv versions命令查看服务器是否安装pyenv，如果未安装，则执行第二步操作，安装pyenv。

pyenv是Python版本管理器，可以实现Python的多版本共存。

执行pyenv versions后，如果返回只有system，则代表未安装pyenv。

• linux安装pyenv：执行命令 curl -L https://github.com/pyenv/pyenv-installer/raw/master/bin/pyenv-installer | bash

返回：

[appuser@spython ~]$ curl -L https://github.com/pyenv/pyenv-installer/raw/master/bin/pyenv-installer | bash
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   148  100   148    0     0    103      0  0:00:01  0:00:01 --:--:--   103
100  2188  100  2188    0     0   1098      0  0:00:01  0:00:01 --:--:-- 2136k

...省略...

WARNING: seems you still have not added 'pyenv' to the load path.

# Load pyenv automatically by adding
# the following to ~/.bashrc:

# 下一步配置环境变量会使用到！！！
export PATH="/home/appuser/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

报错：pyenv: Git is not installed, can’t continue 解决: yum install git

配置用户环境变量

• 将安装pyenv后返回信息的最后三行添加至用户环境变量，执行 vi ~/.bash_profile

# 新增环境变量

export PATH="/home/appuser/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

• 新增完成，保存退出，执行 source ~/.bash_profile

安装gcc pip setuptools

yum -y install gcc-c++ python-devel python2-pip 

pip install -U pip
pip install -U setuptools 

解决yum安装报错Protected multilib versions

yum install -y zlib zlib-devel --setopt=protected_multilib=false

安装openssl openssl-devel

yum install openssl openssl-devel

如果没下载这个会报错
The Python ssl extension was not compiled. Missing the OpenSSL lib?

离线安装

下载相应的安装包地址忘了可以用一下方法查

pyenv install -v 3.6.4
# 会卡住但是会出现一个下载地址

在python用户的./python/.pyenv目录下新建cache目录，然后复制下载好的python版本的安装包到cache目录下

安装python3.6.4

• 查看可以安装的python版本：pyenv install -list
• 安装python3.6.4：pyenv install -v 3.6.4
• 查看python版本：pyenv versions

正常返回：

[appuser@spython ~]$ pyenv versions
  system
* 3.6.4 (set by /home/appuser/.pyenv/version)

• 查看当前使用的版本：pyenv version（system 代表当前系统的python 版本）
• 切换python版本 pyenv global 3.6.4

卸载python3.6.4：pyenv uninstall -f 3.6.4

pandas

概要

Pandas是一个强大的分析结构化数据的工具集；它的使用基础是Numpy（提供高性能的矩阵运算）；用于数据挖掘和数据分析，同时也提供数据清洗功能。

Pandas数据结构介绍

Series

Series是一种类似于一维数组的对象，是由一组数据以及一组与之相关联的标签（即索引）组成的，具体的表现形式就是索引在左边，值在右边。

a. 通过列表创建Series：

import pandas as pd
import numpy as np

# 创建Series并且为其设置索引
obj2 = pd.Series([4,7,-5,3], index=['d','b','a','c'])

b.通过字典创建Series：

sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
obj3 = pd.Series(sdata)

用字典创建Series时，同时为Series设置index属性，结果Series的索引以index的参数值为准，若存在索引没有对应值的情况，则结果就是NaN:

sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
states = ['California','Ohio','Oregon','Texas']
obj3 = pd.Series(sdata, index=states)

DataFrame

DataFrame是一个表型的数据结构，它含有一组有序的列，每列间可以是不同的数据类型（数值，字符串，布尔值等）。DataFrame既有行索引又有列索引，其中的数据是以一个或多个二维块存放的，而不是列表，字典或别的一维数据结构。虽然它是个二维的结构，但是DataFrame仍然可以表示更高维的数据（利用层次化索引的表结构）。

1. 创建DataFrame:

a. 由等长的列表或Numpy数组组成的字典创建DataFrame:

data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],
'year':[2000,,2001,2002,2001,2002],
'pop':[1.5,1.7,3.6,2.4,2.9]}
frame = pd.DataFrame(data)

b. 由等长的列表或Numpy数组组成的字典创建DataFrame，同时指定列顺序：

data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],
'year':[2000,2001,2002,2001,2002],
'pop':[1.5,1.7,3.6,2.4,2.9]}
frame = pd.DataFrame(data,columns=['year','state','pop'])

和Series一样，如果传入index的参数在数据中找不到对应值，就会产生NaN：

frame2 = pd.DataFrame(data,columns=['years','state','pop','dept'],index=['one','two','three','four','five'])

c. 通过嵌套字典创建DataFrame:

如果将嵌套字典传递DataFrame，外层字典的键作为列，内层键则作为行索引：

pop = {'Nevada':{2001:2.4,2002:2.9},
'Ohio':{2000:1.5,2001:1.7,2002:3.6}}
frame3 = pd.DataFrame(pop)

函数清单

api地址
https://pandas.pydata.org/pandas-docs/version/0.22/api.html

python数据分析总结

python中对list去重的多种方法

1. 以下的几种情况结果是一样的，去重之后顺序会改变:

ids = [1,2,3,3,4,2,3,4,5,6,1]
news_ids = []
for id in ids:
    if id not in news_ids:
        news_ids.append(id)
print news_ids

用set

ids = [1,4,3,3,4,2,3,4,5,6,1]
ids = list(set(ids))

使用itertools.grouby

import itertools
ids = [1,4,3,3,4,2,3,4,5,6,1]
ids.sort()
it = itertools.groupby(ids)
for k, g in it:
    print k

运用while循环遍历的方式

def quchong(lb):
    for x in lb:
        while lb.count(x)>1:
            del lb[lb.index(x)]
    return lb
li3 = [1,4,3,3,4,2,3,4,5,6,1]
quchong(li3)

使用keys()方式

li4 = [1,0,3,7,7,5]
formatli = list({}.fromkeys(li4).keys())
print (formatli)

2. 去列表去重，不改变原来的顺序，还可以使用一个空列表把原列表里面不重复的数据"装起来"

list2 = []
list1 = [1,2,3,2,2,2,4,6,5]
for i in list1:
    if i not in list2:
        list2.append(i)
list2
[1, 2, 3, 4, 6, 5]

3. 对数据框去重

用unique()对单属性列去重

import pandas as pd
data = {'id':['A','B','C','C','C','A','B','C','A'],'age':[18,20,14,10,50,14,65,14,98]}
data = pd.DataFrame(data)
data.id.unique()
#或者
import numpy as np
np.unique(data.id)

用frame.drop_duplicates()对单属性列去重

data.drop_duplicates(['id'])

用frame.drop_duplicates()对多属性列去重

data.drop_duplicates(['id','age'])

用frame.duplicated()对多属性列去重

isduplicated = data.duplicated(['id','age'],keep='first')
data.loc[~isduplicated,:]

pandas用法

Series 和 DataFrame 两个核心数据结构展开的,Series 和 DataFrame 分别对应于一维的序列和二维的表结构

一. 生成数据

1. 导入库

import numpy as np
import pandas as pd

2. 导入CSV或者xlsx文件

df = pd.DataFrame(pd.read_csv('name.csv',header=1))
df = pd.DataFrame(pd.read_excel('name.xlsx'))

3. 用pandas创建数据表

df = pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006], 
 "date":pd.date_range('20130102', periods=6),
 "city":['Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '],
 "age":[23,44,54,32,34,32],
 "category":['100-A','100-B','110-A','110-C','210-A','130-F'],
 "price":[1200,np.nan,2133,5433,np.nan,4432]},
 columns =['id','date','city','category','age','price'])

二. 数据表查看

维度查看

df.shape

数据表基本信息（维度、列名称、数据格式、所占空间等）：

df.info()

每一列数据的格式：

df.dtypes

某一列格式

df['B'].dtype

isnull：缺失值为True，非缺失值为False
notnull：缺失值为False，非缺失值为True

空值

df.isnull()

查看某一列空值

df.isnull()

查看某一列的唯一值：

df['B'].unique()

查看数据表的值：

df.values

查看列名称

df.columns

查看前10行数据、后10行数据

df.head() #默认前10行数据
df.tail()  #默认后10 行数据

三. 数据表清洗

fillna(method,inplace=True)
用数字0填充空值

df.fillna(value=0)

参数解析
inplace参数的取值：True、False
True：直接修改原对象
False：创建一个副本，修改副本，原对象不变（缺省默认）
method参数的取值 ： {‘pad’, ‘ffill’,‘backfill’, ‘bfill’, None}, default None
pad/ffill：用前一个非缺失值去填充该缺失值
backfill/bfill：用下一个非缺失值填充该缺失值
None：指定一个值去替换缺失值（缺省默认这种方式）
limit参数：限制填充个数
axis参数：修改填充方向

使用列prince的均值对NA进行填充：

df['prince'].fillna(df['prince'].mean())

清楚city字段的字符空格：

df['city']=df['city'].map(str.strip)

大小写转换：

df['city']=df['city'].str.lower()

更改数据格式：

df['price'].astype('int')

更改列名称：

df.rename(columns={'category': 'category-size'})

drop_duplicates
去除特定列下面的重复行

函数原型：
  DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)
 
参数：
  subset:列名或列名的序列，用来指定特定的列，默认所有列
  keep: {‘first’, ‘last’, False}, 默认为‘first’，
     first : 删除重复行，除了第一次出现的行；
     last : 删除重复行，除了最后一次出现的行；
     False :删除所有重复的行；
  inplace:boolean,默认为False，是否修改原DataFrame；

删除后出现的重复值：

df['city'].drop_duplicates()

删除先出现的重复值：

df['city'].drop_duplicates(keep='last')

数据替换：

df['city'] = df['city'].replace('sh', 'shanghai')

四. 数据预处理

df1=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006,1007,1008], 
"gender":['male','female','male','female','male','female','male','female'],
"pay":['Y','N','Y','Y','N','Y','N','Y',],
"m-point":[10,12,20,40,40,40,30,20]})

数据表合并

df_inner=pd.merge(df,df1,how='inner') # 匹配合并，交集
df_left=pd.merge(df,df1,how='left')    #
df_right=pd.merge(df,df1,how='right')
df_outer=pd.merge(df,df1,how='outer') #并集

设置索引列

df_inner.set_index('id')

按照特定列的值排序：

df_inner.sort_values(by=['age'])

按照索引列排序：

df_inner.sort_index()

如果prince列的值>3000，group列显示high，否则显示low：

df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')

对复合多个条件的数据进行分组标记

df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=1

对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和size

pd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size']))

将完成分裂后的数据表和原df_inner数据表进行匹配

df_inner=pd.merge(df_inner,split,right_index=True, left_index=True)

五. 数据提取

主要用到的三个函数：loc,iloc和ix，loc函数按标签值进行提取，iloc按位置进行提取，ix可以同时按标签和位置进行提取。

按索引提取单行的数值

df_inner.loc[3]

按索引提取区域行数值

df_inner.iloc[0:5]

重设索引

df_inner.reset_index()

设置日期为索引

df_inner=df_inner.set_index('date')

提取4日之前的所有数据

df_inner[:'2013-01-04']

使用iloc按位置区域提取数据

df_inner.iloc[:3,:2] #冒号前后的数字不再是索引的标签名称，而是数据所在的位置，从0开始，前三行，前两列。

适应iloc按位置单独提起数据

df_inner.iloc[[0,2,5],[4,5]] #提取第0、2、5行，4、5列

使用ix按索引标签和位置混合提取数据

df_inner.ix[:'2013-01-03',:4] #2013-01-03号之前，前四列数据

判断city列的值是否为北京

df_inner['city'].isin(['beijing'])

判断city列里是否包含beijing和shanghai，然后将符合条件的数据提取出来

df_inner.loc[df_inner['city'].isin(['beijing','shanghai'])]

提取前三个字符，并生成数据表

pd.DataFrame(category.str[:3])

六. 数据筛选

使用与、或、非三个条件配合大于、小于、等于对数据进行筛选，并进行计数和求和。

使用’与’进行筛选

df_inner.loc[(df_inner['age'] > 25) & (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']]

使用“或”进行筛选

df_inner.loc[(df_inner['age'] > 25) | (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']].sort(['age'])

使用“非”条件进行筛选

df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id'])

对筛选后的数据按city列进行计数

df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id']).city.count()

使用query函数进行筛选

df_inner.query('city == ["beijing", "shanghai"]')

对筛选后的结果按prince进行求和

df_inner.query('city == ["beijing", "shanghai"]').price.sum()

七. 数据汇总

主要函数是groupby和pivote_table

对所有的列进行计数汇总

df_inner.groupby('city').count()

按城市对id字段进行计数

df_inner.groupby('city')['id'].count()

对两个字段进行汇总计数

df_inner.groupby(['city','size'])['id'].count()

对city字段进行汇总，并分别计算prince的合计和均值

df_inner.groupby('city')['price'].agg([len,np.sum, np.mean])

八. 数据统计

数据采样，计算标准差，协方差和相关系数

简单的数据采样

df_inner.sample(n=3)

手动设置采样权重

weights = [0, 0, 0, 0, 0.5, 0.5]
df_inner.sample(n=2, weights=weights)

采样后不放回

df_inner.sample(n=6, replace=False)

采样后放回

df_inner.sample(n=6, replace=True)

数据表描述性统计

df_inner.describe().round(2).T #round函数设置显示小数位，T表示转置

计算列的标准差

df_inner['price'].std()

计算两个字段间的协方差

df_inner['price'].cov(df_inner['m-point'])

数据表中所有字段间的协方差

df_inner.cov()

两个字段的相关性分析

df_inner['price'].corr(df_inner['m-point']) #相关系数在-1到1之间，接近1为正相关，接近-1为负相关，0为不相关

数据表的相关性分析

df_inner.corr()

九. 数据输出

分析后的数据可以输出为xlsx格式和csv格式

写入Excel

df_inner.to_excel('excel_to_python.xlsx', sheet_name='bluewhale_cc')

写入到CSV

df_inner.to_csv('excel_to_python.csv') 

拓展

pandas读取数据

pd.read.csv

读取CSV（逗号分割）文件到DataFrame

pd.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None, decimal=b'.', lineterminator=None, quotechar='"', quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=False, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, skip_footer=0, doublequote=True, delim_whitespace=False, as_recarray=False, compact_ints=False, use_unsigned=False, low_memory=True, buffer_lines=None, memory_map=False, float_precision=None)

必填参数

filepath_or_buffer : str，pathlib。str, pathlib.Path,
#py._path.local.LocalPath or any object with a read() method 
#(such as a file handle or StringIO)
#读取文件路径，可以是URL，可用URL类型包括：http, ftp, s3和文件

常用参数

sep :str, default ‘,’
#指定分隔符。如果不指定参数，则会尝试使用逗号分隔。csv文件一般为逗号分隔符。

delimiter ： str, default None
#定界符，备选分隔符（如果指定该参数，则sep参数失效）

delim_whitespace :boolean, default False.
#指定空格(例如’ ‘或者’ ‘)是否作为分隔符使用，等效于设定sep='\s+'。如果这个参数设定为Ture那么delimiter 参数失效。

常用参数(对于数据读取有表头和没表头的情况很实用)

header :int or list of ints, default ‘infer’
#指定行数用来作为列名，数据开始行数。如果文件中没有列名，则默认为0，否则设置为None。

names :  array-like, default None
#用于结果的列名列表，对各列重命名，即添加表头。
#如数据有表头，但想用新的表头，可以设置header=0,names=['a','b']实现表头定制。

index_col : int or sequence or False, default None
#用作行索引的列编号或者列名，如果给定一个序列则有多个行索引。
#可使用index_col=[0,1]来指定文件中的第1和2列为索引列。

usecols : array-like, default None
#返回一个数据子集，即选取某几列，不读取整个文件的内容，有助于加快速度和降低内存。
#usecols=[1,2]或usercols=['a','b']

squeeze : boolean, default False
#如果文件只包含一列，则返回一个Series

prefix :  str, default None
#在没有列标题时，给列添加前缀。例如：添加‘X’ 成为 X0, X1, ...

mangle_dupe_cols : boolean, default True
#重复的列，将‘X’...’X’表示为‘X.0’...’X.N’。如果设定为False则会将所有重名列覆盖。

常用参数，主要用于指定日期类型

parse_dates : boolean or list of ints or names or list of lists or dict, default False

boolean. True -> 解析索引
list of ints or names. e.g. If [1, 2, 3] -> 解析1,2,3列的值作为独立的日期列；
list of lists. e.g. If [[1, 3]] -> 合并1,3列作为一个日期列使用
dict, e.g. {‘foo’ : [1, 3]} -> 将1,3列合并，并给合并后的列起名为"foo"

示例：df=pd.read_csv(file_path,parse_dates=['time1','time2'])，
把time1和time2两列解析为日期格式。
这里不得不说，很遗憾中文不行，比如‘4月5日’这种格式就不能解析。

infer_datetime_format :boolean, default False
#如果设定为True并且parse_dates 可用，那么pandas将尝试转换为日期类型，如果可以转换，转换方法并解析。
#在某些情况下会快5~10倍。

keep_date_col : boolean, default False
#如果连接多列解析日期，则保持参与连接的列。默认为False。

date_parser :  function, default None
#于解析日期的函数，默认使用dateutil.parser.parser来做转换。
#Pandas尝试使用三种不同的方式解析，如果遇到问题则使用下一种方式。
#1.使用一个或者多个arrays（由parse_dates指定）作为参数；
#2.连接指定多列字符串作为一个列作为参数；
#3.每行调用一次date_parser函数来解析一个或者多个字符串（由parse_dates指定）作为参数。

dayfirst : boolean, default False
#DD/MM格式的日期类型

大文件常用参数

iterator : boolean, default False
#返回一个TextFileReader 对象，以便逐块处理文件。

chunksize : int, default None
#文件块的大小， See IO Tools docs for more informationon iterator and chunksize.

compression : {‘infer’, ‘gzip’, ‘bz2’, ‘zip’, ‘xz’, None}, default ‘infer’
#直接使用磁盘上的压缩文件。如果使用infer参数，则使用 gzip, bz2, zip或者解压文件名中以‘.gz’, ‘.bz2’, ‘.zip’, or ‘xz’这些为后缀的文件，否则不解压。
#如果使用zip，那么ZIP包中必须只包含一个文件。设置为None则不解压。
#新版本0.18.1版本支持zip和xz解压

thousands : str, default None
#千分位分割符，如“，”或者“."

decimal : str, default ‘.’
#字符中的小数点 (例如：欧洲数据使用’，‘).

float_precision : string, default None
#Specifies which converter the C engine should use for floating-point values. 
#The options are None for the ordinary converter, high for the high-precision converter,
#and round_trip for the round-trip converter.

lineterminator : str (length 1), default None
#行分割符，只在C解析器下使用。

quotechar : str (length 1), optional
#引号，用作标识开始和解释的字符，引号内的分割符将被忽略。

quoting : int or csv.QUOTE_* instance, default 0
#控制csv中的引号常量。
#可选 QUOTE_MINIMAL (0), QUOTE_ALL (1), QUOTE_NONNUMERIC (2) or QUOTE_NONE (3)

doublequote : boolean, default True
#双引号，当单引号已经被定义，并且quoting 参数不是QUOTE_NONE的时候，
#使用双引号表示引号内的元素作为一个元素使用。

escapechar : str (length 1), default None
#当quoting 为QUOTE_NONE时，指定一个字符使的不受分隔符限值。

comment : str, default None
#标识着多余的行不被解析。如果该字符出现在行首，这一行将被全部忽略。
#这个参数只能是一个字符，空行（就像skip_blank_lines=True）注释行被header和skiprows忽略一样。
#例如如果指定comment='#' 解析‘#empty\na,b,c\n1,2,3’ 以header=0 那么返回结果将是以’a,b,c'作为header。

常用参数

encoding : str, default None
#指定字符集类型，通常指定为'utf-8'. List of Python standard encodings

dialect : str or csv.Dialect instance, default None
#如果没有指定特定的语言，如果sep大于一个字符则忽略。具体查看csv.Dialect 文档

tupleize_cols : boolean, default False
#Leave a list of tuples on columns as is (default is to convert to a Multi Index on the columns)

error_bad_lines : boolean, default True
#如果一行包含太多的列，那么默认不会返回DataFrame ，如果设置成false，那么会将改行剔除（只能在C解析器下使用）。

warn_bad_lines : boolean, default True
#如果error_bad_lines =False，并且warn_bad_lines =True 那么所有的“bad lines”将会被输出（只能在C解析器下使用）。

low_memory : boolean, default True
#分块加载到内存，在低内存消耗中解析。但是可能出现类型混淆。
#确保类型不被混淆需要设置为False。或者使用dtype 参数指定类型。
#注意使用chunksize 或者iterator 参数分块读入会将整个文件读入到一个Dataframe，
#而忽略类型（只能在C解析器中有效）

读取多个文件

import pandas
import glob
for r in glob.glob("test*.csv"):
        csv=pandas.read_csv(r)
        csv.to_csv("test.txt",mode="a+")

pd.read_csv(‘demo.csv’,nrows=1000,usecols=[‘column1’, ‘column2’, ‘column3’])

使用pandas分块处理大文件

这一类读取文件的函数有两个参数：chunksize，iterator
原理就是不一次性把文件数据读入内存中，而是分多次。

1.指定CHUNKSIZE分块读取文件

read_csv 和 read_table 有一个chunksize参数，用以指定一个块大小（每次读取多少行），返回一个可迭代的 TextFileReader 对象。

table=pd.read_table(path+'kuaishou.txt',sep='\t',chunksize=1000000)
for df in table:
    对df处理
    #如df.drop(columns=['page','video_id'],axis=1,inplace=True)
    #print(type(df),df.shape)打印看一下信息

我这里又对文件进行了划分，分成若干个子文件分别处理（没错，to_csv也同样有CHUNKSIZE参数）

2. 指定迭代=真

iterator=True报道查看同样的的英文TextFileReader对象

reader = pd.read_table('tmp.sv', sep='\t', iterator=True)
df=reader.get_chunk(10000)
#通过get_chunk(size)，返回一个size行的块
#接着同样可以对df处理

DataFrame与Series数据结构对比

Series:构建的方法，一组数组（列表或元组），利用Series(),自动生成索引。或Series(字典),值只有一列，无列索引，只有行索引

属性： .index、.values .name .index.name .values.name