互聯網 - 大數據

文章出處
Windows Server 2012 NIC Teaming介紹及注意事項
 
轉載自：http://www.it165.net/os/html/201303/4799.html
 
Windows Server 2012 NIC Teaming 也稱作 負載平衡/故障轉移 （LBFO)。主要功能就是帶寬聚合，負載均衡以及故障轉移。Windows Server 2012 首次內置了這個功能，所以配置NIC Teaming不再需要網卡廠商的驅動程序上配置。具體就不多說了，想必大家都已經有所了解。直接進入主題寫一些我最近學到的關于NIC Teaming的配置細節和要求限制。
 
從很多朋友的反饋得知，使用Windows Server 2012 或Windows Server 2012 R2 內置的NIC Teaming非常穩定比使用第三方軟件和驅動穩定得多
所以建議大家盡快將操作系統升級到Windows Server 2012 R2
一，NIC Teaming的要求及限制
1. 在Hyper-V 主機上支持最多32個網卡組成一個Team.
2. 在VM上支持最多2個網卡組成一個Team。
3. 在VM 上做NIC TEAMING 只支持“Switch Independent configuration / Address Hash distribution”模式。
4. 在VM上做TEAMING 不會影響Live Migration.
5. 只能用以太網卡組成TEAM，不支持WWAN,WLAN,Bluetooth.
6. 不能對在hyper-V主機上的虛擬網卡做Team。
7. 對于兩個速度不一樣的網卡，不支持使用active/active 模式。可以用一個 活動（active）,一個備用（standby）模式。NIC TEAMING的分發模式不會基于網卡的速度來分發，一個包含10Gbps 的網卡和一個100Mbps網卡的TEAM，可能會給兩塊網卡各發送一半的流量。但是可以讓10Gbps網卡作為活動，100Mbps網卡作為備用。
8. 不能在Team之上再建Team。并且不能將第三方的TEAM 方案和Windows Server 2012 的Teaming 混合使用。
具體還有很多細節，這個官方文檔上寫的挺詳細的，值得一讀：
http://www.microsoft.com/en-us/download/details.aspx?id=30160
二，NIC Teaming 的配置模式以及負載平衡模式
1. 配置模式
配置模式有3種：
Switch-independent
交換機上不需要做任何配置
Static teaming (Switch-dependent teaming)
需要在交換機和主機上都做配置
LACP (Switch-dependent teaming)
少數交換機上實現自動配置，在大多數交換機上需要在端口上啟用LACP
后兩種Switch-dependent teaming 模式可以讓入站和出站帶寬達到Team成員適配器的聚合帶寬，因為所有的Team 成員適配器是被看做一條大的通道。
Switch-independent 模式中，組成Team的網絡適配器可以連接在不同的交換機上。
Switch-dependent teaming模式則要求，組成Team的適配器都必須連接在同一個物理交換機上。
2. 負載平衡模式
Load balancing mode 有兩種：
· Address Hashing
這種算法會基于數據包的地址組成部（源，目標的MAC, IP, 以及端口號）分創建一個哈希值，然后把具有這個哈希值的數據包分配到可用的NIC上。通常這種分配方式就足夠在可用的NIC上建立有效負載。
· Hyper-V switch port
因為每個VM都有獨立的MAC地址，所以VM的MAC地址或者VM所連接的Hyper-V switch 端口可以做為劃分流量的基礎，交換機在分發入站流量的時候，可以基于目標Mac 地址（VM Mac地址）來在多條鏈路上分發。然后如果HOST上的VM數量較少時，這種分發方式不能充分做到負載均衡，因為同一時間內，只有一個NIC在發送一個VM上的流量，并且單一VM的帶寬也被限制在單一NIC的可用帶寬之內。但這種方式在使用VMQs的時候非常有用。
3.如何選擇不同的配置方法 （NIC Teaming Configuration）和數據分發算法(Load distribution algorithms)
· Switch Independent configuration / Address Hash distribution
這種配置方式會通過選用的地址哈希來分發送數據包到所有活動的NIC成員上，因為在路由的時候，一個IP地址只能關聯一個MAC地址，所以這種方式在接收入站通信時，只能通過一個TEAM 成員來接收。這也意味著入站通信不會超過TEAM 中一個成員的帶寬。
這種配置方式最適合用在如下的情況里：
需要考慮在不同的物理交換機上做Team；需要用 活動/備用 （active/standby）模式；Team VM；在服務器上跑的工作流有大量出站負載，少量入站負載，例如IIS。
· Switch Independent configuration / Hyper-V Port distribution
這種方式會基于Hyper-V 交換機的端口號來在所有活動的Team 成員（NIC）上分發流量。每個Hyper-V端口的帶寬不會大于一個TEAM 成員（NIC）的帶寬。
由于Hyper-V 端口號是和Team NIC 綁定的，所以同一個VM上的入站和出站流量都用的是同一個Team NIC。
這種配置方式最適合用在如下的情況里（同時）：
VM的數量遠大于Team 成員的數量，可以接受VM的帶寬被限制在一個TEAM NIC成員的可用帶寬之內。
· Switch Dependent configuration / Address Hash distribution
這種配置方式會通過選用的地址哈希來分發送數據包到所有活動的NIC成員上。和所有switch dependent configurations 一樣，交換機來決定如何在TEAM NIC上分發入站通信。
這種配置方式最適合用在如下的情況里（同時）：
在可以保證使用相同交換機上做TEAM時，達到最大性能；在Hyper-V 交換機下做Teaming,VM的帶寬需要大于一個TEAM NIC 的可用帶寬。
· Switch Dependent configuration / Hyper-V Port distribution
這種方式會基于Hyper-V 交換機的端口號來在所有活動的Team 成員（NIC）上分發流量。每個Hyper-V端口的帶寬不會大于一個TEAM 成員（NIC）的帶寬。和所有switch dependent configurations 一樣，交換機來決定如何在TEAM NIC上分發入站通信。
這種配置方式最適合用在如下的情況里 （同時）：
VM的數量遠大于TEAM NIC 的數量；需要用使用特定協議（如LACP） 而對TEAM方式有要求；限制VM的帶寬不能大于TEAM 成員中一個NIC的帶寬。
三，配置 NIC Teaming
1 打開Server Manger. NIC Teaming，點 'Disabled'
2. 點擊TASKS -- New Team
3. 給NIC Team起一個名字, 選擇想要做Team的網卡，
然后選擇Teaming Mode,這里我就選擇“Switch Independent”; 負載均衡模式選擇“Address Hash”;Standby Adapter 選擇None.2個網卡都設置為活動。
如果需要給Team 做VLAN， 可以在最下方的Primary team interface 選擇VLAN number.
配置好之后點擊OK。必須注意，如果需要在Team上做VLAN，不要在組成Team的網卡上（例如這里是Internal 1, Internal 2）分別作VLAN設置。
4. 等待NIC Team配置完成，完成后狀態會顯示‘OK’
5. 這時我們在網絡連接中就可以看到新建號的NIC Team.
在給Hyper-V HOST 創建虛擬網絡的時候，可以選擇用新建的 NIC Team 來創建Hyper-V 交換機，如圖。
 
 
參考配置
 

---

Windows Server 2012 R2 NIC Teaming配置手冊
1. 開始—運行 lbfoadmin
2. 在彈出的窗口中選Teams—TASKS—New Team

 
3. 在彈出的窗口中填寫Team name：Team1，并選擇相應的網卡：

 
4. 在上述窗口中展開Additional properties,做如下選擇：

 
hyper-v虛擬機的負載均衡模式只能用adress hash
 
5. 點擊OK，網卡可能會因初始化配置而變紅，一會兒即正常

 
6. 配置IP：

 
7. 結束。
 
人家的配置

文章出處
看完SQL Server 2014 Q/A答疑集錦:想不升級都難！
轉載自：http://mp.weixin.qq.com/s/5rZCgnMKmJqeC7hbe4CZ_g
 
