python多對多
① python + django 多表聯合查詢方法求教
先讓我們回憶一下在第五章里的關於書本(book)的數據模型：
1
from django.db import models
class Publisher(models.Model):
name = models.CharField(max_length=30)
address = models.CharField(max_length=50)
city = models.CharField(max_length=60)
state_province = models.CharField(max_length=30)
country = models.CharField(max_length=50)
website = models.URLField()
def __unicode__(self):
return self.name
class Author(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=40)
email = models.EmailField()
def __unicode__(self):
return u'%s %s' % (self.first_name, self.last_name)
class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()
def __unicode__(self):
return self.title
如我們在第5章的講解,獲取資料庫對象的特定欄位的值只需直接使用屬性。 例如,要確定ID為50的書本的標題,我們這樣做:
>>> from mysite.books.models import Book
>>> b = Book.objects.get(id=50)
>>> b.title
u'The Django Book'
但是,在之前有一件我們沒提及到的是表現為ForeignKey 或 ManyToManyField的關聯對象欄位,它們的作用稍有不同。
訪問外鍵(Foreign Key)值
當你獲取一個ForeignKey 欄位時,你會得到相關的數據模型對象。 例如:
>>> b = Book.objects.get(id=50)
>>> b.publisher
<Publisher: Apress Publishing>
>>> b.publisher.website
u'http://www.apress.com/'
對於用`` ForeignKey``
來定義的關系來說，在關系的另一端也能反向的追溯回來，只不過由於不對稱性的關系而稍有不同。 通過一個`` publisher`` 對象，直接獲取
books ，用 publisher.book_set.all() ，如下：
>>> p = Publisher.objects.get(name='Apress Publishing')
>>> p.book_set.all()
[<Book: The Django Book>, <Book: Dive Into Python>, ...]
實際上，book_set 只是一個 QuerySet（參考第5章的介紹），所以它可以像QuerySet一樣,能實現數據過濾和分切，例如：
1
>>> p = Publisher.objects.get(name='Apress Publishing')
>>> p.book_set.filter(name__icontains='django')
[<Book: The Django Book>, <Book: Pro Django>]
屬性名稱book_set是由模型名稱的小寫(如book)加_set組成的。
訪問多對多值(Many-to-Many Values)
多對多和外鍵工作方式相同，只不過我們處理的是QuerySet而不是模型實例。 例如,這里是如何查看書籍的作者：
>>> b = Book.objects.get(id=50)
>>> b.authors.all()
[<Author: Adrian Holovaty>, <Author: Jacob Kaplan-Moss>]
>>> b.authors.filter(first_name='Adrian')
[<Author: Adrian Holovaty>]
>>> b.authors.filter(first_name='Adam')
[]
反向查詢也可以。 要查看一個作者的所有書籍,使用author.book_set ,就如這樣:
>>> a = Author.objects.get(first_name='Adrian', last_name='Holovaty')
>>> a.book_set.all()
[<Book: The Django Book>, <Book: Adrian's Other Book>]
這里,就像使用 ForeignKey欄位一樣，屬性名book_set是在數據模型(model)名後追加_set。
更改資料庫模式(Database Schema)
3
在我們在第5章介紹 syncdb 這個命令時, 我們注意到 syncdb僅僅創建資料庫里還沒有的表，它 並不 對你數據模型的修改進行同步,也不處理數據模型的刪除。 如果你新增或修改數據模型里的欄位,或是刪除了一個數據模型，你需要手動在資料庫里進行相應的修改。 這段將解釋了具體怎麼做：
當處理模型修改的時候，將Django的資料庫層的工作流程銘記於心是很重要的。
如果模型包含一個未曾在資料庫里建立的欄位，Django會報出錯信息。 當你第一次用Django的資料庫API請求表中不存在的欄位時會導致錯誤（就是說，它會在運行時出錯，而不是編譯時）。
3
Django不關心資料庫表中是否存在未在模型中定義的列。
Django不關心資料庫中是否存在未被模型表示的表格。
1
改變模型的模式架構意味著需要按照順序更改Python代碼和資料庫。
添加欄位
1
當要向一個產品設置表(或者說是model)添加一個欄位的時候，要使用的技巧是利用Django不關心表裡是否包含model里所沒有的列的特性。 策略就是現在資料庫里加入欄位，然後同步Django的模型以包含新欄位。
3
然而 這里有一個雞生蛋蛋生雞的問題 ,由於要想了解新增列的sql語句，你需要使用Django的
manage.py sqlall命令進行查看 ,而這又需要欄位已經在模型里存在了。 (注意:你並 不是非得使用與Django相同的SQL語句創建新的欄位，但是這樣做確實是一個好主意 ,它能讓一切都保持同步。)
3
這個雞-蛋的問題的解決方法是在開發者環境里而不是發布環境里實現這個變化。 (你正使用的是測試/開發環境，對吧?)下面是具體的實施步驟。
首先，進入開發環境(也就是說，不是在發布環境里)：
在你的模型里添加欄位。
運行 manage.py sqlall [yourapp] 來測試模型新的 CREATE TABLE 語句。 注意為新欄位的列定義。
開啟你的資料庫的交互命令界面(比如, psql 或mysql , 或者可以使用
manage.py dbshell )。 執行 ALTER TABLE 語句來添加新列。
使用Python的manage.py shell，通過導入模型和選中表單(例如，
MyModel.objects.all()[:5] )來驗證新的欄位是否被正確的添加 ,如果一切順利,所有的語句都不會報錯。
3
然後在你的產品伺服器上再實施一遍這些步驟。
啟動資料庫的交互界面。
5
執行在開發環境步驟中，第三步的ALTER TABLE語句。
將新的欄位加入到模型中。 如果你使用了某種版本控制工具，並且在第一步中，已經提交了你在開發環境上的修改，現在，可以在生產環境中更新你的代碼了（例如，如果你使用Subversion，執行svn update。
重新啟動Web server，使修改生效。
讓我們實踐下，比如添加一個num_pages欄位到第五章中Book模型。首先，我們會把開發環境中的模型改成如下形式：
class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()
**num_pages = models.IntegerField(blank=True, null=True)**
def __unicode__(self):
return self.title
② python 多對多關系怎麼賦值
#給多個變數賦值
data=['alex',84,[1900,3,38]]
name,age,birth=data
print(name)
print(age)
print(birth)
#
msg='hello'
a,b,c,d,e=msg
print(a,b,c,d,e)
msg='hello'
a,_,_,_,b=msg
print(a)
print(b)
#只給第一個和最後一個變數賦值
a,*_,b=msg
print(a,b)
③ python原生SQL多對多
Python由荷蘭數學和計算機科學研究學會的Guido van Rossum於1990 年代初設計，作為一門叫做ABC語言的替代品。 Python提供了高效的高級數據結構，還能簡單有效地面向對象編程。Python語法和動態類型，以及解釋型語言的本質，使它成為多數平台上寫腳本和快速開發應用的編程語言， 隨著版本的不斷更新和語言新功能的添加，逐漸被用於獨立的、大型項目的開發。
Python解釋器易於擴展，可以使用C或C++(或者其他可以通過C調用的語言)擴展新的功能和數據類型。 Python 也可用於可定製化軟體中的擴展程序語言。Python豐富的標准庫，提供了適用於各個主要系統平台的源碼或機器碼。
2021年10月，語言流行指數的編譯器Tiobe將Python加冕為最受歡迎的編程語言，20年來首次將其置於Java、C和JavaScript之上。
④ python 多對多匹配
ip.txt 跟 data.txt 的每一行都是單獨一個ip的話, 整個過程應該是很容易的, 而且不用正則那麼復雜啊, 只有10k跟3m行數據. 不知道你的慢是有多慢, 我自己本機上跑, 大概是0.4s內完成
ps, 你可以重寫一下save函數用來保存你的數據, 我這就是簡單的列印到標准輸出
#!/usr/bin/envpython
#-*-encoding:utf-8-*-
defsave(line):
print(line.rstrip())
deffun():
s=set()
[s.add(e)foreinopen('ip.txt')]
[save(e)foreinopen('data.txt')ifeins]
if__name__=='__main__':
fun()
⑤ 如何理解python的多線程編程
線程是程序員必須掌握的知識，多線程對於代碼的並發執行、提升代碼效率和運行都至關重要。今天就分享一個黑馬程序員Python多線程編程的教程，從0開始學習python多任務編程，想了解python高並發實現，從基礎到實踐，通過知識點 + 案例教學法幫助你想你想迅速掌握python多任務。
課程內容：
1.掌握多任務實現的並行和並發
2.掌握多進程實現多任務
3.掌握多線程實現多任務
4.掌握合理搭配多進程和線程
適用人群：
1、對python多任務編程感興趣的在校生及應屆畢業生。
2、對目前職業有進一步提升要求，希望從事python人工智慧行業高薪工作的在職人員。
3、對python人工智慧行業感興趣的相關人員。
基礎課程主講內容包括：
1.python多任務編程
基礎班課程大綱：
00-課程介紹
01-多任務介紹
02-進程介紹
03-使用多進程來完成多任務
04-多進程執行帶有參數的任務
05-獲取進程的編號
06-進程注意點
07-案例-多進程實現傳智視頻文件夾多任務拷貝器
08-線程介紹
09-使用多線程執行多任務
10-線程執行帶有參數的任務
11-主線程和子線程的結束順序
12-線程之間的執行順序是無序
13-線程和進程的對比
14-案例-多線程實現傳智視頻文件夾多任務拷貝器
15-課程總結
⑥ python 多線程
python支持多線程效果還不錯，很多方面都用到了python 多線程的知識，我前段時間用python 多線程寫了個處理生產者和消費者的問題，把代碼貼出來給你看下：
#encoding=utf-8
import threading
import random
import time
from Queue import Queue
class Procer(threading.Thread):
def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue
def run(self):
for i in range(20):
print self.getName(),'adding',i,'to queue'
self.sharedata.put(i)
time.sleep(random.randrange(10)/10.0)
print self.getName(),'Finished'
# Consumer thread
class Consumer(threading.Thread):
def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue
def run(self):
for i in range(20):
print self.getName(),'got a value:',self.sharedata.get()
time.sleep(random.randrange(10)/10.0)
print self.getName(),'Finished'
# Main thread
def main():
queue = Queue()
procer = Procer('Procer', queue)
consumer = Consumer('Consumer', queue)
print 'Starting threads ...'
procer.start()
consumer.start()
procer.join()
consumer.join()
print 'All threads have terminated.'
if __name__ == '__main__':
main()
如果你想要了解更多的python 多線程知識可以點下面的參考資料的地址，希望對有幫助！
⑦ python 多進程
基於官方文檔：
https://docs.python.org/zh-cn/3/library/multiprocessing.html
日樂購，剛才看到的一個博客，寫的都不太對，還是基於官方的比較穩妥
我就是喜歡抄官方的，哈哈
通常我們使用Process實例化一個進程，並調用 他的 start() 方法啟動它。
這種方法和 Thread 是一樣的。
上圖中，我寫了 p.join() 所以主進程是 等待 子進程執行完後，才執行 print("運行結束")
否則就是反過來了（這個不一定，看你的語句了，順序其實是隨機的）例如：
主進加個 sleep
所以不加join() ,其實子進程和主進程是各干各的，誰也不等誰。都執行完後，文件運行就結束了
上面我們用了 os.getpid() 和 os.getppid() 獲取 當前進程，和父進程的id
下面就講一下，這兩個函數的用法：
os.getpid()
返回當前進程的id
os.getppid()
返回父進程的id。 父進程退出後，unix 返回初始化進程（1）中的一個
windows返回相同的id (可能被其他進程使用了)
這也就解釋了，為啥我上面 的程序運行多次， 第一次列印的parentid 都是 14212 了。
而子進程的父級 process id 是調用他的那個進程的 id ： 1940
視頻筆記：
多進程：使用大致方法：
參考： 進程通信（pipe和queue）
pool.map （函數可以有return 也可以共享內存或queue） 結果直接是個列表
poll.apply_async() （同map,只不過是一個進程，返回結果用 xx.get() 獲得）
報錯：
參考 ： https://blog.csdn.net/xiemanR/article/details/71700531
把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。
結果：
這個肯定有解釋的
測試多進程計算效果：
進程池運行：
結果：
普通計算：
我們同樣傳入 1 2 10 三個參數測試：
其實對比下來開始快了一半的；
我們把循環里的數字去掉一個 0；
單進程：
多進程：
兩次測試 單進程/進程池 分別為 0.669 和 0.772 幾乎成正比的。
問題 二：
視圖：
post 視圖裡面
Music 類：
直接報錯：
寫在 類裡面也 在函數里用 self.pool 調用也不行，也是相同的錯誤。
最後 把 pool = Pool 直接寫在 search 函數裡面，奇跡出現了：
前台也能顯示搜索的音樂結果了
總結一點，進程這個東西，最好 寫在 直接運行的函數裡面，而不是 一個函數跳來跳去。因為最後可能 是在子進程的子進程運行的，這是不許的，會報錯。
還有一點，多進程運行的函數對象，不能是 lambda 函數。也許lambda 虛擬，在內存？？
使用 pool.map 子進程 函數報錯，導致整個 pool 掛了:
參考： https://blog.csdn.net/hedongho/article/details/79139606
主要你要，對函數內部捕獲錯誤，而不能讓異常拋出就可以了。
關於map 傳多個函數參數
我一開始，就是正常思維，多個參數，搞個元祖，讓參數一一對應不就行了：
報錯：
參考：
https://blog.csdn.net/qq_15969343/article/details/84672527
普通的 process 當讓可以穿多個參數，map 卻不知道咋傳的。
apply_async 和map 一樣，不知道咋傳的。
最簡單的方法：
使用 starmap 而不是 map
結果：
子進程結束
1.8399453163146973
成功拿到結果了
關於map 和 starmap 不同的地方看源碼：
關於apply_async() ,我沒找到多參數的方法，大不了用 一個迭代的 starmap 實現。哈哈
關於 上面源碼裡面有 itertools.starmap
itertools 用法參考：
https://docs.python.org/zh-cn/3/library/itertools.html#itertool-functions
有個問題，多進程最好不要使用全部的 cpu , 因為這樣可能影響其他任務，所以 在進程池 添加 process 參數 指定，cpu 個數：
上面就是預留了 一個cpu 干其他事的
後面直接使用 Queue 遇到這個問題：
解決：
Manager().Queue() 代替 Queue()
因為 queue.get() 是堵塞型的，所以可以提前判斷是不是 空的，以免堵塞進程。比如下面這樣：
使用 queue.empty() 空為True
⑧ python多線程對多核的利用
GIL 與 Python 線程的糾葛
GIL 是什麼東西？它對我們的 python 程序會產生什麼樣的影響？我們先來看一個問題。運行下面這段 python 程序，CPU 佔用率是多少？
# 請勿在工作中模仿，危險:)
def dead_loop():
while True:
pass
dead_loop()
答案是什麼呢，佔用 100％ CPU？那是單核！還得是沒有超線程的古董 CPU。在我的雙核 CPU 上，這個死循環只會吃掉我一個核的工作負荷，也就是只佔用 50％ CPU。那如何能讓它在雙核機器上佔用 100％ 的 CPU 呢？答案很容易想到，用兩個線程就行了，線程不正是並發分享 CPU 運算資源的嗎。可惜答案雖然對了，但做起來可沒那麼簡單。下面的程序在主線程之外又起了一個死循環的線程
import threading
def dead_loop():
while True:
pass
# 新起一個死循環線程
t = threading.Thread(target=dead_loop)
t.start()
# 主線程也進入死循環
dead_loop()
t.join()
按道理它應該能做到佔用兩個核的 CPU 資源，可是實際運行情況卻是沒有什麼改變，還是只佔了 50％ CPU 不到。這又是為什麼呢？難道 python 線程不是操作系統的原生線程？打開 system monitor 一探究竟，這個佔了 50% 的 python 進程確實是有兩個線程在跑。那這兩個死循環的線程為何不能占滿雙核 CPU 資源呢？其實幕後的黑手就是 GIL。
GIL 的迷思：痛並快樂著
GIL 的全稱為 Global Interpreter Lock ，意即全局解釋器鎖。在 Python 語言的主流實現 CPython 中，GIL 是一個貨真價實的全局線程鎖，在解釋器解釋執行任何 Python 代碼時，都需要先獲得這把鎖才行，在遇到 I/O 操作時會釋放這把鎖。如果是純計算的程序，沒有 I/O 操作，解釋器會每隔 100 次操作就釋放這把鎖，讓別的線程有機會執行（這個次數可以通過sys.setcheckinterval 來調整）。所以雖然 CPython 的線程庫直接封裝操作系統的原生線程，但 CPython 進程做為一個整體，同一時間只會有一個獲得了 GIL 的線程在跑，其它的線程都處於等待狀態等著 GIL 的釋放。這也就解釋了我們上面的實驗結果：雖然有兩個死循環的線程，而且有兩個物理 CPU 內核，但因為 GIL 的限制，兩個線程只是做著分時切換，總的 CPU 佔用率還略低於 50％。
看起來 python 很不給力啊。GIL 直接導致 CPython 不能利用物理多核的性能加速運算。那為什麼會有這樣的設計呢？我猜想應該還是歷史遺留問題。多核 CPU 在 1990 年代還屬於類科幻，Guido van Rossum 在創造 python 的時候，也想不到他的語言有一天會被用到很可能 1000＋ 個核的 CPU 上面，一個全局鎖搞定多線程安全在那個時代應該是最簡單經濟的設計了。簡單而又能滿足需求，那就是合適的設計（對設計來說，應該只有合適與否，而沒有好與不好）。怪只怪硬體的發展實在太快了，摩爾定律給軟體業的紅利這么快就要到頭了。短短 20 年不到，代碼工人就不能指望僅僅靠升級 CPU 就能讓老軟體跑的更快了。在多核時代，編程的免費午餐沒有了。如果程序不能用並發擠干每個核的運算性能，那就意謂著會被淘汰。對軟體如此，對語言也是一樣。那 Python 的對策呢？
Python 的應對很簡單，以不變應萬變。在最新的 python 3 中依然有 GIL。之所以不去掉，原因嘛，不外以下幾點：
欲練神功，揮刀自宮：
CPython 的 GIL 本意是用來保護所有全局的解釋器和環境狀態變數的。如果去掉 GIL，就需要多個更細粒度的鎖對解釋器的眾多全局狀態進行保護。或者採用 Lock-Free 演算法。無論哪一種，要做到多線程安全都會比單使用 GIL 一個鎖要難的多。而且改動的對象還是有 20 年歷史的 CPython 代碼樹，更不論有這么多第三方的擴展也在依賴 GIL。對 Python 社區來說，這不異於揮刀自宮，重新來過。
就算自宮，也未必成功：
有位牛人曾經做了一個驗證用的 CPython，將 GIL 去掉，加入了更多的細粒度鎖。但是經過實際的測試，對單線程程序來說，這個版本有很大的性能下降，只有在利用的物理 CPU 超過一定數目後，才會比 GIL 版本的性能好。這也難怪。單線程本來就不需要什麼鎖。單就鎖管理本身來說，鎖 GIL 這個粗粒度的鎖肯定比管理眾多細粒度的鎖要快的多。而現在絕大部分的 python 程序都是單線程的。再者，從需求來說，使用 python 絕不是因為看中它的運算性能。就算能利用多核，它的性能也不可能和 C/C++ 比肩。費了大力氣把 GIL 拿掉，反而讓大部分的程序都變慢了，這不是南轅北轍嗎。
難道 Python 這么優秀的語言真的僅僅因為改動困難和意義不大就放棄多核時代了嗎？其實，不做改動最最重要的原因還在於：不用自宮，也一樣能成功！
其它神功
那除了切掉 GIL 外，果然還有方法讓 Python 在多核時代活的滋潤？讓我們回到本文最初的那個問題：如何能讓這個死循環的 Python 腳本在雙核機器上佔用 100％ 的 CPU？其實最簡單的答案應該是：運行兩個 python 死循環的程序！也就是說，用兩個分別占滿一個 CPU 內核的 python 進程來做到。確實，多進程也是利用多個 CPU 的好方法。只是進程間內存地址空間獨立，互相協同通信要比多線程麻煩很多。有感於此，Python 在 2.6 里新引入了 multiprocessing這個多進程標准庫，讓多進程的 python 程序編寫簡化到類似多線程的程度，大大減輕了 GIL 帶來的不能利用多核的尷尬。
這還只是一個方法，如果不想用多進程這樣重量級的解決方案，還有個更徹底的方案，放棄 Python，改用 C/C++。當然，你也不用做的這么絕，只需要把關鍵部分用 C/C++ 寫成 Python 擴展，其它部分還是用 Python 來寫，讓 Python 的歸 Python，C 的歸 C。一般計算密集性的程序都會用 C 代碼編寫並通過擴展的方式集成到 Python 腳本里（如 NumPy 模塊）。在擴展里就完全可以用 C 創建原生線程，而且不用鎖 GIL，充分利用 CPU 的計算資源了。不過，寫 Python 擴展總是讓人覺得很復雜。好在 Python 還有另一種與 C 模塊進行互通的機制 : ctypes
利用 ctypes 繞過 GIL
ctypes 與 Python 擴展不同，它可以讓 Python 直接調用任意的 C 動態庫的導出函數。你所要做的只是用 ctypes 寫些 python 代碼即可。最酷的是，ctypes 會在調用 C 函數前釋放 GIL。所以，我們可以通過 ctypes 和 C 動態庫來讓 python 充分利用物理內核的計算能力。讓我們來實際驗證一下，這次我們用 C 寫一個死循環函數
extern"C"
{
void DeadLoop()
{
while (true);
}
}
用上面的 C 代碼編譯生成動態庫 libdead_loop.so （Windows 上是 dead_loop.dll）
，接著就要利用 ctypes 來在 python 里 load 這個動態庫，分別在主線程和新建線程里調用其中的 DeadLoop
from ctypes import *
from threading import Thread
lib = cdll.LoadLibrary("libdead_loop.so")
t = Thread(target=lib.DeadLoop)
t.start()
lib.DeadLoop()
這回再看看 system monitor，Python 解釋器進程有兩個線程在跑，而且雙核 CPU 全被占滿了，ctypes 確實很給力！需要提醒的是，GIL 是被 ctypes 在調用 C 函數前釋放的。但是 Python 解釋器還是會在執行任意一段 Python 代碼時鎖 GIL 的。如果你使用 Python 的代碼做為 C 函數的 callback，那麼只要 Python 的 callback 方法被執行時，GIL 還是會跳出來的。比如下面的例子：
extern"C"
{
typedef void Callback();
void Call(Callback* callback)
{
callback();
}
}
from ctypes import *
from threading import Thread
def dead_loop():
while True:
pass
lib = cdll.LoadLibrary("libcall.so")
Callback = CFUNCTYPE(None)
callback = Callback(dead_loop)
t = Thread(target=lib.Call, args=(callback,))
t.start()
lib.Call(callback)
注意這里與上個例子的不同之處，這次的死循環是發生在 Python 代碼里 (DeadLoop 函數) 而 C 代碼只是負責去調用這個 callback 而已。運行這個例子，你會發現 CPU 佔用率還是只有 50％ 不到。GIL 又起作用了。
其實，從上面的例子，我們還能看出 ctypes 的一個應用，那就是用 Python 寫自動化測試用例，通過 ctypes 直接調用 C 模塊的介面來對這個模塊進行黑盒測試，哪怕是有關該模塊 C 介面的多線程安全方面的測試，ctypes 也一樣能做到。
結語
雖然 CPython 的線程庫封裝了操作系統的原生線程，但卻因為 GIL 的存在導致多線程不能利用多個 CPU 內核的計算能力。好在現在 Python 有了易經筋（multiprocessing）, 吸星大法（C 語言擴展機制）和獨孤九劍（ctypes），足以應付多核時代的挑戰，GIL 切還是不切已經不重要了，不是嗎。
⑨ python特點和優點
python作為一門高級編程語言，它的誕生雖然很偶然，但是它得到程序員的喜愛卻是必然之路，Python入門簡單，相比於其他語言，初學者很容易入門。除此之外，Python還具有以下優點：
1. 簡單：Python奉行簡潔主義，易於讀寫，它使你能夠專注於解決問題而不是去搞明白語言本身。
2. 免費：Python是開源軟體。這意味著你不用花一分錢便能復制、閱讀、改動它，這也是Python越來越優秀的原因——它是由一群希望看到一個更加優秀的Python的人創造並經常改進著的。
3. 兼容性：Python兼容眾多平台，所以開發者不會遇到使用其他語言時常會遇到的困擾。
4. 面向對象：Python既支持面向過程，也支持面向對象編程。在面向過程編程中，程序員復用代碼，在面向對象編程中，使用基於數據和函數的對象。
5. 豐富的庫：Python標准庫確實很龐大。它可以幫助你處理各種工作，包括正則表達式、文檔生成、單元測試、線程、資料庫、網頁瀏覽器、CGI、FTP、電子郵件、XML、XML-RPC、HTML、WAV文件、密碼系統、GUI(圖形用戶界面)、Tk和其他與系統有關的操作。
6. 規范的代碼：Python採用強制縮進的方式使得代碼具有極佳的可讀性。
7. 可擴展性和可嵌入性。如果你需要你的一段關鍵代碼運行得更快或者希望某些演算法不公開，你可以把你的部分程序用C或C++編寫，然後在你的Python程序中使用它們。你可以把Python嵌入你的C/C++程序，從而向你的程序用戶提供腳本功能。