python編程csdn

1. 什麼是python編程

Python是一門新興的編程語言，編程語言有很多，比如C++、Java、C#、PHP、JavaScript等，Python也是其中之一，在學習Python前，我們需要對它有一定的了解。
Python支持多種編程范型，如函數式、指令式、結構化、面向對象和反射式編程。
Python解釋器易於擴展，可以使用C或C++或其他可以通過C調用的語言擴展新的功能和數據類型。
Python編寫的程序不需要編譯成二進制代碼，可以直接從源代碼運行程序，在計算機內部，Python解釋器把源代碼轉換成位元組碼的中間形式，然後再把它翻譯成計算機使用的機器語言並運行。
語法簡潔而清晰，具有豐富和強大的類庫，使用Python快速生成程序的原型，然後對其中有特別要求的部分，用更合適的語言改寫，性能要求特別高，就可以用C/C++重寫，而後封裝為Python可以調用的擴展類庫。
只有基礎建牢固了，才會更利於我們以後的發展及進步，現如今Python的發展十分迅速，已經將C++語言甩在了後邊，在不久的將來，可能會超過C和Java這些主流語言。

2. python編程例子有哪些

python編程經典例子：

1、畫愛心表白、圖形都是由一系列的點(X，Y)構成的曲線，由於X，Y滿足一定的關系，所以就可以建立模型，建立表達式expression，當滿足時，兩個for循環（for X in range；for Y in range）就會每行每列的列印。

(2)python編程csdn擴展閱讀：

Python的設計目標之一是讓代碼具備高度的可閱讀性。它設計時盡量使用其它語言經常使用的標點符號和英文單字，讓代碼看起來整潔美觀。它不像其他的靜態語言如C、Pascal那樣需要重復書寫聲明語句，也不像它們的語法那樣經常有特殊情況和意外。

Python開發者有意讓違反了縮進規則的程序不能通過編譯，以此來強制程序員養成良好的編程習慣。並且Python語言利用縮進表示語句塊的開始和退出，而非使用花括弧或者某種關鍵字。增加縮進表示語句塊的開始，而減少縮進則表示語句塊的退出，縮進成為了語法的一部分。

3. 編程語言python是用來干什麼的

python的作用：

1、系統編程：提供API(ApplicationProgramming

Interface應用程序編程介面)，能方便進行系統維護和管理，Linux下標志性語言之一，是很多系統管理員理想的編程工具。

2、圖形處理：有PIL、Tkinter等圖形庫支持，能方便進行圖形處理。

3、數學處理：NumPy擴展提供大量與許多標准數學庫的介面。

4、文本處理：python提供的re模塊能支持正則表達式，還提供SGML，XML分析模塊，許多程序員利用python進行XML程序的開發。

5、資料庫編程：程序員可通過遵循PythonDB-API(資料庫應用程序編程介面)規范的模塊與MicrosoftSQL Server，Oracle，Sybase，DB2，MySQL、SQLite等資料庫通信。python自帶有一個Gadfly模塊，提供了一個完整的SQL環境。

(3)python編程csdn擴展閱讀：

python中文就是蟒蛇的意思。在計算機中，它是一種編程語言。Python（英語發音：／ˈpaɪθən／），是一種面向對象、解釋型計算機程序設計語言，由GuidovanRossum於1989年底發明，第一個公開發行版發行於1991年。Python語法簡潔而清晰，具有豐富和強大的類庫。

它常被昵稱為膠水語言，它能夠把用其他語言製作的各種模塊（尤其是C／C＋＋）很輕松地聯結在一起。常見的一種應用情形是，使用Python快速生成程序的原型（有時甚至是程序的最終界面），然後對其中有特別要求的部分，用更合適的語言改寫。

比如3D游戲中的圖形渲染模塊，性能要求特別高，就可以用C++重寫。1發展歷程編輯自從20世紀90年代初Python語言誕生至今，它逐漸被廣泛應用於處理系統管理任務和Web編程。Python已經成為最受歡迎的程序設計語言之一。

4. 用Python如何編程

要它幹嘛？

