pandas的tosql

① 如何从postgresq获取数据到pandas(不通过pandas 的 tosql函数)

直接用pandas读取PostgreSQL数据不行吗
from sqlalchemy import create_engine
engine = create_engine('postgresql://user@localhost:5432/mydb')
df = pd.read_sql_query('select * from "Stat_Table"',con=engine)

② python 用pymysql 包上传 dataframe 到mysql 上怎么操作

可以使用pip安装也可以手动下载安装。
使用pip安装，在命令行执行如下命令：
pip install PyMySQL
手动安装，请先下载。
其中的X.X是版本（目前可以获取的最新版本是0.6.6）。
下载后解压压缩包。在命令行中进入解压后的目录，执行如下的指令：
python setup.py install
建议使用pip安装。

③ 基于Pandas的数据分析平台，数据连接该不该用SqlAlchemy的ORM

一、开始使用：
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
DB_CONNECT_STRING = 'mysql+mysqldb://root:123@localhost/ooxx?charset=utf8'
engine = create_engine(DB_CONNECT_STRING, echo=True)
DB_Session = sessionmaker(bind=engine)
session = DB_Session()
这里的 DB_CONNECT_STRING 就是连接数据库的路径。“mysql+mysqldb”指定了使用 MySQL-Python 来连接，“root”和“123”分别是用户名和密码，“localhost”是数据库的域名，“ooxx”是使用的数据库名（可省略），“charset”指定了连接时使用的字符集（可省略）。
create_engine() 会返回一个数据库引擎，echo 参数为 True 时，会显示每条执行的 SQL 语句，生产环境下可关闭。
sessionmaker() 会生成一个数据库会话类。这个类的实例可以当成一个数据库连接，它同时还记录了一些查询的数据，并决定什么时候执行 SQL 语句。由于 SQLAlchemy 自己维护了一个数据库连接池（默认 5 个连接），因此初始化一个会话的开销并不大。对 Tornado 而言，可以在 BaseHandler 的 initialize() 里初始化：
class BaseHandler(tornado.web.RequestHandler):
def initialize(self):
self.session = models.DB_Session()

def on_finish(self):
self.session.close()
对其他 Web 服务器来说，可以使用 sqlalchemy.orm.scoped_session，它能保证每个线程获得的 session 对象都是唯一的。不过 Tornado 本身就是单线程的，如果使用了异步方式，就可能会出现问题，因此并没使用它。

拿到 session 后，就可以执行 SQL 了：
session.execute('create database abc')
print session.execute('show databases').fetchall()
session.execute('use abc')
# 建 user 表的过程略
print session.execute('select * from user where id = 1').first()
print session.execute('select * from user where id = :id', {'id': 1}).first()
不过这和直接使用 MySQL-Python 没啥区别；ORM 的方式，这也是采用 SQLAlchemy 的唯一原因。

于是来定义一个表：
from sqlalchemy import Column
from sqlalchemy.types import CHAR, Integer, String
from sqlalchemy.ext.declarative import declarative_base

BaseModel = declarative_base()

def init_db():
BaseModel.metadata.create_all(engine)

def drop_db():
BaseModel.metadata.drop_all(engine)

class User(BaseModel):
__tablename__ = 'user'

id = Column(Integer, primary_key=True)
name = Column(CHAR(30)) # or Column(String(30))

init_db()
declarative_base() 创建了一个 BaseModel 类，这个类的子类可以自动与一个表关联。
以 User 类为例，它的 __tablename__ 属性就是数据库中该表的名称，它有 id 和 name 这两个字段，分别为整型和 30 个定长字符。Column 还有一些其他的参数，我就不解释了。
最后，BaseModel.metadata.create_all(engine) 会找到 BaseModel 的所有子类，并在数据库中建立这些表；drop_all() 则是删除这些表。

接着就开始使用这个表吧：
from sqlalchemy import func, or_, not_

user = User(name='a')
session.add(user)
user = User(name='b')
session.add(user)
user = User(name='a')
session.add(user)
user = User()
session.add(user)
session.commit()