本期嘉賓為微軟技術中心技術架構師韓凱(社區ID：Chris_Han0015)，主要負責大數據和云計算領域。在美國取得系統工程碩士學位后，服務于華爾街主要銀行與金融機構。從事流程再造與創新與商務智能方案設計實施。
　　IT名人堂欄目對微軟技術中心技術架構師韓凱進行了獨家訪談，揭秘了SQL Server 2014不可不知的那些事兒。訪談期間，網友們針對自己的困擾積極提問，專家坐鎮解答，給予了精辟實用的指導，沒準您也遇到過這些困惑哦!
　　Q1:現在還有用2008，沒有用過2012和2014，相對于2008來說，2014的優勢是什么，僅僅是增加了內在數據庫支持嗎?能直接兼容NoSQL嗎?
　　A:從SQL 2008到SQL 2014，中間還跨越了SQL Server 2008 R2，SQL Server 2012兩個版本，這中間的改變自然遠不止內存數據庫這一項功能，其實還有很多，比如說從大的方面，包括支持快速查詢和高壓縮比的列存儲索引技術，支持高可用性并實現讀寫分離的AlwaysOn技術，提供數據清理功能的數據質量服務，提供企業信息管理功能的主數據管理服務。最大的變化還包括SQL Server 2014極大的增強了對云的支持，幫助用戶輕松實現混合云方式的數據備份、災難恢復以及應用擴展。此外，SQL 2014相比于SQL 2008，在安全性、管理性、T-SQL增強、SSIS集成服務，SSAS分析服務以及SSRS報表服務方面均有很大的增強。你可以通過下載SQL 2014的評估版本(具備完整的SQL 2014功能)進行180天的免費試用，親自去感受SQL 2014的新功能吧!SQL 2014評估版本下載地址：http://www.microsoft.com/en-us/evalcenter/evaluate-sql-server-2014 。
　　NoSQL的概念主要是根據CAP定理定義的。從這一角度看，我個人認為SQL Server 2014作為定位于“關鍵任務”場景的數據平臺，是不會以犧牲全時一致性來提供互聯網應用級的可用性的。對于適合NoSQL的“有損服務”應用場景，微軟有如下PaaS服務可供選擇：
　　
　　DocumentDB在國內尚未落地，現在可以通過IaaS級的服務使用MongoDB。另外對于Key-Value緩存微軟也開始在國外的Azure提供Redis服務。但那里的數據只在內存中，不具有持久性。我就不將它歸于“數據庫”范疇了。
　　Q2:印象中SQL Server一般是中小企業的數據庫，SQL Server 2014是否支持百TB、PB的OLAP數據庫?
　　A：SQL Server 2014 數據庫目前對OLAP的數據庫支持到TB級別，對于PB級別的需求，可采用微軟基于SQL Server的軟硬件一體機產品APS，可橫向擴展到6PB。SQL Server 經過15年的發展，到今天的SQL Server 2014版本，在性能、安全性、高可用性，可擴展性等多個方面的表現，還是已經完全能夠支撐大型企業的關鍵業務應用。
　　Q3:大數據的來臨，SQL SERVER 2014對于非結構化的數據類型，有沒有做哪些方面的查詢優化?
　　A:SQL Server 2014產品本身只提供對結構化數據的存儲，分析和處理。對于非結構化數據而言，微軟提供一個叫HDInsight的產品--微軟與Hortonworks合作的Hadoop。可以部署在一體機APS中或者使用在Azure公有云上提供的PaaS層服務。兩者都提供Hadoop中的建庫與查詢工具例如HBase和Hvie。對于熟悉SQL的開發者，APS中提供一項特別的技術叫做“Polybase”，它能夠實現通過統一的SQL語言實現對結構化數據和非結構化數據的聯合查詢。
　　Q4:SQL Server 2014支持的操作系統有哪些?是否只是基于microsoft實施?
　　A:目前只支持Windows的操作系統，安裝SQL Server 2014支持的軟硬件配置及版本可參考：
　　https://msdn.microsoft.com/zh-cn/library/ms143506.aspx
　　Q5:SQL Server老版本升級到新版本2014上，要注意哪些地方，升級后，與其他系統集成的外圍系統數據交互和接口的程序修改量大嗎?
　　A： 升級自然不是安裝一套SQL 2014版本的數據庫就算完事兒，成功的數據庫升級不僅要有技術層面的考慮，還要有方法論層面的考慮，所謂方法論，就是除了技術本身之外需要考慮的因素，包括升級的范圍設定，對業務影響的評估，升級前的評估和必要測試，升級時可能發生的宕機時間， 升級的方式是采用在新的軟硬件環境下構建一套新的系統，然后遷移數據庫(推薦方式)，還是在原有版本上做版本升級，不移動數據庫。從技術層面，SQL Server 2014內置的升級向導以及一系列免費的系統評測工具幫助用戶完成升級。具體可參考：https://msdn.microsoft.com/zh-cn/library/dn236457.aspx ;
　　關于程序的修改量問題，取決于程序設計時與數據庫的耦合程度，需要具體問題具體分析。
　　Q6:在SQL SERVER 2014中，對性能優化方面有哪些新的功能?比如新增了哪些語法特性?
　　A：SQL Server 2014對性能優化最重要的新功能就是In-memory OLTP, 或者內存數據庫。SQL Server 2014的內存數據庫可以在表級操作。也就說說你可以在建/改表的時候，指定那些比較“熱”的表建在內存了，而將偶爾訪問的表留在存儲上以節約駐留內存。反映在DDL語法上，最主要的就是在CREATE TABLE語句中增加的兩個可選變量：
　　[MEMORY_OPTIMIZED = {ON | OFF}]
　　[DURABILITY = {SCHEMA_ONLY | SCHEMA_AND_DATA}]
　　前者指定這張新建表的數據是否在內存中操作;后者則指定如果該表為內存表，那其中的數據是否最終要固化到存儲中。有些場景，比如計算中間結果，只需要保留表結構以便重用即可，其中的數據每次計算完成就沒有保留價值了。
　　對于性能促進的另一重要特性是所謂原生編譯的存儲過程(Natively Compiled Stored Procedure)。與傳統的存儲過程相比，原生編譯的存儲過程在建立時就編譯成機器代碼了，而不是在第一次運行時。語法上和之前版本的CREATE PROC語句的主要區別就是增加一個WITH NATIVE_COMPILATION選項以及DELAYED_DURABILITY = { OFF | ON }選項。前者不言自明，后者由你決定是否以可能的數據丟失換取更快的寫操作速度。基本原理是后臺進程緩存transaction log，每集齊60KB才寫入存儲。SQL Server 2014 在性能提升方面還有許多重新設計的系統級功能。比如Clustered Columnstore Indexes、Lock Priorities、Buffer Pool Extensions、Resource Governor等。有興趣的讀者可以關注MSDN的相關文章。
　　Q7:SQL Server 2014的云端備份，想法很好，但是實際備份的時候，是否得考慮帶寬?內外網環境? 備份時是否影響生產? 增量備份還是全量備份?
　　如果是全量備份，是否需要停掉業務進行備份? 我考慮的比較現實，還請見諒。
　　A：我們談“數據庫備份”這個概念，通常講的是對于已經寫到數據庫不再發生變化的數據庫進行復制，相比于另外一個概念“數據庫同步”對帶寬和實時性沒有那么高的要求，對生產系統也不會產生任何影響。如果是采用“數據庫同步”的方式將本地數據庫復制副本到云端，則需要對帶寬、內外網環境進行詳細的評估，并且數據庫同步對生產系統的性能會有影響。
　　云端備份可執行全量或增量備份。SQL 2014全量和增量備份都支持。全量備份時，被備份的數據庫是要暫停服務的，所以最佳實踐是建立AlwaysOn同步，從復制節點上做備份。
　　Q8:關于異地云備份，微軟是如何保證數據的安全性，如何讓企業用戶放心的把數據交個云端，數據加密的方式是用戶可選，可控嗎?
　　A：你所說的數據安全看來主要是指防止意外訪問。微軟對數據安全的考量，還包括避免意外丟失。后者是通過冗余存儲實現的。具體說，是為客戶在數據在每個數據中心本地存三份。選擇異地災備服務的客戶可以再存三份，達到一共6份冗余。而前者，防止意外訪問，是需要一整套管理流程配合技術實現的。從管理策略上說，首要規則就是建立防御縱深、并且實施職能分離。SQL Server自2008就可以通過透明數據加密 (TDE)加密整個數據庫包括日志。但這種全面加密方式會相應增加CPU負擔，并且影響備份文件的壓縮率。SQL 2014增加了專用的備份加密功能。加密都是需要密鑰的。為了配合實現管理策略，微軟將實例級的服務主鑰(SMK)與庫級的數據庫主鑰 (DMK) 分開生成、并建議客戶授予不同級別的管理員。這些主鑰是通過AES 256 算法產生的。然后數據庫管理員可以用DMK和私鑰生成證書文件。有了這個證書，備份管理員就可以選擇以下任意一種加密算法生成加密的備份文件了：AES 128, AES 192, AES 256 或 Triple DES.
　　Q9:內存數據庫在企業中的適用場景?一般處理哪些業務比較合適?對此比較感興趣，能否舉例說明?
　　A：基本上高吞吐率的OLTP的場景都是合適的。在線數字化娛樂公司 bwin.party 提供的在線游戲與其他服務用戶數超過兩百萬。原本的游戲系統每秒只能處理大約 15,000 個請求，使用SQL 2014后每秒可以處理250,000 個請求，在硬件成本方面節約十萬美元，并實現了增收。詳情請參見Case Study: http://download.microsoft.com/download/A/B/8/AB8266E6-ABA9-461D-B29B-5079B066E6B8/SQL%20Server%202014%20Case%20Study-BWIN.pdf
　　Q10:對于新版本中的內存數據庫改善部分，能不能詳細介紹一下。
　　A:SQL Server 2014最大的一個功能上的飛躍就是內存數據庫，通俗的說就是把數據庫放在內存中而非磁盤里。傳統基于磁盤的表通常會遇到內存頁面置換、死鎖、造成了吞吐量有限、事務延遲較長等問題，內存數據庫的內存優化表由于常駐內存，適用于低延遲、高并發、快速數據傳輸和加載等場景，其帶來的性能提升也是可想而知的。
　　接下來我從操作的層面詳細介紹一下SQL Server 2014內存數據庫的特點，
(1)提供簡單的向導幫助用戶選擇最頻繁被訪問的數據庫表遷移到內存;
(2)用戶可以靈活的選擇同一個數據庫中的哪些表放在內存，哪些表放在硬盤。
(3)用戶還可以通過T-SQL語句輕松創建內存編譯存儲過程，從而進一步提高訪問數據的速度和執行查詢的效率。
　　Q11:Hekaton什么時候能支持中文的排序規則呢?
　　A:我估計您指的是CTP1時的In-Memory表不支持Code page – 936的問題?這個在CTP2時就已經解決了。正式產品放心用。具體使用排序規則請參見關于COLLATE的文檔，中文排序規則支持拼音和筆畫兩種：https://msdn.microsoft.com/zh-cn/library/ms184391.aspx
　　Q12:可否提供一個日期類型格式化的函數，就像c#中的DateTime.Now.ToString("yyyy-MM-dd") 現在只能通用CLR處理，若數據庫能處理就好了。
　　A：SQL轉換函數可以的：
　　SELECT CONVERT(VARCHAR(10), GETDATE(), 20) AS '[YYYY-MM-DD]'
　　更多細節請參閱MSDN：https://msdn.microsoft.com/zh-cn/sqlserver/ms187928
　　Q13:基于元數據這塊，對于數據各個層之間關聯，您那怎么處理的?
　　A:SQL Server 從2008 R2版提供開箱即用的主數據管理服務(MDS)。SQL Server MDS 既支持根據數據關系屬性自動生成層級關系(derived hierarchy)也支持手動創建參差型層級(Ragged Hierarchy)。 在有些場景，你甚至可以混合這兩種方式(“derived hierarchy with an explicit cap”)，在最高層采用參差型層級，之下使用自動生成層級。深度知識建議閱讀這些資料：
　　Master Data Services 功能和任務
　　https://technet.microsoft.com/zh-cn/library/hh231022.aspx
　　Master Data Services Training Guide: Managing Hierarchies
　　http://download.microsoft.com/download/5/9/F/59F1639E-EF57-4915-8848-EF1DC2157EBB/04%20Managing%20Hierarchies.pdf
　　Tutorial: Enterprise Information Management using SSIS, MDS, and DQS Together
　　http://www.microsoft.com/en-us/download/details.aspx?id=35462
　　Q14:在下一代數據庫版本中可否將權限更加細化，現行很多服務器的很多功能如函數kill spid,sp_spaceused tablename等服務器調優方面函數及其他功能，再如job作業創建等權限只有管理員才有，能否將這些功能的粒度再細化，可由管理員進行分配。
　　A：微軟對安全管理的層級是非常清晰、直觀和靈活的。清晰、直觀主要通過服務器級別角色(Server Role)和數據庫級別角色(Database Role)來管理權限。靈活體現在不直接授權到具體用戶而是到角色。因為用戶(人)可以變動，但授權相對固定。人離職了可以統一在AD中去掉這個用戶賬號，而不必改動SQL Server角色授權。這就是微軟在安全策略上平臺化設計的優勢。環環相扣、分工協作。這樣非常契合企業實際管理的組織架構、最大程度分權治理、同時減少管理功能重復與多余的工作量。當然數據庫管理員的盡職驗證流程也要有。這個暫不展開。SQL Server 有一長串內置角色，對于更細化的管理，SQL系統管理員可以通過CREATE SERVER ROLE 和CREATE ROLE建立新的服務器級別和數據庫級別的定制角色。然后通過GRANT/ DENY權限的方式控制這個角色的權限，從而達到細度控制。
　　具體請參閱MSDN文章：
　　https://msdn.microsoft.com/zh-cn/library/ee677610.aspx
　　https://msdn.microsoft.com/zh-cn/library/ms186717.aspx
　　https://msdn.microsoft.com/zh-cn/library/ms182763.aspx
　　負載均衡的支持，之前的版本中雖然號稱對負載均衡有支持，但是效果都不是很理想，不知道在這個版本中有沒有改進。
　　“負載均衡的支持”存在于多個領域。我不知道您具體對那一部分的效果不滿意。Azure的更新確實是非常快的。例如對于網絡負載均衡，Azure上現在既有同一數據中心內的負載均衡服務，也有跨地理分布/數據中心的Traffic Manager服務保證您的客戶就近接入。例如對于數據庫負載均衡，過去確實存在限制比如SQL Server AlwaysOn 的入口必須是公網 IP。而現在也支持通過虛擬內網IP了的內部均衡了。這樣對混合云部署的LOB應用來說，網絡架構也更簡約、安全、高效了。架構拓撲見下圖。
　　
   Q15:備份到Azure，我知道存儲收費，但備份網絡流量收費不?