5. 什麼是Python編程語言

優點：Python是一種代表簡單主義思想的語言，閱讀一個良好的Python程序就感覺像是在讀英語一樣，使你能夠專注於解決問題而不是去搞明白語言本身;
Python底層是用C語言編寫的，很多標准庫和第三方庫也都是用C寫的，運行速度非常快;
IPython
Notebook使我們更容易使用Python進行數據工作，可以輕松地與同時共享Notebook，無需他們安裝任何東西，大大減少組織代碼，輸出和注釋文件的開銷;
Python是一種通用語言，容易和直觀，在學習上會比較容易，可以加快你寫一個程序的快速，此外Python測試框架是一個內置的，可以保證你的代碼是可重復使用和可靠的;
Python還是一個多用途語言，把不同背景的人結合在一起，作為一種常見的、容易理解，大部分程序員都懂，可以很容易地和統計學家溝通，你可以使用一個簡單的工具就把你每一個工作夥伴整合起來。
由於它的開源本質，Python已經被移植在許多平台上，比如說：Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS等。
很多時候不能將程序連寫成一行，如import sys;for i in sys.path:print
i，而perl和awk就無此限制，可以較為方便的在shell下完成簡單程序，不需要如Python一樣，必須將程序寫入一個.py文件;
Python語法獨特，也許不應該被稱為局限，但是它用縮進來區分語句關系的方式還是給很多初學者帶來了困惑，即便是很有經驗的Python程序員，也可能陷入陷阱;
Python對比C、C++語言運行速度要慢一些。

6. 怎麼利用python爬取csdn博客訪問量例子

一、網址分析

進入自己的博客頁面，網址為：http://blog.csdn.net/xingjiarong 網址還是非常清晰的就是csdn的網址+個人csdn登錄賬號，我們來看一下下一頁的網址。

看到第二頁的地址為：http://blog.csdn.net/xingjiarong/article/list/2
後邊的數字表示現在正處於第幾頁，再用其他的頁面驗證一下，確實是這樣的，那麼第一頁為什麼不是http://blog.csdn.net
/xingjiarong/article/list/1呢，那麼我們在瀏覽器中輸入http://blog.csdn.net/xingjiarong
/article/list/1試試，哎，果然是第一頁啊，其實第一頁是被重定向了，http://blog.csdn.net/xingjiarong
被重定向到http://blog.csdn.net/xingjiarong/article/list/1，所以兩個網址都能訪問第一頁，那麼現在規
律就非常明顯了：
http://blog.csdn.net/xingjiarong/article/list/ + 頁號

二、如何獲取標題

右鍵查看網頁的源代碼，我們看到可以找到這樣一段代碼：

我們可以看到標題都是在標簽

<span class="link_title"><a href="/xingjiarong/article/details/50651235">

所以我們可以使用下面的正則表達式來匹配標題：

<span class="link_title"><a href=".*?">(.*?)</a></span>

三、如何獲取訪問量

拿到了標題之後，就要獲得對應的訪問量了，經過對源碼的分析，我看到訪問量的結構都是這樣的：

<span class="link_view" title="閱讀次數"> <a href="/xingjiarong/article/details/50651235" title="閱讀次數">閱讀</a>(1140)</span>

括弧中的數字即為訪問量，我們可以用下面的正則表達式來匹配：

<span class="link_view".*?><a href=".*?" title="閱讀次數">閱讀</a>\((.*?)\)</span>

四、如何判斷是否為尾頁

接下來我們要判斷當前頁是否為最後一頁，否則我們就不能判斷什麼時候結束了，我找到了源碼中『尾頁'的標簽，發現是下面的結構：

<a href="/xingjiarong/article/list/2">下一頁</a> <a href="/xingjiarong/article/list/7">尾頁</a>

所以我們可以用下面的正則表達式來匹配，如果匹配成功就說明當前頁不是最後一頁，否則當前頁就是最後一頁。

<a href=".*?">尾頁</a>

五、編程實現

下面是完整的代碼實現：

