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.