　　A:關于價格，我和您一樣會查看Azure運營商——世紀互聯的官網：http://www.windowsazure.cn/pricing/details/backup/。如您所愿，流量是不另收費的：“我們將基于在備份服務中存儲的數據量對備份收費。將不會對帶寬、存儲、存儲事務、計算或與提供備份服務相關聯的其他資源額外向您計費。”
　　Q16:公司的SQL SERVER2005若要升級到sql server 2008 R2 或者 sql server 2012.費用如何計算的，是只付升級費用，還是重新買SQL SERVER 2008 R2 或SQL SEVER2012？
　　A：升級費用的計算取決于你在購買SQL Server2005時是否購買了微軟的SA(軟件保障)以及SA是否在生效期內，如果是，則可以免費升級至微軟最新版本。如果不是，則需要重新購買。另外，SQL Server的最新版本是SQL Server 2014, 建議你直接升級數據庫到最新的版本，使用更多最新功能。具體SQL Server 2014的介紹可參見：http://www.microsoft.com/zh-cn/server-cloud/products/sql-server/default.aspx 。當然，如果你不想采用SQL Server 2014，也可以購買安裝低版本的SQL Server。
　　Q17:您好，我有個問題想請教一下，數據治理，可以作為一個大數據方面的體系，它與數據質量監管，元數據之間存在哪些關系，能否結合您實際應用場景，介紹一下數據治理的典型應用，多謝!
　　A:數據治理相對來說還是一個非常寬泛的概念，包括技術治理和人的治理兩個范疇。我就從技術實現的角度，介紹SQL Server 2014內置的在數據治理方面的兩個工具，一個叫做主數據服務(MDS)，對數據建立和維護數據進行監管，從而確保分布在多個系統中的數據的完整性和一致性。另外一個叫SQL Server 數據質量服務(DQS)，它針對清除和復制數據提供了一項基于知識的解決方案，以此來確保用戶數據集成的準確性，從而檢測并避免出現重復或不規范的數據。SQL Server 2014在提供的數據質量服務(DQS)和主數據服務(MDS)為企業端對端的數據治理提供了基礎。幫助用戶通過更先進的數據清洗算法確保數據的可靠、一致，提高數據質量，使后續的大數據分析的可信度得到增強。相關案例及應用場景可參考：http://www.microsoft.com/china/casestudies/details.aspx?CompanyProfileID=149 。
　　Q18:問個職業生涯的問題，你以前做過前端、后端、項目管理、數據庫，很全才，但想做到每個點都精通，很難，那么如何選擇做哪個作為自己的奮斗目標?是按興趣走，還是跟著公司的發展需求走?你是如何轉到微軟做數據架構師的?
　　A：我會跟著興趣走。但興趣點在不同職業階段和環境是會變的。我個人的干貨體驗是，興趣變化基本規律和馬斯洛的需要層次理論吻合的。沒本事的時候公司的興趣就是你的興趣。有本事的時候你的興趣會影響公司的方向。架構設計就是一個取舍的過程，這一法則同樣適用職業生涯。如果我還沒到能影響公司方向的時候，那么上策是找一個公司，需求和我興趣一致;中策是自己培養和公司一致目標的興趣;下策是自然是格格不入，那就要考慮換崗了。流程圖自己腦補吧。不過多跟朋友、長輩溝通，開闊眼界是避免太過自己的前提。公司、乃至行業的發展趨勢是什么，很大程度決定你的方向。俗套說法叫找風口。但沒有一定的積累，飛起來的姿勢也會很難看的。所以職業生涯沒有捷徑，尤其是做技術的。我在加入微軟之前就很認同微軟的工程師文化。前端、后端開發也有大量時間用的微軟技術平臺。我后來慢慢專注于后臺、尤其是數據架構是因為我工作的關系。在華爾街上，”知識就是金錢“ 這句話你基本可以照字面意思理解。而知識來自于數據。不同于國內，微軟數據平臺在”花街“各大銀行中的應用是非常流行的。因為銀行對資產利用率和投資回報率都是非常看重的，技術決策更多的是市場化的。我個人的體驗是，微軟在工程實踐方面的積累是非常深厚的。前期平臺架構設計很謹慎、周期很長。但平臺的優勢就是你一旦完成，后面的應用就可以非常快速推進。必要的非功能性需求比如安全就可以在應用層很少考慮了。從系統工程專業學者的角度，我對微軟文化心有戚戚焉。我加入黑石，是因為彼時對以技術戰勝對手獲得金錢回報有很大興趣;我加入微軟，是因為我看到微軟正重拾創客精神，而且云平臺的布局也以處于領先地位。領導下一次技術革命，無論是風口還是姿勢，都是我的興趣所在。
 

文章出處
SQL Server2014 SP2新增的數據庫克隆功能
 
創建測試庫

--創建測試數據庫
create database testtest
use testtest
go
--創建表
create table testtest(id int ,name varchar(20))
--插入數據
insert into testtest select 1,'sdfsdf'
--創建存儲過程
create proc testproc 
as 
select 1

 
 
 
創建克隆數據庫的命令形式

DBCC CLONEDATABASE (source_database_name, target_database_name) –– Default CLONE WITH SCHEMA, STATISTICS and QUERYSTORE metadata.
DBCC CLONEDATABASE (source_database_name, target_database_name) WITH NO_STATISTICS –– SCHEMA AND QUERY STORE ONLY CLONE
DBCC CLONEDATABASE (source_database_name, target_database_name) WITH NO_QUERYSTORE –– SCHEMA AND STATISTICS ONLY CLONE
DBCC CLONEDATABASE (source_database_name, target_database_name) WITH NO_STATISTICS,NO_QUERYSTORE –– SCHEMA ONLY CLONE

 
 
 
開始創建克隆庫

DBCC CLONEDATABASE (testtest, testtestclone) 
已開始對“testtest”執行數據庫克隆操作，目標為“testtestclone”。
已完成對“testtest”執行數據庫克隆操作。克隆數據庫為“testtestclone”。
數據庫“testtestclone”是克隆數據庫。克隆數據庫應僅用于診斷目的，不得用于生產環境。
DBCC 執行完畢。如果 DBCC 輸出了錯誤信息，請與系統管理員聯系。

 
 
 
創建成功之后，克隆庫是只讀狀態的，并且庫里所有表都沒有數據
 
存儲過程也會克隆過來，在克隆庫打開存儲過程定義
 
克隆庫也會在數據目錄下創建mdf和ldf文件
 
 
可以看到，克隆庫其實跟源庫沒有太大差別，只是克隆庫里面沒有業務數據
 
利用克隆庫診斷數據庫問題，把克隆庫進行數據庫備份或分離數據庫然后發給SQL Server專家就可以幫你診斷了，非常方便

--備份克隆庫
backup database [testtestclone] to disk='D:\DBBackup\testtestclone.bak' with compression,stats=5
--還原克隆庫
USE [master]
RESTORE DATABASE [testtestclone] 
FROM DISK = N'D:\DBBackup\testtestclone.bak' WITH FILE = 1, 
MOVE N'testtest' TO N'D:\DataBase\testtest_843330487.mdf', 
MOVE N'testtest_log' TO N'D:\DataBase\testtest_log_82742540.ldf', 
NOUNLOAD, STATS = 5
GO
--分離克隆庫
USE [master]
GO
EXEC master.dbo.sp_detach_db @dbname = N'testtestclone'
GO

 
只要對方還原你的數據庫就可以對你的數據庫問題進行診斷了
 
如有不對的地方，歡迎大家拍磚o(∩_∩)o 
本文版權歸作者所有，未經作者同意不得轉載。

文章出處
Python第九天  面向對象  類定義   類的屬性    類的方法    內部類   垃圾回收機制   類的繼承
目錄
Pycharm使用技巧（轉載）
Python第一天 安裝 shell 文件
Python第二天 變量 運算符與表達式 input()與raw_input()區別 字符編碼
Python第三天 序列 數據類型 數值 字符串 列表 元組 字典
Python第四天 流程控制 ifelse條件判斷 forwhile循環
Python第五天 文件訪問 for循環訪問文件 while循環訪問文件 字符串的startswith函數和split函數
Python第六天 類型轉換
Python第七天 函數 函數參數 函數變量 函數返回值 多類型傳值 冗余參數 函數遞歸調用 匿名函數 內置函數 列表表達式/列表重寫
Python第八天 模塊 包 全局變量和內置變量__name__ Python path
Python第九天 面向對象 類定義 類的屬性 類的方法 內部類 垃圾回收機制 類的繼承
Python第十天 print >> f,和fd.write()的區別 stdout的buffer 標準輸入 標準輸出 標準錯誤 重定向
Python第十一天 異常處理 glob模塊和shlex模塊 打開外部程序和subprocess模塊 subprocess類 Pipe管道 operator模塊 sorted函數 生成器 walk模塊 hashlib模塊
Python第十二天   收集主機信息   正則表達式   正則表達式  無名分組   有名分組
Python第十三天   django 1.6   導入模板   定義數據模型   訪問數據庫   GET和POST方法    SimpleCMDB項目   urllib模塊   urllib2模塊  httplib模塊  django和web服務器整合  wsgi模塊   gunicorn模塊
Python第十四天 序列化  pickle模塊  cPickle模塊  JSON模塊  API的兩種格式
 
 
 
面向對象
類和對象
Python類定義
類屬性
類方法
面向過程和面向對象編程
- 面向過程編程：函數式編程，C程序等
- 面向對象編程：C++,Java,Python等
str. ->顯示字符串的方法，屬性
list. ->顯示列表的方法，屬性
tuple. ->顯示元組的方法，屬性
dict. ->顯示字典的方法，屬性
面向對象的主要思想是：
- 封裝
- 繼承
- 多態
這種思想方便解決較為復雜的項目，且維護起來較為容易。
 
-----------------------------------------
Python類定義
類定義：
類把需要的變量和函數組合成一起，這種包含稱為“封裝”
class A(object): 繼承object這個類，跟C#一樣，object是根對象
類的結構：
class 類名:
成員變量 – 屬性
成員函數 – 方法
類名：每個單詞首字母大寫
函數名：第二個單詞開始首字母大寫
class MyClass(object):
def fun(self):
print "I am function"
類的方法中至少有一個參數self，self表示類本身
定義類有2中方法
一種是不加(object) class A():
一種是加(object) class A(object):
前者是傳統的定義方法，后者是新的風格，建議使用后者，super這個內置函數支持新風格定義的類。
 