query = session.query(User)
print query # 显示SQL 语句
print query.statement # 同上
for user in query: # 遍历时查询
print user.name
print query.all() # 返回的是一个类似列表的对象
print query.first().name # 记录不存在时，first() 会返回 None
# print query.one().name # 不存在，或有多行记录时会抛出异常
print query.filter(User.id == 2).first().name
print query.get(2).name # 以主键获取，等效于上句
print query.filter('id = 2').first().name # 支持字符串

query2 = session.query(User.name)
print query2.all() # 每行是个元组
print query2.limit(1).all() # 最多返回 1 条记录
print query2.offset(1).all() # 从第 2 条记录开始返回
print query2.order_by(User.name).all()
print query2.order_by('name').all()
print query2.order_by(User.name.desc()).all()
print query2.order_by('name desc').all()
print session.query(User.id).order_by(User.name.desc(), User.id).all()

print query2.filter(User.id == 1).scalar() # 如果有记录，返回第一条记录的第一个元素
print session.query('id').select_from(User).filter('id = 1').scalar()
print query2.filter(User.id > 1, User.name != 'a').scalar() # and
query3 = query2.filter(User.id > 1) # 多次拼接的 filter 也是 and
query3 = query3.filter(User.name != 'a')
print query3.scalar()
print query2.filter(or_(User.id == 1, User.id == 2)).all() # or
print query2.filter(User.id.in_((1, 2))).all() # in

query4 = session.query(User.id)
print query4.filter(User.name == None).scalar()
print query4.filter('name is null').scalar()
print query4.filter(not_(User.name == None)).all() # not
print query4.filter(User.name != None).all()

print query4.count()
print session.query(func.count('*')).select_from(User).scalar()
print session.query(func.count('1')).select_from(User).scalar()
print session.query(func.count(User.id)).scalar()
print session.query(func.count('*')).filter(User.id > 0).scalar() # filter() 中包含 User，因此不需要指定表
print session.query(func.count('*')).filter(User.name == 'a').limit(1).scalar() == 1 # 可以用 limit() 限制 count() 的返回数
print session.query(func.sum(User.id)).scalar()
print session.query(func.now()).scalar() # func 后可以跟任意函数名，只要该数据库支持
print session.query(func.current_timestamp()).scalar()
print session.query(func.md5(User.name)).filter(User.id == 1).scalar()

query.filter(User.id == 1).update({User.name: 'c'})
user = query.get(1)
print user.name

user.name = 'd'
session.flush() # 写数据库，但并不提交
print query.get(1).name

session.delete(user)
session.flush()
print query.get(1)

session.rollback()
print query.get(1).name
query.filter(User.id == 1).delete()
session.commit()
print query.get(1)

二、进阶的知识。
1）如何批量插入大批数据？
可以使用非 ORM 的方式：
session.execute(
User.__table__.insert(),
[{'name': `randint(1, 100)`,'age': randint(1, 100)} for i in xrange(10000)]
)
session.commit()

如何批量插入大批数据？
可以使用非 ORM 的方式：
session.execute(
User.__table__.insert(),
[{'name': `randint(1, 100)`,'age': randint(1, 100)} for i in xrange(10000)]
)
session.commit()
上面批量插入了 10000 条记录，半秒内就执行完了；而 ORM 方式会花掉很长时间。

2）如何让执行的 SQL 语句增加前缀？
使用 query 对象的 prefix_with() 方法：
session.query(User.name).prefix_with('HIGH_PRIORITY').all()
session.execute(User.__table__.insert().prefix_with('IGNORE'), {'id': 1, 'name': '1'})

3）如何替换一个已有主键的记录？
使用 session.merge() 方法替代 session.add()，其实就是 SELECT + UPDATE：
user = User(id=1, name='ooxx')
session.merge(user)
session.commit()
或者使用 MySQL 的 INSERT … ON DUPLICATE KEY UPDATE，需要用到 @compiles 装饰器，有点难懂，自己看吧：《SQLAlchemy ON DUPLICATE KEY UPDATE》 和 sqlalchemy_mysql_ext。

