可以用 Python 編程語言做哪些神奇好玩的事情？
請說明為什麼這些事情適合用 Python 做。
大一剛學Python的時候，寫了一隻12306爬蟲，採集車次、時刻表數據
多線程採集，經過不斷調試終於穩定，速度也還可以
每天大概可以採集到2000多個車站，5000多個車次，5萬多條時刻信息（這些信息每天都在變的，所以要設置不同日期，然後保存）
當然這不算有意思的
有意思的是這個
可以可視化顯示各個站點不同時間的車輛運行情況（當然顯示部分不是用Python寫的了）
採集了這麼多數據不利用就太可惜了，於是動了點腦筋，把數據利用起來，就有了下面這些（下面就與Python無關了）
那個時候鐵道部還沒有發布官網的購票APP，於是有了這個
自己做了個訂票的APP，可查詢車次、時刻、余票、正晚點
（請忽略圖上的水印，這個APP首發是在百度火車吧，懶得再重新截圖了）
嗯，雖然當時沒有官方的APP，但第三方的還不少，上面的功能也沒什麼新鮮的
不過下面幾個功能一般的APP是沒有的
車站詳細信息查詢，包括所在地址、是否辦理旅客乘降、是否辦理行包業務，也有一些非路內人士不會在意的信息，比如所屬線路、所在路局、是否為接算站等等
編組、乘務、套跑信息
上面兩個功能非路內人士應該不會用的太多，下面還有幾個實用的功能
電話訂票
在高峰時期訂票電話經常打不通，其實這個是有些小技巧的，加撥同路局其它城市區號效果會好很多（當時電話訂票是要撥打出發地所在路局的電話的，不知道現在是否實現了電話跨路局售票）
座位分布，想刷靠窗座位就看這個吧
根據二維碼驗票真偽
將來的你一定會感謝今天拚命努力的你 (二維碼自動識別)
放票時間查詢
界面丑的要死，請大家忽略界面吧。。
以上
可以畫畫啊！可以畫畫啊！可以畫畫啊！ 對，有趣的事情需要講三遍。
事情是這樣的，通過python的深度學習演算法包去訓練計算機模仿世界名畫的風格，然後應用到另一幅畫中，不多說直接上圖！
這個是世界名畫」畢加索的自畫像「（我也不懂什麼是世界名畫，但是我會google呀哈哈），以這張圖片為模板，讓計算機去學習這張圖片的風格（至於怎麼學習請參照這篇國外大牛的論文http://arxiv.org/abs/1508.06576）應用到自己的這張圖片上。
結果就變成下面這個樣子了
咦，嚇死寶寶了，不過好玩的東西當然要身先士卒啦！
接著由於距離開學也越來越近了，為了給廣大新生營造一個良好的校園，噗！為了美化校園在新生心目中的形象學長真的不是有意要欺騙你們的。特意製作了下面的《梵高筆下的東華理工大學》，是不是沒有聽說過這個大學，的確她就是一個普通的二本學校不過這都不是重點。
左邊的圖片是梵高的《星空》作為模板，中間的圖片是待轉化的圖片，右邊的圖片是結果
這是我們學校的內「湖」（池塘）
校園裡的櫻花廣場（個人覺得這是我校最浪漫的地方了）
不多說，學校圖書館
「池塘」邊的柳樹
學校東大門
學校測繪樓
學校地學樓
為了便於觀看，附上生成後的大圖：
別看才區區七張圖片，可是這讓計算機運行了好長的時間，期間電腦死機兩次！
好了廣告打完了，下面是福利時間
在本地用keras搭建風格轉移平台
1.相關依賴庫的安裝
# 命令行安裝keras、h5py、tensorflow
pip3 install keras
pip3 install h5py
pip3 install tensorflow
如果tensorflowan命令行安裝失敗，可以在這裡下載whl包Python Extension Packages for Windows（進入網址後ctrl+F輸入tensorflow可以快速搜索）
2.配置運行環境
下載VGG16模型 https://pan.baidu.com/s/1i5wYN1z 放入如下目錄當中
3.代碼編寫
from __future__ import print_function
from keras.preprocessing.image import load_img, img_to_array
from scipy.misc import imsave
import numpy as np
from scipy.optimize import fmin_l_bfgs_b
import time
import argparse
from keras.applications import vgg16
from keras import backend as K
parser = argparse.ArgumentParser(description="Neural style transfer with Keras.")
parser.add_argument("base_image_path", metavar="base", type=str,
help="Path to the image to transform.")
parser.add_argument("style_reference_image_path", metavar="ref", type=str,
help="Path to the style reference image.")
parser.add_argument("result_prefix", metavar="res_prefix", type=str,
help="Prefix for the saved results.")
parser.add_argument("--iter", type=int, default=10, required=False,
help="Number of iterations to run.")
parser.add_argument("--content_weight", type=float, default=0.025, required=False,
help="Content weight.")
parser.add_argument("--style_weight", type=float, default=1.0, required=False,
help="Style weight.")
parser.add_argument("--tv_weight", type=float, default=1.0, required=False,
help="Total Variation weight.")
args = parser.parse_args()
base_image_path = args.base_image_path
style_reference_image_path = args.style_reference_image_path
result_prefix = args.result_prefix
iterations = args.iter
# these are the weights of the different loss components
total_variation_weight = args.tv_weight
style_weight = args.style_weight
content_weight = args.content_weight
# dimensions of the generated picture.
width, height = load_img(base_image_path).size
img_nrows = 400
img_ncols = int(width * img_nrows / height)
# util function to open, resize and format pictures into appropriate tensors
def preprocess_image(image_path):
img = load_img(image_path, target_size=(img_nrows, img_ncols))
img = img_to_array(img)
img = np.expand_dims(img, axis=0)
img = vgg16.preprocess_input(img)
return img
# util function to convert a tensor into a valid image
def deprocess_image(x):
if K.image_data_format() == "channels_first":
x = x.reshape((3, img_nrows, img_ncols))
x = x.transpose((1, 2, 0))
else:
x = x.reshape((img_nrows, img_ncols, 3))
# Remove zero-center by mean pixel
x[:, :, 0] += 103.939
x[:, :, 1] += 116.779
x[:, :, 2] += 123.68
# "BGR"-&>"RGB"
x = x[:, :, ::-1]
x = np.clip(x, 0, 255).astype("uint8")
return x
# get tensor representations of our images
base_image = K.variable(preprocess_image(base_image_path))
style_reference_image = K.variable(preprocess_image(style_reference_image_path))
# this will contain our generated image
if K.image_data_format() == "channels_first":
combination_image = K.placeholder((1, 3, img_nrows, img_ncols))
else:
combination_image = K.placeholder((1, img_nrows, img_ncols, 3))
# combine the 3 images into a single Keras tensor
input_tensor = K.concatenate([base_image,
style_reference_image,
combination_image], axis=0)
# build the VGG16 network with our 3 images as input
# the model will be loaded with pre-trained ImageNet weights
model = vgg16.VGG16(input_tensor=input_tensor,
weights="imagenet", include_top=False)
print("Model loaded.")
# get the symbolic outputs of each "key" layer (we gave them unique names).
outputs_dict = dict([(layer.name, layer.output) for layer in model.layers])
# compute the neural style loss
# first we need to define 4 util functions
# the gram matrix of an image tensor (feature-wise outer product)
def gram_matrix(x):
assert K.ndim(x) == 3
if K.image_data_format() == "channels_first":
features = K.batch_flatten(x)
else:
features = K.batch_flatten(K.permute_dimensions(x, (2, 0, 1)))
gram = K.dot(features, K.transpose(features))
return gram
# the "style loss" is designed to maintain
# the style of the reference image in the generated image.
# It is based on the gram matrices (which capture style) of
# feature maps from the style reference image
# and from the generated image
def style_loss(style, combination):
assert K.ndim(style) == 3
assert K.ndim(combination) == 3
S = gram_matrix(style)
C = gram_matrix(combination)
channels = 3
size = img_nrows * img_ncols
return K.sum(K.square(S - C)) / (4. * (channels ** 2) * (size ** 2))
# an auxiliary loss function
# designed to maintain the "content" of the
# base image in the generated image
def content_loss(base, combination):
return K.sum(K.square(combination - base))
# the 3rd loss function, total variation loss,
# designed to keep the generated image locally coherent
def total_variation_loss(x):
assert K.ndim(x) == 4
if K.image_data_format() == "channels_first":
a = K.square(x[:, :, :img_nrows - 1, :img_ncols - 1] - x[:, :, 1:, :img_ncols - 1])
b = K.square(x[:, :, :img_nrows - 1, :img_ncols - 1] - x[:, :, :img_nrows - 1, 1:])
else:
a = K.square(x[:, :img_nrows - 1, :img_ncols - 1, :] - x[:, 1:, :img_ncols - 1, :])
b = K.square(x[:, :img_nrows - 1, :img_ncols - 1, :] - x[:, :img_nrows - 1, 1:, :])
return K.sum(K.pow(a + b, 1.25))
# combine these loss functions into a single scalar
loss = K.variable(0.)
layer_features = outputs_dict["block4_conv2"]
base_image_features = layer_features[0, :, :, :]
combination_features = layer_features[2, :, :, :]
loss += content_weight * content_loss(base_image_features,
combination_features)
feature_layers = ["block1_conv1", "block2_conv1",
"block3_conv1", "block4_conv1",
"block5_conv1"]
for layer_name in feature_layers:
layer_features = outputs_dict[layer_name]
style_reference_features = layer_features[1, :, :, :]
combination_features = layer_features[2, :, :, :]
sl = style_loss(style_reference_features, combination_features)
loss += (style_weight / len(feature_layers)) * sl
loss += total_variation_weight * total_variation_loss(combination_image)
# get the gradients of the generated image wrt the loss
grads = K.gradients(loss, combination_image)
outputs = [loss]
if isinstance(grads, (list, tuple)):
outputs += grads
else:
outputs.append(grads)
f_outputs = K.function([combination_image], outputs)
def eval_loss_and_grads(x):
if K.image_data_format() == "channels_first":
x = x.reshape((1, 3, img_nrows, img_ncols))
else:
x = x.reshape((1, img_nrows, img_ncols, 3))
outs = f_outputs([x])
loss_value = outs[0]
if len(outs[1:]) == 1:
grad_values = outs[1].flatten().astype("float64")
else:
grad_values = np.array(outs[1:]).flatten().astype("float64")
return loss_value, grad_values
# this Evaluator class makes it possible
# to compute loss and gradients in one pass
# while retrieving them via two separate functions,
# "loss" and "grads". This is done because scipy.optimize
# requires separate functions for loss and gradients,
# but computing them separately would be inefficient.
class Evaluator(object):
def __init__(self):
self.loss_value = None
self.grads_values = None
def loss(self, x):
assert self.loss_value is None
loss_value, grad_values = eval_loss_and_grads(x)
self.loss_value = loss_value
self.grad_values = grad_values
return self.loss_value
def grads(self, x):
assert self.loss_value is not None
grad_values = np.copy(self.grad_values)
self.loss_value = None
self.grad_values = None
return grad_values
evaluator = Evaluator()
# run scipy-based optimization (L-BFGS) over the pixels of the generated image
# so as to minimize the neural style loss
if K.image_data_format() == "channels_first":
x = np.random.uniform(0, 255, (1, 3, img_nrows, img_ncols)) - 128.
else:
x = np.random.uniform(0, 255, (1, img_nrows, img_ncols, 3)) - 128.
for i in range(iterations):
print("Start of iteration", i)
start_time = time.time()
x, min_val, info = fmin_l_bfgs_b(evaluator.loss, x.flatten(),
fprime=evaluator.grads, maxfun=20)
print("Current loss value:", min_val)
# save current generated image
img = deprocess_image(x.copy())
fname = result_prefix + "_at_iteration_%d.png" % i
imsave(fname, img)
end_time = time.time()
print("Image saved as", fname)
print("Iteration %d completed in %ds" % (i, end_time - start_time))
複製上述代碼保存為neural_style_transfer.py(隨便命名)
4.運行
新建一個空文件夾，把上一步驟的文件neural_style_transfer.py放入這個空文件夾中。然後把相應的模板圖片，待轉化圖片放入該文件當中。
python neural_style_transfer.py 你的待轉化圖片路徑 模板圖片路徑 保存的生產圖片路徑加名稱（注意不需要有.jpg等後綴）
python neural_style_transfer.py "./me.jpg" "./starry_night.jpg" "./me_t"
迭代結果截圖：
迭代過程對比
其它庫實現風格轉化
基於python深度學習庫DeepPy的實現：GitHub - andersbll/neural_artistic_style: Neural Artistic Style in Python
基於python深度學習庫TensorFlow的實現：GitHub - anishathalye/neural-style: Neural style in TensorFlow!
基於python深度學習庫Caffe的實現：https://github.com/fzliu/style-transfer
國外有一位程序員 Kurt Grandis， 家裡後院常常遭受松鼠小偷，於是乎他使用Python創造了一套智能武裝系統：Kinect定位 -&> OpenCV識別松鼠 -&> Arduino控制水槍攻擊。這是他在PyCon 2012的 Slide（牆外）：
http://www.slideshare.net/kgrandis/pycon-2012-militarizing-your-backyard-computer-vision-and-the-squirrel-hordes
Python作為一種應用極為廣泛的語言，幾乎在任何領域都能派上用場。想做Web有Flask/Django/Tornado；想做分散式有Celery；想做手機App有Kivy；想做數據分析有Pandas；想做可視化有Matplotlib/Seaborn/Plotly/Bokeh；想做機器學習有Tensorflow/PyTorch/MxNet……
誇張一點說，幾乎沒有什麼做不了的東西（筆芯）。小慕今天分享兩個可以用Python做的非常好玩的事情，大家都可以試試看~
一、面部識別
得益於大量前人的工作，如今利用Python做一些簡單的計算機視覺工作已經變得非常非常簡單了。像人臉識別、面部特徵提取之類的工作，就可以直接拿來用，極少需要自己實現繁瑣的演算法。
DLib就是一個這樣的C++庫，而同時它也提供了Python介面。
想必大家都有過在辦公室遭遇boss探視的經歷，而此時此刻你卻在毫無自知地逛著淘寶/知乎/豆瓣，場面一度十分尷尬……
那我們就來嘗試一下，用Python通過攝像頭探測人臉。如果有人進入了攝像頭範圍，則讓Python提出一個通知，告訴你——趕緊把不相關的東西關掉！
整個代碼很短，無非幾十行，為了能夠使用，我們還需要安裝一些包和庫。這裡需要用到的包括OpenCV和DLib。由於dlib需要boost-python，因此還需要安裝boost和boost-python。（注意：boost-python默認情況下只編譯python2依賴的庫，如果使用python3，需要加編譯開關；而dlib里是沒有探測python版本的，所以可能還需要做一些小hack或者是直接改boost-python庫里的文件名）
至於代碼，可以簡單地放出來：
import cv2
import dlib
from subprocess import call
from time import time
FREQ = 5
FACE_DETECTOR = dlib.get_frontal_face_detector()
# macOS下可以使用AppleScript發送通知
def notify(text, title):
cmd = r"display notification "%s" with title "%s""%(text, title)
call(["osascript", "-e", cmd])
if __name__ == "__main__":
# 初始化攝像頭
cap = cv2.VideoCapture(0)
# 創建繪圖窗口
# cv2.namedWindow("face")
notify_time = 0
while True:
# 獲取一幀
ret, frame = cap.read()
# 不需要太精細的圖片
frame = cv2.resize(frame, (320, 240))
# 探測人臉，可能有多個
faces = FACE_DETECTOR(frame, 1)
for face in faces:
# 提取人臉部分 畫個方框
# fimg = frame[face.top():face.bottom(), face.left():face.right()]
# cv2.rectangle(frame, (face.left(), face.top()), (face.right(), face.bottom()), (255, 0, 0), 3)
# 不超過FREQ秒一次的發提醒
if time() - notify_time &> FREQ:
notify(u"檢測到人臉", u"注意")
notify_time = time()
# 畫到窗口裡
# cv2.imshow("face", frame)
# 按Q退出
if cv2.waitKey(500) 0xff == ord("q"):
break
# 清理窗口 釋放攝像頭
# cv2.destroyAllWindows()
cap.release()
代碼的原理很簡單：通過opencv捕獲攝像頭獲取的圖像，然後交由dlib的face detector進行檢測。如果檢測到臉部，則通過AppleScript發出系統提醒（notify函數即通過process執行AppleScript發出提醒，如果你使用的是Windows，也可以替換成別的內容，例如Win下使用VBScript發出彈窗提醒）。
當然，既然檢測到人臉，那就不僅僅只是能做簡單提醒了。還可以做的事情包括多張照片的臉部變形合成——比如，找出你和你女朋友的照片來做個夫妻相合成什麼的……
或者，提取所有的標誌性點，給人臉合成出意外的表情或者哈哈鏡效果。
甚至可以藉助其它的深度學習網路進行人臉識別。這算是超級弱化版的臉部識別，比不上FaceID但也挺好玩，不過計算量就不容樂觀了。
順便說一句，什麼人臉識別關掉不該看的東西，對小慕來說不存在的，人家上班刷知乎可是經過老闆點頭的！（驕傲臉叉腰）
二、數據分析
來分析下Marvel 今年的最後一部戲：「雷神3：諸神的黃昏」。前一段時間滿天飛的預告片，神秘博士的客串，綠巨人的出演，看得人十分興奮！來張大圖：
大家對於這部電影的評價是怎麼樣的呢？小慕爬取了2w條豆瓣影評，做一個簡單分析。
先來看看豆瓣的短評：
這裡只抓取了前2w條評論，說一個小技巧，喜歡寫爬蟲的小夥伴們注意了：爬取的網頁一定要緩存到本地！這可以減少解析網頁時出錯，避免需要重新再爬一遍的「尷尬」！另外這能給伺服器減少負載，人家網站管理員看你的請求還算守規矩，也就不會封你賬號/ip啦！
代碼大概是這樣的：
下面是緩存下來的網頁文件：
既然有2w多條數據，怎麼能直接寫sql，那會累死的……於是要來封裝一下操作資料庫的邏輯：
來看看效果，除去部分出錯的，還剩下19672條：
具體的數據是長這樣的：
另外，贊同數量排名第一 卷耳 君的影評實在是太有意思了：
第一部：《爸爸，再愛我一次》
第二部：《哥哥，再愛我一次》
第三部：《姐姐，再愛我一次》
ps:托爾終於從錘神變成了雷神
鎚子之神這個梗小慕表示能玩一年（手動微笑臉）。
光有數據還不足以說明什麼，深入分析一波：細心的小夥伴一定發現了，雷神明明是11月3號才上映，為啥10月份就有影評了？小慕猜測，這肯定是漫威鐵杆粉跑國外看了，一查發現，果然人家洛杉磯10月10號就上映了：
既然關心到日期，可以來統計一下周一到周日哪天去看電影的人比較多：
整體數據顯示：果然還是周末去看電影的人更多……周一數據高於二、三、四的原因，不知道是不是沒有周末的朋友調休去看的？
PS： 資料庫里的日期是2017-10-25格式的：怎麼快速讓他顯示成周X呢？ 這裡只要寫個小函數就行：
從資料庫里讀數據和統計的方式在這：（後面的統計方式也都類似，就不每次都把代碼放出來啦）
說了這麼多還是沒提到電影的受歡迎程度，直接放圖：
總體上看還是推薦的人比較多耶，這應該挺符合大家的預期，畢竟是漫威出品，光忠實粉絲就不計其數。更何況這個片子里出現了很多超級火爆的場面戲，還有各種超級英雄助陣，這樣的統計結果也就不足為奇了。
最後將排名前100的評論內容做了一下分詞，做成詞雲：
至於補充提問中提到的這為什麼適合用Python做，其實說到底就是用Python來抓取和處理各種數據都非常「順手」。
據小慕所知，目前的數據工作中，數據科學家使用最多的工具語言就是Python，排在第二的工具語言是R語言。但這裡有一個有趣的現象，那就是同時使用Python或者R語言的人，推薦別人使用Python的卻遠高於R語言。Why?
答案是：
1. Python簡單易學，極其容易上手，語法簡單，處理速度會比R語言要快，而且無需把資料庫切割。
2. 市場前景好，是目前的趨勢，就業也會更容易。
3. 標準庫非常龐大，特別的「功能齊全」，可以處理各種工作，其中就包含抓取和處理數據。
所以，有一種說法是：python語言在工程方便比較實用，R語言則更受學術界歡迎。具體是否贊同這種說法，還要看大家自己的理解咯~其實除了小慕舉例說的這兩種有趣的事情，Python能做的還有很多，在此不一一列舉，如果感覺get到了新姿勢，記得回來點贊啦~
最後，雙十一要到了，小慕也為廣大程序員朋友們準備了禮物，歡迎大家積极參加活動贏取獎品哦~
活動詳情請戳→慕課網11.11狂歡趴開始了，程序員快來！！
第一次回答...
我只是因為兩個upvote很高的關於火狐圖標的答案並未給出這個演算法的真正原作者表示不滿。
我在這裡還是把原作者和他公布的代碼發一下吧。
原作者Roger Alsing關於這個程序的Blog（發於2008年12月）：
Genetic Programming: Evolution of Mona Lisa
他自己的實驗：
跟進的幾篇Blog：
Genetic Programming: Mona Lisa FAQ
Genetic Gallery
最後，作者很好心地放出了源代碼(c#)以及binary：
Genetic Programming: Mona Lisa Source Code and Binaries
Google Code：
Downloads - alsing - Roger Alsing"s code repository
然後，這裡是用Firefox圖標做實驗的這位的Blog：
Genetic algorithms, Mona Lisa and JavaScript + Canvas
在松鼠科學會的那篇文章： http://songshuhui.net/archives/10462
作者（fwjmath）以很曖昧的態度在下面評論這樣寫：
原文中一句沒有提程序原作者，而這裡又這樣寫，彷彿這個程序的原作者是自己一樣（雖然這篇文章的作者沒說是自己原創的演算法/程序，但這種說辭很容易讓人誤以為是這樣。）
我覺得這種行為很不厚道。
而且Y.X的評論中提到的網站，都已經寫清原作者（Roger Alsing）了：
這個是nihilogic在Roger Alsing放出源碼研究後的Implementation。
貌似十分湊巧和@詹昊恂隨手選的圖片一樣。
最後我為什麼肯定「科學松鼠會的作者知道原作者是誰故意不提」，而不是「這位作者自己寫出了這個程序（沒有看原博客，自己空想出這個演算法並實現）」呢？
請看這裡：
Genetic Gallery
和這裡：
http://songshuhui.net/archives/10462
故意左右反過來，更能說明作者居心吧。
【EDIT：這裡是我多疑了。fwjmath的圖應該是自己寫的程序處理的這個圖。但選擇的圖和原文選的一樣，幾乎可以肯定作者是看過原博文而故意不引用。】
不愧是松鼠科學會，真有國內引用別人作品的風氣。
這也是我為什麼要花時間來寫這麼一個回答。先看到@TonyZeng的回答覺得很新奇，因為自己從來沒看過這個，而且的確很cool，於是就想找來代碼學習一番。
本來好不容易找到了回來打算給@TonyZeng 留言，沒想到在另外一個回答的跟進回復里發現松鼠科學會的這樣一個帖子，覺得十分反感。個人認為好好研究科學必須先有正確的風氣才行，不加引用地使用別人的成果可不是認真做科學的態度。
竟然沒人提到Norvig大神用21行python寫出的拼寫檢查器... http://norvig.com/spell-correct.html
好像沒人說樹莓派（Raspberry Pi），它其實是一款主要基於Linux的單機電腦，可以連接電視、顯示器、鍵盤滑鼠等設備, 還可以玩遊戲和播放視頻。Python是樹莓派的主要編程語言。它長得大概這個樣子(From Wikipedia)：
看看這個小玩意能幹啥？
1. 用Python讓樹莓派「說話」（roll code）
2. 用樹莓派打造一個魔鏡吧（http://blog.jobbole.com/97180/）：
4. 一個利用3D印表機和樹莓派製作的開源大狗機器人 （Fenrir: An Open source dog robot）
5. 一個有趣的360度照相機的開源項目:樹莓派+OpenCV （http://mt.sohu.com/20160418/n444818210.shtml）
6. 另外一個魔鏡（https://github.com/MicrosoftEdge/magic-mirror-demo/blob/master/.github/ASSEMBLY.md）
6. 定格相機/機器人管家/數字時鐘/復古遊戲機（別小看樹莓派 極客們玩出16個倍兒有趣的項目）
7. 家庭自動化（http://www.instructables.com/id/Raspberry-Pi-GPIO-home-automation/）
8. 樹莓派FM廣播點歌系統
9. 豆瓣前台開門器（https://blog.douban.com/douban/2013/01/07/2135/）
更多有意思的可以看看 別小看樹莓派 極客們玩出16個倍兒有趣的項目
要不考慮入手一個玩玩？
歡迎關注本人的微信公眾號獲取更多Python相關的內容（也可以直接搜索「Python之美」）：
http://weixin.qq.com/r/D0zH35LE_s_Frda89xkd (二維碼自動識別)
來來來，告訴你們一點人生經驗，想知道哪個微信好友把你刪了嗎？
github地址：https://github.com/0x5e/wechat-deleted-friends
原理就是新建群組,如果加不進來就是被刪好友了(不要在群組裡講話,別人是看不見的)，用的是微信網頁版的介面。
github上只有在Mac OS上的用法，親測Windows下可以正常使用，下面說一下Windows下用法：
首先下載到你的電腦上，然後打開命令行，然後用cd命令找到源代碼所在目錄。
然後運行&> python wdf.py 入下圖所示：
是的，大膽的按下回車鍵！！！
然後就彈出了二維碼！，如下圖所示：
接著微信掃一掃，程序會自動登錄網頁版微信。一會就可以查看誰把你刪除了，如圖所示：
哈哈，人品還好，我沒有被任何好友刪除。
比那些群發消息來清理通訊錄的童鞋不知道高到哪裡去了！識得唔識得嘎？？？
曾經把以前寫的幾篇博客弄了個專欄叫《Python 也可以》，也許能回答一點這個問題。
專欄：Python 也可以
用微信控制燈泡。
搞個微信公眾號，設置把請求轉發到你自己的公眾號伺服器。公眾號伺服器上用Python搭一個HTTP伺服器，獲取到來自微信的請求。然後用Python開多一個線程通過TCP/UDP協議把消息推送到本地電腦，電腦通過串口連接Arduino電路板。Python調用serial模塊和Arduino電路板通信，Arduino控制燈泡的行為。
實現了一下，寫得很簡陋：livoras/wx-arduino · GitHub
要是你有興趣，還可以把Arduino接入你的家用電路，腦洞大一點你就可以在公司用微信控制你家的空調。
UPDATE：代碼倉庫已經沒有維護了，哪位大神有興趣可以把它弄成通用的流程和組件，說不定是個商機（逃用於加密和解密：encode程序把一段密文寫入一張圖片，且完全不破壞圖片的視覺效果，肉眼無法察覺差異。decode程序把密文從圖片中讀出來（無需任何母版做對照），即使圖片被壓縮或者被降低quality或者格式轉換。後來又寫了升級做法，encode及decode中加入了鑰匙，decode只有拿到鑰匙才能解出正確的密文。
使用python的原因：1）剛學Python，拿它做項目練手
2）有Numpy/Scipy/PIL等，一些數學計算和圖像處理幾行代碼就搞定
（身邊同學面google的真實事例）
面試官：請實現一個中序表達式求值程序，支持四則運算和括弧。比如輸入"3+6/(3-2)"，輸出9。
同學：我什麼語言都能用嗎？
面試官：是的，但最好常用。
同學：那我用python行嗎？
面試官：沒問題。
同學：eval(x)
面試官：（冷汗。。）同學你看看，這個程序是不是有點。。
同學：啊！不安全對吧。（用正則表達式加了個檢查，看是不是僅含四則運算和括弧的表達式）你看，我還帶語法報錯，除零檢測，浮點精度支持。是不是你都被我的機智感動了！
面試官：（瀑布汗）額。。好吧你過了。。
竟然沒有那個調戲蹭網者的事情？當然下邊的 Perl 腳本可以換成 Python
敢偷偷用我的Wi-Fi？看我怎麼治你
實現微信機器人。定時向好友推送消息，並用圖靈機器人回復指定好友的消息。
wxBot是封裝Web微信API實現的，wxBot可以登錄你的Web微信並處理所有的微信消息，還可以主動向好友發送消息。
wxBot+圖靈機器人的效果：
wxBot地址：GitHub - liuwons/wxBot: Python微信機器人框架
圖靈機器人：圖靈機器人－中文語境下智能度最高的機器人大腦圖靈機器人API的免費額度足夠個人機器人使用了。
知乎全部話題關係可視化（Docker+Flask+Bootstrap+echarts+uWSGI+Nginx）
算不上神奇，但是個人覺得挺好玩的。網站訪問地址：http://59.110.49.40/。這裡建議用電腦訪問，手機訪問在排版上還有點問題。
以「數據」為根的話題關係可視化：
右上角有個搜索框，可以對自己喜歡的話題關係進行搜索。比如搜索「周杰倫」：
比如搜索「Python」：
又比如搜索「蘋果公司」（比較亂，可進行縮放和拖拽）：
至於為什麼用Python做，簡單唄！
使用Python繪圖
不同於排名在前的畫畫，這裡講的更多的是數據的可視化。
我們先來看看，能畫出哪樣的圖
更強大的是，每張圖片下都有提供源代碼，可以直接拿來用，修改參數即可。
"""
===============
Basic pie chart
===============
Demo of a basic pie chart plus a few additional features.
In addition to the basic pie chart, this demo shows a few optional features:
* slice labels
* auto-labeling the percentage
* offsetting a slice with "explode"
* drop-shadow
* custom start angle
Note about the custom start angle:
The default ``startangle`` is 0, which would start the "Frogs" slice on the
positive x-axis. This example sets ``startangle = 90`` such that everything is
rotated counter-clockwise by 90 degrees, and the frog slice starts on the
positive y-axis.
"""
import matplotlib.pyplot as plt
# Pie chart, where the slices will be ordered and plotted counter-clockwise:
labels = "Frogs", "Hogs", "Dogs", "Logs"
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. "Hogs")
fig1, ax1 = plt.subplots()
ax1.pie(sizes, explode=explode, labels=labels, autopct="%1.1f%%",
shadow=True, startangle=90)
ax1.axis("equal") # Equal aspect ratio ensures that pie is drawn as a circle.
plt.show()
"""
Demonstrates the visual effect of varying blend mode and vertical exaggeration
on "hillshaded" plots.
Note that the "overlay" and "soft" blend modes work well for complex surfaces
such as this example, while the default "hsv" blend mode works best for smooth
surfaces such as many mathematical functions.
In most cases, hillshading is used purely for visual purposes, and *dx*/*dy*
can be safely ignored. In that case, you can tweak *vert_exag* (vertical
exaggeration) by trial and error to give the desired visual effect. However,
this example demonstrates how to use the *dx* and *dy* kwargs to ensure that
the *vert_exag* parameter is the true vertical exaggeration.
"""
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.cbook import get_sample_data
from matplotlib.colors import LightSource
dem = np.load(get_sample_data("jacksboro_fault_dem.npz"))
z = dem["elevation"]
#-- Optional dx and dy for accurate vertical exaggeration --------------------
# If you need topographically accurate vertical exaggeration, or you don"t want
# to guess at what *vert_exag* should be, you"ll need to specify the cellsize
# of the grid (i.e. the *dx* and *dy* parameters). Otherwise, any *vert_exag*
# value you specify will be relative to the grid spacing of your input data
# (in other words, *dx* and *dy* default to 1.0, and *vert_exag* is calculated
# relative to those parameters). Similarly, *dx* and *dy* are assumed to be in
# the same units as your input z-values. Therefore, we"ll need to convert the
# given dx and dy from decimal degrees to meters.
dx, dy = dem["dx"], dem["dy"]
dy = 111200 * dy
dx = 111200 * dx * np.cos(np.radians(dem["ymin"]))
#-----------------------------------------------------------------------------
# Shade from the northwest, with the sun 45 degrees from horizontal
ls = LightSource(azdeg=315, altdeg=45)
cmap = plt.cm.gist_earth
fig, axes = plt.subplots(nrows=4, ncols=3, figsize=(8, 9))
plt.setp(axes.flat, xticks=[], yticks=[])
# Vary vertical exaggeration and blend mode and plot all combinations
for col, ve in zip(axes.T, [0.1, 1, 10]):
# Show the hillshade intensity image in the first row
col[0].imshow(ls.hillshade(z, vert_exag=ve, dx=dx, dy=dy), cmap="gray")
# Place hillshaded plots with different blend modes in the rest of the rows
for ax, mode in zip(col[1:], ["hsv", "overlay", "soft"]):
rgb = ls.shade(z, cmap=cmap, blend_mode=mode,
vert_exag=ve, dx=dx, dy=dy)
ax.imshow(rgb)
# Label rows and columns
for ax, ve in zip(axes[0], [0.1, 1, 10]):
ax.set_title("{0}".format(ve), size=18)
for ax, mode in zip(axes[:, 0], ["Hillshade", "hsv", "overlay", "soft"]):
ax.set_ylabel(mode, size=18)
# Group labels...
axes[0, 1].annotate("Vertical Exaggeration", (0.5, 1), xytext=(0, 30),
textcoords="offset points", xycoords="axes fraction",
ha="center", va="bottom", size=20)
axes[2, 0].annotate("Blend Mode", (0, 0.5), xytext=(-30, 0),
textcoords="offset points", xycoords="axes fraction",
ha="right", va="center", size=20, rotation=90)
fig.subplots_adjust(bottom=0.05, right=0.95)
plt.show()
圖片來自Matplotlib官網 Thumbnail gallery
這是圖片的索引，可以看看有沒有自己需要的
然後在Github上有非常漂亮的可視化作品 ioam/holoviews
Stop plotting your data - annotate your data and let it visualize itself.
Gridded Datasets
Scatter economic
Verhulst mandelbrot
Nytaxi hover - HoloViews
同樣每張圖都有代碼講解，相信你一定可以看懂。
Python可以做的事情真的太多了，不要猶豫，趕緊畫起來吧。
Python控制的樂高機器人，能識別障礙，語音交互：
先看一看上面這個是幹嘛的！！！！！不知道往下看！
————————
鑒於問題是編程語言可以做哪些神器好玩的事，我先把Python可以應用於哪些領域和使用了哪些框架技術整理出來，然後再給大家收集可以用於的神器好玩的事，也希望大家留言給我，我補充給大家。
本文分為兩部分：
第一部分：可以用 Python 編程語言做哪些神奇好玩的事情？
第二部分： Python 編程有哪些神奇簡單的框架？
更新於2017.08.03-09:22
—————第一部分：可以用 Python 編程語言做哪些神奇好玩的事情？———————
1.介紹一個異常簡單的使用Python語言和開源庫OpenCV的人臉識別方法，供此開啟人臉識別之旅。
讓我們再對Abba圖片進行一次測試。 $ python face_detect.py abba.png haar級聯_frontalface_default.xml
這個工作正常，其他圖片檢測結果如何？
那個…不是人臉。讓我們再試一次。我修改了參數設置，發現將scaleFactor設置成1.2可以將識別錯識的人臉過濾掉。
發生了什麼？好吧，第一張相片使用了一個高相素相機在較近的距離進行拍攝。第二張相片貌似是使用的手機在較遠距離進行的拍攝。這就是參數scaleFactor需要修改的原因。就像我說過的，你需要根據不同測試案例對演算法進行不同的參數設置從而避免誤識別的發生。
需要注意的是，由於採用了基於機械學習的演算法，檢測結果永遠無法達到100%精確。大多數案例中你都能得到較好的結果，但偶爾演算法也會檢測到錯誤的對象，就像檢測到錯誤的人臉一樣。
OpenCV是計算機視覺領域最受歡迎的庫。OpenCV最早是使用C/C++語言進行編寫的，現已支持Python語言捆綁使用。
OpenCV使用機械學習演算法對圖像中的人臉進行搜索。由於有著與人臉一樣複雜的原因，不存在一項簡便的測試可以告知人們是否能夠識別出人臉。相反，演算法需要對成千上萬細小的模式和特徵進行匹配。面部識別演算法被分解成成千上萬很小的、易理解的任務，每一個任務較易實現。這些任務被稱為分類器。
像人臉一樣，你可能有6，000個基於更多的分類器在進行人臉檢測過程中，每一個分類器都需要進行匹配（當然要在一定的誤差範圍內）。但這其中就有問題了。在人臉識別過程中，演算法從圖片的左上角開始向右下角按小塊逐步進行匹配，對每一個小塊的識別過程中，演算法都會持續的問：「這是人臉么？這是人臉么？這是人臉么？」由於在每個小塊有著6000甚至更多的匹配項需要進行匹配，你可能會有無數的計算要執行，這些計算將引發你的電腦發生死機。
本文采編自：25行Python代碼完成人臉識別
2.機器自己學唱歌一首
現在我們可以開始了解這樣一個系統是如何工作了。一種音頻指紋識別系統做到兩點：
- 1.通過指紋標記學習一首新歌
- 2.通過在資料庫中搜索已經學習過的歌曲來識別一首未知歌曲
為此，我們將用到以上的所有知識和MySQL資料庫功能。我們的資料庫將包含兩個表：
- 1.指紋記錄
- 2.歌曲記錄
音頻指紋記錄表
音頻指紋記錄表有如下欄位：
首先，注意到我們不僅有一個hash和song_id 欄位，還有一個offset 欄位。這對應於哈希來源的譜圖上的時間偏移量。這會在後面我們在通過匹配哈希值來過濾時用到。只有哈希值與真實信息一致才是我們真正要識別出的（更多看下面音頻指紋比對）。
其次，我們有很好的理由把hash 設置成INDEX。因為所有的查詢都將需要做匹配操作，所以這裡我們需要一個真正的快速檢索。
然後，UNIQUE只是確保我們沒有重複。無需浪費空間或者因為重複的音頻影響匹配查詢速度。
如果你在絞盡腦汁地想我為什麼把 hash 設置成 binary(10)，原因是，哈希值通常太長，設置少點有得於減少存儲。下面是每首歌的音頻指紋數圖：
最前面的是Justin Timberlake 的"Mirrors" ，音頻指紋數超過240K，其次Robin Thicke 的"Blurred Lines" 也有180k。底部是acapella演藝的」Cups」, 是一首樂器很少，僅有人聲和和聲的歌曲。 做個對比，聽聽 "Mirrors"。你會發現明顯的樂器聲組成的「噪音牆」並且填充的頻譜數從高到低分類，即頻譜豐富與否與峰的頻率高低是一致的。這個數據集里每首歌平均超過100k個音頻指紋數。
有這麼多的指紋，我們需要從哈希值水平上減少不必要的硬碟存儲。對於指紋哈希，我們將開始使用SHA-1哈希，然後減少一半大小（只有前20個字元）。這使我們每個哈希值減少了一半的位元組數：
下一步，我們將採取十六進位編碼，並將其轉換為二進位，再次大幅削減空間：
現在好多了。我們把hash欄位從320 bits降到了80 bits，減少了75%。
我在系統中第一次嘗試時，我把hash欄位設置成了char(40)-這導致了單單音頻指紋表就佔據超過了1GB的空間。設置成binary(10)後，我們把表的大小降低到只需377M就成存儲520萬個音頻指紋。
我們確實丟失了一些信息——從統計學的角度來說我們的哈希值現在碰撞的更頻繁。我們降低了哈希相當多的「信息熵」。然而，重要的是要記住，我們的熵（或信息）也包括offset欄位，這有4個位元組。這使得我們每個音頻指紋的總信息熵為：
就說，我們已經節省了自己75%的空間，但仍然有一個巨大無比的指紋空間要處理。要保證每個欄位的理想分布是很困難的，但是我們已經有足夠的信息熵進行接下來的工作了。
本文采編自：Python和Numpy 處理音頻指紋 一
3.使用python基於Tensorflow設計手寫數字識別演算法，並編程實現GUI界面，構建手寫數字識別系統。本文實現的系統其實是基於卷積神經網路的手寫數字識別系統。該系統能快速實現手寫數字識別，成功識別率高。缺點：只能正確識別單個數字，圖像預處理還不夠，沒有進行圖像分割，讀者也可以自行添加，進行完善。
本文采編自：Python(TensorFlow框架)實現手寫數字識別系統 - louishao的博客 - CSDN博客
寫了一些輔助函數，可以查看部分識別錯誤的圖片，
還可以查看混淆矩陣，
系統中還添加了一點圖像預處理的操作，比如灰度化，圖像信息的歸一化等，更貼近實際應用。 系統可進行快速識別，如下圖
4.python 畫圖--簡單開始及折線圖
相關參考資料：
matplotlib官方文檔：http://matplotlib.org/api/pyplot_summary.html （api的調用及一些示例代碼）
一個中文版的文檔（不全）：http://old.sebug.net/paper/books/scipydoc/matplotlib_intro.html
matplotlib較詳細的剖析：http://www.cnblogs.com/vamei/archive/2013/01/30/2879700.html
三種圖的繪製：http://www.cnblogs.com/hustlx/p/5264562.html
多張圖的繪製：http://www.2cto.com/kf/201407/317115.html
一、環境準備
linux ubuntu 下需安裝下面三個包： Numpy, Scipy,Matplotlib
分別輸入下面的代碼進行安裝：
pip install numpy
pip install scipy
sudo apt-get install python-matplotlib
測試是否安裝成功
python
&>&>&> import pylab
如果沒有報錯則安裝成功
二、開始畫圖
1. 畫最簡單的直線圖
代碼如下：
import numpy as np
import matplotlib.pyplot as plt
x=[0,1]
y=[0,1]
plt.figure()
plt.plot(x,y)
plt.savefig("easyplot.jpg")
結果如下：
代碼解釋：
#x軸，y軸
x=[0,1]
y=[0,1]
#創建繪圖對象
plt.figure()
#在當前繪圖對象進行繪圖（兩個參數是x,y軸的數據）
plt.plot(x,y)
#保存圖象
plt.savefig("easyplot.jpg")
2. 給圖加上標籤與標題
上面的圖沒有相應的X，Y軸標籤說明與標題
在上述代碼基礎上，可以加上這些內容
代碼如下：
import numpy as np
import matplotlib.pyplot as plt
x=[0,1]
y=[0,1]
plt.figure()
plt.plot(x,y)
plt.xlabel("time(s)")
plt.ylabel("value(m)")
plt.title("A simple plot")
結果如下：
代碼解釋：
- plt.xlabel("time(s)") #X軸標籤
- plt.ylabel("value(m)") #Y軸標籤
- plt.title("A simple plot") #標題
3. 畫sinx曲線
代碼如下：
# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
#設置x,y軸的數值（y=sinx）
x = np.linspace(0, 10, 1000)
y = np.sin(x)
#創建繪圖對象，figsize參數可以指定繪圖對象的寬度和高度，單位為英寸，一英寸=80px
plt.figure(figsize=(8,4))
#在當前繪圖對象中畫圖（x軸,y軸,給所繪製的曲線的名字，畫線顏色，畫線寬度）
plt.plot(x,y,label="$sin(x)$",color="red",linew=2)
#X軸的文字
plt.xlabel("Time(s)")
#Y軸的文字
plt.ylabel("Volt")
#圖表的標題
plt.title("PyPlot First Example")
#Y軸的範圍
plt.ylim(-1.2,1.2)
#顯示圖示
plt.legend()
#顯示圖
plt.show()
#保存圖
plt.savefig("sinx.jpg")
結果如下：
4. 畫折線圖
代碼如下：
# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
#X軸，Y軸數據
x = [0,1,2,3,4,5,6]
y = [0.3,0.4,2,5,3,4.5,4]
plt.figure(figsize=(8,4)) #創建繪圖對象
plt.plot(x,y,"b--",linew=1) #在當前繪圖對象繪圖（X軸，Y軸，藍色虛線，線寬度）
plt.xlabel("Time(s)") #X軸標籤
plt.ylabel("Volt") #Y軸標籤
plt.title("Line plot") #圖標題
plt.show() #顯示圖
plt.savefig("line.jpg") #保存圖
結果如下：
原文轉載地址：python 畫圖--簡單開始及折線圖
————————————
現在Python成為了熾手可熱的一門語言，在如何快速入門的同時，如何進行高效的開發是一門語言非常重要的優勢。我們收集馬哥Python了超過2000名學員的意見和建議，對Python常用的框架進行了梳理，這些框架包括事件I/O，OLAP，Web開發，高性能網路通信，測試，爬蟲等。
Python目前主流的應用包括：Web開發、圖形界面開發、系統網路運維、網路編程、科學數字計算、3D遊戲開發，而我們特別針對這6個方向進行了框架和庫的整理。
一、Python的幾大主流Web開發框架
1.Django: Python Web應用開發框架
Django 應該是最出名的Python框架，GAE甚至Erlang都有框架受它影響。Django是走大而全的方向，它最出名的是其全自動化的管理後台：只需要使用起ORM，做簡單的對象定義，它就能自動生成資料庫結構、以及全功能的管理後台。
網址：The Web framework for perfectionists with deadlines
2.Bottle: 微型Python Web框架
Bottle是一個簡單高效的遵循WSGI的微型python Web框架。說微型，是因為它只有一個文件，除Python標準庫外，它不依賴於任何第三方模塊。
網址：Bottle: Python Web Framework
3.Flask：也是一個Web應用框架
不同於Django它是輕量級Web應用框架。基於Werkzeug WSGI工具箱和Jinja2 模板引擎。Flask也被稱為「microframework」，因為它使用簡單的核心，用extension增加其他功能。Flask沒有默認使用的資料庫、窗體驗證工具。 但是Flask是可以擴增的，你可以使用可以用Flask-extension增加前邊沒有的一些功能。
網址：Flask (A Python Microframework)
4.Tornado：非同步非阻塞IO的Python Web框架
Tornado的全稱是Torado Web Server，從名字上看就可知道它可以用作Web伺服器，但同時它也是一個Python Web的開發框架。最初是在FriendFeed公司的網站上使用，FaceBook收購了之後便開源了出來。Tornado 和現在的主流 Web 伺服器框架和大多數Python框架有著明顯的區別：它是非阻塞式伺服器，而且速度相當快。也是比較常被使用的Python開源框架之一。
網址：Tornado Web Server - Tornado 4.5.1 documentation
Web2py：全棧式Web框架
Web2py是一個為Python語言提供的全功能Web應用框架，旨在敏捷快速的開發Web應用，具有快速、安全以及可移植的資料庫驅動的應用，兼容Google App Engine。
網址：http://www.web2py.com/
webpy: 輕量級的Python Web框架
webpy的設計理念力求精簡（Keep it simple and powerful），源碼很簡短，只提供一個框架所必須的東西，不依賴大量的第三方模塊，它沒有URL路由、沒有模板也沒有資料庫的訪問。
網址：Welcome to web.py! (web.py)
二、Python的爬蟲框架
Scrapy：Python的爬蟲框架
Scrapy是一個使用Python編寫的，輕量級的，簡單輕巧，並且使用起來非常的方便。
網址：A Fast and Powerful Scraping and Web Crawling Framework
三、圖形界面開發框架
PyQt
PyQt能夠實現高人氣Qt庫，因此如果大家熟知如何利用其它語言進行Qt開發，那麼上手PyQt也不會出現什麼障礙。其能夠讓Python應用具備跨平台外觀風格與使用感受，同時繼承Qt社區所帶來的龐大知識支持與工具選項。
PyQt同時提供商用與GPL許可（這一點與Qt項目本身有所不同），感興趣的朋友也可點擊此處了解與PyQt許可相關的常見問題（英文原文）。
網址：Riverbank | Software | PyQt | What is PyQt?
Tkinter
如果要為Python選出一款能夠稱得上「標準」的GUI工具包，那麼答案應該是Tkinter。Tkinter是一款以Tcl/Tk為基礎的打包工具，而後者則屬於誕生自上世紀九十年代初的高人氣圖形界面與語言組合。Tkinter的最大優勢在於擁有豐富的資源，其中包括文本與代碼示例以及龐大的用戶社區。通過示例，我們能夠輕鬆上手這套圖形界面實現方案。
Tkinter遵循Python許可，同時基於Tcl/Tk的BSD許可。
網址：24.1. Tkinter - Python interface to Tcl/Tk - Python 2.7.13 documentation
WxPython
WxPython 將針對C++的wxWidgets跨平台GUI庫帶給了Python。WxPython是一套較為現代的方案，其外觀的原生程度高於Tkinter，這主要歸功於其更傾向於針對不同系統平台建立控制項成果。其易於上手，同時擁有快速發展的開發者社區。不過大家需要自行將wxPython與應用相綁定，因為其無法通過Python自動進行安裝。
WxPython採用其父項目wxWindows的庫許可，這一許可獲得了OSI批准。
網址：Welcome to wxPython!
四、Python系統運維常用庫
1、psutil是一個跨平台庫（http://code.google.com/p/psutil/）
能夠實現獲取系統運行的進程和系統利用率（內存，CPU,磁碟，網路等），主要用於系統監控，分析和系統資源及進程的管理。
2、IPy（http://github.com/haypo/python-ipy）,輔助IP規劃。
3、dnspython(http://dnspython.org)Python實現的一個DNS工具包。
4、difflib：difflib作為Python的標準模塊，無需安裝，作用是對比文本之間的差異。
5、filecmp:系統自帶，可以實現文件，目錄，遍歷子目錄的差異，對比功能。
6、smtplib：發送電子郵件模塊
7、pycurl(http://pycurl.sourceforge.net)是一個用C語言寫的libcurl Python實現，功能強大，支持的協議有：FTP,HTTP,HTTPS,TELNET等，可以理解為Linux下curl命令功能的Python封裝。
8、XlsxWriter:操作Excel工作表的文字，數字，公式，圖表等。
9、rrdtool:用於跟蹤對象的變化，生成這些變化的走走勢圖
10、scapy(http://www.wecdev.org/projects/scapy/)是一個強大的互動式數據包處理程序，它能夠對數據包進行偽造或解包，包括發送數據包，包嗅探，應答和反饋等功能。
11、Clam Antivirus免費開放源代碼防毒軟體，pyClamad,可以讓Python模塊直接使用ClamAV病毒掃描守護進程calmd。
12、pexpect:可以理解成Linux下expect的Python封裝，通過pexpect我們可以實現對ssh,ftp,passwd,telnet等命令行進行自動交互，而無需人工干涉來達到自動化的目的。
13、paramiko是基於Python實現的SSH2遠程安裝連接，支持認證及密鑰方式。可以實現遠程命令執行，文件傳輸，中間SSH代理等功能。相對於Pexpect,封裝的層次更高，更貼近SSH協議的功能，官網地址：http://paramiko.org(依賴：Crypto,Ecdsa,Python開發包python-devel)
14、fabric是基於Python實現的SSH命令行工具，簡化了SSH的應用程序部署及系統管理任務，它提供了系統基礎的操作組件，可以實現本地或遠程shell命令，包括命令執行，文件上傳，下載及完整執行日誌輸出等功能。Fabric在paramiko的基礎上做了更高一層的封裝，操作起來更加簡單。官網地址：http://www.fabfile.org(依賴setuptools,Crypto,paramiko包支持)
15、CGIHTTPRequestHandler實現對CGI的支持。
16、ansible(http://www.ansibleworks.com/)一種集成IT系統的配置管理，應用部署，執行特定任務的開源平台。基於Python實現，由Paramiko和PyYAML兩個關鍵模塊構建。Ansibl與Saltstack最大的區別是Ansible無需在被控主機上部署任何客戶端，默認直接通過SSH通道進行遠程命令執行或下發功能。
17、YAML:是一種用來表達數據序列的編程語言。
18、playbook：一個非常簡單的配置管理和多主機部署系統。
19、saltstack(http://saltstack.com)是一個伺服器基礎架構集中化管理平台，一般可以理解為簡化版的puppet和加強版的func。Saltstack基於Python語言實現，結合輕量級消息隊列ZeroMQ,與Python每三方模塊（Pyzmq,PyCrypto,Pyjinja2,python-msgpack和PyYAML等）構建。
20、func，為解決集群管理，監控問題需設計開發的系統管理基礎框架。
四、Python科學數字計算的框架
Python中的數據科學計算庫有Numpy、Scipy、pandas、matplotlib
Numpy是一個基礎性的Python庫，為我們提供了常用的數值數組和函數。numpy(Numerical Python extensions)是一個第三方的Python包，用於科學計算。這個庫的前身是1995年就開始開發的一個用於數組運算的庫。經過了長時間的發展，基本上成了絕大部分Python科學計算的基礎包，當然也包括所有提供Python介面的深度學習框架。
網址：NumPy - NumPy
Scipy是Python的科學計算庫，對Numpy的功能進行了擴充，同時也有部分功能是重合的。Numpy和Scipy曾經共享過基礎代碼。
網址：SciPy.org - SciPy.org
pandas是一個流行的開源Python項目，它的名稱取panel data（面板數據，一個計量經濟學的術語）和Python data analysis（Python數據分析）的意思。matplotlib是一個基於Numpy的繪圖庫。
網址：Python Data Analysis Library
Matplotlib是Python中最常用的可視化工具之一，可以非常方便地創建海量類型地2D圖表和一些基本的3D圖表。Matplotlib最早是為了可視化癲癇病人的腦皮層電圖相關的信號而研發，因為在函數的設計上參考了MATLAB，所以叫做Matplotlib。Matplotlib首次發表於2007年，在開源和社區的推動下，現在在基於Python的各個科學計算領域都得到了廣泛應用。Matplotlib的原作者John D. Hunter博士是一名神經生物學家，2012年不幸因癌症去世，感謝他創建了這樣一個偉大的庫。
網址：Python plotting - Matplotlib 2.0.2 documentation
四、Python的3D遊戲開發框架
Pygame是跨平台Python模塊，專為電子遊戲設計。包含圖像、聲音。pygame建立在SDL基礎上，允許實時電子遊戲研發而無需被低級語言（如機器語言和彙編語言）束縛。基於這樣一個設想，所有需要的遊戲功能和理念都（主要是圖像方面）都完全簡化為遊戲邏輯本身，所有的資源結構都可以由高級語言提供，如Python。
網址：http://www.pygame.org/news
ocos2d-python上面很多都用pyglet這個庫的，裡面主要的精靈什麼的也是針對pyglet的封裝，另外還封裝了些音頻庫什麼的。
網址：cocos2d
五、Python的其他流行的開發框架
Diesel：基於Greenlet的事件I/O框架
Diesel提供一個整潔的API來編寫網路客戶端和伺服器。支持TCP和UDP。
Cubes：輕量級Python OLAP框架
Cubes是一個輕量級Python框架，包含OLAP、多維數據分析和瀏覽聚合數據（aggregated data）等工具。
Kartograph.py：創造矢量地圖的輕量級Python框架
Kartograph是一個Python庫，用來為ESRI生成SVG地圖。Kartograph.py目前仍處於beta階段，你可以在virtualenv環境下來測試。
Pulsar：Python的事件驅動並發框架
Pulsar是一個事件驅動的並發框架，有了pulsar，你可以寫出在不同進程或線程中運行一個或多個活動的非同步伺服器。
Falcon：構建雲API和網路應用後端的高性能Python框架
Falcon是一個構建雲API的高性能Python框架，它鼓勵使用REST架構風格，儘可能以最少的力氣做最多的事情。
Dpark：Python版的Spark
DPark是Spark的Python克隆，是一個Python實現的分散式計算框架，可以非常方便地實現大規模數據處理和迭代計算。DPark由豆瓣實現，目前豆瓣內部的絕大多數數據分析都使用DPark完成，正日趨完善。
Buildbot：基於Python的持續集成測試框架
Buildbot是一個開源框架，可以自動化軟體構建、測試和發布等過程。每當代碼有改變，伺服器要求不同平台上的客戶端立即進行代碼構建和測試，收集並報告不同平台的構建和測試結果。
Zerorpc：基於ZeroMQ的高性能分散式RPC框架
Zerorpc是一個基於ZeroMQ和MessagePack開發的遠程過程調用協議（RPC）實現。和 Zerorpc 一起使用的 Service API 被稱為 zeroservice。Zerorpc 可以通過編程或命令行方式調用。
好了，最後我們再來看看，到底是哪些人學習呢？
目前來學的人群分為以下幾類：
第一類：入行編程新手：大學剛畢業或者其他行業轉崗，想從事編程開發的工作，目前認為Python比較火，想入行；
第二類：Linux系統運維人員：Linux運維以繁雜著稱，對人員系統掌握知識的能力要求非常高，那麼也就需要一個編程語言能解決自動化的問題，Python開發運維工作是首選，Python運維工資的薪資普遍比Linux運維人員的工資高。
第三類：做數據分析或者人工智慧：不管是常見的大數據分析或者一般的金融分析、科學分析都比較大程度的應用了數據分析，人工智慧的一些常見應用也使用了Python的一些技術。
第四類：在職程序員轉Python開發：平常只關注div+css這些頁面技術，很多時候其實需要與後端開發人員進行交互的，現在有很多Java程序在轉到Python語言，他們都被Python代碼的優美和開發效率所折服
第五類：其他：一些工程師以前在做很多SEO優化的時候，苦於不會編程，一些程序上面的問題，得不到解決，只能做做簡單的頁面優化。 現在學會Python之後，可以編寫一些查詢收錄，排名，自動生成網路地圖的程序，解決棘手的SEO問題
如果你有更好的建議，歡迎留言和討論。
寫了個腳本將所有A片格式化命名，整理，歸類，去重，建立索引。
方便查閱，減少硬碟浪費或者重複下載。
想當一把老司機，結果死在了半路。。。
這是前言，也是遺言
----------------------------------------------
自從有了知乎，再也不上什麼1024了。
自從發現了知乎可以釣魚，帶逛之後，老夫的麒麟臂就愈發粗壯了。
但是一個一個翻答案實在是太累，於是有各路老司機開始用爬蟲爬答案里的圖看。
雖然我也爬了一堆，但是，我發現，特么佔地盤，我也沒那個收藏愛好。
乾脆就練練python，寫個小網站。
於是擼了幾天教程，終於寫出來了。
大概就是flask + beautifulsoup
主界面大概是這樣的
只要輸入問題的鏈接地址，然後就beautifulsoup去解析。
比如前兩天看這個問題很是帶感啊
世界上存在動漫少女般完美的身體嗎？ - 日本動漫
原來我的計劃是，用pinterest一樣的瀑布流來展示，然後搞個作者名字跟贊數在下面作參考。
發現有趣的可以根據圖鏈接回知乎看看詳細。
【這裡原本是一張福利圖，要求被修改了】
後來我發現，我想多了
於是大面積的死掉了，圖片都被403了。顯示出來的這兩張，也僅僅是因為瀏覽器緩存。
所以，我決定去轉戰豆瓣了。
另外，老爺機開滿了功率，爬了知乎3萬用戶基本資料，最近還在繼續爬，等爬完了再上來彙報。
推薦閱讀：
※Python 的練手項目有哪些值得推薦？
※在大型項目上，Python 是個爛語言嗎？
※對 Quant 而言 Python 的需求高嗎，除 C++ 外還有哪些流行的編程語言？
※使用 Python 會降低程序員的編程能力嗎？