#!/usr/bin/python
#-*- coding:utf8 -*-
class People(object):
color = 'yellow'
__age = 30
def think(self):
self.color = "black"
print "I am a %s" % self.color
print "I am a " + self.color
print "I am a thinker"
print self.__age
ren = People()
ren.color = '白色人'
print ren.color
ren.think()
print ren.__dict__
print '#' *30
print People.color
print '#' *30
print People.__dict__
-----------------------------------------
對象的創建
創建對象的過程稱之為實例化；當一個對象被創建后，包含三個方面的特性：對象句柄、屬性和方法。
句柄用于區分不同的對象
對象的屬性和方法與類中的成員變量和成員函數對應
obj = MyClass() //創建類的一個實例(對象)
通過對象來調用方法和屬性
 
 
-----------------------------------------
類的屬性
類的屬性按使用范圍分為公有屬性和私有屬性，類的屬性范圍取決于屬性的名稱。
- 公有屬性：在類中和類外都能調用的屬性。
公有屬性可以不用實例化對象就可以訪問，classname.attribute，print People.color
- 私有屬性：不能在類外及被類以外的函數調用。 定義方式：以”__”雙下劃線開始的成員變量就是私有屬性，可以通過instance._classname__attribute方式訪問，print ren._People__age
實例化對象名._類名__私有屬性名
- 內置屬性：由系統在定義類的時候默認添加的，由前后雙下劃線構成，__dict__, __module__。
實例化對象.__dict__ :只能訪問公有屬性
類名.__dict__ ：可以訪問私有屬性
靜態屬性和動態屬性
實例化對象之后調用的屬性是動態屬性，可以修改屬性值
ren = People()
ren.color = '白色人'
print ren.color
沒有實例化對象用類名直接調用的屬性是靜態屬性，不能修改
print People.color
-----------------------------------------
類的方法
方法的定義和函數一樣，但是需要self作為第一個參數。
類方法為：
- 公有方法
- 私有方法
- 類方法
- 靜態方法
- 內置方法
公有方法：在類中和類外都能調用的方法。
私有方法：不能被類的外部調用，在方法前面加上”__”雙下劃線就是私有方法。
self參數：用于區分函數和類的方法(必須有一個self)，self參數表示執行對象本身。
內置方法：由系統在定義類的時候默認添加的，由前后雙下劃線構成，__str__(self)， __init__(self)
類方法：被classmethod()函數處理過的函數，能被類所調用，也能被對象所調用(是繼承的關系)
classmethod(函數名)
classmethod(test) test是一個方法
def test(self):
print self.color
cm = classmethod(test)
People.cm()
 
靜態方法：相當于”全局函數”，可以被類直接調用，可以被所有實例化對象共享，通過staticmethod()定義，靜態方法沒有”self”參數。
def test():
print People.color 訪問類里面屬性
sm = staticmethod(test)
People.sm()
裝飾器：
- @classmethod
- @staticmethod
靜態方法和動態方法
實例化對象之后調用的方法是動態方法，有一個例外，類方法classmethod(函數名)是動態方法，可以訪問實例里的屬性
沒有實例化對象staticmethod() 直接調用的方法是靜態方法
 
#!/usr/bin/python
#-*- coding:utf8 -*-
class People(object):
color = 'yellow'
__age = 30
def think(self):
self.color = "black"
print "I am a %s" % self.color
print "I am a thinker"
print self.__age
def __talk(self):
print "I am talking with Tom"
@classmethod
def test(self):
print "this is class method"
@staticmethod
def test1():
print "this is static method"
cm = classmethod(test)
People.cm()
jack = People()
People.test()
People.test1()
-----------------------------------------
Python內部類
在類的內部定義的類，主要目的是為了更好的抽象現實世界
內部類的實例化方法
方法1：直接使用外部類調用內部類
object_name = outclass_name.inclass_name()
方法2：先對外部類進行實例化，然后再實例化內部類
out_name = outclass_name()
in_name = out_name.inclass_name()
in_name.method()
 
 
--------------------------------------------------------
 
魔術方法/類內置方法
跟內置屬性一樣，類也有內置方法
__str__(self)
構造函數與析構函數
- 構造函數：
用于初始化類的內部狀態，Python提供的構造函數是__init__()；
__init__()方法是可選的，如果不提供，Python會給出一個默認的__init__方法
初始化傳參
def __init__(self, c='white'):
print "Init..."
self.color = c
self.think()
self.fd = open('/etc/hosts')
- 析構函數：
用于釋放對象占用的資源，Python提供的析構函數是__del__();
__del__()也是可選的，如果不提供，則Python會在后臺提供默認析構函數
-----------------------------------------
垃圾回收機制
Python采用垃圾回收機制來清理不再使用的對象；python提供gc模塊釋放不再使用的對象。
Python采用”引用計數”的算法方式來處理回收，即：當某個對象在其作用域內不再被其他對象引用的時候，python就自動清除對象；
gc模塊的collect()函數可以一次性收集所有待處理的對象(gc.collect)
import  gc
print gc.collect()
示例腳本
#!/usr/bin/python
#-*- coding:utf8 -*-
import gc
class People(object):
color = 'yellow'
__age = 30
class Chinese(object):
name = "I am chinese"
def __str__(self):
return "This is People class"
def __init__(self, c='white'):
print "Init..."
self.color = c
self.think()
self.fd = open('/etc/hosts')
def think(self):
self.color = "black"
print "I am a %s" % self.color
print "I am a thinker"
print self.__age
def __talk(self):
print "I am talking with Tom"
@classmethod
def test(self):
print "this is class method"
@staticmethod
def test1():
print "this is static method"
def __del__(self):
print "Del..."
self.fd.close()
print gc.collect()
jack = People('green')
print jack.color
print People.color
print 'Main end'
print gc.collect()
-----------------------------------------
類的繼承
繼承是面向對象的重要特性之一；
繼承關系：繼承是相對兩個類而言的父子關系，子類繼承了父類的所有公有屬性和方法
繼承實現了代碼重用。
繼承可以重用已經存在的數據和行為，減少代碼的重復編寫。
Python在類名后使用一對括號來表示繼承關系，括號中的類即為父類。
class Myclass(ParentClass)
如果父類定義了__init__方法，子類必須顯式調用父類的__init__方法：
ParentClass.__init__(self, [args…])
如果子類需要擴展父類的行為，可以添加__init__方法的參數。
示例1
class A:
def __init__(self):
print "enter A"
print "leave A"
class B(A):
def __init__(self):
print "enter B"
A.__init__(self)
print "leave B"
b = B()
輸出：
enter B
enter A
leave A
leave B
class A:
def __init__(self):
print "enter A"
print "leave A"
class B(A):
def __init__(self):
print "enter B"
#A.__init__(self)
print "leave B"
b = B()
輸出：
enter B
leave B
class A:
def __init__(self):
print "enter A"
print "leave A"
class B(A):
print 'ccc'
b = B()
輸出：
ccc
enter A
leave A
 
示例2
#!/usr/bin/python
#-*- coding:utf8 -*-
class People(object):
color = 'yellow'
def __init__(self, c):
print "Init..."
self.dwell = 'Earth'
def think(self):
print "I am a %s" % self.color
print "I am a thinker"
class Chinese(People):
def __init__(self):
#super(Chinese, self).__init__('red')
People.__init__(self, 'red')
def think(self):
print "I like talking"
cn = Chinese()
cn.think()
 
 
 
super函數
class A(object):
def __init__(self):
print "enter A"
print "leave A"
class B(A):
def __init__(self):
print "enter B"
super(B, self).__init__()
print "leave B"
b = B()
 
多重繼承
Python支持多重繼承，即一個類可以繼承多個父類；
語法：
class class_name(Parent_c1, Parent_c2,…)
注意：
當父類中出現多個自定義的__init__方法時，多重繼承只執行第一個類的__init__方法，其他不執行。
#!/usr/bin/python
#-*- coding:utf8 -*-
class People(object):
color = 'yellow'
def __init__(self):
self.dwell = 'Earth'
self.color = 'yellow'
def think(self):
print "I am a %s" % self.color
print "My home is %s" % self.dwell
class Martian(object):
color = 'red'
def __init__(self):
self.dwell = 'Martian'
def talk(self):
print "I like talking"
class Chinese(Martian, People):
def __init__(self):
People.__init__(self)
cn = Chinese()
cn.think()
cn.talk()
print cn.__dict__
 
 
-----------------------------------------
 類的屬性-總結
類屬性，也是共有屬性
類的私有屬性
對象的共有屬性
對象的私有屬性
內置屬性
函數的局部變量
全局變量
#!/usr/bin/python
#coding:utf8
var5 = "全局變量 var5"
class MyClass(object):
var1 = '類屬性，類的公有屬性 var1'
__var2 = '類的私有屬性 __var2'
def func1(self):
self.var3 = '對象的公有屬性 var3'
self.__var4 = '對象的私有屬性 __var4'
var5 = '函數的局部變量 var5'
print self.__var4
print var5
def func2(self):
print self.var1
print self.__var2
print self.var3
print self.__var4
print var5
mc = MyClass()
mc.func1() #要訪問var3 這個對象公有屬性要先執行一下func1這個方法
print '*' * 50
mc.func2()
print '*' * 50
print mc.__dict__
print '*' * 50
print MyClass.__dict__
 
類的方法-總結
公有方法
私有方法
類方法 --動態 @classmethod
靜態方法 --靜態 @staticmethod
內置方法
#!/usr/bin/python
#coding:utf8
class MyClass(object):
name = 'Test'
def __init__(self):
self.func1()
self.__func2()
self.classFun()
self.staticFun()
def func1(self):
print self.name,
print "我是公有方法"
#self.__func2()
def __func2(self):
print self.name,
print "我是私有方法"
@classmethod
def classFun(self):
print self.name,
print "我是類方法"
@staticmethod
def staticFun():
print MyClass.name,
print "我是靜態方法"
mc = MyClass()
 
 
 

---

函數/方法、類、模塊的幫助
In [1]: help('aa'.strip())
no Python documentation found for 'aa'
需要把后面的括號去掉，即這樣：help('aa'.strip)
如果帶括號是看'aa'.strip()的返回結果幫助了 help('aa'.strip())。
所有看函數/方法、類、模塊的幫助都不需要后面的括號。
 
S.strip([chars]) -> string or unicode   去除前后的空格和換行符，制表符，\t   \n  
Return a copy of the string S with leading and trailing whitespace removed.
 
 
 
 

文章出處
Python第十天   print >> f,和fd.write()的區別    stdout的buffer  標準輸入 標準輸出  標準錯誤   重定向
 
 
目錄
Pycharm使用技巧（轉載）
Python第一天 安裝 shell 文件
Python第二天 變量 運算符與表達式 input()與raw_input()區別 字符編碼
Python第三天 序列 數據類型 數值 字符串 列表 元組 字典
Python第四天 流程控制 ifelse條件判斷 forwhile循環
Python第五天 文件訪問 for循環訪問文件 while循環訪問文件 字符串的startswith函數和split函數
Python第六天 類型轉換
Python第七天 函數 函數參數 函數變量 函數返回值 多類型傳值 冗余參數 函數遞歸調用 匿名函數 內置函數 列表表達式/列表重寫
Python第八天 模塊 包 全局變量和內置變量__name__ Python path
Python第九天 面向對象 類定義 類的屬性 類的方法 內部類 垃圾回收機制 類的繼承
Python第十天 print >> f,和fd.write()的區別 stdout的buffer 標準輸入 標準輸出 標準錯誤 重定向
Python第十一天 異常處理 glob模塊和shlex模塊 打開外部程序和subprocess模塊 subprocess類 Pipe管道 operator模塊 sorted函數 生成器 walk模塊 hashlib模塊
Python第十二天   收集主機信息   正則表達式   正則表達式  無名分組   有名分組
Python第十三天   django 1.6   導入模板   定義數據模型   訪問數據庫   GET和POST方法    SimpleCMDB項目   urllib模塊   urllib2模塊  httplib模塊  django和web服務器整合  wsgi模塊   gunicorn模塊
Python第十四天 序列化  pickle模塊  cPickle模塊  JSON模塊  API的兩種格式
 
 
函數名：如果由多個單詞組成，第二個單詞的首字母應該大寫
類名：如果由多個單詞組成，每個單詞的首字母應該大寫
變量名：全部小寫或者單詞之間用下劃線
 