4）如何使用无符号整数？
可以使用 MySQL 的方言：
from sqlalchemy.dialects.mysql import INTEGER

id = Column(INTEGER(unsigned=True), primary_key=True)

5）模型的属性名需要和表的字段名不一样怎么办？
开发时遇到过一个奇怪的需求，有个其他系统的表里包含了一个“from”字段，这在 Python 里是关键字，于是只能这样处理了：
from_ = Column('from', CHAR(10))

6）如何获取字段的长度？
Column 会生成一个很复杂的对象，想获取长度比较麻烦，这里以 User.name 为例：
User.name.property.columns[0].type.length

7）如何指定使用 InnoDB，以及使用 UTF-8 编码？
最简单的方式就是修改数据库的默认配置。如果非要在代码里指定的话，可以这样：
class User(BaseModel):
__table_args__ = {
'mysql_engine': 'InnoDB',
'mysql_charset': 'utf8'
}
MySQL 5.5 开始支持存储 4 字节的 UTF-8 编码的字符了，iOS 里自带的 emoji（如 ?? 字符）就属于这种。
如果是对表来设置的话，可以把上面代码中的 utf8 改成 utf8mb4，DB_CONNECT_STRING 里的 charset 也这样更改。
如果对库或字段来设置，则还是自己写 SQL 语句比较方便，具体细节可参考《How to support full Unicode in MySQL databases》。
不建议全用 utf8mb4 代替 utf8，因为前者更慢，索引会占用更多空间。

8）如何设置外键约束？
from random import randint
from sqlalchemy import ForeignKey

class User(BaseModel):
__tablename__ = 'user'

id = Column(Integer, primary_key=True)
age = Column(Integer)

class Friendship(BaseModel):
__tablename__ = 'friendship'

id = Column(Integer, primary_key=True)
user_id1 = Column(Integer, ForeignKey('user.id'))
user_id2 = Column(Integer, ForeignKey('user.id'))

for i in xrange(100):
session.add(User(age=randint(1, 100)))
session.flush() # 或 session.commit()，执行完后，user 对象的 id 属性才可以访问（因为 id 是自增的）

for i in xrange(100):
session.add(Friendship(user_id1=randint(1, 100), user_id2=randint(1, 100)))
session.commit()

session.query(User).filter(User.age < 50).delete()
执行这段代码时，应该会遇到一个错误：
sqlalchemy.exc.IntegrityError: (IntegrityError) (1451, 'Cannot delete or update a parent row: a foreign key constraint fails (`ooxx`.`friendship`, CONSTRAINT `friendship_ibfk_1` FOREIGN KEY (`user_id1`) REFERENCES `user` (`id`))') 'DELETE FROM user WHERE user.age < %s' (50,)原因是删除 user 表的数据，可能会导致 friendship 的外键不指向一个真实存在的记录。在默认情况下，MySQL 会拒绝这种操作，也就是 RESTRICT。InnoDB 还允许指定 ON DELETE 为 CASCADE 和 SET NULL，前者会删除 friendship 中无效的记录，后者会将这些记录的外键设为 NULL。
除了删除，还有可能更改主键，这也会导致 friendship 的外键失效。于是相应的就有 ON UPDATE 了。其中 CASCADE 变成了更新相应的外键，而不是删除。
而在 SQLAlchemy 中是这样处理的：
class Friendship(BaseModel):
__tablename__ = 'friendship'

id = Column(Integer, primary_key=True)
user_id1 = Column(Integer, ForeignKey('user.id', ondelete='CASCADE', onupdate='CASCADE'))
user_id2 = Column(Integer, ForeignKey('user.id', ondelete='CASCADE', onupdate='CASCADE'))

9）如何连接表？
from sqlalchemy import distinct
from sqlalchemy.orm import aliased

Friend = aliased(User, name='Friend')

