MySQL創立新用戶、增長賬戶的2種辦法及應用實例

MySQL創立新用戶、增長賬戶的2種辦法及應用實例。本站提示廣大學習愛好者：（MySQL創立新用戶、增長賬戶的2種辦法及應用實例）文章只能為提供參考，不一定能成為您想要的結果。以下是MySQL創立新用戶、增長賬戶的2種辦法及應用實例正文

簡略類型

內置到 Python 編程說話中的簡略數據類型包含：

    bool
    int
    float
    complex

支撐簡略數據類型不是 Python 獨有的功效，由於多半古代編程說話都具有完全類型彌補。例如 Java? 說話乃至有一組更豐碩的原始數據類型：

    byte
    short
    int
    long
    float
    double
    char
    boolean

然則，在 Python 中，簡略數據類型其實不是原始數據類型，而是完美的對象，它們有自已的辦法和類。別的，這些簡略的內置類型是弗成轉變的，這意味著：創立對象以後，您沒法更改對象的值。假如須要新值，則必需創立新的對象。Python 簡略數據類型的弗成轉變特征與其他多半風行說話（如 Java 說話）處置簡略原始類型的方法分歧。然則，當您對這些簡略數據類型的對象屬性有了更多的懂得以後，就很輕易懂得這類差別。

所以，整數若何可以或許具有一些辦法？它僅僅是一個數字嗎？不是的，至多在 Python 中謎底能否定的。您自已可以對它停止磨練：僅借助內置的 help 辦法，便可以向 Python 說明器征詢關於 int 對象的信息（拜見清單 1 ）。
清單 1. Python 說明器: 用於整數對象的 Help

rb% python
Python 2.4 (#1, Mar 29 2005, 12:05:39) 
[GCC 3.3 20030304ppp(Apple Computer, Inc. build 1495)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> help(int)
Help on class int in module __builtin__:
class int(object)
 | int(x[, base]) -> integer
 | 
 | Convert a string or number to an integer, if possible. A floating point
 | argument will be truncated towards zero (this does not include a string
 | representation of a floating point number!) When converting a string, use
 | the optional base. It is an error to supply a base when converting a
 | non-string. If the argument is outside the integer range a long object
 | will be returned instead.
 | 
 | Methods defined here:
 | 
 | __abs__(...)
 |   x.__abs__() <==> abs(x)
 | 
 | __add__(...)
 |   x.__add__(y) <==> x+y
...

這詳細解釋了甚麼？只要一個工作，那就是可以便利地從 Python 說明器中獲得贊助，然則從前面部門可以取得更多贊助。第一行告知您正在檢查 int 類的贊助頁面，它是一個內置的數據類型。假如您對面向對象的編程的概念不太熟習，那末可以將類 想像成只是一個用於構建特別事物並與之交互的藍圖。比如房子的設計藍圖，不只顯示若何構建房子，還顯示房子落成以後，若何更好地應用房子。例如，設計圖會顯示分歧房間的地位、在房間之間的挪動方法和收支房子的通道情形。

第一行的上面是對現實 int 類的具體解釋。在這一點上，您能夠不熟習若何在 Python 中創立類，由於顯示的語法相似於外語。沒緊要，我將在另外一篇文章中對此停止周全引見。如今，您只須要曉得：int 對象是從 object 類中繼續而來，它是 Python 中很多內容的一個基類。

前面的幾行引見 int 類的結構函數。結構函數 只是創立特定類實例（或對象) 的特別辦法。結構函數辦法比如修建承包人，它應用房子的設計圖建房子。在 Python 中，結構函數的稱號與其創立的類的稱號雷同。類可以有分歧的結構函數辦法，這些辦法是經由過程類稱號後的圓括號內附帶的分歧屬性停止辨別。類可以有分歧結構函數辦法的較好的一個例子就是 int 類, 現實上，您可以用多種辦法挪用它，詳細采取哪一種辦法取決於圓括號中放置的參數（拜見清單 2）。
清單 2. Python 說明器：int 類結構函數

>>> int()
0
>>> int(100)     # Create an integer with the value of 100
>>> int("100", 10)  # Create an integer with the value of 100 in base 10
100
100
>>> int("100", 8)   # Create an integer with the value of 100 in base 8
64

這四個結構函數挪用創立了四個分歧的整數。第一個結構函數創立了一個整數對象，其值為 0，在沒有值供給給 int 類結構函數的情形下，該值是所應用的默許值。第二個結構函數依據劃定創立了一個值為 100 的整數。第三個結構函數采取了字符串“100”並創立了以 10 為基數的整數值（罕見的十進制體系）。最初一個結構函數也采取了字符串“100”—— 然則它應用基數 8 來創立整數值，平日稱為 八進制。不外，該值在輸入時會被轉換成十進制數值，這就是該數字顯示為 64 的緣由。

您能夠想曉得假如省略了結構函數挪用中的圓括號將會產生甚麼。在這類情形下，您可以向該變量分派一個現實的類稱號，有用地為本來的類創立一個體名（拜見清單 3）。
清單 3. Python 說明器：int 類型

>>> it = int     # Create an alias to the integer class
>>> it(100)
100
>>> type(it)     # We created a new type
<type 'type'>
>>> type(it(100))  # Our new type just makes integers
<type 'int'>

真是太棒了！您立刻可以創立一個由內置 int 類界說的新數據類型。但請留意欠好的一面，不要濫用這一新功效。優良的法式員除使代碼具有優越機能外，還應盡力使代碼清淅。這類編碼技能切實其實有其應用價值，但它們其實不罕見。

應用 Python 說明器可使新的 Python 法式員簡化進修進程，少走彎路。假如您想具體懂得 Python 內的 help 對象，只需在 Python 說明器中的敕令提醒符下鍵入 help() ，便可以拜訪交互式的贊助對象（拜見清單 4)。
清單 4. Python 說明器：贊助說明器