#!/usr/bin/python和#!/usr/bin/env python的區別
/usr/bin/env表示到$PATH環境變量去找python執行文件，如果當前系統有兩套python，那么不需要更改腳本內容
如果使用/usr/bin/python 絕對路徑，就需要更改腳本
 
Python如何處理管道輸入輸出
Python處理命令行參數
OS.path對文件路徑的處理
逐步實現python版的wc命令

示例 1
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys
input = sys.stdin
def lineCount(f):
n = 0
for i in f:
n += 1
return n
print lineCount(input)

 
從標準輸入讀取

示例 2
#!/usr/bin/python
#coding:utf8
import sys
fd = sys.stdin
data = fd.read()
sys.stdout.write(data+"\n")
print "你好"

 
文件對象的方法：
f.read()
f.readline() //用while遍歷每一行
f.readlines() 與[i for i in f] //對文件每一行進行遍歷
f.write()
f.close()
 
輸出
#!/usr/bin/env python
import sys
print “hello world”
sys.stdout.write(“Hello world”)
sys.stderr.write(“Hello Error”)
 
 
輸出
#!/usr/bin/env python
import sys
print “hello world”
sys.stdout.write(“Hello world”)
sys.stderr.write(“Hello Error”)
print和stdout的區別
print通常是調用一個stdout對象的write方法
print會先進行格式轉換
print會在最后加上換行符，要加逗號才能屏蔽換行符
示例
#!/usr/bin/python
f = open('tmp','w')
print >> f,"Hello world, I'm writting to file",11,200,300,400,500
f.close()
 
-------------------------------------------------------------
print >> f,和fd.write()的區別
fd.write()只能輸入字符串write('123')不能輸入int write(123) 報錯
print >> f,可以直接輸入int
print >> f,"Hello world, I'm writting to file",11,200,300,400,500
fd = open('tmp','w')
fd.write('123')
 
 
stderr和重定向
#!/usr/bin/env python
import sys
print >> sys.stderr, "I am going to stderr"
sys.stdout.write("I am standard output\n")
python print2stderr.py 2> /dev/null
 
#寫入到標準錯誤
print >> sys.stderr ,"Hello world, I'm writting to file",11,200,300,400,500
python xx.py 2>/dev/null 可以重定向
 
------------------------------------------------------
stdout的buffer
#!/usr/bin/python
import sys
import time
for i in range(1,10):
sys.stdout.write("str:%d\n" % i)
time.sleep(1)
#sys.stdout.flush()
python buffer.py | cat -
python -u buffer.py | cat - -u表示不需要buffer
 
格式化字符串："str:%d\n" % i
 
--------------------------------------------------
簡單的word count
day04：包名
wc：模塊名
wordCount：函數名
from day04 import wc
#!/usr/bin/python
from sys import stdin
data = stdin.read()
chars = len(data)
words = len(data.split())
lines = data.count('\n')
print "%(lines)s %(words)s %(chars)s" % locals()
locals()返回一個字典對象，代表當前的變量情況
#!/usr/bin/python
import sys
data = sys.stdin.read()
chars = len(data)
words = len(data.split())
lines = data.count('\n')
print "%(lines)s %(words)s %(chars)s" % locals()
locals()返回一個字典對象，代表當前的變量情況
下面兩種方法都可以
print "%s %s %s " %(chars,words,lines)
print "%(lines)s %(words)s %(chars)s" % locals()
 
 

#!/usr/bin/python
import sys
import os
try:
fn = sys.argv[1]
except IndexError:
print "please follow a argument at %s" % __file__
sys.exit()
if not os.path.exists(fn):
print "%s is not exists" % fn
sys.exit()
fd = open(fn)
data = fd.read()
chars = len(data)
words = len(data.split())
lines = data.count('\n')
print "%(lines)s %(words)s %(chars)s" % locals()

 
 
 
--------------------------------------------------------
optparse
真正的命令行參數，代替sys.argv[]
-c、--chars：命令行選項
dest：為選項定義變量名，值characters就是’-c’選項的名字，同理，words就是‘-w’選項的名字，lines就是‘-l’選項的名字，每個選項就是一個變量，選項的值就是變量的值
default=False：characters的值False，意思是默認情況下命令不帶-c選項
help：選項的解釋說明部分
 

示例1
from optparse import OptionParser
import sys, os
#parser = OptionParser()
parser = OptionParser("Usage: %prog [file1] [file2]...")
parser.add_option("-c", 
"--chars",
dest="characters",
action="store_true",
default=False,
help="only count characters",)
parser.add_option("-w",
"--words",
dest="words",
action="store_true",
default=False,
help="only count words",)
parser.add_option("-l",
"--lines",
dest="lines",
action="store_true",
default=False,
help="only count lines",)
options, args = parser.parse_args()
if not (options.characters or options.words or options.lines):
options.characters, options.words, options.lines = True, True, True
示例2
#!/usr/bin/env python
import sys
import os
from optparse import OptionParser
def opt():
parser = OptionParser("Usage: %prog [option] [file1] [file2]")
parser.add_option("-c", "--char",
dest="chars",
action="store_true",
default=False,
help="only count chars")
parser.add_option("-w", "--word",
dest="words",
action="store_true",
default=False,
help="only count words")
parser.add_option("-l", "--line",
dest="lines",
action="store_true",
default=False,
help="only count lines")
options, args = parser.parse_args()
return options, args
def get_count(data):
chars = len(data)
words = len(data.split())
lines = data.count('\n')
return lines, words, chars
def print_wc(options, lines, words, chars, fn):
if options.lines:
print lines,
if options.words:
print words,
if options.chars:
print chars,
print fn
def main():
options, args = opt()
if not (options.lines or options.words or options.chars):
options.lines, options.words, options.chars = True, True, True
if args:
total_lines, total_words, total_chars = 0, 0, 0
for fn in args:
if os.path.isfile(fn):
with open(fn) as fd:
data = fd.read()
lines, words, chars = get_count(data)
print_wc(options, lines, words, chars, fn)
total_lines += lines
total_words += words
total_chars += chars
elif os.path.isdir(fn):
print >> sys.stderr, "%s: is a directory" % fn
else:
sys.stderr.write("%s: No such file or direcotry\n" % fn)
if len(args) > 1:
print_wc(options, total_lines, total_words, total_chars, 'total')
else:
data = sys.stdin.read()
fn = ''
lines, words, chars = get_count(data)
print_wc(options, lines, words, chars, fn)
if __name__ == '__main__':
main()

 
 
 
 
系統中的wc命令用C語言寫
 

文章出處
SQL Server 2014內存優化表的使用場景
 
最近一個朋友找到走起君，咨詢走起君內存優化表如何做高可用的問題
大家知道，內存優化表作為In-Memory OLTP功能是從SQL Server 2014開始引入，用來對抗Oracle 12C的In-Memory OLTP選件
不過SQL Server的In-Memory OLTP功能是完全內置的功能，不像Oracle需要額外付費才能獲得
由于是比較新的技術，可能大家對內存優化表還是比較陌生，網上也鮮有內存優化表使用場景的文章
朋友公司做的業務是跟蜂鳥配送類似的配送業務，整個配送系統平臺每天訂單量超過30W
 

---

坐標問題
系統中某一個部分需要保存跑男的坐標
坐標需要保存到redis和數據庫，一旦坐標更新也需要更新redis中的數據
剛開始朋友用傳統表來保存坐標數據，但是很快遇到問題，傳統表在更新的速度跟不上
后來改用內存優化表，使用了之后

剛開始上傳坐標的接口，延遲很大，用了內存表，100毫秒以內，搞定

這些坐標是需要持久化的，而內存優化表是完全支持ACID的，所以也不需要擔心數據丟失的問題
內存優化表更新速度快的另一個原因：無鎖機制，  并發（如閂鎖爭用或阻塞）影響的應用程序遷移到內存中 OLTP 時，其性能會顯著提高。
 
 
大家知道，內存優化表需要有一個非聚集哈希主鍵索引，大概的表結構是
每個跑男占用一行記錄
 
對應到redis里面大家應該都知道怎麼存儲了吧，使用redis的散列類型來存儲跑男的坐標

hmset 跑男ID X坐標 value Y坐標 value 跑男在線時間 value
hmset 1 X坐標 12 Y坐標 10 跑男在線時間 60

 
 
因為數據庫高可用的問題，朋友就購置了新服務器，用來搭建AlwaysOn，新服務器都用SSD固態硬盤
內存優化表的瓶頸主要在事務日志固化，雖然有延遲持久化，但是延遲持久化在意外宕機的時候可能丟失部分數據
現在新服務器使用SSD固態硬盤之后，事務日志固化的瓶頸基本消失
使用新服務器之后，支撐30w/日訂單是完全沒有問題的
 
 

---

另一個問題是AlwaysOn問題
實際上，SQL Server 2014的AlwaysOn集群已經支持內存優化表，只是不支持在輔助副本上查詢內存優化表數據，在故障轉移之后
輔助副本上的內存優化表數據是完全沒有丟失的，SQL Server 2016對AlwaysOn集群的內存優化表做了改進，支持在輔助副本上查詢內存優化表數據
 
 

---

總結
 
實際上，如果大家對內存優化表研究比較深入的話，內存優化表實際上相當于把redis嵌入到SQL Server，再在上面加上事務等關系型數據庫特性
因為兩者實現的底層都是哈希表
 
注意：內存優化表跟redis一樣，是純內存操作的，所以機器內存不能太小，SQL Server在啟動時候會把內存優化表數據庫文件
里面的數據全部load入內存，朋友的redis服務器和SQL Server服務器都用的256G內存，內存還算足夠
 
 
這篇文章寫得比較粗糙，最后祝大家新年快樂！
 
 
 
 
 
參考文章
http://www.cnblogs.com/lyhabc/p/3691911.html
http://www.cnblogs.com/lyhabc/articles/4230547.html
https://msdn.microsoft.com/en-us/library/dn635118(v=sql.120)
 
如有不對的地方，歡迎大家拍磚o(∩_∩)o 
本文版權歸作者所有，未經作者同意不得轉載。