print session.query(User.id).join(Friendship, User.id == Friendship.user_id1).all() # 所有有朋友的用户
print session.query(distinct(User.id)).join(Friendship, User.id == Friendship.user_id1).all() # 所有有朋友的用户（去掉重复的）
print session.query(User.id).join(Friendship, User.id == Friendship.user_id1).distinct().all() # 同上
print session.query(Friendship.user_id2).join(User, User.id == Friendship.user_id1).order_by(Friendship.user_id2).distinct().all() # 所有被别人当成朋友的用户
print session.query(Friendship.user_id2).select_from(User).join(Friendship, User.id == Friendship.user_id1).order_by(Friendship.user_id2).distinct().all() # 同上，join 的方向相反，但因为不是 STRAIGHT_JOIN，所以 MySQL 可以自己选择顺序
print session.query(User.id, Friendship.user_id2).join(Friendship, User.id == Friendship.user_id1).all() # 用户及其朋友
print session.query(User.id, Friendship.user_id2).join(Friendship, User.id == Friendship.user_id1).filter(User.id < 10).all() # id 小于 10 的用户及其朋友
print session.query(User.id, Friend.id).join(Friendship, User.id == Friendship.user_id1).join(Friend, Friend.id == Friendship.user_id2).all() # 两次 join，由于使用到相同的表，因此需要别名
print session.query(User.id, Friendship.user_id2).outerjoin(Friendship, User.id == Friendship.user_id1).all() # 用户及其朋友（无朋友则为 None，使用左连接）
-

④ 如何将pandas.dataframe的数据写入到文件中

步骤操作方法如下：

1、环境准备:

a、右击桌面上选择【Open in Terminal】 打开终端。

b、在弹出的终端中输入【ipython】进入Python的解释器中，如图1所示。

⑤ python pandas怎么输出结果

本文是对pandas官方网站上《10 Minutes to pandas》的一个简单的翻译，原文在这里。这篇文章是对pandas的一个简单的介绍，详细的介绍请参考：Cookbook 。习惯上，我们会按下面格式引入所需要的包：

一、 创建对象
可以通过 Data Structure Intro Setion 来查看有关该节内容的详细信息。
1、可以通过传递一个list对象来创建一个Series，pandas会默认创建整型索引：

2、通过传递一个numpy array，时间索引以及列标签来创建一个DataFrame：

3、通过传递一个能够被转换成类似序列结构的字典对象来创建一个DataFrame：

4、查看不同列的数据类型：

5、如果你使用的是IPython，使用Tab自动补全功能会自动识别所有的属性以及自定义的列，下图中是所有能够被自动识别的属性的一个子集：

二、 查看数据
详情请参阅：Basics Section

1、 查看frame中头部和尾部的行：

2、 显示索引、列和底层的numpy数据：

3、 describe()函数对于数据的快速统计汇总：

4、 对数据的转置：

5、 按轴进行排序

6、 按值进行排序

三、 选择
虽然标准的Python/Numpy的选择和设置表达式都能够直接派上用场，但是作为工程使用的代码，我们推荐使用经过优化的pandas数据访问方式： .at, .iat, .loc, .iloc 和 .ix详情请参阅Indexing and Selecing Data 和 MultiIndex / Advanced Indexing。
l 获取
1、 选择一个单独的列，这将会返回一个Series，等同于df.A：

2、 通过[]进行选择，这将会对行进行切片

l 通过标签选择
1、 使用标签来获取一个交叉的区域

2、 通过标签来在多个轴上进行选择

3、 标签切片

4、 对于返回的对象进行维度缩减

5、 获取一个标量

6、 快速访问一个标量（与上一个方法等价）

l 通过位置选择
1、 通过传递数值进行位置选择（选择的是行）

2、 通过数值进行切片，与numpy/python中的情况类似

3、 通过指定一个位置的列表，与numpy/python中的情况类似

4、 对行进行切片

5、 对列进行切片

6、 获取特定的值

l 布尔索引
1、 使用一个单独列的值来选择数据：

2、 使用where操作来选择数据：

3、 使用isin()方法来过滤：

l 设置
1、 设置一个新的列：

2、 通过标签设置新的值：