#!usr/bin/python
# -*- coding: utf-8 -*-
'''
Created on 2016年2月13日
@author: xingjiarong
使用python爬取csdn個人博客的訪問量，主要用來練手
'''
import urllib2
import re
#當前的博客列表頁號
page_num = 1
#不是最後列表的一頁
notLast = 1
account = str(raw_input('輸入csdn的登錄賬號:'))
while notLast:
#首頁地址
baseUrl = 'http://blog.csdn.net/'+account
#連接頁號，組成爬取的頁面網址
myUrl = baseUrl+'/article/list/'+str(page_num)
#偽裝成瀏覽器訪問，直接訪問的話csdn會拒絕
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
headers = {'User-Agent':user_agent}
#構造請求
req = urllib2.Request(myUrl,headers=headers)
#訪問頁面
myResponse = urllib2.urlopen(req)
myPage = myResponse.read()
#在頁面中查找是否存在『尾頁'這一個標簽來判斷是否為最後一頁
notLast = re.findall('<a href=".*?">尾頁</a>',myPage,re.S)
print '-----------------------------第%d頁---------------------------------' % (page_num,)
#利用正則表達式來獲取博客的標題
title = re.findall('<span class="link_title"><a href=".*?">(.*?)</a></span>',myPage,re.S)
titleList=[]
for items in title:
titleList.append(str(items).lstrip().rstrip())
#利用正則表達式獲取博客的訪問量
view = re.findall('<span class="link_view".*?><a href=".*?" title="閱讀次數">閱讀</a>\((.*?)\)</span>',myPage,re.S)
viewList=[]
for items in view:
viewList.append(str(items).lstrip().rstrip())
#將結果輸出
for n in range(len(titleList)):
print '訪問量:%s 標題:%s' % (viewList[n].zfill(4),titleList[n])
#頁號加1
page_num = page_num + 1

7. 看完python語法之後應該怎麼做 csdn

從開始看Python到現在也有半個多月了，前後看了Python核心編程和Dive into
Python兩本書。話說半個月看兩本，是個人都知道有多囫圇吞棗，這也是因為我暫時沒有需求拿這個做大型開發，主要是平時的小程序test用一用。所以

我的策略是，整體瀏覽，用到時候現查。話說這核心編程第一版太古老了，老在講2.2之前的東西，我看的翻譯電子版，翻譯得也不好，很晦澀。看完這個後還有
點雲里霧里，看網上人家說DIP好，啄木鳥還有免費電子文檔，就找來看這個。怎麼說呢，講的比核心編程好，但不適合第一次看的初學者。我之所以覺得講得
好，是因為看核心編程，有些概念還有些模糊，看了這本書就明白不少了。要是初學者上來就看這本，保證不好理解。

下面就是在學習的過程中，在翻閱資料的過程中，總結的一些C和python比較明顯的不同之處，有大方向的，也有細節的。肯定沒有總結完，比如動態

函數，lambda這些，我都懶得往上寫了。實際上，作為兩種完全不同的語言，下面這些差異只是冰山一角而已。權當拋磚引玉吧，至少應該對和我有相同研究

興趣，正在考慮是否學習另一門語言的朋友有點幫助。此文也算是DIP的學習筆記吧。順帶說一句，要是有朋友了解，可以幫忙推薦一下實戰性強的Python
教材，語言這東西，不多練手，光比劃，是不可能學好的。

學習目的

我的以後的研究方向是嵌入式，顯然，C語言是我的主要語言。我不是一個語言愛好者，我以前覺得，對於做研究而不是應用的人來說，了解多門語言，不如

精通一門語言。之所以去看python，主要還是因為python更有利於快速開發一些程序，也是因為現在認識到，研究和應用是不能分離的。個人以為，要
想在計算機工程的競爭中立足，必須懂C語言。因為真正要做高性能編程,
不可能將機器的體系架構拋到腦後讓Python虛擬機（或Java虛擬機等）幫你搞定所有底層。越來越多的CPU
core，越來越恐怖的內存性能瓶頸，對於上層開發人員來說，無所謂，但是對高性能程序開發人員來說，這些是無法透明的。很多應用，還是自己掌控比較有
效。這些場合中，匯編和C還是不可替代的。但是，光知道C是不夠的，掌握一門面向對象語言，相對更高層的語言，不僅對以後的個人發展有利，也會對自己的技
術認識產生幫助。