文章出處
Python第十一天    異常處理  glob模塊和shlex模塊    打開外部程序和subprocess模塊  subprocess類  Pipe管道  operator模塊   sorted函數   生成器  walk模塊   hashlib模塊
 
 
目錄
Pycharm使用技巧（轉載）
Python第一天 安裝 shell 文件
Python第二天 變量 運算符與表達式 input()與raw_input()區別 字符編碼
Python第三天 序列 數據類型 數值 字符串 列表 元組 字典
Python第四天 流程控制 ifelse條件判斷 forwhile循環
Python第五天 文件訪問 for循環訪問文件 while循環訪問文件 字符串的startswith函數和split函數
Python第六天 類型轉換
Python第七天 函數 函數參數 函數變量 函數返回值 多類型傳值 冗余參數 函數遞歸調用 匿名函數 內置函數 列表表達式/列表重寫
Python第八天 模塊 包 全局變量和內置變量__name__ Python path
Python第九天 面向對象 類定義 類的屬性 類的方法 內部類 垃圾回收機制 類的繼承
Python第十天 print >> f,和fd.write()的區別 stdout的buffer 標準輸入 標準輸出 標準錯誤 重定向
Python第十一天 異常處理 glob模塊和shlex模塊 打開外部程序和subprocess模塊 subprocess類 Pipe管道 operator模塊 sorted函數 生成器 walk模塊 hashlib模塊
Python第十二天   收集主機信息   正則表達式   正則表達式  無名分組   有名分組
Python第十三天   django 1.6   導入模板   定義數據模型   訪問數據庫   GET和POST方法    SimpleCMDB項目   urllib模塊   urllib2模塊  httplib模塊  django和web服務器整合  wsgi模塊   gunicorn模塊
Python第十四天 序列化  pickle模塊  cPickle模塊  JSON模塊  API的兩種格式
 
 
python標準庫，python自帶的模塊
不是python標準庫，不是python自帶的模塊都需要安裝第三方軟件
 
 
 
hashlib模塊
相當于shell里面的md5sum命令
一定要去除換行符
import hashlib
md5 = hashlib.md5()
md5.update('hello')
md5.hexdigest()
'5d41402abc4b2a76b9719d911017c592'
等價于 echo -n hello |md5sum
5d41402abc4b2a76b9719d911017c592
md5.update方法會追加后來添加的值
md5.update('a')
md5.update('b')
#計算出來的是ab的md5值，也就是md5.update('ab')
md5.hexdigest()

示例
#!/usr/bin/env python
import sys
import hashlib
def md5sum(f):
m = hashlib.md5()
with open(f) as fd:
while True:
data = fd.read(4096)
if data:
m.update(data)
else:
break
return m.hexdigest()
if __name__ == '__main__':
try:
print md5sum(sys.argv[1])
except IndexError:
print "%s follow a argument" % __file__

----------------------------------------------------------
walk模塊
os.walk
迭代目錄里文件
os.walk返回的是1個元組（生成器對象），這個元組有3個元素，分別是dirpath, dirnames, filenames，所以使用3個變量p,d,f去接收這3個元素，即for p,d,f in a
filenames是個列表，對應的是f，所以對f進行for循環遍歷，取里面的每一個文件名，最后把文件名組織成帶路徑的，即os.path.join(p,i)。
 

示例
#!/usr/bin/env python
import os
import sys
import hashlib
def md5sum(f):
m = hashlib.md5()
with open(f) as fd:
while True:
data = fd.read(4096)
if data:
m.update(data)
else:
break
return m.hexdigest()
def file_md5(topdir):
a = os.walk(topdir)
for p, d, f in a:
for i in f:
fn = os.path.join(p,i)
md5 = md5sum(fn)
yield "%s %s" % (md5, fn)
if __name__ == '__main__':
lines = ''
try:
topdir = sys.argv[1]
except IndexError:
print "%s follow a dir"
sys.exit()
gen = file_md5(topdir)
for i in gen:
lines += i+'\n'
print lines
print hashlib.md5(lines).hexdigest()

 
 
-----------------------------------------------------------------
生成器
生成器是一次生成一個值的特殊類型函數。可以將其視為可恢復函數。調用該函數將返回一個可用于生成連續 x 值的生成器【Generator】，簡單的說就是在函數的執行過程中，yield語句會把你需要的值返回給調用生成器的地方，然后退出函數，下一次調用生成器函數的時候又從上次中斷的地方開始執行，而生成器內的所有變量參數都會被保存下來供下一次使用。
 
生成器對象
mygenerator = (x*x for x in range(4))  #用小括號而不是中括號，中括號是列表重寫
for i in mygenerator : print i 調用next方法
next()方法
mygenerator.next()
#文件也是生成器
f=open('/etc/hosts')
for i in f : print i 調用next方法
yield
當調用這個函數的時候，函數內部的代碼并不立馬執行 ，
這個函數只是返回一個生成器對象
當使用for進行迭代的時候，函數內的代碼才會被執行
因為函數里出現了yield，我們把這個函數叫做生成器
當產生一個生成器的時候，每遍歷一次，yield就會吐出一個值，這個值是不會保存在內存里的，除非有其他變量來接收這個值。
>>> def h():
... print 'one'
... yield 1
... print 'two'
... yield 2
... print 'three'
... yield 3
...
>>> c = h()
>>> c.next()
def f(n):
    for i in range(n):
    yield i
a = f(5)
a.next()
for i in a: print i
生成器是一個可迭代的對象，可以對可迭代對象進行遍歷，比如字符串，列表等，都是可迭代對象
return與yield區別
return的時候這個函數的局部變量就都銷毀了
所以return是得到所有結果之后的返回
yield是產生了一個可以恢復的函數（生成器），恢復了局部變量。
生成器只有在調用.next()時才運行函數生成一個結果
---------------------------------------------------------------
operator模塊
sorted函數
按字典值排序
第一個參數是必須的，必須傳入一個可迭代對象用來排序，其他參數都有默認值
reverse表示正向還是反向排序
key表示排序的值，如果是字典通過operator來選擇key排序還是value排序
返回值是一個列表
sorted(可迭代對象,cmp,key,reverse)
operator.itemgetter(0)：按照key來排序
operator.itemgetter(1)：按照value來排序
按照字典value排序，類似sort -k命令
import operator
x = {1:2, 3:4, 4:3, 2:1, 0:0}
sorted_x = sorted(x.iteritems(), key=operator.itemgetter(1))
sorted_y = sorted(x.iteritems(), key=operator.itemgetter(1), reverse=True)