3、 通过位置设置新的值：

4、 通过一个numpy数组设置一组新值：

上述操作结果如下：

5、 通过where操作来设置新的值：

四、 缺失值处理
在pandas中，使用np.nan来代替缺失值，这些值将默认不会包含在计算中，详情请参阅：Missing Data Section。
1、 reindex()方法可以对指定轴上的索引进行改变/增加/删除操作，这将返回原始数据的一个拷贝：、

2、 去掉包含缺失值的行：

3、 对缺失值进行填充：

4、 对数据进行布尔填充：

五、 相关操作
详情请参与 Basic Section On Binary Ops
统计（相关操作通常情况下不包括缺失值）
1、 执行描述性统计：

2、 在其他轴上进行相同的操作：

3、 对于拥有不同维度，需要对齐的对象进行操作。Pandas会自动的沿着指定的维度进行广播：

Apply
1、 对数据应用函数：

直方图
具体请参照：Histogramming and Discretization

字符串方法
Series对象在其str属性中配备了一组字符串处理方法，可以很容易的应用到数组中的每个元素，如下段代码所示。更多详情请参考：Vectorized String Methods.

六、 合并
Pandas提供了大量的方法能够轻松的对Series，DataFrame和Panel对象进行各种符合各种逻辑关系的合并操作。具体请参阅：Merging section
Concat

Join 类似于SQL类型的合并，具体请参阅：Database style joining

Append 将一行连接到一个DataFrame上，具体请参阅Appending：

七、 分组
对于”group by”操作，我们通常是指以下一个或多个操作步骤：
（Splitting）按照一些规则将数据分为不同的组；
（Applying）对于每组数据分别执行一个函数；
（Combining）将结果组合到一个数据结构中；
详情请参阅：Grouping section

1、 分组并对每个分组执行sum函数：

2、 通过多个列进行分组形成一个层次索引，然后执行函数：

八、 Reshaping
详情请参阅 Hierarchical Indexing 和 Reshaping。
Stack

数据透视表，详情请参阅：Pivot Tables.

可以从这个数据中轻松的生成数据透视表：

九、 时间序列
Pandas在对频率转换进行重新采样时拥有简单、强大且高效的功能（如将按秒采样的数据转换为按5分钟为单位进行采样的数据）。这种操作在金融领域非常常见。具体参考：Time Series section。

1、 时区表示：

2、 时区转换：

3、 时间跨度转换：

4、 时期和时间戳之间的转换使得可以使用一些方便的算术函数。

十、 Categorical
从0.15版本开始，pandas可以在DataFrame中支持Categorical类型的数据，详细 介绍参看：categorical introction和API documentation。

1、 将原始的grade转换为Categorical数据类型：

2、 将Categorical类型数据重命名为更有意义的名称：

3、 对类别进行重新排序，增加缺失的类别：

4、 排序是按照Categorical的顺序进行的而不是按照字典顺序进行：

5、 对Categorical列进行排序时存在空的类别：

十一、 画图
具体文档参看：Plotting docs

对于DataFrame来说，plot是一种将所有列及其标签进行绘制的简便方法：

十二、 导入和保存数据
CSV，参考：Writing to a csv file
1、 写入csv文件：

2、 从csv文件中读取：

HDF5，参考：HDFStores
1、 写入HDF5存储：

2、 从HDF5存储中读取：

Excel，参考：MS Excel
1、 写入excel文件：

2、 从excel文件中读取：

来自为知笔记(Wiz)

⑥ python pandas to_sql将excel数据导入到MySQL数据库

其实吧， 一分钟10W条数据不能算太快，10秒10W条还差不多。 可以研究一下线程+进程来处理， 或者协程+进程。处理速度肯定能让你喊一声“卧槽！” 哈哈。
言归正传， 你说的别的MySQL是不是远程的，通过ip来连接的哈， 如果是的话那就可以理解了。 每次连接一次数据库，都有一个网络延迟的，2台电脑之间距离越远，这个延迟就越高，而每次导入数据的时间必须要加上这个延迟的时间的， 而本地测试的时候因为连接数据库的时间延迟基本可以忽略不计，所以速度要比连接远程数据库要快很多很多。
最后， 如果想要解决这个问题的话，要么把业务数据库移到本地，去掉时间延迟。 要么就用我上面说的线程+进程 或者 协程+进程的方式提高程序效率。如果无法把业务数据库移到本地的话， 我非常推荐后者，成本也就是多学一点东西而已， 但以后可以省下非常多的时间， 效率为王嘛~