>>> help()
Welcome to Python 2.4! This is the online help utility.
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://www.python.org/doc/tut/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type "quit".
To get a list of available modules, keywords, or topics, type "modules",
"keywords", or "topics". Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as "spam", type "modules spam".
help>

您能夠曾經對此有所懂得，但在 help> 提醒符處輸出 int 可以顯示那些為之前的 int 類顯示的類描寫。

容器類型

到今朝為止，曾經議論了很多 Python 說話中應用的簡略類型。然則多半法式其實不簡略，它們觸及平日由簡略類型構成的龐雜數據。是以，如今的成績就成了“若何在 Python 中處置龐雜數據？”

假如您熟習面向對象的說話，如 Java 或 C#，那末您能夠以為該成績的謎底很簡略：只需創立一個新類來處置龐雜的數據便可。該辦法也實用於 Python，緣由是 Python 支撐經由過程類創立新類型。然則，在多半情形下，Python 還可以供給更加簡略的辦法。當您的法式須要一次處置多個對象時，便可以應用 Python 容器類：

    tuple
    string
    unicode
    list
    set
    frozenset
    dictionary

這些容器類型供給了兩種功效。前六個類型是有序的，最初一個類型 dictionary 則是一個映照。有序類型與映照類型的差別較為簡略。有序類型 僅僅是指對象的次序。一切的有序類型（除 set 和 frozenset 類型外）都支撐拜訪給定次序的對象。比擬之下，映照容器 則用於保留那些對次序不是很敏感的對象；經由過程供給可以找到關系值的密鑰，便可以自在器中提取值。

容器類型間的另外一個分歧點來自於它們所持有的數據的特征，上面四種容器類型的次序是弗成變的：

    tuple
    string
    unicode
    frozenset

這意味著在您創立了這些容器類型之一後，所存儲的數據就弗成更改。假如出於某種緣由須要更改數據，則須要創立一個新容器來保留新的數據。

後三種容器類型（list、set 和 dictionary）都是可變容器，是以，它們可以依據須要更改保留的任何數據（但在 dictionary 中所應用的密鑰是弗成變的，就像您房間的鑰匙）。固然可變容器異常靈巧，但它們的靜態特征會對機能形成影響。例如，tuple 類型，雖然它是弗成變的，靈巧性較差，但在統一情況中應用時，它們平日比 list 類型快很多。