找出占用空間大的文件
os.walk
os.path.getsize
dict sort (top10)
#!/usr/bin/env python
import os
import sys
import operator
def gen_dic(topdir):
dic = {}
a = os.walk(topdir)
for p, d, f in a:
for i in f:
fn = os.path.join(p, i)
f_size = os.path.getsize(fn)
dic[fn] = f_size
return dic
if __name__ == '__main__':
dic = gen_dic(sys.argv[1])
sorted_dic = sorted(dic.iteritems(), key=operator.itemgetter(1), reverse=True)
for k, v in sorted_dic[:10]:
print k, '-->', v

 
-----------------------------------------------------------------------
打開外部程序和subprocess模塊  subprocess類  Pipe管道
os.system：輸出在終端上，捕獲不到
os.popen：只能捕捉到標準輸出，捕捉不到標準錯誤輸出
os.popen2：返回2個對象，一個是標準輸入，一個標準輸出
os.popen3：返回3個對象，標準輸入，標準輸出，標準錯誤輸出
os.popen4：已經廢棄，不建議使用，用subprocess模塊代替，返回2個對象，pipe_in和pipe_out_err
os.popenX都不建議使用，使用subprocess模塊代替os.popenX
示例
import os
s = os.system('ls')
print s # 只能看到命令成功與否的返回值，不能保存命令執行結果
pipe_out = os.popen('ls')
pipe_out.wait()   # wait方法，父進程等待子進程執行完才返回
pipe_out.read() # 讀取命令執行結果
(pipe_in, pipe_out) = os.popen2('sort')
pipe_in.write('z\n')
pipe_in.write('a\n')
pipe_in.close() # 關閉管道 關閉文件
pipe_out.read()
pipe_in, pipe_out, pipe_err = os.popen3('sort')
pipe_err.read()
pipe_in, pipe_out_err = os.popen4('sort')
subprocess
import subprocess
subprocess.call(['ls', '-l','--color','/root']
subprocess.call('ls -l --color /root', shell=True) # shell=True表示命令在shell下執行，默認情況shell=False
subprocess.call(['ls','-l', '--color', '/root']) 等價于subprocess.call('ls -l --color /root', shell=True)
輸出不能捕捉到，與os.system一樣
subprocess.check_call(['mkdir', '/tmp/aaa'])
check_call會拋python異常
call和check_call跟os.popenX不一樣，不需要調用wait方法，父進程會默認等待子進程執行完才返回
 
 
 
subprocess類
subprocess.Popen(['mkdir', 'aaa'],stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
為什麼叫subprocess，調用外部命令的時候實際上是fork出一個子進程子shell來執行
communicate()方法
p.communicate()方法相當于p.stdin.write()、p.stdin.close()與p.stdout.read()這3個方法
p = Popen(['wc'], stdin=PIPE, stdout=PIPE, stderr=PIPE)
p.terminate() #終止子進程
p.wait() #等待子進程
p.pid #子進程的pid
p.returncode #子進程執行完的返回碼
 
Pipe管道
p1 = Popen(['ls'], stdout=PIPE)
p2 = Popen(['grep', 'py'], stdin=p1.stdout, stdout=PIPE)
result = p2.stdout
for i in result:print i,
 
 
----------------------------------------------------------------------------
glob模塊和shlex模塊
 
glob模塊
glob：擴展shell通配符的
import glob
glob.glob('/etc/*.conf')
 
 
shlex模塊
import shlex
cmd = "mysql -u root -p123 -e 'show processlist'"
shlex.split(cmd)
ps ax -o pid,ppid,cmd
shlex.split()能識別引號，認為引號里的為一個元素，例如：
shlex.split('ps -eo "pid lstart"')與'ps -eo "pid lstart"'.split()得到的結果是不一樣的。
 
 
 
 
----------------------------------------------------------------------------
異常處理
NameError 嘗試訪問一個沒有聲明的變量
ImportError 無法引入模塊或包；可能路徑不存在
IndentationError 語法錯誤（的子類）；代碼沒有正確對齊
SyntaxError 語法錯誤
IndexError 索引超出序列范圍
KeyError 請求一個不存在的字典關鍵字
IOError 輸入輸出錯誤（比如你要讀的文件不存在）
AttributeError 嘗試訪問未知的對象屬性
ValueError 傳給函數的參數類型不正確，比如給int()函數傳入字符串類型
UnboundLocalError 試圖訪問一個還未被設置的局部變量
KeyboardInterrupt
import subprocess
try:
subprocess.check_call('exit 1', shell=True) # shell里面退出碼非0會觸發異常
except subprocess.CalledProcessError:
print 'call fail'
except Exception, e:
print e
print ‘hello world’
 
自定義異常，繼承Exception根類
class FuncError(Exception):
def __str__(self):
return "I am a funError"
def func():
raise FuncError()
func()
#try:
# func()
#except FuncError, e:
# print e
print 'hello world'
 
#如果不知道異常的類型，就寫Exception，Exception是總的異常
func()
try:
func()
except Exception:
print e
#如果有多個異常，那么只會捕獲一個異常
func()
try:
func()
except NameError:
print e
except IndexError:
print e
except ValueError:
print e
 
異常在try塊里拋。
finally：無論try塊是否拋異常，永遠執行的代碼，通常用來執行關閉文件，斷開服務器連接的功能。
try無異常，才會執行else
語法格式
try:
except:
else:
finally:
 
 

文章出處
Pycharm使用技巧（轉載）
 
轉載自：http://www.cnblogs.com/cloudtj/articles/5980666.html
 
0.先安裝python解釋器
Linux不需要安裝，默認自帶，Windows需要安裝，當前最新版本是2.7和3.6
下載地址：https://www.python.org/downloads/windows/
 
默認安裝位置：C:\Python27\
記得把環境變量勾選上
 --------------------------------------------------------------------------------------------------------
1.在Pycharm下為你的Python項目配置Python解釋器
View-》Toolbar和Tool Buttons
Project:當前項目名>Project Interpreter>add Local
或者
file->setting
 
Project :pyproject1-》Project Interpreter
如果當前電腦安裝了3.6和2.7兩個python，如果項目是用3.6來編寫的，就要選擇3.6作為解析器
 
 
----------------------------------------------------------------------------------------------------
2.在Pycharm下創建Python文件、Python模塊
File>New>Python File
File>New>Python Package
-----------------------------------------------------------------------------------------------
3.使用Pycharm安裝Python第三方模塊
Project:當前項目名>Project Interpreter>點擊右側綠色小加號
PyPI - the Python Package Index --python包索引
pip install
第三方模塊安裝位置：C:\Python27\Lib\site-packages
Linux：
/usr/lib/python2.6/site-packages
/usr/lib64/python2.6/site-packages/
 
搜索并安裝第三方模塊
選擇模塊的版本
倉庫來源，實際連接的是：https://pypi.python.org/simple/
從網上下載，電腦必須能上網
安裝位置：C:\Python27\Lib\site-packages
---------------------------------------------------------------------------------------------------
4.Pycharm基本設置，例如不使用tab、tab=4空格、字體、字體顏色、主題、腳本頭設置、顯示行號等。如何導出和導入自定義設置。
不使用tab、tab=4空格：Editor -> Code Style -> Python
縮進四個空格，不管在哪個操作系統，哪個IDE都不會有問題，tab可能在其他操作系統縮進會有問題
use tab character和smart tabs的勾去掉，然后下面是4 ，4， 8
字體、字體顏色：
Appearance & Behavior ->Appearance-> Theme : Darcula
Editor -> Colors & Fonts ->Font
Primary font:Courier New ，Size：14
 
 
關閉自動更新：Appearance & Behavior  ->System Settings ->Updates
腳本頭設置：Editor ->File and Code Templates ->Python Script 注：其他類似
 
 
顯示行號：Editor -> General  -> Appearance -> Show line numbers  注：2016.2默認顯示行號
右側豎線是PEP8的代碼規范，提示一行不要超過120個字符
導出、導入你自定義的配置： File -> Export Settings、Import Settings
 
 
 
-------------------------------------------------------------------------------------------------------------
5.常用快捷鍵，例如復制當前行、刪除當前行、批量注釋、縮進、查找和替換。
常用快捷鍵的查詢和配置：Keymap
Ctrl + D：復制當前行 或Ctrl + C -> Ctrl + V
Ctrl + E：刪除當前行  或Ctrl + X
Shift + Enter：快速換行
Ctrl + /：快速注釋（選中多行后可以批量注釋）
Tab：縮進當前行（選中多行后可以批量縮進）
Shift + Tab：取消縮進（選中多行后可以批量取消縮進）
Ctrl + F：查找
Ctrl + H：替換
 
--------------------------------------------------------------------------------------------------------------------
6.Pycharm安裝插件，例如Markdown support、數據庫支持插件等。
Plugins -> Browse repositories -> 搜索‘markdown support’ -> install
右上角View有三個選項可選，一般我們都用中間那個左側編寫，右側實時預覽
 
 
-----------------------------------------------------------------------------------------------------
7.Git配置
需要本地安裝好Git
Version Control ->  Git
配置了Git等版本控制系統之后，可以很方便的diff查看文件的不用
 
-----------------------------------------------------------------------------------------------------------------
8.常用操作指南。例如復制文件路徑、在文件管理器中打開、快速定位、查看模塊結構視圖、tab批量換space、TODO的使用、Debug的使用。
復制文件路徑：左側文件列表右鍵選中的文件  -> Copy Path
在文件管理器中打開：右鍵選中的文件  -> 往下找到Show In Explorer
快速定位：按住Ctrl +鼠標左鍵點擊 ，點擊在源文件中展開類，函數，方法等的定義
查看結構：IDE左側邊欄Structure 查看當前項目的結構
tab批量換space：Edit  ->  Convert Indents
TODO的使用：# TODO 要記錄的事情
Debug設置斷點，直接點擊行號與代碼之間的空白處即可設置斷點
Tab頁上右鍵 -> Move Right（Down），把當前Tab頁移到窗口右邊（下邊），方便對比
文件中右鍵 -> Local History能夠查看文件修改前后的對比
IDE右下角能看到一些有用的信息，光標當前在第幾行的第幾個字符、當前回車換行、當前編碼類型、當前Git分支
IDE右側邊欄  ->  Database
 
--------------------------------------------------------------------------------------
9.去掉煩人的波浪線
單獨一行的注釋：#+1空格+注釋內容
代碼后跟著的注釋：2空格+#+1空格+注釋內容
保持良好的統一的編程風格是十分重要的。
Google上面有很多關于各種語言的編程規范指導，Python也有自己的一些編程規范，
PyCharm也會按一定的規范（比如PEP8）來檢查編輯器中的代碼。
這里的編程風格有代碼編寫格式層面的也有代碼邏輯組織層面的。
https://github.com/iwhgao/zh-google-styleguide/blob/master/google-python-styleguide/python_language_rules.rst
https://github.com/iwhgao/zh-google-styleguide/blob/master/google-python-styleguide/python_style_rules.rst
 
黃色波浪色不合規范
綠色波浪線符合規范
 
----------------------------------------------------------------------------------------
10.SSH Terminal： Default encoding:UTF8
Settings   ->   Tools   ->   SSH Terminal    ->   最后一行Default encoding:選擇UTF-8
 
 
 

---

 
示例

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#__author__ = "huazai"
"""
pycharm使用指南
Date：2016.08.12
"""
def test（num）
"""
test function 
"""
for i in range(num): #代碼后面的注釋
j=i+1
if j%2 ==0
print j
#單獨一行注釋
else:
print "The end"
if __name__=="__main__":
test(10)

 
 
 
 
f

文章出處
查看SQL Server服務運行帳戶和SQL Server的所有注冊表項
 

SELECT * FROM sys.dm_server_registry
SELECT * FROM sys.dm_server_services

 

文章出處
Python第十二天     收集主機信息   正則表達式   正則表達式  無名分組   有名分組
 
 
目錄
Pycharm使用技巧（轉載）
Python第一天 安裝 shell 文件
Python第二天 變量 運算符與表達式 input()與raw_input()區別 字符編碼
Python第三天 序列 數據類型 數值 字符串 列表 元組 字典
Python第四天 流程控制 ifelse條件判斷 forwhile循環
Python第五天 文件訪問 for循環訪問文件 while循環訪問文件 字符串的startswith函數和split函數
Python第六天 類型轉換
Python第七天 函數 函數參數 函數變量 函數返回值 多類型傳值 冗余參數 函數遞歸調用 匿名函數 內置函數 列表表達式/列表重寫
Python第八天 模塊 包 全局變量和內置變量__name__ Python path
Python第九天 面向對象 類定義 類的屬性 類的方法 內部類 垃圾回收機制 類的繼承
Python第十天 print >> f,和fd.write()的區別 stdout的buffer 標準輸入 標準輸出 標準錯誤 重定向
Python第十一天 異常處理 glob模塊和shlex模塊 打開外部程序和subprocess模塊 subprocess類 Pipe管道 operator模塊 sorted函數 生成器 walk模塊 hashlib模塊
Python第十二天   收集主機信息   正則表達式   正則表達式  無名分組   有名分組
Python第十三天   django 1.6   導入模板   定義數據模型   訪問數據庫   GET和POST方法    SimpleCMDB項目   urllib模塊   urllib2模塊  httplib模塊  django和web服務器整合  wsgi模塊   gunicorn模塊
Python第十四天 序列化  pickle模塊  cPickle模塊  JSON模塊  API的兩種格式
 
 
 
 
收集主機信息
1. 主機名：hostname
2. IP地址：ip
3. 操作系統版本：osver
4. 服務器廠商：vendor
5. 服務器型號：product
6. 服務器序列號：sn
7. cpu型號：cpu_model
8. cpu核數：cpu_num
9. 內存大小：memory
python中，platform模塊給我們提供了很多方法去獲取操作系統的信息
 

示例1
#!/usr/bin/env python
from subprocess import Popen, PIPE
p = Popen(['dmidecode'], stdout=PIPE)
data = p.stdout # 從標準輸出讀取 返回一個文件對象
lines = []
dmi = {}
a = True
while a:
line = data.readline()
if line.startswith('System Information'):
while True:
line = data.readline()
if line == '\n': # 如果讀到空行，那么結束讀取，整行就有一個換行符就是空行\n
a = False # 退出外層循環
break
else:
lines.append(line)
dmi_dic = dict([i.strip().split(':') for i in lines]) # 將列表變為字典
dmi['Manufacturer'] = dmi_dic['Manufacturer'].strip()
dmi['Product'] = dmi_dic['Product Name'].strip()
dmi['Serial'] = dmi_dic['Serial Number'].strip()
print dmi

 

示例2
#!/usr/bin/env python
from subprocess import Popen, PIPE
def getDmi():
p = Popen(['dmidecode'], stdout=PIPE)
data = p.stdout.read()
return data
def parseDmi(data):
lines = []
line_in = False
dmi_list = [i for i in data.split('\n') if i]
for line in dmi_list:
if line.startswith('System Information'):
line_in = True
continue
if line_in:
if not line[0].strip():
lines.append(line)
else:
break
return lines
def dmiDic():
dmi_dic = {}
data = getDmi()
lines = parseDmi(data)
dic = dict([i.strip().split(': ') for i in lines])
dmi_dic['vendor'] = dic['Manufacturer']
dmi_dic['product'] = dic['Product Name']
dmi_dic['sn'] = dic['Serial Number']
return dmi_dic
if __name__ == '__main__':
print dmiDic()

 
在Python里，以下這些對象相當于布爾值的False
空列表([] )
空元組(() )
空字典({} )
空字符串('' )
零值(0 )
特殊對象None
對象False
 
 

獲取網卡信息示例1
#!/usr/bin/env python
from subprocess import Popen, PIPE
def getIfconfig():
p = Popen(['ifconfig'], stdout=PIPE)
data = p.stdout.read().split('\n\n')
return [i for i in data if i and not i.startswith('lo')]
def parseIfconfig(data):
dic = {}
for lines in data:
line_list = lines.split('\n')
devname = line_list[0].split()[0]
macaddr = line_list[0].split()[-1]
ipaddr = line_list[1].split()[1].split(':')[1]
dic[devname] = [ipaddr, macaddr]
return dic
if __name__ == '__main__':
data = getIfconfig()
print parseIfconfig(data)

 

獲取網卡信息示例2
#!/usr/bin/env python
from subprocess import Popen, PIPE
def getIP():
p = Popen(['ifconfig'], stdout=PIPE, stderr=PIPE)
stdout, stderr = p.communicate()
data = [i for i in stdout.split('\n') if i]
return data
def genIP(data):
new_line = ''
lines = []
for line in data:
if line[0].strip():
lines.append(new_line)
new_line = line + '\n'
else:
new_line += line + '\n'
lines.append(new_line)
return [i for i in lines if i and not i.startswith('lo')]
def parseIfconfig(data):
dic = {}
for lines in data:
line_list = lines.split('\n')
devname = line_list[0].split()[0]
macaddr = line_list[0].split()[-1]
ipaddr = line_list[1].split()[1].split(':')[1]
dic[devname] = [ipaddr, macaddr]
return dic
if __name__ == '__main__':
data = getIP()
data_list = genIP(data)
print parseIfconfig(data_list)

 
 

#!/usr/bin/env python
import re
from subprocess import Popen, PIPE
def getIfconfig():
p = Popen(['ifconfig'], stdout=PIPE)
data = p.stdout.read().split('\n\n')
return [i for i in data if i and not i.startswith('lo')]
def parseIfconfig(data):
re_devname = re.compile(r'(br|eth|em|virbr|lo|bond)[\d:]+',re.M)
re_mac = re.compile(r'HWaddr ([0-9A-F:]{17})', re.M)
re_ip = re.compile(r'inet addr:([\d\.]{7,15})', re.M)
devname = re_devname.search(data)
if devname:
devname = devname.group()
else:
devname = ''
mac = re_mac.search(data)
if mac:
mac = mac.group(1)
else:
mac = ''
ip = re_ip.search(data)
if ip:
ip = ip.group(1)
else:
ip = ''
return {devname: [ip, mac]}
if __name__ == '__main__':
dic = {}
data = getIfconfig()
for i in data:
dic.update(parseIfconfig(i))
print dic

 
 
 
---------------------------------------------------------------
正則表達式
re模塊（標準庫里面）
分析日志、提取信息
普通字符
元字符： .、^、$、*、+、?、{}、[]、\ 轉義、|、()
\d: 匹配任何十進制數，相當于[0-9]
\D: 匹配任何非數字字符，相當于[^0-9]
\s: 匹配任何空白字符，相當于[\t\n\r\f\v]
\S: 匹配任何非空白字符，相當于[^\t\n\r\f\v]
\w: 匹配任何字母數字字符，相當于[a-zA-Z0-9]，包括下劃線等特殊符號
\W: 匹配任何非字母數字字符，相當于[^a-zA-Z0-9]
findall(pattern, string, flags=0)
flags：指定匹配的模式，比如re.S匹配空字符
re.findall(r'.','ab\nss',re.S)
['a', 'b', '\n', 's', 's']
 
正則方法
re.findall()方法：找到re匹配的所有子串，并把它作為一個列表返回，如果用到()元字符只返回()里的內容這時候要用search的group方法
re.match()方法：返回一個對象，只匹配開始的位置
text = ‘hello world ’
m = re.match(r’(\w+)\s’, text)
m.group() 等價于 m.group(0) 整行數據
m.group(1) 打印第一組
按照括號分的，第一個括號是group(1)，第二個括號是group(2)
re.sub()方法：替換
re.sub('he' ,'HE' ,'hellohe',count=2)
re.sub(old ,'new ,字符串,替換的次數)
re.search()方法:從左到右掃描字符串，直到找到第一個re匹配的字符串就停止，不會再匹配后面的即使后面也有匹配字符串
re.match與re.search的區別：re.match只匹配字符串的開始，如果成功的話，返回MatchObject實例，
如果字符串開始不符合正則表達式，則匹配失敗，函數返回None；
而re.search匹配整個字符串，直到找到一個匹配，如果成功的話，返回MatchObject實例
compile()：將正則表達式編譯成對象，并用他們來進行匹配，compile(正則表達式)
p = re.compile(r'ab*')
p = re.compile(r'ab*',re.I|re.S|re.M)
p.findall('G\nd')
>>> import re
>>> p = re.compile(r'ab*') #正則表達式
>>> p
<_sre.SRE_Pattern object at 0x7fa2c0deb960>
s = ‘abc’
p.findall(s) # 匹配ab* 正則
或：
reg = r’ab*’
re.findall(reg, s)
標志flags
re.I 對應2
re.IGNORECASE 忽略大小寫
re.L 對應4
re.LOCALE
re.M 對應8
re.MULTILINE 多行匹配
re.S 對應16 使.匹配包括換行符在內的所有字符
re.Scanner 包括換行符
re.T 對應1
re.TEMPLATE 模板匹配
re.U 對應32
re.UNICODE 包含unicode字符
re.X 對應64 正則可以使用多行來寫
re.S和re.I
s = 'god GOD G\nd'
re.findall(r'g.d',s ,re.S|re.I)
re.M
data = open('/etc/passwd').read()
ftp = re.compile(r'(^ftp)',re.M)
ftp.findall(data)
a = ftp.search(data)
a.group()
 
示例1
>>> smail = "root@123.com"
>>> rmail = r'[\w_]+@\w+\.[a-zA-Z]{2,3}‘
>>> re.findall(rmail, smail)
>>> rmail = r"""[0-9a-zA-Z_]+
... @
... [0-9a-zA-Z]+
... \.
... [a-zA-Z]{2,3}
... ""“
>>> re.findall(rmail,smail,re.X)
re.X：正則可以使用多行來寫
 
greedy模式 greedy貪婪 貪婪匹配
?：抑制貪婪
>>> ss = '<h1> hello </h1>‘
>>> re.findall(r'<.*>', ss)
['<h1> hello </h1>']
>>> re.findall(r'<.*?>', ss)
['<h1>', '</h1>']
syslog reg
reg_syslog = re.compile(r'\w+ \d+ [\d:]+ [\w\d.]+ \w+(\[\d+\])?: .*')
ss = 'Nov 21 14:52:23 localhost dhclient[1005]: bound to 192.168.3.163 -- renewal in 2843 seconds.'
s = reg_syslog.search(ss) # 不能用findall，因為用到了()元字符
s.group()
 
無名分組：沒有定義別名的分組，訪問的時候使用數字來訪問，s.group(1)
有名分組：
(?P<name>...)
REG_LOG = re.compile(r'(?P<logtime>\w+ \d+ [\d:]+) (?P<hostname>[\w\d.]+) (?P<programe>\w+(\[\w+\])?:) (?P<msg>.*)')
s = REG_LOG.search(ss)
s.groupdict() #返回一個字典
/var/log/message有四個部分
1、時間戳
2、主機名，由哪臺主機產生的日志，有些主機名是用FQDN的形式
3、進程名，一般包含pid
4、具體日志信息
 

# 收集主機信息
# collect_info.py
#!/usr/bin/env python
import urllib, urllib2
from subprocess import Popen, PIPE
import pickle
def getIfconfig():
p = Popen(['ifconfig'], stdout=PIPE)
data = p.stdout.read()
return data
def getDmi():
p = Popen(['dmidecode'], stdout=PIPE)
data = p.stdout.read()
return data
def parseData(data):
parsed_data = []
new_line = ''
data = [i for i in data.split('\n') if i]
for line in data:
if line[0].strip():
parsed_data.append(new_line)
new_line = line+'\n'
else:
new_line += line+'\n'
parsed_data.append(new_line)
return [i for i in parsed_data if i]
def parseIfconfig(parsed_data):
dic = {}
parsed_data = [i for i in parsed_data if not i.startswith('lo')]
for lines in parsed_data:
line_list = lines.split('\n')
devname = line_list[0].split()[0]
macaddr = line_list[0].split()[-1]
ipaddr = line_list[1].split()[1].split(':')[1]
break
dic['ip'] = ipaddr
return dic
def parseDmi(parsed_data):
dic = {}
parsed_data = [i for i in parsed_data if i.startswith('System Information')]
parsed_data = [i for i in parsed_data[0].split('\n')[1:] if i]
dmi_dic = dict([i.strip().split(':') for i in parsed_data])
dic['vendor'] = dmi_dic['Manufacturer'].strip()
dic['product'] = dmi_dic['Product Name'].strip()
dic['sn'] = dmi_dic['Serial Number'].strip()[:15]
return dic
def getHostname(f):
with open(f) as fd:
for line in fd:
if line.startswith('HOSTNAME'):
hostname = line.split('=')[1].strip()
break
return {'hostname':hostname} # 返回一個字典
def getOSver(f):
with open(f) as fd:
for line in fd:
osver = line.strip()
break
return {'osver':osver}
def getCpu(f):
num = 0
with open(f) as fd:
for line in fd:
if line.startswith('processor'):
num += 1
if line.startswith('model name'):
cpu_model = line.split(':')[1].split()
cpu_model = cpu_model[0]+' '+cpu_model[-1]
return {'cpu_num':num, 'cpu_model':cpu_model}
def getMemory(f):
with open(f) as fd:
for line in fd:
if line.startswith('MemTotal'):
mem = int(line.split()[1].strip())
break
mem = "%s" % int(mem/1024.0)+'M'
return {'memory':mem}
if __name__ == '__main__':
dic = {}
data_ip = getIfconfig()
parsed_data_ip = parseData(data_ip)
ip = parseIfconfig(parsed_data_ip)
data_dmi = getDmi()
parsed_data_dmi = parseData(data_dmi)
dmi = parseDmi(parsed_data_dmi)
hostname = getHostname('/etc/sysconfig/network')
osver = getOSver('/etc/issue')
cpu = getCpu('/proc/cpuinfo')
mem = getMemory('/proc/meminfo')
dic.update(ip)
dic.update(dmi)
dic.update(hostname)
dic.update(osver)
dic.update(cpu)
dic.update(mem)
print dic
#d = urllib.urlencode(dic)
d = pickle.dumps(dic)
req = urllib2.urlopen('http://192.168.1.5:8000/hostinfo/collect/',d)
print req.read()
# 收集主機信息 正則表達式版本
#!/usr/bin/env python
import re
from subprocess import Popen, PIPE
def getIfconfig():
p = Popen(['ifconfig'], stdout=PIPE)
data = p.stdout.read().split('\n\n')
return [i for i in data if i and not i.startswith('lo')]
def parseIfconfig(data):
re_devname = re.compile(r'(br|eth|em|virbr|lo|bond)[\d:]+',re.M)
re_mac = re.compile(r'HWaddr ([0-9A-F:]{17})', re.M)
re_ip = re.compile(r'inet addr:([\d\.]{7,15})', re.M)
devname = re_devname.search(data)
if devname:
devname = devname.group()
else:
devname = ''
mac = re_mac.search(data)
if mac:
mac = mac.group(1)
else:
mac = ''
ip = re_ip.search(data)
if ip:
ip = ip.group(1)
else:
ip = ''
return {devname: [ip, mac]}
if __name__ == '__main__':
dic = {}
data = getIfconfig()
for i in data:
dic.update(parseIfconfig(i))
print dic

 
 

# group示例
# 按照括號分的，第一個括號是group(1),第二括號是group(2)，以此類推。
group(0)與group()相同，表示匹配到的內容。
In [35]: m = re.match(r'(\w+)\s(\w+)\s', 'hello world abc')
In [36]: m.group()
Out[36]: 'hello world '
In [37]: m.group(0)
Out[37]: 'hello world '
In [38]: m.group(1)
Out[38]: 'hello'
In [39]: m.group(2)
Out[39]: 'world'