<em id="hh9r9"><nobr id="hh9r9"><nobr id="hh9r9"></nobr></nobr></em>

        <form id="hh9r9"><listing id="hh9r9"><meter id="hh9r9"></meter></listing></form>

                        <address id="hh9r9"></address>

                        葵花寶典教程,一個自學編程平臺

                        葵花寶典教程,一個自學編程平臺

                        Python - 異常處理

                        Python 提供了兩個非常重要的功能來處理 Python 程序中的任何意外錯誤并在其中添加調試功能 -


                        異常處理- 這將在本教程中介紹。這是 Python 中可用的標準異常列表:標準異常。


                        Assertions - 這將在 Python教程中的 Assertions 中介紹。


                        標準例外列表 -


                        編號 異常名稱和描述

                        1

                        例外


                        所有異常的基類


                        2

                        停止迭代


                        當迭代器的 next() 方法不指向任何對象時引發。


                        3

                        系統退出


                        由 sys.exit() 函數引發。


                        4

                        標準錯誤


                        除 StopIteration 和 SystemExit 之外的所有內置異常的基類。


                        5

                        算術錯誤


                        數值計算發生的所有錯誤的基類。


                        6

                        溢出錯誤


                        當計算超出數值類型的最大限制時引發。


                        7

                        浮點錯誤


                        當浮點計算失敗時引發。


                        8

                        零除法錯誤


                        當所有數字類型發生除零或模零時引發。


                        9

                        斷言錯誤


                        在 Assert 語句失敗的情況下引發。


                        10

                        屬性錯誤


                        在屬性引用或分配失敗的情況下引發。


                        11

                        EOF錯誤


                        當 raw_input() 或 input() 函數沒有輸入并且到達文件末尾時引發。


                        12

                        導入錯誤


                        當導入語句失敗時引發。


                        13

                        鍵盤中斷


                        當用戶中斷程序執行時引發,通常通過按 Ctrl+c。


                        14

                        查找錯誤


                        所有查找錯誤的基類。


                        15

                        索引錯誤


                        在序列中未找到索引時引發。


                        16

                        鍵錯誤


                        當在字典中找不到指定的鍵時引發。


                        17

                        名稱錯誤


                        在本地或全局命名空間中找不到標識符時引發。


                        18

                        UnboundLocalError


                        嘗試訪問函數或方法中的局部變量但未為其分配值時引發。


                        19

                        環境錯誤


                        在 Python 環境之外發生的所有異常的基類。


                        20

                        IO錯誤


                        當輸入/輸出操作失敗時引發,例如嘗試打開不存在的文件時的 print 語句或 open() 函數。


                        21

                        IO錯誤


                        針對與操作系統相關的錯誤引發。


                        22

                        語法錯誤


                        當 Python 語法出現錯誤時引發。


                        23

                        縮進錯誤


                        未正確指定縮進時引發。


                        24

                        系統錯誤


                        當解釋器發現內部問題時引發,但遇到此錯誤時 Python 解釋器不會退出。


                        25

                        系統退出


                        當使用 sys.exit() 函數退出 Python 解釋器時引發。如果未在代碼中處理,則導致解釋器退出。


                        26

                        類型錯誤


                        當嘗試對指定數據類型無效的操作或函數時引發。


                        27

                        值錯誤


                        當數據類型的內置函數具有有效的參數類型,但參數指定的值無效時引發。


                        28

                        運行時錯誤


                        當生成的錯誤不屬于任何類別時引發。


                        29

                        未實現錯誤


                        當需要在繼承的類中實現的抽象方法沒有實際實現時引發。


                        Python 中的斷言

                        斷言是一種健全性檢查,您可以在完成程序測試后打開或關閉它。


                        考慮斷言的最簡單方法是將其比作raise-if語句(或者更準確地說,是 raise-if-not 語句)。測試表達式,如果結果為假,則引發異常。


                        斷言由 assert 語句執行,它是 Python 的最新關鍵字,在 1.5 版中引入。


                        程序員經常在函數開頭放置斷言以檢查有效輸入,并在函數調用之后檢查有效輸出。


                        斷言聲明_

                        當遇到斷言語句時,Python 會計算伴隨的表達式,希望這是真的。如果表達式為假,Python 會引發AssertionError異常。


                        斷言的語法是 -


                        assert Expression[, Arguments]

                        如果斷言失敗,Python 使用 ArgumentExpression 作為 AssertionError 的參數。AssertionError 異??梢韵袷褂?try-except 語句的任何其他異常一樣被捕獲和處理,但如果不處理,它們將終止程序并產生回溯。


                        例子

                        這是一個將溫度從開爾文度轉換為華氏度的函數。由于開氏零度的溫度非常低,因此如果它看到負溫度,該功能就會退出 -


                        現場演示

                        #!/usr/bin/python

                        def KelvinToFahrenheit(Temperature):

                           assert (Temperature >= 0),"Colder than absolute zero!"

                           return ((Temperature-273)*1.8)+32

                        print KelvinToFahrenheit(273)

                        print int(KelvinToFahrenheit(505.78))

                        print KelvinToFahrenheit(-5)

                        執行上述代碼時,會產生以下結果 -


                        32.0

                        451

                        Traceback (most recent call last):

                        File "test.py", line 9, in <module>

                        print KelvinToFahrenheit(-5)

                        File "test.py", line 4, in KelvinToFahrenheit

                        assert (Temperature >= 0),"Colder than absolute zero!"

                        AssertionError: Colder than absolute zero!

                        什么是異常?

                        異常是在程序執行期間發生的事件,它破壞了程序指令的正常流程。通常,當 Python 腳本遇到無法應對的情況時,它會引發異常。異常是表示錯誤的 Python 對象。


                        當 Python 腳本引發異常時,它必須立即處理異常,否則它會終止并退出。


                        處理異常

                        如果您有一些可能引發異常的可疑代碼,您可以通過將可疑代碼放在try:塊中來保護您的程序。在 try: 塊之后,包含一個except:語句,然后是一個盡可能優雅地處理問題的代碼塊。


                        句法

                        這是try....except...else塊的簡單語法 -


                        try:

                           You do your operations here;

                           ......................

                        except ExceptionI:

                           If there is ExceptionI, then execute this block.

                        except ExceptionII:

                           If there is ExceptionII, then execute this block.

                           ......................

                        else:

                           If there is no exception then execute this block. 

                        以下是關于上述語法的幾個要點 -


                        一個 try 語句可以有多個 except 語句。當 try 塊包含可能引發不同類型異常的語句時,這很有用。


                        您還可以提供一個通用的 except 子句,它處理任何異常。


                        在 except 子句之后,您可以包含一個 else 子句。如果 try: 塊中的代碼沒有引發異常,則執行 else 塊中的代碼。


                        else 塊是不需要 try: 塊保護的代碼的好地方。


                        例子

                        這個例子打開一個文件,在文件中寫入內容并優雅地出來,因為根本沒有問題 -


                        現場演示

                        #!/usr/bin/python


                        try:

                           fh = open("testfile", "w")

                           fh.write("This is my test file for exception handling!!")

                        except IOError:

                           print "Error: can\'t find file or read data"

                        else:

                           print "Written content in the file successfully"

                           fh.close()

                        這會產生以下結果 -


                        Written content in the file successfully

                        例子

                        此示例嘗試打開您沒有寫入權限的文件,因此會引發異常 -


                        現場演示

                        #!/usr/bin/python


                        try:

                           fh = open("testfile", "r")

                           fh.write("This is my test file for exception handling!!")

                        except IOError:

                           print "Error: can\'t find file or read data"

                        else:

                           print "Written content in the file successfully"

                        這會產生以下結果 -


                        Error: can't find file or read data

                        無例外的except子句

                        您還可以使用 except 語句,沒有異常定義如下 -


                        try:

                           You do your operations here;

                           ......................

                        except:

                           If there is any exception, then execute this block.

                           ......................

                        else:

                           If there is no exception then execute this block. 

                        這種try-except語句會捕獲所有發生的異常。但是,使用這種 try-except 語句并不被認為是一種好的編程習慣,因為它會捕獲所有異常,但不會使程序員確定可能發生的問題的根本原因。


                        帶有多個例外的except子句

                        您還可以使用相同的except語句來處理多個異常,如下所示 -


                        try:

                           You do your operations here;

                           ......................

                        except(Exception1[, Exception2[,...ExceptionN]]]):

                           If there is any exception from the given exception list, 

                           then execute this block.

                           ......................

                        else:

                           If there is no exception then execute this block. 

                        try-finally 子句

                        您可以使用finally:塊和try:塊。finally 塊是放置任何必須執行的代碼的地方,無論 try 塊是否引發異常。try-finally 語句的語法是這樣的 -


                        try:

                           You do your operations here;

                           ......................

                           Due to any exception, this may be skipped.

                        finally:

                           This would always be executed.

                           ......................

                        您不能同時使用else子句和 finally 子句。


                        例子

                        現場演示

                        #!/usr/bin/python


                        try:

                           fh = open("testfile", "w")

                           fh.write("This is my test file for exception handling!!")

                        finally:

                           print "Error: can\'t find file or read data"

                        如果您無權以寫入模式打開文件,則會產生以下結果 -


                        Error: can't find file or read data

                        同樣的例子可以寫得更清楚如下 -


                        現場演示

                        #!/usr/bin/python


                        try:

                           fh = open("testfile", "w")

                           try:

                              fh.write("This is my test file for exception handling!!")

                           finally:

                              print "Going to close the file"

                              fh.close()

                        except IOError:

                           print "Error: can\'t find file or read data"

                        當try塊中拋出異常時,執行立即轉到finally塊。在finally塊中的所有語句都執行完之后,再次引發異常,如果出現在try-except語句的下一個更高層中,則在except語句中處理。


                        異常論證

                        異??梢杂幸粋€參數,它是一個提供有關問題的附加信息的值。參數的內容因例外而異。您可以通過在 except 子句中提供一個變量來捕獲異常的參數,如下所示 -


                        try:

                           You do your operations here;

                           ......................

                        except ExceptionType, Argument:

                           You can print value of Argument here...

                        如果您編寫代碼來處理單個異常,則可以在 except 語句中的異常名稱后面添加一個變量。如果要捕獲多個異常,則可以在異常的元組后面添加一個變量。


                        這個變量接收異常的值,主要包含異常的原因。變量可以接收單個值或元組形式的多個值。該元組通常包含錯誤字符串、錯誤編號和錯誤位置。


                        例子

                        以下是單個異常的示例 -


                        現場演示

                        #!/usr/bin/python


                        # Define a function here.

                        def temp_convert(var):

                           try:

                              return int(var)

                           except ValueError, Argument:

                              print "The argument does not contain numbers\n", Argument


                        # Call above function here.

                        temp_convert("xyz");

                        這會產生以下結果 -


                        The argument does not contain numbers

                        invalid literal for int() with base 10: 'xyz'

                        引發異常

                        您可以使用 raise 語句以多種方式引發異常。raise語句的一般語法如下。


                        句法

                        raise [Exception [, args [, traceback]]]

                        這里,Exception是異常的類型(例如 NameError),argument是異常參數的值。參數是可選的;如果未提供,則異常參數為無。


                        最后一個參數 traceback 也是可選的(在實踐中很少使用),如果存在,它是用于異常的 traceback 對象。


                        例子

                        異??梢允亲址?、類或對象。Python 核心引發的大多數異常都是類,其參數是類的實例。定義新的異常非常容易,可以按如下方式完成 -


                        def functionName( level ):

                           if level < 1:

                              raise "Invalid level!", level

                              # The code below to this would not be executed

                              # if we raise the exception

                        注意:為了捕獲異常,“except”子句必須引用類對象或簡單字符串引發的相同異常。例如,要捕獲上述異常,我們必須編寫 except 子句如下 -


                        try:

                           Business Logic here...

                        except "Invalid level!":

                           Exception handling here...

                        else:

                           Rest of the code here...

                        用戶定義的異常

                        Python 還允許您通過從標準內置異常派生類來創建自己的異常。


                        這是一個與RuntimeError相關的示例。在這里,創建了一個從RuntimeError子類化的類。當您需要在捕獲異常時顯示更具體的信息時,這很有用。


                        在 try 塊中,引發用戶定義的異常并在 except 塊中捕獲。變量 e 用于創建類Networkerror的實例。


                        class Networkerror(RuntimeError):

                           def __init__(self, arg):

                              self.args = arg

                        所以一旦你定義了上面的類,你可以引發如下異常 -


                        try:

                           raise Networkerror("Bad hostname")

                        except Networkerror,e:

                           print e.args


                        Python - 文件 I/O

                        本章涵蓋了 Python 中可用的所有基本 I/O 函數。更多功能請參考標準 Python 文檔。


                        打印到屏幕

                        產生輸出的最簡單方法是使用print語句,您可以在其中傳遞零個或多個用逗號分隔的表達式。此函數將您傳遞的表達式轉換為字符串并將結果寫入標準輸出,如下所示 -


                        現場演示

                        #!/usr/bin/python


                        print "Python is really a great language,", "isn't it?"

                        這會在您的標準屏幕上產生以下結果 -


                        Python is really a great language, isn't it?

                        閱讀鍵盤輸入

                        Python 提供了兩個內置函數來從標準輸入中讀取一行文本,默認情況下來自鍵盤。這些功能是 -


                        原始輸入

                        輸入

                        raw_input函數_

                        raw_input([prompt])函數從標準輸入中讀取一行并將其作為字符串返回(刪除尾隨的換行符)。


                        #!/usr/bin/python


                        str = raw_input("Enter your input: ")

                        print "Received input is : ", str

                        這會提示您輸入任何字符串,它會在屏幕上顯示相同的字符串。當我輸入“Hello Python!”時,它的輸出是這樣的 -


                        Enter your input: Hello Python

                        Received input is :  Hello Python

                        輸入函數_

                        input ( [prompt])函數等效于 raw_input,除了它假定輸入是有效的 Python 表達式并將計算結果返回給您。


                        #!/usr/bin/python


                        str = input("Enter your input: ")

                        print "Received input is : ", str

                        這將針對輸入的輸入產生以下結果 -


                        Enter your input: [x*5 for x in range(2,10,2)]

                        Recieved input is :  [10, 20, 30, 40]

                        打開和關閉文件

                        到現在為止,您一直在讀寫標準輸入和輸出?,F在,我們將看到如何使用實際的數據文件。


                        默認情況下,Python 提供了操作文件所需的基本函數和方法。您可以使用文件對象進行大部分文件操作。


                        開放功能_

                        在您可以讀取或寫入文件之前,您必須使用 Python 的內置open()函數打開它。此函數創建一個文件對象,該對象將用于調用與其關聯的其他支持方法。


                        句法

                        file object = open(file_name [, access_mode][, buffering])

                        以下是參數詳細信息 -


                        file_name - file_name 參數是一個字符串值,其中包含您要訪問的文件的名稱。


                        access_mode - access_mode 確定必須打開文件的模式,即讀取、寫入、追加等。下表中給出了可能值的完整列表。這是可選參數,默認文件訪問模式為讀取 (r)。


                        buffering - 如果緩沖值設置為 0,則不會發生緩沖。如果緩沖值為 1,則在訪問文件時執行行緩沖。如果將緩沖值指定為大于 1 的整數,則使用指示的緩沖區大小執行緩沖操作。如果為負,則緩沖區大小為系統默認值(默認行為)。


                        以下是打開文件的不同模式的列表 -


                        編號 模式和說明

                        1

                        r


                        打開一個只讀文件。文件指針位于文件的開頭。這是默認模式。


                        2

                        rb


                        以二進制格式打開一個只讀文件。文件指針位于文件的開頭。這是默認模式。


                        3

                        r+


                        打開一個文件進行讀寫。放置在文件開頭的文件指針。


                        4

                        rb+


                        以二進制格式打開一個文件進行讀寫。放置在文件開頭的文件指針。


                        5

                        w


                        打開一個僅用于寫入的文件。如果文件存在,則覆蓋文件。如果文件不存在,則創建一個新文件進行寫入。


                        6

                        wb


                        打開一個僅以二進制格式寫入的文件。如果文件存在,則覆蓋文件。如果文件不存在,則創建一個新文件進行寫入。


                        7

                        w+


                        打開一個文件進行寫入和讀取。如果文件存在,則覆蓋現有文件。如果文件不存在,則創建一個新文件進行讀寫。


                        8

                        wb+


                        打開一個文件以二進制格式寫入和讀取。如果文件存在,則覆蓋現有文件。如果文件不存在,則創建一個新文件進行讀寫。


                        9

                        一種


                        打開要追加的文件。如果文件存在,則文件指針位于文件末尾。也就是說,文件處于附加模式。如果文件不存在,它會創建一個新文件進行寫入。


                        10

                        抗體


                        打開一個文件以二進制格式追加。如果文件存在,則文件指針位于文件末尾。也就是說,文件處于附加模式。如果文件不存在,它會創建一個新文件進行寫入。


                        11

                        一個+


                        打開一個文件以進行追加和讀取。如果文件存在,則文件指針位于文件末尾。該文件以附加模式打開。如果該文件不存在,則創建一個新文件進行讀寫。


                        12

                        ab+


                        以二進制格式打開一個文件以進行追加和讀取。如果文件存在,則文件指針位于文件末尾。該文件以附加模式打開。如果該文件不存在,則創建一個新文件進行讀寫。


                        文件對象屬性

                        一旦打開一個文件并且您擁有一個文件對象,您就可以獲得與該文件相關的各種信息。


                        這是與文件對象相關的所有屬性的列表 -


                        編號 屬性和描述

                        1

                        文件關閉


                        如果文件已關閉,則返回 true,否則返回 false。


                        2

                        文件模式


                        返回打開文件的訪問模式。


                        3

                        文件名


                        返回文件的名稱。


                        4

                        文件.softspace


                        如果 print 明確需要空間,則返回 false,否則返回 true。


                        例子

                        現場演示

                        #!/usr/bin/python


                        # Open a file

                        fo = open("foo.txt", "wb")

                        print "Name of the file: ", fo.name

                        print "Closed or not : ", fo.closed

                        print "Opening mode : ", fo.mode

                        print "Softspace flag : ", fo.softspace

                        這會產生以下結果 -


                        Name of the file:  foo.txt

                        Closed or not :  False

                        Opening mode :  wb

                        Softspace flag :  0

                        close( )方法

                        文件對象的 close() 方法會刷新所有未寫入的信息并關閉文件對象,之后就不能再進行寫入了。


                        當一個文件的引用對象被重新分配給另一個文件時,Python 會自動關閉一個文件。使用 close() 方法關閉文件是一個好習慣。


                        句法

                        fileObject.close()

                        例子

                        現場演示

                        #!/usr/bin/python


                        # Open a file

                        fo = open("foo.txt", "wb")

                        print "Name of the file: ", fo.name


                        # Close opend file

                        fo.close()

                        這會產生以下結果 -


                        Name of the file:  foo.txt

                        讀取和寫入文件

                        文件對象提供了一組訪問方法,使我們的生活更輕松。我們將看到如何使用read()和write()方法來讀取和寫入文件。


                        write( )方法

                        write()方法將任何字符串寫入打開的文件。重要的是要注意 Python 字符串可以包含二進制數據而不僅僅是文本。


                        write() 方法不會在字符串末尾添加換行符 ('\n') -


                        句法

                        fileObject.write(string)

                        這里,傳遞的參數是要寫入打開文件的內容。


                        例子

                        #!/usr/bin/python


                        # Open a file

                        fo = open("foo.txt", "wb")

                        fo.write( "Python is a great language.\nYeah its great!!\n")


                        # Close opend file

                        fo.close()

                        上述方法將創建foo.txt文件并將給定的內容寫入該文件,最后關閉該文件。如果你打開這個文件,它會有以下內容。


                        Python is a great language.

                        Yeah its great!!

                        read( )方法

                        read()方法從打開的文件中讀取字符串。重要的是要注意 Python 字符串可以包含二進制數據。除了文本數據。


                        句法

                        fileObject.read([count])

                        這里,傳遞的參數是要從打開的文件中讀取的字節數。此方法從文件開頭開始讀取,如果缺少計數,則嘗試盡可能多地讀取,可能直到文件末尾。


                        例子

                        讓我們使用我們在上面創建的文件foo.txt。


                        #!/usr/bin/python


                        # Open a file

                        fo = open("foo.txt", "r+")

                        str = fo.read(10);

                        print "Read String is : ", str

                        # Close opend file

                        fo.close()

                        這會產生以下結果 -


                        Read String is :  Python is

                        文件位置

                        tell()方法告訴您文件中的當前位置;換句話說,下一次讀取或寫入將發生在文件開頭的那么多字節處。


                        seek(offset[, from])方法改變當前文件位置。offset參數表示要移動的字節數。from參數指定要移動字節的參考位置。


                        如果from設置為0,表示以文件開頭為參考位置,1表示以當前位置為參考位置,如果設置為2,則以文件結尾為參考位置.


                        例子

                        讓我們獲取我們在上面創建的文件foo.txt。


                        #!/usr/bin/python


                        # Open a file

                        fo = open("foo.txt", "r+")

                        str = fo.read(10)

                        print "Read String is : ", str


                        # Check current position

                        position = fo.tell()

                        print "Current file position : ", position


                        # Reposition pointer at the beginning once again

                        position = fo.seek(0, 0);

                        str = fo.read(10)

                        print "Again read String is : ", str

                        # Close opend file

                        fo.close()

                        這會產生以下結果 -


                        Read String is :  Python is

                        Current file position :  10

                        Again read String is :  Python is

                        重命名和刪除文件

                        Python os模塊提供了幫助您執行文件處理操作的方法,例如重命名和刪除文件。


                        要使用此模塊,您需要先導入它,然后才能調用任何相關函數。


                        rename() 方法

                        rename()方法有兩個參數,當前文件名和新文件名。


                        句法

                        os.rename(current_file_name, new_file_name)

                        例子

                        以下是重命名現有文件test1.txt的示例-


                        #!/usr/bin/python

                        import os


                        # Rename a file from test1.txt to test2.txt

                        os.rename( "test1.txt", "test2.txt" )

                        remove( )方法

                        您可以使用remove()方法通過提供要刪除的文件的名稱作為參數來刪除文件。


                        句法

                        os.remove(file_name)

                        例子

                        以下是刪除現有文件test2.txt的示例-


                        #!/usr/bin/python

                        import os


                        # Delete file test2.txt

                        os.remove("text2.txt")

                        Python中的目錄

                        所有文件都包含在不同的目錄中,Python 處理這些也沒有問題。os模塊有幾種方法可以幫助您創建、刪除和更改目錄。


                        mkdir( )方法

                        您可以使用os模塊的mkdir()方法在當前目錄中創建目錄。您需要為此方法提供一個參數,其中包含要創建的目錄的名稱。


                        句法

                        os.mkdir("newdir")

                        例子

                        以下是在當前目錄中創建目錄test的示例 -


                        #!/usr/bin/python

                        import os


                        # Create a directory "test"

                        os.mkdir("test")

                        chdir( )方法

                        您可以使用chdir()方法更改當前目錄。chdir() 方法接受一個參數,它是您想要創建當前目錄的目錄的名稱。


                        句法

                        os.chdir("newdir")

                        例子

                        以下是進入“/home/newdir”目錄的示例 -


                        #!/usr/bin/python

                        import os


                        # Changing a directory to "/home/newdir"

                        os.chdir("/home/newdir")

                        getcwd( )方法

                        getcwd()方法顯示當前工作目錄。


                        句法

                        os.getcwd()

                        例子

                        以下是給出當前目錄的示例 -


                        #!/usr/bin/python

                        import os


                        # This would give location of the current directory

                        os.getcwd()

                        rmdir( )方法

                        rmdir()方法刪除目錄,該目錄作為方法中的參數傳遞。


                        在刪除目錄之前,應該刪除其中的所有內容。


                        句法

                        os.rmdir('dirname')

                        例子

                        以下是刪除“/tmp/test”目錄的示例。需要提供目錄的完全限定名稱,否則它將在當前目錄中搜索該目錄。


                        #!/usr/bin/python

                        import os


                        # This would  remove "/tmp/test"  directory.

                        os.rmdir( "/tmp/test"  )

                        文件和目錄相關方法

                        有三個重要的來源,它們提供了廣泛的實用方法來處理和操作 Windows 和 Unix 操作系統上的文件和目錄。它們如下 -


                        文件對象方法:文件對象提供操作文件的功能。


                        操作系統對象方法:這提供了處理文件和目錄的方法。


                        Python - 模塊

                        模塊允許您從邏輯上組織您的 Python 代碼。將相關代碼分組到一個模塊中,使代碼更易于理解和使用。模塊是一個 Python 對象,具有可以綁定和引用的任意命名屬性。


                        簡單地說,模塊是由 Python 代碼組成的文件。一個模塊可以定義函數、類和變量。模塊還可以包含可運行代碼。


                        例子

                        名為aname的模塊的 Python 代碼通常位于名為aname.py的文件中。這是一個簡單模塊的示例,support.py


                        def print_func( par ):

                           print "Hello : ", par

                           return

                        進口聲明_

                        通過在其他 Python 源文件中執行 import 語句,您可以將任何 Python 源文件用作模塊。導入具有以下語法 -


                        import module1[, module2[,... moduleN]

                        當解釋器遇到 import 語句時,如果模塊存在于搜索路徑中,它會導入該模塊。搜索路徑是解釋器在導入模塊之前搜索的目錄列表。例如,要導入模塊 support.py,您需要將以下命令放在腳本頂部 -


                        #!/usr/bin/python


                        # Import module support

                        import support


                        # Now you can call defined function that module as follows

                        support.print_func("Zara")

                        執行上述代碼時,會產生以下結果 -


                        Hello : Zara

                        一個模塊只加載一次,不管它被導入多少次。如果發生多個導入,這可以防止模塊執行一遍又一遍地發生。


                        from ...import語句

                        Python 的from語句允許您將模塊中的特定屬性導入當前命名空間。from...import具有以下語法 -


                        from modname import name1[, name2[, ... nameN]]

                        例如,要從模塊 fib 導入函數 fibonacci,請使用以下語句 -


                        from fib import fibonacci

                        該語句不會將整個模塊 fib 導入當前命名空間;它只是將模塊 fib 中的項 fibonacci 引入到導入模塊的全局符號表中。


                        from ...import *語句

                        也可以使用以下導入語句將模塊中的所有名稱導入當前命名空間 -


                        from modname import *

                        這提供了一種將模塊中的所有項目導入當前命名空間的簡單方法;但是,應謹慎使用此語句。


                        定位模塊

                        導入模塊時,Python 解釋器按以下順序搜索模塊 -


                        當前目錄。


                        如果未找到該模塊,Python 將搜索 shell 變量 PYTHONPATH 中的每個目錄。


                        如果一切都失敗了,Python 會檢查默認路徑。在 UNIX 上,此默認路徑通常是 /usr/local/lib/python/。


                        模塊搜索路徑作為sys.path變量存儲在系統模塊 sys 中。sys.path 變量包含當前目錄、PYTHONPATH 和依賴于安裝的默認值。


                        PYTHONPATH變量_

                        PYTHONPATH 是一個環境變量,由目錄列表組成。PYTHONPATH 的語法與 shell 變量 PATH 的語法相同。


                        這是來自 Windows 系統的典型 PYTHONPATH -


                        set PYTHONPATH = c:\python20\lib;

                        這是來自 UNIX 系統的典型 PYTHONPATH -


                        set PYTHONPATH = /usr/local/lib/python

                        命名空間和作用域

                        變量是映射到對象的名稱(標識符)。命名空間是變量名稱(鍵)及其對應對象(值)的字典。


                        Python 語句可以訪問本地命名空間和全局命名空間中的變量。如果局部變量和全局變量具有相同的名稱,則局部變量會隱藏全局變量。


                        每個函數都有自己的本地命名空間。類方法遵循與普通函數相同的范圍規則。


                        Python 對變量是局部變量還是全局變量進行有根據的猜測。它假定在函數中賦值的任何變量都是局部的。


                        因此,為了給函數內的全局變量賦值,必須首先使用 global 語句。


                        語句global VarName告訴 Python VarName 是一個全局變量。Python 停止在本地命名空間中搜索該變量。


                        例如,我們在全局命名空間中定義了一個變量Money。在函數Money中,我們為Money賦值,因此 Python 將Money假定為局部變量。但是,我們在設置之前訪問了局部變量Money的值,所以結果是 UnboundLocalError。取消注釋全局語句可以解決問題。


                        #!/usr/bin/python


                        Money = 2000

                        def AddMoney():

                           # Uncomment the following line to fix the code:

                           # global Money

                           Money = Money + 1


                        print Money

                        AddMoney()

                        print Money

                        dir() 函數

                        dir() 內置函數返回一個排序的字符串列表,其中包含模塊定義的名稱。


                        該列表包含在模塊中定義的所有模塊、變量和函數的名稱。以下是一個簡單的例子 -


                        現場演示

                        #!/usr/bin/python


                        # Import built-in module math

                        import math


                        content = dir(math)

                        print content

                        執行上述代碼時,會產生以下結果 -


                        ['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 

                        'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 

                        'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',

                        'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 

                        'sqrt', 'tan', 'tanh']

                        這里,特殊的字符串變量__name__是模塊的名稱,而 __file__是加載模塊的文件名。


                        globals()和locals ()函數

                        globals()和locals()函數可用于返回全局和本地命名空間中的名稱,具體取決于調用它們的位置。


                        如果從函數中調用 locals(),它將返回可以從該函數本地訪問的所有名稱。


                        如果從函數中調用 globals(),它將返回可以從該函數全局訪問的所有名稱。


                        這兩個函數的返回類型都是字典。因此,可以使用 keys() 函數提取名稱。


                        reload( )函數

                        當模塊被導入腳本時,模塊頂層部分的代碼只執行一次。


                        因此,如果要重新執行模塊中的頂層代碼,可以使用reload()函數。reload() 函數再次導入之前導入的模塊。reload() 函數的語法是這樣的 -


                        reload(module_name)

                        這里,module_name是您要重新加載的模塊的名稱,而不是包含模塊名稱的字符串。例如,要重新加載hello模塊,請執行以下操作 -


                        reload(hello)

                        Python 中的包

                        包是一種分層文件目錄結構,它定義了一個由模塊和子包以及子子包等組成的單個 Python 應用程序環境。


                        考慮Phone目錄 中的Pots.py文件。該文件具有以下源代碼行 -


                        #!/usr/bin/python


                        def Pots():

                           print "I'm Pots Phone"

                        類似地,我們還有另外兩個具有不同功能的文件,其名稱與上述相同 -


                        具有函數 Isdn() 的電話/Isdn.py文件


                        具有函數 G3() 的電話/G3.py文件


                        現在,在Phone目錄中再創建一個文件 __init__.py -


                        電話/__init__.py

                        要在導入 Phone 后使所有功能可用,您需要在 __init__.py 中添加顯式導入語句,如下所示 -


                        from Pots import Pots

                        from Isdn import Isdn

                        from G3 import G3

                        將這些行添加到 __init__.py 后,導入 Phone 包時所有這些類都可用。


                        #!/usr/bin/python


                        # Now import your Phone Package.

                        import Phone


                        Phone.Pots()

                        Phone.Isdn()

                        Phone.G3()

                        執行上述代碼時,會產生以下結果 -


                        I'm Pots Phone

                        I'm 3G Phone

                        I'm ISDN Phone

                        在上面的示例中,我們以每個文件中的單個函數為例,但您可以在文件中保留多個函數。您還可以在這些文件中定義不同的 Python 類,然后您可以從這些類中創建包。


                        Python - 函數

                        函數是一個有組織的、可重用的代碼塊,用于執行單個相關操作。函數為您的應用程序提供更好的模塊化和高度的代碼重用。


                        如您所知,Python 為您提供了許多內置函數,例如 print() 等,但您也可以創建自己的函數。這些函數稱為用戶定義函數。


                        定義函數

                        您可以定義函數來提供所需的功能。以下是在 Python 中定義函數的簡單規則。


                        功能塊以關鍵字def開頭,后跟功能名稱和括號 ( ( ) )。


                        任何輸入參數或參數都應放在這些括號內。您還可以在這些括號內定義參數。


                        函數的第一條語句可以是可選語句 - 函數的文檔字符串或docstring。


                        每個函數中的代碼塊都以冒號 (:) 開頭并縮進。


                        語句 return [expression] 退出一個函數,可選擇將一個表達式傳回給調用者。沒有參數的 return 語句與 return None 相同。


                        句法

                        def functionname( parameters ):

                           "function_docstring"

                           function_suite

                           return [expression]

                        默認情況下,參數具有位置行為,您需要按照定義它們的順序通知它們。


                        例子

                        以下函數將字符串作為輸入參數并將其打印在標準屏幕上。


                        def printme( str ):

                           "This prints a passed string into this function"

                           print str

                           return

                        調用函數

                        定義一個函數只是給它一個名字,指定要包含在函數中的參數并構造代碼塊。


                        一旦函數的基本結構最終確定,您可以通過從另一個函數調用它或直接從 Python 提示符調用它來執行它。以下是調用 printme() 函數的示例 -


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def printme( str ):

                           "This prints a passed string into this function"

                           print str

                           return;


                        # Now you can call printme function

                        printme("I'm first call to user defined function!")

                        printme("Again second call to the same function")

                        執行上述代碼時,會產生以下結果 -


                        I'm first call to user defined function!

                        Again second call to the same function

                        通過引用與值傳遞

                        Python 語言中的所有參數(參數)都是通過引用傳遞的。這意味著如果您更改函數中參數所指的內容,則更改也會反映在調用函數中。例如 -


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def changeme( mylist ):

                           "This changes a passed list into this function"

                           mylist.append([1,2,3,4]);

                           print "Values inside the function: ", mylist

                           return


                        # Now you can call changeme function

                        mylist = [10,20,30];

                        changeme( mylist );

                        print "Values outside the function: ", mylist

                        在這里,我們維護傳遞對象的引用并在同一個對象中附加值。因此,這將產生以下結果 -


                        Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]

                        Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

                        還有一個例子,參數是通過引用傳遞的,而引用在被調用函數內部被覆蓋。


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def changeme( mylist ):

                           "This changes a passed list into this function"

                           mylist = [1,2,3,4]; # This would assig new reference in mylist

                           print "Values inside the function: ", mylist

                           return


                        # Now you can call changeme function

                        mylist = [10,20,30];

                        changeme( mylist );

                        print "Values outside the function: ", mylist

                        參數mylist是函數 changeme 的本地參數。在函數中更改 mylist 不會影響mylist。該函數什么也沒做,最后這將產生以下結果 -


                        Values inside the function:  [1, 2, 3, 4]

                        Values outside the function:  [10, 20, 30]

                        函數參數

                        您可以使用以下類型的形式參數調用函數 -


                        必需的參數

                        關鍵字參數

                        默認參數

                        可變長度參數

                        必需的參數

                        必需參數是以正確的位置順序傳遞給函數的參數。在這里,函數調用中的參數數量應該與函數定義完全匹配。


                        要調用函數printme(),您肯定需要傳遞一個參數,否則會出現如下語法錯誤 -


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def printme( str ):

                           "This prints a passed string into this function"

                           print str

                           return;


                        # Now you can call printme function

                        printme()

                        執行上述代碼時,會產生以下結果 -


                        Traceback (most recent call last):

                           File "test.py", line 11, in <module>

                              printme();

                        TypeError: printme() takes exactly 1 argument (0 given)

                        關鍵字參數

                        關鍵字參數與函數調用有關。當您在函數調用中使用關鍵字參數時,調用者通過參數名稱來識別參數。


                        這允許您跳過參數或將它們亂序放置,因為 Python 解釋器能夠使用提供的關鍵字將值與參數匹配。您還可以通過以下方式對printme()函數進行關鍵字調用 -


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def printme( str ):

                           "This prints a passed string into this function"

                           print str

                           return;


                        # Now you can call printme function

                        printme( str = "My string")

                        執行上述代碼時,會產生以下結果 -


                        My string

                        下面的例子給出了更清晰的畫面。請注意,參數的順序無關緊要。


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def printinfo( name, age ):

                           "This prints a passed info into this function"

                           print "Name: ", name

                           print "Age ", age

                           return;


                        # Now you can call printinfo function

                        printinfo( age=50, name="miki" )

                        執行上述代碼時,會產生以下結果 -


                        Name:  miki

                        Age  50

                        默認參數

                        默認參數是一個參數,如果在該參數的函數調用中未提供值,則該參數采用默認值。下面的例子給出了一個關于默認參數的想法,如果它沒有被傳遞,它會打印默認年齡 -


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def printinfo( name, age = 35 ):

                           "This prints a passed info into this function"

                           print "Name: ", name

                           print "Age ", age

                           return;


                        # Now you can call printinfo function

                        printinfo( age=50, name="miki" )

                        printinfo( name="miki" )

                        執行上述代碼時,會產生以下結果 -


                        Name:  miki

                        Age  50

                        Name:  miki

                        Age  35

                        可變長度參數

                        在定義函數時,您可能需要處理比您指定的參數更多的函數。這些參數稱為可變長度參數,與必需參數和默認參數不同,它們不在函數定義中命名。


                        具有非關鍵字變量參數的函數的語法是這樣的 -


                        def functionname([formal_args,] *var_args_tuple ):

                           "function_docstring"

                           function_suite

                           return [expression]

                        星號 (*) 放置在包含所有非關鍵字變量參數值的變量名稱之前。如果在函數調用期間未指定其他參數,則此元組保持為空。以下是一個簡單的例子 -


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def printinfo( arg1, *vartuple ):

                           "This prints a variable passed arguments"

                           print "Output is: "

                           print arg1

                           for var in vartuple:

                              print var

                           return;


                        # Now you can call printinfo function

                        printinfo( 10 )

                        printinfo( 70, 60, 50 )

                        執行上述代碼時,會產生以下結果 -


                        Output is:

                        10

                        Output is:

                        70

                        60

                        50

                        匿名函數_

                        這些函數之所以稱為匿名函數,是因為它們不是使用def關鍵字以標準方式聲明的。您可以使用lambda關鍵字來創建小型匿名函數。


                        Lambda 形式可以采用任意數量的參數,但僅以表達式的形式返回一個值。它們不能包含命令或多個表達式。


                        匿名函數不能直接調用 print,因為 lambda 需要表達式


                        Lambda 函數有自己的本地命名空間,不能訪問除參數列表和全局命名空間中的變量之外的變量。


                        盡管 lambda 看起來是函數的單行版本,但它們并不等同于 C 或 C++ 中的內聯語句,其目的是出于性能原因在調用期間傳遞函數堆棧分配。


                        句法

                        lambda函數的語法僅包含一條語句,如下所示 -


                        lambda [arg1 [,arg2,.....argn]]:expression

                        以下是展示lambda形式的函數如何工作的示例 -


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        sum = lambda arg1, arg2: arg1 + arg2;


                        # Now you can call sum as a function

                        print "Value of total : ", sum( 10, 20 )

                        print "Value of total : ", sum( 20, 20 )

                        執行上述代碼時,會產生以下結果 -


                        Value of total :  30

                        Value of total :  40

                        退貨聲明_

                        語句 return [expression] 退出一個函數,可選擇將一個表達式傳回給調用者。沒有參數的 return 語句與 return None 相同。


                        以上所有示例均未返回任何值。您可以從函數返回一個值,如下所示 -


                        現場演示

                        #!/usr/bin/python


                        # Function definition is here

                        def sum( arg1, arg2 ):

                           # Add both the parameters and return them."

                           total = arg1 + arg2

                           print "Inside the function : ", total

                           return total;


                        # Now you can call sum function

                        total = sum( 10, 20 );

                        print "Outside the function : ", total 

                        執行上述代碼時,會產生以下結果 -


                        Inside the function :  30

                        Outside the function :  30

                        變量范圍

                        程序中的所有變量可能無法在該程序的所有位置訪問。這取決于您聲明變量的位置。


                        變量的范圍決定了您可以訪問特定標識符的程序部分。Python中有兩個基本的變量范圍 -


                        全局變量

                        局部變量

                        全局變量與局部變量

                        在函數體內部定義的變量具有局部作用域,而在外部定義的變量具有全局作用域。


                        這意味著局部變量只能在聲明它們的函數內部訪問,而全局變量可以在整個程序體中被所有函數訪問。當你調用一個函數時,它里面聲明的變量被帶入作用域。以下是一個簡單的例子 -


                        現場演示

                        #!/usr/bin/python


                        total = 0; # This is global variable.

                        # Function definition is here

                        def sum( arg1, arg2 ):

                           # Add both the parameters and return them."

                           total = arg1 + arg2; # Here total is local variable.

                           print "Inside the function local total : ", total

                           return total;


                        # Now you can call sum function

                        sum( 10, 20 );

                        print "Outside the function global total : ", total 

                        執行上述代碼時,會產生以下結果 -


                        Inside the function local total :  30

                        Outside the function global total :  0


                        Python - 日期和時間

                        Python 程序可以通過多種方式處理日期和時間。在日期格式之間轉換是計算機的一項常見工作。Python 的時間和日歷模塊有助于跟蹤日期和時間。


                        什么是蜱?

                        時間間隔是以秒為單位的浮點數。從 1970 年 1 月 1 日(紀元)00:00:00 開始,特定的時間點以秒表示。


                        Python 中有一個流行的時間模塊,它提供了處理時間和在表示之間轉換的函數。函數time.time()返回自 1970 年 1 月 1 日(紀元)00:00:00 以來的當前系統時間(以刻度為單位)。


                        例子

                        現場演示

                        #!/usr/bin/python

                        import time;  # This is required to include time module.


                        ticks = time.time()

                        print "Number of ticks since 12:00am, January 1, 1970:", ticks

                        這將產生如下結果 -


                        Number of ticks since 12:00am, January 1, 1970: 7186862.73399

                        日期算術很容易用刻度來完成。但是,紀元之前的日期不能以這種形式表示。遙遠未來的日期也不能用這種方式表示——對于 UNIX 和 Windows,截止點是 2038 年的某個時間。


                        什么是時間元組?

                        許多 Python 的時間函數將時間處理為 9 個數字的元組,如下所示 -


                        指數 場地 價值觀

                        0 4 位數年份 2008年

                        1 1 到 12

                        2 1 至 31

                        3 小時 0 到 23

                        4 分鐘 0 到 59

                        5 第二 0 到 61(60 或 61 是閏秒)

                        6 星期幾 0 到 6(0 是星期一)

                        7 一年中的一天 1 至 366(儒略日)

                        8 夏令時 -1, 0, 1, -1 表示庫確定 DST

                        上面的元組等價于struct_time結構。該結構具有以下屬性 -


                        指數 屬性 價值觀

                        0 tm_year 2008年

                        1 tm_mon 1 到 12

                        2 tm_mday 1 至 31

                        3 tm_hour 0 到 23

                        4 tm_min 0 到 59

                        5 tm_sec 0 到 61(60 或 61 是閏秒)

                        6 tm_wday 0 到 6(0 是星期一)

                        7 tm_yday 1 至 366(儒略日)

                        8 tm_isdst -1, 0, 1, -1 表示庫確定 DST

                        獲取當前時間

                        要將自紀元浮點值以來的秒數轉換為時間元組,請將浮點值傳遞給一個函數(例如,本地時間),該函數返回一個所有九項都有效的時間元組。


                        現場演示

                        #!/usr/bin/python

                        import time;


                        localtime = time.localtime(time.time())

                        print "Local current time :", localtime

                        這將產生以下結果,可以以任何其他可呈現的形式格式化 -


                        Local current time : time.struct_time(tm_year=2013, tm_mon=7, 

                        tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

                        獲取格式化時間

                        您可以根據您的要求隨時格式化,但是以可讀格式獲取時間的簡單方法是 asctime() -


                        現場演示

                        #!/usr/bin/python

                        import time;


                        localtime = time.asctime( time.localtime(time.time()) )

                        print "Local current time :", localtime

                        這將產生以下結果 -


                        Local current time : Tue Jan 13 10:17:09 2009

                        獲取一個月的日歷

                        日歷模塊提供了多種使用年歷和月歷的方法。在這里,我們打印給定月份的日歷(2008 年 1 月) -


                        現場演示

                        #!/usr/bin/python

                        import calendar


                        cal = calendar.month(2008, 1)

                        print "Here is the calendar:"

                        print cal

                        這將產生以下結果 -


                        Here is the calendar:

                           January 2008

                        Mo Tu We Th Fr Sa Su

                            1  2  3  4  5  6

                         7  8  9 10 11 12 13

                        14 15 16 17 18 19 20

                        21 22 23 24 25 26 27

                        28 29 30 31

                        時間模塊_

                        Python中有一個流行的時間模塊,它提供了處理時間和在表示之間轉換的函數。這是所有可用方法的列表 -


                        編號 功能說明

                        1 時間.altzone

                        本地 DST 時區的偏移量,以 UTC 以西的秒數為單位(如果已定義)。如果當地 DST 時區在 UTC 以東(如在西歐,包括英國),則這是負數。僅當日光不為零時才使用此選項。


                        2 time.asctime([元組時間])

                        接受時間元組并返回可讀的 24 個字符的字符串,例如 'Tue Dec 11 18:07:14 2008'。


                        3 時間.時鐘()

                        以浮點秒數返回當前 CPU 時間。為了衡量不同方法的計算成本,time.clock 的值比 time.time() 的值更有用。


                        4 time.ctime([秒])

                        像 asctime(localtime(secs)) 并且沒有參數就像 asctime()


                        5 time.gmtime([秒])

                        接受自紀元以來以秒表示的瞬間,并返回帶有 UTC 時間的時間元組 t。注意:t.tm_isdst 始終為 0


                        6 time.localtime([秒])

                        接受自紀元以來以秒表示的瞬間,并返回帶有本地時間的時間元組 t(t.tm_isdst 為 0 或 1,取決于 DST 是否適用于本地規則的瞬間秒)。


                        7 time.mktime(元組時間)

                        接受以本地時間表示為時間元組的瞬間,并返回一個浮點值,該瞬間以自紀元以來的秒數表示。


                        8 時間.睡眠(秒)

                        將調用線程掛起 secs 秒。


                        9 time.strftime(fmt[,tupletime])

                        接受以本地時間表示為時間元組的瞬間,并返回表示由字符串 fmt 指定的瞬間的字符串。


                        10 time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')

                        根據格式字符串 fmt 解析 str 并以時間元組格式返回瞬間。


                        11 時間.時間()

                        返回當前時刻,即自紀元以來的浮點秒數。


                        12 時間.tzset()

                        重置庫例程使用的時間轉換規則。環境變量 TZ 指定如何完成。


                        讓我們簡要介紹一下這些功能 -


                        時間模塊有以下兩個重要屬性 -


                        編號 帶有描述的屬性

                        1

                        時間.時區


                        屬性 time.timezone 是本地時區(不含 DST)與 UTC 的偏移量(在美洲 > 0;在歐洲、亞洲、非洲的大部分地區 <= 0)。


                        2

                        時間.tzname


                        屬性 time.tzname 是一對依賴于語言環境的字符串,它們分別是不帶夏令時和帶夏令時的本地時區名稱。


                        日歷模塊_

                        日歷模塊提供與日歷相關的功能,包括打印給定月份或年份的文本日歷的功能。


                        默認情況下,日歷將星期一作為一周的第一天,將星期日作為最后一天。要更改這一點,請調用 calendar.setfirstweekday() 函數。


                        這是日歷模塊可用的功能列表-


                        編號 功能說明

                        1

                        calendar.calendar(年,w=2,l=1,c=6)


                        返回一個多行字符串,其中包含一年的日歷,格式為由 c 個空格分隔的三列。w 是每個日期的字符寬度;每行的長度為 21*w+18+2*c。l 是每周的行數。


                        2

                        calendar.firstweekday()


                        返回每周開始的工作日的當前設置。默認情況下,首次導入日歷時,此值為 0,表示星期一。


                        3

                        calendar.isleap(年)


                        如果 year 是閏年,則返回 True;否則為假。


                        4

                        calendar.leapdays(y1,y2)


                        返回范圍 (y1,y2) 內年份的閏日總數。


                        5

                        calendar.month(年,月,w=2,l=1)


                        返回一個多行字符串,其中包含一年中月份的日歷,每周一行加上兩個標題行。w 是每個日期的字符寬度;每行的長度為 7*w+6。l 是每周的行數。


                        6

                        calendar.monthcalendar(年,月)


                        返回整數列表的列表。每個子列表表示一周。年月月外的天數設置為 0;月內的天數設置為當月的第 1 天及以上。


                        7

                        calendar.monthrange(年,月)


                        返回兩個整數。第一個是年年月月第一天的工作日代碼;第二個是一個月的天數。工作日代碼為 0(星期一)至 6(星期日);月份數字是 1 到 12。


                        8

                        calendar.prcal(年,w=2,l=1,c=6)


                        就像打印 calendar.calendar(year,w,l,c)。


                        9

                        calendar.prmonth(年,月,w=2,l=1)


                        就像打印 calendar.month(year,month,w,l)。


                        10

                        calendar.setfirstweekday(工作日)


                        將每周的第一天設置為工作日代碼工作日。工作日代碼為 0(星期一)到 6(星期日)。


                        11

                        calendar.timegm(元組時間)


                        time.gmtime 的倒數:接受時間元組形式的時間瞬間,并返回與自紀元以來的浮點秒數相同的瞬間。


                        12

                        calendar.weekday(年,月,日)


                        返回給定日期的工作日代碼。工作日代碼為 0(星期一)至 6(星期日);月份編號為 1(一月)到 12(十二月)。


                        其他模塊和功能

                        如果您有興趣,那么在這里您可以找到在 Python 中使用日期和時間的其他重要模塊和函數的列表 -


                        日期時間模塊


                        pytz模塊_


                        dateutil模塊_


                        Python - 字典

                        每個鍵與其值用冒號 (:) 分隔,項目用逗號分隔,整個內容用花括號括起來。一個沒有任何項目的空字典只用兩個花括號編寫,如下所示:{}。


                        鍵在字典中是唯一的,而值可能不是。字典的值可以是任何類型,但鍵必須是不可變的數據類型,例如字符串、數字或元組。


                        訪問字典中的值

                        要訪問字典元素,您可以使用熟悉的方括號和鍵來獲取其值。以下是一個簡單的例子 -


                        現場演示

                        #!/usr/bin/python


                        dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

                        print "dict['Name']: ", dict['Name']

                        print "dict['Age']: ", dict['Age']

                        執行上述代碼時,會產生以下結果 -


                        dict['Name']:  Zara

                        dict['Age']:  7

                        如果我們嘗試使用不屬于字典的鍵訪問數據項,則會收到如下錯誤 -


                        現場演示

                        #!/usr/bin/python


                        dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

                        print "dict['Alice']: ", dict['Alice']

                        執行上述代碼時,會產生以下結果 -


                        dict['Alice']:

                        Traceback (most recent call last):

                           File "test.py", line 4, in <module>

                              print "dict['Alice']: ", dict['Alice'];

                        KeyError: 'Alice'

                        更新字典

                        您可以通過添加新條目或鍵值對、修改現有條目或刪除現有條目來更新字典,如下簡單示例所示 -


                        現場演示

                        #!/usr/bin/python


                        dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

                        dict['Age'] = 8; # update existing entry

                        dict['School'] = "DPS School"; # Add new entry


                        print "dict['Age']: ", dict['Age']

                        print "dict['School']: ", dict['School']

                        執行上述代碼時,會產生以下結果 -


                        dict['Age']:  8

                        dict['School']:  DPS School

                        刪除字典元素

                        您可以刪除單個字典元素或清除字典的全部內容。您還可以在一次操作中刪除整個字典。


                        要顯式刪除整個字典,只需使用del語句。以下是一個簡單的例子 -


                        現場演示

                        #!/usr/bin/python


                        dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

                        del dict['Name']; # remove entry with key 'Name'

                        dict.clear();     # remove all entries in dict

                        del dict ;        # delete entire dictionary


                        print "dict['Age']: ", dict['Age']

                        print "dict['School']: ", dict['School']

                        這會產生以下結果。請注意,會引發異常,因為在del dict字典不再存在之后 -


                        dict['Age']:

                        Traceback (most recent call last):

                           File "test.py", line 8, in <module>

                              print "dict['Age']: ", dict['Age'];

                        TypeError: 'type' object is unsubscriptable

                        注意- del() 方法將在后續部分討論。


                        字典鍵的屬性

                        字典值沒有限制。它們可以是任意 Python 對象,可以是標準對象,也可以是用戶定義的對象。但是,對于鍵來說,情況并非如此。


                        關于字典鍵有兩點要記住 -


                        (a)每個鍵不允許超過一個條目。這意味著不允許重復密鑰。當分配過程中遇到重復鍵時,最后一個分配獲勝。例如 -


                        現場演示

                        #!/usr/bin/python


                        dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}

                        print "dict['Name']: ", dict['Name']

                        執行上述代碼時,會產生以下結果 -


                        dict['Name']:  Manni

                        (b)密鑰必須是不可變的。這意味著您可以使用字符串、數字或元組作為字典鍵,但不允許使用 ['key'] 之類的東西。以下是一個簡單的例子 -


                        現場演示

                        #!/usr/bin/python


                        dict = {['Name']: 'Zara', 'Age': 7}

                        print "dict['Name']: ", dict['Name']

                        執行上述代碼時,會產生以下結果 -


                        Traceback (most recent call last):

                           File "test.py", line 3, in <module>

                              dict = {['Name']: 'Zara', 'Age': 7};

                        TypeError: unhashable type: 'list'

                        內置字典函數和方法

                        Python 包括以下字典函數 -


                        編號 功能說明

                        1 cmp(dict1, dict2)

                        比較兩個字典的元素。


                        2 len(字典)

                        給出字典的總長度。這將等于字典中的項目數。


                        3 字符串(字典)

                        生成字典的可打印字符串表示


                        4 類型(變量)

                        返回傳遞變量的類型。如果傳遞的變量是字典,那么它將返回字典類型。


                        Python 包括以下字典方法 -


                        編號 帶有描述的方法

                        1 dict.clear()

                        刪除字典dict的所有元素


                        2 dict.copy()

                        返回字典dict的淺拷貝


                        3 dict.fromkeys()

                        使用來自 seq 的鍵和設置為value的值創建一個新字典。


                        4 dict.get(鍵,默認=無)

                        對于鍵鍵,如果鍵不在字典中,則返回值或默認值


                        5 dict.has_key(key)

                        如果字典dict中的鍵返回true,否則返回false


                        6 dict.items()

                        返回dict的 (key, value) 元組對的列表


                        7 dict.keys()

                        返回字典 dict 鍵的列表


                        8 dict.setdefault(鍵,默認=無)

                        類似于 get(),但如果key不在dict 中,將設置 dict[key]=default


                        9 dict.update(dict2)

                        將字典dict2的鍵值對添加到dict


                        10 dict.values()

                        返回字典dict的值列表


                        Python - 元組

                        元組是有序且不可變的對象的集合。元組是序列,就像列表一樣。元組和列表之間的區別在于,元組不能更改,不像列表和元組使用括號,而列表使用方括號。


                        創建一個元組就像放置不同的逗號分隔值一樣簡單?;蛘?,您也可以將這些逗號分隔的值放在括號之間。例如 -


                        tup1 = ('physics', 'chemistry', 1997, 2000);

                        tup2 = (1, 2, 3, 4, 5 );

                        tup3 = "a", "b", "c", "d";

                        空元組寫成兩個括號,不包含任何內容 -


                        tup1 = ();

                        要編寫一個包含單個值的元組,您必須包含一個逗號,即使只有一個值 -


                        tup1 = (50,);

                        像字符串索引一樣,元組索引從 0 開始,它們可以被切片、連接等等。


                        訪問元組中的值

                        要訪問元組中的值,請使用方括號進行切片以及索引或索引以獲得該索引處可用的值。例如 -


                        現場演示

                        #!/usr/bin/python


                        tup1 = ('physics', 'chemistry', 1997, 2000);

                        tup2 = (1, 2, 3, 4, 5, 6, 7 );

                        print "tup1[0]: ", tup1[0];

                        print "tup2[1:5]: ", tup2[1:5];

                        執行上述代碼時,會產生以下結果 -


                        tup1[0]:  physics

                        tup2[1:5]:  [2, 3, 4, 5]

                        更新元組

                        元組是不可變的,這意味著您不能更新或更改元組元素的值。您可以使用現有元組的一部分來創建新元組,如下例所示 -


                        現場演示

                        #!/usr/bin/python


                        tup1 = (12, 34.56);

                        tup2 = ('abc', 'xyz');


                        # Following action is not valid for tuples

                        # tup1[0] = 100;


                        # So let's create a new tuple as follows

                        tup3 = tup1 + tup2;

                        print tup3;

                        執行上述代碼時,會產生以下結果 -


                        (12, 34.56, 'abc', 'xyz')

                        刪除元組元素

                        無法刪除單個元組元素。當然,將另一個元組與丟棄的不需要的元素放在一起并沒有錯。


                        要顯式刪除整個元組,只需使用del語句。例如 -


                        現場演示

                        #!/usr/bin/python


                        tup = ('physics', 'chemistry', 1997, 2000);

                        print tup;

                        del tup;

                        print "After deleting tup : ";

                        print tup;

                        這會產生以下結果。注意引發異常,這是因為在del tup 元組之后不再存在 -


                        ('physics', 'chemistry', 1997, 2000)

                        After deleting tup :

                        Traceback (most recent call last):

                           File "test.py", line 9, in <module>

                              print tup;

                        NameError: name 'tup' is not defined

                        基本元組操作

                        元組對 + 和 * 運算符的響應很像字符串;他們在這里也意味著連接和重復,除了結果是一個新的元組,而不是一個字符串。


                        事實上,元組響應我們在前一章中對字符串使用的所有一般序列操作 -


                        Python 表達式 結果 描述

                        長度 ((1, 2, 3)) 3 長度

                        (1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 級聯

                        ('嗨!',)* 4 (“嗨!”、“嗨!”、“嗨!”、“嗨!”) 重復

                        3 英寸 (1, 2, 3) 真的 會員資格

                        對于 (1, 2, 3) 中的 x:打印 x, 1 2 3 迭代

                        索引、切片和矩陣

                        因為元組是序列,所以索引和切片對元組的工作方式與對字符串的工作方式相同。假設以下輸入 -


                        L = ('spam', 'Spam', 'SPAM!')

                         


                        Python 表達式 結果 描述

                        L[2] '垃圾郵件!' 偏移量從零開始

                        L[-2] '垃圾郵件' 負數:從右數

                        L[1:] ['垃圾郵件','垃圾郵件!'] 切片獲取部分

                        沒有封閉分隔符

                        任何一組多個對象,逗號分隔,不帶識別符號,即列表的括號,元組的括號等,默認為元組,如這些簡短的示例所示 -


                        現場演示

                        #!/usr/bin/python


                        print 'abc', -4.24e93, 18+6.6j, 'xyz';

                        x, y = 1, 2;

                        print "Value of x , y : ", x,y;

                        執行上述代碼時,會產生以下結果 -


                        abc -4.24e+93 (18+6.6j) xyz

                        Value of x , y : 1 2

                        內置元組函數

                        Python 包括以下元組函數 -


                        編號 功能說明

                        1 cmp(元組1,元組2)

                        比較兩個元組的元素。


                        2 len(元組)

                        給出元組的總長度。


                        3 最大值(元組)

                        從具有最大值的元組中返回項目。


                        4 分鐘(元組)

                        從具有最小值的元組中返回項目。


                        5 元組(序列)

                        將列表轉換為元組。


                        Python - 列表

                        Python中最基本的數據結構是序列。序列的每個元素都被分配了一個數字——它的位置或索引。第一個索引為零,第二個索引為一,依此類推。


                        Python 有六種內置的序列類型,但最常見的是列表和元組,我們將在本教程中看到它們。


                        您可以對所有序列類型執行某些操作。這些操作包括索引、切片、加法、乘法和檢查成員資格。此外,Python 具有用于查找序列長度以及查找其最大和最小元素的內置函數。


                        Python 列表

                        列表是 Python 中最通用的數據類型,可以寫成方括號之間的逗號分隔值(項目)列表。關于列表的重要一點是列表中的項目不必屬于同一類型。


                        創建列表就像在方括號之間放置不同的逗號分隔值一樣簡單。例如 -


                        list1 = ['physics', 'chemistry', 1997, 2000];

                        list2 = [1, 2, 3, 4, 5 ];

                        list3 = ["a", "b", "c", "d"]

                        與字符串索引類似,列表索引從 0 開始,列表可以切片、連接等。


                        訪問列表中的值

                        要訪問列表中的值,請使用方括號進行切片以及索引或索引以獲得該索引處可用的值。例如 -


                        現場演示

                        #!/usr/bin/python


                        list1 = ['physics', 'chemistry', 1997, 2000];

                        list2 = [1, 2, 3, 4, 5, 6, 7 ];

                        print "list1[0]: ", list1[0]

                        print "list2[1:5]: ", list2[1:5]

                        執行上述代碼時,會產生以下結果 -


                        list1[0]:  physics

                        list2[1:5]:  [2, 3, 4, 5]

                        更新列表

                        您可以通過在賦值運算符左側給出切片來更新列表的單個或多個元素,并且可以使用 append() 方法添加到列表中的元素。例如 -


                        現場演示

                        #!/usr/bin/python


                        list = ['physics', 'chemistry', 1997, 2000];

                        print "Value available at index 2 : "

                        print list[2]

                        list[2] = 2001;

                        print "New value available at index 2 : "

                        print list[2]

                        注意- append() 方法將在后續部分討論。


                        執行上述代碼時,會產生以下結果 -


                        Value available at index 2 :

                        1997

                        New value available at index 2 :

                        2001

                        刪除列表元素

                        要刪除列表元素,如果您確切知道要刪除的元素,可以使用 del 語句,如果不知道,可以使用 remove() 方法。例如 -


                        現場演示

                        #!/usr/bin/python


                        list1 = ['physics', 'chemistry', 1997, 2000];

                        print list1

                        del list1[2];

                        print "After deleting value at index 2 : "

                        print list1

                        執行上述代碼時,會產生以下結果 -


                        ['physics', 'chemistry', 1997, 2000]

                        After deleting value at index 2 :

                        ['physics', 'chemistry', 2000]

                        注意- remove() 方法將在后續部分討論。


                        基本列表操作

                        列表響應 + 和 * 操作符很像字符串;它們在這里也意味著連接和重復,只是結果是一個新列表,而不是一個字符串。


                        事實上,列表響應了我們在前一章中對字符串使用的所有一般序列操作。


                        Python 表達式結果描述

                        len([1, 2, 3])3長度

                        [1, 2, 3] + [4, 5, 6][1、2、3、4、5、6]級聯

                        ['嗨!'] * 4['嗨!','嗨!','嗨!','嗨!']重復

                        3 在 [1, 2, 3]真的會員資格

                        對于 [1, 2, 3] 中的 x:打印 x,1 2 3迭代

                        索引、切片和矩陣

                        因為列表是序列,所以索引和切片對列表的工作方式與對字符串的工作方式相同。


                        假設以下輸入 -


                        L = ['spam', 'Spam', 'SPAM!']

                        Python 表達式結果描述

                        L[2]垃圾郵件!偏移量從零開始

                        L[-2]垃圾郵件負數:從右數

                        L[1:]['垃圾郵件','垃圾郵件!']切片獲取部分

                        內置列表函數和方法

                        Python 包括以下列表函數 -


                        編號功能說明

                        1cmp(列表 1,列表 2)

                        比較兩個列表的元素。


                        2長度(列表)

                        給出列表的總長度。


                        3最大值(列表)

                        從列表中返回具有最大值的項目。


                        4分鐘(列表)

                        從列表中返回具有最小值的項目。


                        5列表(序列)

                        將元組轉換為列表。


                        Python 包括以下列表方法


                        編號帶有描述的方法

                        1list.append(obj)

                        將對象 obj 附加到列表


                        2list.count(obj)

                        返回 obj 在列表中出現的次數


                        3list.extend(seq)

                        將 seq 的內容追加到列表中


                        4list.index(obj)

                        返回 obj 出現的列表中的最低索引


                        5list.insert(索引,obj)

                        將對象 obj 插入到偏移索引處的列表中


                        6list.pop(obj=list[-1])

                        從列表中移除并返回最后一個對象或 obj


                        7list.remove(obj)

                        從列表中刪除對象 obj


                        8list.reverse()

                        將列表對象反轉到位


                        9list.sort([函數])

                        對列表對象進行排序,如果給定則使用比較函數


                        Python - 字符串

                        字符串是 Python 中最流行的類型之一。我們可以簡單地通過將字符括在引號中來創建它們。Python 將單引號視為雙引號。創建字符串就像為變量賦值一樣簡單。例如 -


                        var1 = 'Hello World!'

                        var2 = "Python Programming"

                        訪問字符串中的值

                        Python 不支持字符類型;這些被視為長度為 1 的字符串,因此也被視為子字符串。


                        要訪問子字符串,請使用方括號進行切片以及索引或索引來獲取子字符串。例如 -


                        現場演示

                        #!/usr/bin/python


                        var1 = 'Hello World!'

                        var2 = "Python Programming"


                        print "var1[0]: ", var1[0]

                        print "var2[1:5]: ", var2[1:5]

                        執行上述代碼時,會產生以下結果 -


                        var1[0]:  H

                        var2[1:5]:  ytho

                        更新字符串

                        您可以通過(重新)將變量分配給另一個字符串來“更新”現有字符串。新值可以與其先前的值相關,也可以與完全不同的字符串相關。例如 -


                        現場演示

                        #!/usr/bin/python


                        var1 = 'Hello World!'

                        print "Updated String :- ", var1[:6] + 'Python'

                        執行上述代碼時,會產生以下結果 -


                        Updated String :-  Hello Python

                        轉義字符

                        下表是可以用反斜杠表示法表示的轉義或不可打印字符的列表。


                        轉義字符被解釋;在單引號和雙引號字符串中。


                        反斜杠符號 十六進制字符 描述

                        \一種 0x07 響鈴或警報

                        \b 0x08 退格

                        \cx 控制-x

                        \Cx 控制-x

                        \e 0x1b 逃脫

                        \F 0x0c 換頁

                        \M-\Cx 元控制-x

                        \n 0x0a 新隊

                        \nnn 八進制表示法,其中 n 在 0.7 范圍內

                        \r 0x0d 回車

                        \s 0x20 空間

                        \t 0x09 標簽

                        \v 0x0b 垂直選項卡

                        \X 字符 x

                        \xnn 十六進制表示法,其中 n 在 0.9、af 或 AF 范圍內

                        字符串特殊運算符

                        假設字符串變量a持有“Hello”,變量b持有“Python”,那么 -


                        操作員 描述 例子

                        + 串聯 - 在運算符的任一側添加值 a + b 會給 HelloPython

                        * 重復 - 創建新字符串,連接同一字符串的多個副本 a*2 將給出 -HelloHello

                        [] Slice - 給出給定索引中的字符 a[1] 會給 e

                        [:] Range Slice - 給出給定范圍內的字符 a[1:4] 會給 ell

                        Membership - 如果給定字符串中存在字符,則返回 true H in a 將給出 1

                        不在 Membership - 如果給定字符串中不存在字符,則返回 true M not in a 將給出 1

                        讀/讀 原始字符串 - 抑制轉義字符的實際含義。原始字符串的語法與普通字符串的語法完全相同,但原始字符串運算符除外,即引號前面的字母“r”?!皉”可以是小寫字母 (r) 或大寫字母 (R),并且必須緊挨在第一個引號之前。 print r'\n' 打印 \n 和 print R'\n' 打印 \n

                        % Format - 執行字符串格式化 見下一節

                        字符串格式化運算符

                        Python 最酷的特性之一是字符串格式運算符 %。該運算符是字符串獨有的,彌補了 C 的 printf() 系列中的函數包。以下是一個簡單的例子 -


                        現場演示

                        #!/usr/bin/python


                        print "My name is %s and weight is %d kg!" % ('Zara', 21)

                        執行上述代碼時,會產生以下結果 -


                        My name is Zara and weight is 21 kg!

                        這是可與 % 一起使用的完整符號集列表 -


                        格式化符號 轉換

                        %C 特點

                        %s 在格式化之前通過 str() 進行字符串轉換

                        %一世 有符號十進制整數

                        %d 有符號十進制整數

                        %u 無符號十進制整數

                        %o 八進制整數

                        %X 十六進制整數(小寫字母)

                        %X 十六進制整數(大寫字母)

                        %e 指數符號(帶小寫“e”)

                        %E 指數符號(大寫“E”)

                        %F 浮點實數

                        %G %f 和 %e 中較短的一個

                        %G %f 和 %E 中較短的一個

                        下表列出了其他支持的符號和功能 -


                        象征 功能性

                        * 參數指定寬度或精度

                        - 左對齊

                        + 顯示標志

                        <sp> 在正數前留一個空格

                        # 添加八進制前導零(“0”)或十六進制前導“0x”或“0X”,具體取決于使用的是“x”還是“X”。

                        0 從左邊用零填充(而不是空格)

                        % '%%' 給你留下一個文字 '%'

                        (變種) 映射變量(字典參數)

                        m 是最小總寬度,n 是小數點后顯示的位數(如果適用)

                        三重引號

                        Python 的三重引號允許字符串跨越多行,包括逐字換行符、制表符和任何其他特殊字符,從而起到救援作用。


                        三引號的語法由三個連續的單引號或雙引號組成。


                        現場演示

                        #!/usr/bin/python


                        para_str = """this is a long string that is made up of

                        several lines and non-printable characters such as

                        TAB ( \t ) and they will show up that way when displayed.

                        NEWLINEs within the string, whether explicitly given like

                        this within the brackets [ \n ], or just a NEWLINE within

                        the variable assignment will also show up.

                        """

                        print para_str

                        執行上述代碼時,會產生以下結果。請注意每個特殊字符是如何轉換為其打印形式的,一直到字符串末尾“up”之間的最后一個 NEWLINE。并關閉三重引號。另請注意,NEWLINEs 出現在行尾的顯式回車或其轉義碼 (\n) -


                        this is a long string that is made up of

                        several lines and non-printable characters such as

                        TAB (    ) and they will show up that way when displayed.

                        NEWLINEs within the string, whether explicitly given like

                        this within the brackets [

                         ], or just a NEWLINE within

                        the variable assignment will also show up.

                        原始字符串根本不將反斜杠視為特殊字符。您放入原始字符串的每個字符都保持您編寫它的方式 -


                        現場演示

                        #!/usr/bin/python


                        print 'C:\\nowhere'

                        執行上述代碼時,會產生以下結果 -


                        C:\nowhere

                        現在讓我們使用原始字符串。我們將表達式放在r'expression'中,如下所示 -


                        現場演示

                        #!/usr/bin/python


                        print r'C:\\nowhere'

                        執行上述代碼時,會產生以下結果 -


                        C:\\nowhere

                        Unicode 字符串

                        Python 中的普通字符串在內部存儲為 8 位 ASCII,而 Unicode 字符串存儲為 16 位 Unicode。這允許使用更多樣化的字符集,包括來自世界上大多數語言的特殊字符。我將對 Unicode 字符串的處理限制為以下內容 -


                        現場演示

                        #!/usr/bin/python


                        print u'Hello, world!'

                        執行上述代碼時,會產生以下結果 -


                        Hello, world!

                        如您所見,Unicode 字符串使用前綴 u,就像原始字符串使用前綴 r 一樣。


                        內置字符串方法

                        Python 包括以下操作字符串的內置方法 -


                        編號 帶有描述的方法

                        1 大寫()

                        將字符串的第一個字母大寫


                        2 中心(寬度,填充字符)

                        返回一個空格填充的字符串,其中原始字符串以總寬度列為中心。


                        3 計數(str,beg=0,end=len(字符串))

                        如果給定了起始索引 beg 和結束索引 end,則計算 str 在字符串或字符串的子字符串中出現的次數。


                        4 解碼(編碼='UTF-8',錯誤='嚴格')

                        使用為編碼注冊的編解碼器對字符串進行解碼。encoding 默認為默認字符串編碼。


                        5 編碼(編碼='UTF-8',錯誤='嚴格')

                        返回字符串的編碼字符串版本;出錯時,默認是引發 ValueError ,除非使用“忽略”或“替換”給出錯誤。


                        6 結束(后綴,乞求 = 0,結束 = 長度(字符串))

                        確定字符串或字符串的子字符串(如果給出了起始索引 beg 和結束索引 end)是否以后綴結尾;如果是,則返回 true,否則返回 false。


                        7 展開標簽(標簽大小=8)

                        將字符串中的制表符擴展到多個空格;如果未提供 tabsize,則默認為每個制表符 8 個空格。


                        8 查找(str,beg=0 end=len(字符串))

                        如果給出了起始索引 beg 和結束索引 end,則確定 str 出現在字符串中還是出現在字符串的子字符串中,如果找到則返回 index,否則返回 -1。


                        9 索引(str,beg=0,end=len(字符串))

                        與 find() 相同,但如果未找到 str,則會引發異常。


                        10 isalnum()

                        如果字符串至少有 1 個字符并且所有字符都是字母數字,則返回 true,否則返回 false。


                        11 是阿爾法()

                        如果字符串至少有 1 個字符并且所有字符都是字母,則返回 true,否則返回 false。


                        12 是數字()

                        如果字符串僅包含數字,則返回 true,否則返回 false。


                        13 下層()

                        如果字符串至少有 1 個大小寫字符并且所有大小寫字符都是小寫,則返回 true,否則返回 false。


                        14 非數字()

                        如果 unicode 字符串僅包含數字字符,則返回 true,否則返回 false。


                        15 空間()

                        如果字符串僅包含空白字符,則返回 true,否則返回 false。


                        16 標題()

                        如果字符串正確“標題大小寫”,則返回 true,否則返回 false。


                        17 isupper()

                        如果字符串至少有一個大小寫字符并且所有大小寫字符都是大寫,則返回 true,否則返回 false。


                        18 加入(序列)

                        將序列 seq 中元素的字符串表示合并(連接)成一個字符串,并帶有分隔符字符串。


                        19 長度(字符串)

                        返回字符串的長度


                        20 ljust(寬度[,填充字符])

                        返回一個空格填充的字符串,原始字符串左對齊到總寬度列。


                        21 降低()

                        將字符串中的所有大寫字母轉換為小寫。


                        22 lstrip()

                        刪除字符串中的所有前導空格。


                        23 maketrans()

                        返回要在翻譯函數中使用的翻譯表。


                        24 最大值(str)

                        返回字符串 str 中的最大字母字符。


                        25 分鐘(str)

                        返回字符串 str 中的最小字母字符。


                        26 替換(舊,新 [,最大])

                        將字符串中所有出現的 old 替換為新的,或者如果給定 max,則最多替換為 max 出現。


                        27 rfind(str, beg=0,end=len(string))

                        與 find() 相同,但在字符串中向后搜索。


                        28 rindex(str,beg=0,end=len(字符串))

                        與 index() 相同,但在字符串中向后搜索。


                        29 rjust(寬度,[,填充字符])

                        返回一個空格填充的字符串,原始字符串右對齊到總寬度列。


                        30 rstrip()

                        刪除字符串的所有尾隨空格。


                        31 拆分(str="", num=string.count(str))

                        根據分隔符 str 拆分字符串(如果未提供空格)并返回子字符串列表;如果給定,最多拆分為 num 個子字符串。


                        32 分割線(num=string.count('\n'))

                        在所有(或 num)個 NEWLINE 處拆分字符串,并返回刪除了 NEWLINE 的每一行的列表。


                        33 開始(str,beg=0,end=len(字符串))

                        確定字符串或字符串的子字符串(如果給出了起始索引 beg 和結束索引 end)是否以子字符串 str 開頭;如果是,則返回 true,否則返回 false。


                        34 剝離([字符])

                        對字符串執行 lstrip() 和 rstrip()。


                        35 交換箱()

                        反轉字符串中所有字母的大小寫。


                        36 標題()

                        返回“titlecased”版本的字符串,即所有單詞都以大寫開頭,其余的都是小寫。


                        37 翻譯(表,刪除字符=“”)

                        根據翻譯表 str(256 chars) 翻譯字符串,刪除 del 字符串中的那些。


                        38 上()

                        將字符串中的小寫字母轉換為大寫。


                        39 zfill(寬度)

                        返回用零填充到總寬度字符的原始字符串;用于數字,zfill() 保留任何給定的符號(少一個零)。


                        40 十進制()

                        如果 unicode 字符串僅包含十進制字符,則返回 true,否則返回 false。


                        Python - numbers

                        數字數據類型存儲數值。它們是不可變的數據類型,這意味著更改數字數據類型的值會導致新分配的對象。


                        Number 對象是在您為其賦值時創建的。例如 -


                        var1 = 1

                        var2 = 10

                        您還可以使用del語句刪除對數字對象的引用。del 語句的語法是 -


                        del var1[,var2[,var3[....,varN]]]]

                        您可以使用del語句刪除單個對象或多個對象。例如 -


                        del var

                        del var_a, var_b

                        Python 支持四種不同的數值類型 -


                        int (signed integers) - 它們通常被稱為整數或整數,是沒有小數點的正整數或負整數。


                        long (long integers) - 也稱為 long,它們是無限大小的整數,寫成整數,后跟大寫或小寫 L。


                        float (floating point real values) - 也稱為浮點數,它們代表實數,并用小數點分隔整數和小數部分。浮點數也可以是科學記數法,E 或 e 表示 10 的冪 (2.5e2 = 2.5 x 10 2 = 250)。


                        complex(復數) - 形式為 a + bJ,其中 a 和 b 是浮點數,J(或 j)表示 -1(虛數)的平方根。數的實部是a,虛部是b。Python 編程中很少使用復數。


                        例子

                        以下是一些數字示例


                        整數 漂浮 復雜的

                        10 51924361L 0.0 3.14j

                        100 -0x19323L 15.20 45.j

                        -786 0122L -21.9 9.322e-36j

                        080 0xDEFABCECBDAECBFBAEL 32.3+e18 .876j

                        -0490 535633629843L -90。 -.6545+0J

                        -0x260 -052318172735L -32.54e100 3e+26J

                        0x69 -4721885298529L 70.2-E12 4.53e-7j

                        Python 允許您將小寫 L 與 long 一起使用,但建議您僅使用大寫 L 以避免與數字 1 混淆。Python 使用大寫 L 顯示長整數。


                        復數由一對有序的實數浮點數組成,用 a + bj 表示,其中 a 是復數的實部,b 是復數的虛部。


                        數字類型轉換

                        Python 在內部將包含混合類型的表達式中的數字轉換為通用類型以進行評估。但有時,您需要將數字從一種類型顯式強制轉換為另一種類型以滿足運算符或函數參數的要求。


                        鍵入int(x)將 x 轉換為純整數。


                        鍵入long(x)將 x 轉換為長整數。


                        鍵入float(x)將 x 轉換為浮點數。


                        鍵入complex(x)將 x 轉換為實部 x 和虛部為零的復數。


                        鍵入complex(x, y)將 x 和 y 轉換為具有實部 x 和虛部 y 的復數。x 和 y 是數值表達式


                        數學函數

                        Python 包括以下執行數學計算的函數。


                        編號 函數和返回(描述)

                        1 絕對值(x)

                        x 的絕對值:x 和零之間的(正)距離。


                        2 細胞(x)

                        x的上限:不小于x的最小整數


                        3 cmp(x, y)

                        如果 x < y,則為 -1,如果 x == y,則為 0,如果 x > y,則為 1


                        4 exp(x)

                        x 的指數:e x


                        5 晶圓廠(x)

                        x 的絕對值。


                        6 樓層(x)

                        x的下限:不大于x的最大整數


                        7 日志(x)

                        x 的自然對數,對于 x> 0


                        8 日志10(x)

                        x> 0 時 x 的以 10 為底的對數。


                        9 最大值(x1,x2,...)

                        它的最大參數:最接近正無窮大的值


                        10 最?。▁1,x2,...)

                        最小的參數:最接近負無窮的值


                        11 模數(x)

                        兩項元組中 x 的小數和整數部分。兩個部分都具有與 x 相同的符號。整數部分作為浮點數返回。


                        12 pow(x, y)

                        x**y 的值。


                        13 圓形(x [,n])

                        x從小數點四舍五入到 n 位。Python 從零四舍五入作為決勝局:round(0.5) 是 1.0,round(-0.5) 是 -1.0。


                        14 平方(x)

                        x > 0 時 x 的平方根


                        隨機數函數

                        隨機數用于游戲、模擬、測試、安全和隱私應用。Python 包括以下常用函數。


                        編號 功能說明

                        1 選擇(序列)

                        列表、元組或字符串中的隨機項。


                        2 randrange([開始,]停止[,步驟])

                        從范圍(開始,停止,步驟)中隨機選擇的元素


                        3 隨機的()

                        一個隨機浮點數 r,使得 0 小于或等于 r 并且 r 小于 1


                        4 種子([x])

                        設置用于生成隨機數的整數起始值。在調用任何其他隨機模塊函數之前調用此函數。返回無。


                        5 洗牌(一首)

                        隨機化列表中的項目。返回無。


                        6 統一(x,y)

                        一個隨機浮點數 r,使得 x 小于或等于 r 并且 r 小于 y


                        三角函數

                        Python 包括以下執行三角函數計算的函數。


                        編號 功能說明

                        1 acos(x)

                        返回 x 的反余弦,以弧度為單位。


                        2 阿辛(X)

                        返回 x 的反正弦,以弧度為單位。


                        3 atan(x)

                        返回 x 的反正切,以弧度為單位。


                        4 atan2(y, x)

                        返回 atan(y / x),以弧度為單位。


                        5 余弦(x)

                        返回 x 弧度的余弦。


                        6 假設(x,y)

                        返回歐幾里得范數 sqrt(x*x + y*y)。


                        7 罪(x)

                        返回 x 弧度的正弦值。


                        8 tan(x)

                        返回 x 弧度的正切。


                        9 度(x)

                        將角度 x 從弧度轉換為度。


                        10 弧度(x)

                        將角度 x 從度轉換為弧度。


                        數學常數

                        該模塊還定義了兩個數學常數 -


                        編號 常量和描述

                        1

                        圓周率


                        數學常數 pi。


                        2

                        e


                        數學常數 e。


                        << < 1 2 3 4 5 6 7 8 9 10 > >>

                        Copyright www.6798111.com Rights Reserved葵花寶典教程.鄂icp2022001145號-1

                        分享:

                        支付寶

                        微信

                        性欧美乱子伦,两根一进一出啊灌满了啊,被公侵犯玩弄漂亮人妻中文
                        <em id="hh9r9"><nobr id="hh9r9"><nobr id="hh9r9"></nobr></nobr></em>

                              <form id="hh9r9"><listing id="hh9r9"><meter id="hh9r9"></meter></listing></form>

                                              <address id="hh9r9"></address>