如果要問對我來說誰更重要，我覺得還是C更重要。C的學習曲線更陡，貌似簡單，實際上到處都是陷阱，看上去比較簡單低效的程序，也不是學1，2個月

就能搞定的。談到優化的深層次和難度嘛，需要的功底是按年算的。但是一旦你C語言的基礎打好了，對計算機的理解，對其他語言的理解都是大有裨益的。比如，

如果你有C基礎，可以說，學過1天python，就能寫的出來一些不短的程序。後面的優化也不是什麼大不了的演算法，都是非常基本的語句換來換去。當然這里
不是說 Python不好，實際上，上層應用，Python比C方便的不是一個層次。

很多人覺得，既然懂C了，那麼進一步掌握C＋＋應該是水到渠成，但C++不是C的超集，而我又不喜歡C＋＋的繁瑣和巨大，所以才決定看一看Python。我很喜歡Python的優雅與快捷。

語言類型

和C不一樣，Python是一種動態類型語言，又是強類型語言。這個分類怎麼理解呢？大概是可以按照下列說明來分類的：

靜態類型語言

一種在編譯期間就確定數據類型的語言。大多數靜態類型語言是通過要求在使用任一變數之前聲明其數據類型來保證這一點的。Java和 C 是靜態類型語言。

動態類型語言

一種在運行期間才去確定數據類型的語言，與靜態類型相反。Python 是動態類型的，因為它們確定一個變數的類型是在您第一次給它賦值的時候。

強類型語言

一種總是強制類型定義的語言。Java 和 Python 是強制類型定義的。您有一個整數，如果不明確地進行轉換 ，不能將把它當成一個字元串。

弱類型語言

一種類型可以被忽略的語言，與強類型相反。VBScript 是弱類型的。在 VBScript 中，您可以將字元串 『12′ 和整數 3 進行連接得到字元串』123′，然後可以把它看成整數 123 ，所有這些都不需要任何的顯示轉換。

對象機制

具體怎麼來理解這個「動態確定變數類型」，就要從Python的Object對象機制說起了。Objects（以下稱對象）是Python對於數據

的抽象，Python中所有的數據，都是由對象或者對象之間的關系表示的，函數是對象，字元串是對象，每個東西都是對象的概念。每一個對象都有三種屬性：

實體，類型和值。理解實體是理解對象中很重要的一步，實體一旦被創建，那麼就一直不會改變，也不會被顯式摧毀，同時通常意義來講，決定對象所支持的操作方

式的類型（type，包括number，string，tuple及其他）也不會改變，改變的只可能是它的值。如果要找一個具體點的說明，實體就相當於對