這些容器類供給了壯大的功效，它們平日是多半 Python 法式的焦點。本文的其他部門評論辯論了 tuple 類型，它用於引入很多與創立和應用 Python 中的容器類型有關的根本概念。其他的類型將在今後的文章中評論辯論。
元組

tuple 類型像一個口袋，在出門前可以把所需的任何器械一股腦地放在外面。您可以將鑰匙、駕駛證、便箋簿和鋼筆放在口袋裡，您的口袋是寄存各類器械的搜集箱。Python 的 tuple 類型與口袋相似，它可以寄存分歧類型的對象。您只需向變量分派一個用逗號分隔的對象序列，便可以創立一個 tuple（拜見清單 5）。
清單 5. Python 說明器：創立一個 tuple

>>> t = (0,1,2,3,4,5,6,7,8,9)
>>> type(t)
<type 'tuple'>
>>> t
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> tt = 0,1,2,3,4,5,6,7,8,9
>>> type(tt)
<type 'tuple'>
>>> tt
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> tc=tuple((0,1,2,3,4,5,6,7,8,9))
>>> tc
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> et = ()   # An empty tuple
>>> et
()
>>> st = (1,)  # A single item tuple
>>> st
(1,)

該示例代碼顯示了若何以多種方法創立 tuple。第一種辦法是創立一個包括從 0 到 9 整數序列的 tuple。第二種辦法與第一種雷同，但此次省去了括號。在創立一個 tuple 時，括號平日是可選的，但有時是必須的，這取決於高低文。成果，您會習氣性地應用括號來削減混雜。最初一個 tupletc 應用了一個現實的類結構函數來創立 tuple。這裡主要的一點是，結構函數組成中唯一一個變量，是以您必需在括號中包含對象序列。最初兩個結構函數挪用演示了若何經由過程在括號內不聽任何器械來創立空的 tuple (et)，和若何經由過程將一個逗號放在序列中唯一的一個項目前面來創立 tuple (st)。

應用口袋裝器械的一個重要緣由是為了便利生涯。但請求在須要這些器械的時刻可以或許敏捷地從口袋中掏出它們。Python 中的多半容器類型（個中包含 tuple）許可您應用方括號操作符從聚集中便利地拜訪數據項。但 Python 比其他說話更具靈巧性：您可使用平日稱為分段 的辦法選擇一個項目或多個有序項目（拜見清單 6）。
清單 6. Python 說明器：從 tuple 拜訪項目

>>> t = (0,1,2,3,4,5,6,7,8,9)
>>> t[2]
2
>>> type(t[2])
<type 'int'>
>>> t[0], t[1], t[9]
(0, 1, 9)
>>> t[2:7]      # Slice out five elements from the tuple
(2, 3, 4, 5, 6)
>>> type(t[2:7])
<type 'tuple'>
>>> t[2:7:2]     # Slice out three elements from the tuple
(2, 4, 6)

在創立簡略的 tuple 以後，後面的示例顯示若何選擇一個數據項 —— 在本示例中是整數 2。這時候，請留意 Python 應用了零排序，個中聚集中的項目從零開端編號。假如您熟習應用 Java 說話、C# 或其他從 C 說話派生的說話停止編程，那末您應當異常熟習此行動。不然，該概念也長短常簡略的。用於拜訪數據項的索引只聲明聚集中超出第一個數據項有多遠，或許稱為序列，您須要去取得所需的內容。是以，要取得第三個數據項（在本示例中為整數 2），您須要從第一個數據項起超出兩個數據項。在拜訪第三個數據項時，Python 曉得它是一個整數對象。您還可以便利地從聚集中提取多個數據項。在本示例中，您創立了一個新的 tuple，其值為從最後的 tuple 開端第1、第二和第十個值。

其他的示例顯示了若何應用 Python 的分段功效從序列中一次選擇多個數據項。術語分段 是指從序列中對數據項停止分段的辦法。分段的任務方法是聲明開端索引、停止索引和一個可選的步調年夜小，全體都用分號分隔。是以，t[2:7] 將 tuple 中的第三到第七個數據項分段，而 t[2:7:2] 則對每兩個數據項停止分段，從 tuple 中的第三個數據項開端一向到第七個數據項。