⑦ 如何用python将dataframe更新原来的sql表

pandas是python环境下最有名的数据统计包，而DataFrame翻译为数据框，是一种数据组织方式，这么说你可能无法从感性上认识它，举个例子，你大概用过Excel，而它也是一种数据组织和呈现的方式，简单说就是表格，而在在pandas中用DataFrame组织数据，如果你不print DataFrame，你看不到这些数据，下面我们来看看DataFrame是如何使用的。
首先是引入pandas和numpy，这是经常配合使用的两个包，pandas依赖于numpy，引入以后我们可以直接使用np/pd来表示这个两个模块
先创建一个时间索引，所谓的索引（index)就是每一行数据的id，可以标识每一行的唯一值
为了快速入门，我们看一下如何创建一个6X4的数据：randn函数用于创建随机数，参数表示行数和列数，dates是上一步创建的索引列
我们还可以使用字典来创建数据框，例如创建一个列名为A的数据框，索引是自动创建的整数
这又是一个字典创建DataFrame的例子
假如字典内的数据长度不同，以最长的数据为准，比如B列有4行：
可以使用dtypes来查看各行的数据格式
接着看一下如何查看数据框中的数据，看一下所有的数据
使用head查看前几行数据（默认是前5行），不过你可以指定前几行
查看前三行数据
使用tail查看后5行数据
查看数据框的索引
查看列名用columns
查看数据值，用values
查看描述性统计，用describe
使用type看一下输出的描述性统计是什么样的数据类型——DataFrame数据
使用T来转置数据，也就是行列转换
对数据进行排序，用到了sort，参数可以指定根据哪一列数据进行排序。
好了，这篇入门教程到这里，后面还有很多，希望有志同道合的朋友一起交流学习，有什么说的不对的地方，请批评指正。

⑧ 怎么使用Python中Pandas库Resample，实现重采样，完成线性插值