象在內存中的地址，是本質存在。而類型和值都只是實體的外在呈現。然後Python提供一些介面讓使用者和對象交互，比如id(）函數用來獲得對象實體的
整形表示（實際在這里就是地址），type()函數獲取其類型。

這個object機制，就是c所不具備的，主要體現在下面幾點：

1 剛才說了，c是一個靜態類型語言，我們可以定義int a, char
b等等，但必須是在源代碼裡面事先規定。比如我們可以在Python裡面任意一處直接規定a =
「lk」，這樣，a的類型就是string，這是在其賦值的時候才決定的，我們無須在代碼中明確寫出。而在C裡面，我們必須顯式規定char *a =
「lk」，也就是人工事先規定好a的類型

2 由於在C中，沒有對象這個概念，只有「數據的表示」，比如說，如果有兩個int變數a和b，我們想比較大小，可以用a ＝＝
b來判斷，但是如果是兩個字元串變數a和b，我們就不得不用strcmp來比較了，因為此時，a和b本質上是指向字元串的指針，如果直接還是用＝＝比較，
那比較的實際是指針中存儲的值——地址。

在Java中呢，我們通過使用 str1 == str2 可以確定兩個字元串變數是否指向同一塊物理內存位置，這叫做「對象同一性」。在 Java 中要比較兩個字元串值，你要使用 str1.equals(str2)。

然後在Python中，和前兩者都不一樣，由於對象的引入，我們可以用「is」這個運算符來比較兩個對象的實體，和具體對象的type就沒有關系
了，比如你的對象是tuple也好，string也好，甚至class也好，都可以用」is」來比較，本質上就是「對象同一性」的比較，和Java中
的＝＝類似，和 C中的pointer比較類似。Python中也有＝＝比較，這個就是值比較了。

3
由於對象機制的引入，讓Python的使用非常靈活，比如我們可以用自省方法來查看內存中以對象形式存在的其它模塊和函數，獲取它們的信息，並對它們進行
操作。用這種方法，你可以定義沒有名稱的函數，不按函數聲明的參數順序調用函數，甚至引用事先並不知道名稱的函數。 這些操作在C中都是不可想像的。

4 還有一個很有意思的細節，就是類型對對象行為的影響是各方面的，比如說，a = 1; b =
1這個語句中，在Python裡面引發的，可能是a，b同時指向一個值為1的對象，也可能是分別指向兩個值為1的對象。而例如這個語句，c = []; d
= []，那麼c和d是肯定指向不同的，新創建的空list的。沒完，如果是」c = d =
[]「這個語句呢？此時，c和d又指向了相同的list對象了。這些區別，都是在c中沒有的。

最後，我們來說說為什麼python慢。主要原因就是function call
overhead比較大。因為所有東西現在都是對象了，contruct 和destroy 花費也大。連1 + 1 都是 function
call，像』12′+』45′ 這樣的要 create a third string object, then calls the string
obj』s __add。可想而知，速度如何能快起來？

列表和數組

分析Python中的list和C中的數組總是很有趣的。相信可能一些朋友和一樣，初學列表的時候，都是把它當作是數組來學的。最初對於list和數組區別的定性，主要是集中在兩點。首先，list可以包含很多不同的數據類型，比如

["this", 1, "is", "an", "array"]

這個List，如果放在C中，其實是一個字元串數組，相當於二維的了。

其次呢，list有很多方法，其本身就是一個對象，這個和C的單純數組是不同的。對於List的操作很多樣，因為有方法也有重載的運算符。也帶來一些問題，比如下面這個例子：

加入我們要產生一個多維列表，用下面這個語句

A = [[None] * 2] * 3

結果，A的值會是

[[None, None], [None, None], [None, None]]

初一看沒問題，典型的二維數組形式的列表。好，現在我們想修改第一個None的值，用語句

A[0][0] = 5

現在我們再來看看A的值：

[[5, None], [5, None], [5, None]]

發現問題沒有？這是因為用 * 來復制時，只是創建了對這個對象的引用，而不是真正的創建了它。 *3 創建了一個包含三個引用的列表，這三個引用都指向同一個長度為2的列表。其中一個行的改變會顯示在所有行中，這當然不是你想要的。解決方法當然有，我們這樣來創建

A = [None]*3
for i in range(3):
A[i] = [None] * 2

這樣創建了一個包含三個不同的長度為2的列表。

所以，還是一直強調的，越復雜的東西，越靈活，也越容易出錯。

代碼優化

C是一個很簡單的語言，當我們考慮優化的時候，通常想得也很簡單，比如系統級調用越少越好（緩沖區機制），消除循環的低效率和不必要的系統引用，等
等，其實主要都是基於系統和硬體細節考慮的。而Python就完全不一樣了，當然上面說的這些優化形式，對於Python仍然是實用的，但由於
Python的語法形式千差萬別，庫和模塊多種多樣，所以對於語言本身而言，就有很多值得注意的優化要點，舉幾個例子吧。

比如我們有一個list L1，想要構建一個新的list L2，L2包括L1的頭4個元素。按照最直接的想法，代碼應該是

L2 = []
for i in range[3]:
L2.append(L1[i])

而更加優化和優美的版本是

L2 = L1[:3]

再比如，如果s1..s7是大字元串(10K+)，那麼join([s1,s2,s3,s4,s5,s6,s7])就會比
s1+s2+s3+s4+s5+s6+s7快得多,因為後者會計算很多次子表達式，而join()則在一次過程中完成所有的復制。還有，對於字元串操作，
對字元串對象使用replace()方法。僅當在沒有固定字元串模式時才使用正則表達式。

所以說，以優化為評判標准，如果說C是短小精悍，Python就是博大精深。

include和import

在C語言中的include非常簡單，因為形式單一，意義明確，當你需要用到外部函數等資源時，就用include。而Python中有一個相似的
機制，就是import。乍一看，這兩個傢伙挺像的，不都是我們要用外部資源（最常見的就是函數或者模塊（Python））時就用這個來指明么？其實不

然，兩者的處理機制本質區別在於，C中的include是用於告訴預處理器，這個include指定的文件的內容，你都給我當作在本地源文件中出現過。而

import呢，不是簡單的將後面的內容*直接*插入到本地裡面去，這玩意更加靈活。事實上，幾乎所有類似的機制，Python都比C靈活。這里不是說C
不好，C很簡練，我其實更喜歡C。

簡單說說這個靈活性。import在python中有三種形式，import X, from X import *( or a,b,c……),
X = __import__(』x')。最常用的是第二種，因為比較方便，不像第一種那樣老是用X.mole來調用模塊。from X
import *只是import那些public的mole(一般都是不以__命名的模塊)，也可以指定a,b,c來import。

什麼時候用哪一種形式呢？應該說，在大多數的模塊文檔里，都會明確告訴你應該用哪種形式。如果需要用到很多對象，那麼from X import
*可能更合適一些，但是，就目前來看，大多數第三方Python庫都不推薦使用from molename import *
這種格式。這樣做會使引入者的namespace混亂。很多人甚至對於那些專門設計用於這種模式的模塊（包括Tkinter,
threading和matplot）都不採用這種方式。而如果你僅僅需要某個對象類a，那麼用from X import a比用import
X.a更好，因為以後你調用a的函數直接用a.function()既可以了，不用加X。

如果你連自己希望import的模塊都不知道怎麼辦？請注意，此時Python的優勢就體現出來了，我們可以用
__import__(mole)來調用mole，其中這個mole是字元串，這樣，可以在運行時再決定，你到底要調用什麼mole。舉
個例子：

def classFromMole (mole, Name):
mod = __import__ (mole)
return getattr (mod, Name)

這里，定義了一個函數classFromMole，你可以在代碼的任何時候調用它，

o = classFromMole (MoleOfTheClass, NameOfTheAttribute)()

只需要傳入字元串形式的你希望import的模塊MoleOfTheClass和其中屬性的名字NameOfTheAttribute（當然可以是數據也可以是方法），就能調用了，這個名字字元串不用事先指定，而是根據當時運行的情況來判斷。

順帶說一句，Python中import的順序也有默認規定，這個和C中的include有點類似，因為我們一般都是先include系統文件，再
include自己的頭文件（而且還有>和「」的區別）。Python中呢，一般應該按照以下順序import模塊：

1. 標准庫模塊 — 如 sys, os, getopt 等

2. 第三方模塊

3. 本地實現的模塊。

全局變數

這里談全局變數呢，倒不是說Python和c的全局變數概念不同，他們的概念是相同的。只是在使用機制上，是有一些差異的。舉個例子：

– mole.py –
globalvar = 1

def func():
print globalvar
# This makes someglobal readonly,
# any attempt to write to someglobal
# would create a new local variable.

def func2():
global globalvar
globalvar = 2
# this allows you to manipulate the global
# variable

在 func這個函數中，globalvar是只讀的。如果你使用了globalvar =
xxx這種賦值語句，Python會重新創造一個新的本地對象並將新值賦給它，原來的對象值不變。而在func2函數中，由於我們事先申明了
globalvar是global的，那麼此時的更改就直接在全局變數上生效。