我今朝創立的 tuple 對象是同類的，它們僅包括整數對象。所幸的是，tuple 要比顯示的示例龐雜很多，由於 tuple 現實上是一個異構容器（拜見清單 7）。
清單 7. Python 說明器：異構的 tuple

>>> t = (0,1,"two",3.0, "four", (5, 6))
>>> t
(0, 1, 'two', 3.0, 'four', (5, 6))
>>> t[1:4]
(1, 'two', 3.0)
>>> type(t[2]) 
<type 'str'>
>>> type(t[3])
<type 'float'>
>>> type(t[5])
<type 'tuple'>
>>> t[5] = (0,1)
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
TypeError: object does not support item assignment

您會看到，創立可以具有各類類型數據項（個中包含另外一 tuple）的 tuple 是何等便利。而且可使用方括號操作符以雷同的方法拜訪一切數據項，它支撐將分歧類型的有序數據項分段。但是，tuple 是弗成變的。是以，當我測驗考試更改第五個元素時，發明不許可對數據項分派。打一個簡略的比喻，在您將某些器械放進口袋後，轉變所取器械的唯一方法是取一個新口袋，並將一切數據項放出來。

假如須要在現有 tuple 中創立一個包括數據項子集的新 tuple，最簡略的辦法是應用相干的片斷，並依據須要同時添加子集（拜見清單 8）。
清單 8. Python 說明器：應用 tuple

>>> tn = t[1:3] + t[3:6] # Add two tuples
>>> tn
(1, 'two', 3.0, 'four', (5, 6))
>>> tn = t[1:3] + t[3:6] + (7,8,9,"ten")
>>> tn
(1, 'two', 3.0, 'four', (5, 6), 7, 8, 9, 'ten')
>>> t2 = tn[:]      # Duplicate an entire tuple, a full slice
>>> t2
(1, 'two', 3.0, 'four', (5, 6), 7, 8, 9, 'ten')
>>> len(tn)        # Find out how many items are in the tuple
9 
>>> tn[4][0]       # Access a nested tuple
5

您還可以將現有 tuple 的片斷與新 tuple 的片斷歸並在一路。應用片斷語法，無需指定開端或停止索引，便可以制造現有 tuple 的正本。最初兩個示例也異常風趣。內置的 len 辦法告知您 tuple 中數據項的數目。從嵌套的 tuple 拜訪數據項也異常簡略：選擇嵌套的 tuple，然後從中拜訪風趣的數據項。

您還可以從稱為打包 的進程的一組現有變量中創立一個tuple。反之亦然，個中，tuple 中的值被指派給變量。這以後的進程稱為解包，它是用於很多情況的功效非常壯大的技巧，個中包含願望從一個函數中前往多個值。在解包 tuple 時，唯一的成績是必需為 tuple 中的每一個數據項供給一個變量（拜見清單 9）。
清單 9. Python 說明器：打包息爭包 tuple

>>> i = 1
>>> s = "two"
>>> f = 3.0
>>> t = (i, s, f)     # Pack the variables into a tuple
>>> t
(1, 'two', 3.0)
>>> ii, ss, ff = t    # Unpack the tuple into the named variables
>>> ii
1
>>> ii, ff = t      # Not enough variables to unpack three element tuple
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
ValueError: too many values to unpack

簡化概念

雖然看上去非常龐雜，但 Python 的對象屬性現實上簡化了 Python 說話老手經常面對的一些更加龐雜的概念。在懂得若何應用對象以後，一切器械都是對象這一概念意味著您曾經進一步懂得了一些新概念。如 Python 的容器類型。使艱苦的義務變得簡略化是應用 Python 獲得的罕見利益之一；另外一個例子是內置的贊助對象，只需在 Python 提醒符處輸出 help()，便可以在 Python 說明器中看到該對象。因為生涯不是用一些簡略的概念描寫的，所以 Python 供給了一組豐碩的容器（即聚集）對象。在本文中，我引見了個中的最簡略的對象 —— tuple。要准確應用 tuple，就須要熟習它的任務方法。然則，因為很多其他容器類型具有相似的功效，個中包含分段和打包或解包，懂得 tuple 的任務道理意味著您曾經開端完整懂得 Python 中的其他容器類型。