#python中的pandas库主要有DataFrame和Series类(面向对象的的语言更愿意叫类) DataFrame也就是
#数据框(主要是借鉴R里面的data.frame)，Series也就是序列 ，pandas底层是c写的 性能很棒，有大神
#做过测试 处理亿级别的数据没问题，起性能可以跟同等配置的sas媲美
#DataFrame索引 df.loc是标签选取操作，df.iloc是位置切片操作
print(df[['row_names','Rape']])
df['行标签']
df.loc[行标签,列标签]
print(df.loc[0:2,['Rape','Murder']])
df.iloc[行位置,列位置]
df.iloc[1,1]#选取第二行，第二列的值，返回的为单个值
df.iloc[0,2],:]#选取第一行及第三行的数据
df.iloc[0:2,:]#选取第一行到第三行（不包含）的数据
df.iloc[:,1]#选取所有记录的第一列的值，返回的为一个Series
df.iloc[1,:]#选取第一行数据，返回的为一个Series
print(df.ix[1,1]) # 更广义的切片方式是使用.ix，它自动根据你给到的索引类型判断是使用位置还是标签进行切片
print(df.ix[0:2])
#DataFrame根据条件选取子集 类似于sas里面if、where ,R里面的subset之类的函数
df[df.Murder>13]
df[(df.Murder>10)&(df.Rape>30)]
df[df.sex==u'男']
#重命名 相当于sas里面的rename R软件中reshape包的中的rename
df.rename(columns={'A':'A_rename'})
df.rename(index={1:'other'})
#删除列 相当于sas中的drop R软件中的test['col']<-null
df.drop(['a','b'],axis=1) or del df[['a','b']]
#排序 相当于sas里面的sort R软件里面的df[order(x),]
df.sort(columns='C') #行排序 y轴上
df.sort(axis=1) #各个列之间位置排序 x轴上
#数据描述 相当于sas中proc menas R软件里面的summary
df.describe()
#生成新的一列 跟R里面有点类似
df['new_columns']=df['columns']
df.insert(1,'new_columns',df['B']) #效率最高
df.join(Series(df['columns'],name='new_columns'))
#列上面的追加 相当于sas中的append R里面cbind()
df.append(df1,ignore_index=True)
pd.concat([df,df1],ignore_index=True)
#最经典的join 跟sas和R里面的merge类似 跟sql里面的各种join对照
merge()
#删除重行 跟sas里面nokey R里面的which(!plicated(df[])类似
df.drop_plicated()
#获取最大值 最小值的位置 有点类似矩阵里面的方法
df.idxmin(axis=0 ) df.idxmax(axis=1) 0和1有什么不同 自己摸索去
#读取外部数据跟sas的proc import R里面的read.csv等类似
read_excel() read_csv() read_hdf5() 等
与之相反的是df.to_excel() df.to_ecv()
#缺失值处理 个人觉得pandas中缺失值处理比sas和R方便多了
df.fillna(9999) #用9999填充
#链接数据库 不多说 pandas里面主要用 MySQLdb
import MySQLdb
conn=MySQLdb.connect(host="localhost",user="root",passwd="",db="mysql",use_unicode=True,charset="utf8")
read_sql() #很经典
#写数据进数据库
df.to_sql('hbase_visit',con, flavor="mysql", if_exists='replace', index=False)
#groupby 跟sas里面的中的by R软件中dplyr包中的group_by sql里面的group by功能是一样的 这里不多说
#求哑变量
miper=pd.get_mmies(df['key'])
df['key'].join(mpier)
#透视表 和交叉表 跟sas里面的proc freq步类似 R里面的aggrate和cast函数类似
pd.pivot_table()
pd.crosstab()
#聚合函数经常跟group by一起组合用
df.groupby('sex').agg({'height':['mean','sum'],'weight':['count','min']})

#数据查询过滤

test.query("0.2
将STK_ID中的值过滤出来
stk_list = ['600809','600141','600329']中的全部记录过滤出来，命令是：rpt[rpt['STK_ID'].isin(stk_list)].
将dataframe中，某列进行清洗的命令
删除换行符：misc['proct_desc'] = misc['proct_desc'].str.replace('\n', '')
删除字符串前后空格：df["Make"] = df["Make"].map(str.strip)
如果用模糊匹配的话，命令是：
rpt[rpt['STK_ID'].str.contains(r'^600[0-9]{3}$')]

对dataframe中元素，进行类型转换

df['2nd'] = df['2nd'].str.replace(',','').astype(int) df['CTR'] = df['CTR'].str.replace('%','').astype(np.float64)

#时间变换 主要依赖于datemie 和time两个包
http://www.2cto.com/kf/201401/276088.html
#其他的一些技巧
df2[df2['A'].map(lambda x:x.startswith('61'))] #筛选出以61开头的数据
df2["Author"].str.replace("<.+>", "").head() #replace("<.+>", "")表示将字符串中以”<”开头;以”>”结束的任意子串替换为空字符串
commits = df2["Name"].head(15)
print commits.unique(), len(commits.unique()) #获的NAME的不同个数，类似于sql里面count(distinct name)
#pandas中最核心 最经典的函数apply map applymap

⑨ python pandas数据处理赋值编码错误UnicodeWarning: Unicode equal comparison failed to convert both

for row in csv.reader(open(r'testm.csv','rb'),delimiter=','):
sql=""
cursor = MySqlConn.cursor()
cursor.execute(sql)
dbRet=cursor.fetchone()

if not tuple(row)==dbRet:
#其他操作

在ubuntu下if判断出现异常信息:
UnicodeWarning: Unicode equal comparison failed to convert both arguments to Unicode - interpreting them as being unequal.