pythontuplestring

Ⅰ python語言有哪些數據類型

1、number

即數字類型，包含int(整型)、float(浮點型)、bool、complex(復數類型)四種基本類型，可用於存儲數值;

類型轉換：int()、float();

數學運算：+、-、*都與C語言相同，/表示做觸發(結果一定為浮點數)，//表示做除法，(結果只保留整數部分，去掉小數部分)% 表示做求余運算**
表示做冪次方運算 (注意運算次序)

2、string

即字元串類型，字元串需要用單引號』』或雙引號" "括起來 三引號–注釋，字元串也是一種特殊的元組。不能改變字元串中的某個元素的值;

基礎操作：索引、切片、乘法-多次輸出、成員資格檢查、長度len()、最大值、最小值;

3、list

即列表類型，list的數據項可以是不同類型，其各個元素也可以改變，list是使用[]方括弧包含各個數據項，+多個列表進行合並成一個列表*列表重復輸出多次in某個項是否在列表中，可對列表項進行添加、修改、刪除。

4、tuple

即元組類型，tuple 是使用( )小括弧包含各個數據項，tuple與list的唯一區別是tuple的元素是不能修改，而list的元素可以修改。

5、set

即集合類型，是一個無序不重復元素的序列，使用大括弧{}或者set()函數創建集合，用set()創建一個空幾個，使用set也可以去重。

6、dictionary

即字典類型，字典的每個元素是鍵值對，無序的對象集合，是可變容器模型，且可存儲任意類型對象，可以通過鍵來引用，鍵必須是唯一的且鍵名必須是不可改變的(即鍵名必須為Number、String、元組三種類型的某一種)，但值則不必。

Ⅱ 軟體測試中,python可變數據類型和不可變數據類型

不可變數據類型的就是內存中不管有多少個引用，相同的對象只佔用了一塊內存，但是它的缺點就是當需要對變數進行運算從而改變變數引用的對象的值時，由於是不可變的數據類型，所以必須創建新的對象，這樣就會使得一次次的改變創建了一個個新的對象，不過不再使用的內存會被垃圾回收器回收。
其實其他語言，比如java也有類似的功能，就是一些基礎的數字，例如前256個，都是固定在靜態區的某個位置的，而不會隨著指針變數的變化，而導致所指向的地址變化。

Ⅲ python 概念 list,string,tuple 類型區別 以及 數據類型區別

標准答案我是不知道，但是string的元素只能是字元；而list,
tuple中的元素幾乎可以為任意類型(包括list,
tuple,
dict等)。

Ⅳ python 函數參數類型

python 的函數參數類型分為4種：
1.位置參數：調用函數時根據函數定義的參數位置來傳遞參數，位置參數也可以叫做必要參數，函數調用時必須要傳的參數。

當參數滿足函數必要參數傳參的條件，函數能夠正常執行：
add(1,2) #兩個參數的順序必須一一對應，且少一個參數都不可以
當我們運行上面的程序,輸出:

當函數需要兩個必要參數，但是調用函數只給了一個參數時，程序會拋出異常
add(1)
當我們運行上面的程序,輸出：

當函數需要兩個必要參數，但是調用函數只給了三個參數時，程序會拋出異常
add(1,2,3)
當我們運行上面的程序,輸出

2.關鍵字參數：用於函數調用，通過「鍵-值」形式加以指定。可以讓函數更加清晰、容易使用，同時也清除了參數的順序需求。
add(1,2) # 這種方式傳參，必須按順序傳參：x對應1，y對應:2
add(y=2,x=1) #以關健字方式傳入參數（可以不按順序）

正確的調用方式
add(x=1, y=2)
add(y=2, x=1)
add(1, y=2)
以上調用方式都是允許的，能夠正常執行

錯誤的調用方式
add(x=1, 2)
add(y=2, 1)
以上調用都會拋出SyntaxError 異常

上面例子可以看出：有位置參數時，位置參數必須在關鍵字參數的前面，但關鍵字參數之間不存在先後順序的
3.默認參數：用於定義函數，為參數提供默認值，調用函數時可傳可不傳該默認參數的值，所有位置參數必須出現在默認參數前，包括函數定義和調用，有多個默認參數時，調用的時候，既可以按順序提供默認參數，也可以不按順序提供部分默認參數。當不按順序提供部分默認參數時，需要把參數名寫上

默認參數的函數定義

上面示例第一個是正確的定義位置參數的方式，第二個是錯誤的，因為位置參數在前，默認參數在後
def add1(x=1,y) 的定義會拋出如下異常

默認參數的函數調用

注意：定義默認參數默認參數最好不要定義為可變對象，容易掉坑
不可變對象：該對象所指向的內存中的值不能被改變，int,string,float,tuple
可變對象，該對象所指向的內存中的值可以被改變，dict,list
這里只要理解一下這個概念就行或者自行網路，後續會寫相關的專題文章講解
舉一個簡單示例

4.可變參數區別:定義函數時，有時候我們不確定調用的時候會多少個參數,j就可以使用可變參數
可變參數主要有兩類：
*args: (positional argument) 允許任意數量的可選位置參數(參數),將被分配給一個元組, 參數名前帶*，args只是約定俗成的變數名，可以替換其他名稱
**kwargs：(keyword argument) 允許任意數量的可選關鍵字參數，,將被分配給一個字典，參數名前帶**，kwargs只是約定俗成的變數名，可以替換其他名稱

*args 的用法

args 是用來傳遞一個非鍵值對的可變數量的參數列表給函數
語法是使用 符號的數量可變的參數; 按照慣例,通常是使用arg這個單詞，args相當於一個變數名，可以自己定義的

在上面的程序中,我們使用* args作為一個可變長度參數列表傳遞給add()函數。 在函數中,我們有一個循環實現傳遞的參數計算和輸出結果。
還可以直接傳遞列表或者數組的方式傳遞參數,以數組或者列表方式傳遞參數名前面加（*） 號

理解* * kwargs

**kwargs 允許你將不定長度的鍵值對, 作為參數傳遞給函數，這些關鍵字參數在函數內部自動組裝為一個dict

下篇詳細講解 *args, **kwargs 的參數傳遞和使用敬請關注

Ⅳ 列表,元組,字元串是python的什麼序列

序列
序列是Python中最基本的數據結構，包括字元串、列表、元組。

序列，顧名思義，是有序的，序列都有索引，都能進行索引、切片(截取)、加(連接)、乘(倍增)、檢查成員的操作。

因為序列有序，可通過位置來區分元素，所以序列中可含有相同的元素。

序列的通用操作

1、索引

seq[index] index從0開始，支持負數，-1表示最後一個元素。

2、切片(截取)

seq[start:end] 可截取子序列，返回的是副本，原序列不變。預設時默認start為0，end為-1。

3、+(連接)

seq1+seq2+seq3+..... 將多個序列連接為一個序列，返回的是副本，原序列不變

序列的類型要相同，才能相加，比如列表只能+列表，不能+字元串。

4、*(倍增)

seq*n 將序列擴展為原來的n倍，比如「hello」*2就是「hellohello」。返回的是副本，原序列不變。

5、in、not in(檢查成員)

element in/not in seq 判斷某個成員是否在序列中，返回值是bool型

6、python內置函數，不必導入模塊：

len(seq) 返回序列長度(元素個數)

max(seq) 返回序列中值最大的元素

min(seq) 返回序列中值最小的元素

列表(List)

列表中的元素類型可以不同，甚至可以嵌套復雜的數據類型。列表用中括弧[ ]表示。
list1=[1,2,3] #類型相同

list2=[1,"ok",[1,2,3]] #類型不同&&嵌套

列表的常用方法

函數

描述

list.append(ele)

在list末尾添加一個元素

list.insert(index,ele)

在指定位置插入一個元素

list.count(ele)

統計list中ele出現的次數
list.extend(x)

擴展list，x可以是列表、元組、集合、字典(只添加key)。添加到list的末尾。

+連接只能連接相同類型的序列。

list.index(ele)

索引元素，返回索引

list.pop([index])

彈出(刪除)並返回指定位置上的元素，，預設index時默認為-1(最後一個元素)。

list.remove(ele)

移除指定元素，若list中有多個ele，只移除第一個ele

list.()

復制list，返回復制的列表。示例：list2=list1.()

list.clear()

清空列表
list.reverse()
反序排列
list.sort(reverse=True)
將列表中的元素按升/降序排列，預設參數時默認為False(升序)，True是降序。示例：

list.sort() #升序排列

list.sort(reverse=True) #降序排列

注意：此函數不返回排序後的列表。

列表(List)是可變的，如果上述方法修改了List，List會改變。

數字(Number)、字元串(String)、元組(Tuple)是不可變的，操作時返回的往往是副本，原來的值不變。

元組(Tuple)

元組中可以含有不同類型的數據。

元組不能被修改，不能刪除、修改元組中的元素，但可以用del刪除整個元組。

元組用小括弧()表示。

tuple1=() #空元組

tuple2=(1,4,3)

tuple3=(1,"ok",[1,2,3]) #類型不同&&嵌套

列表、元組之間的轉換

1、list(tup) 將元組轉換為列表

myTuple=(1,2,3)print(list(myTuple)) #[1, 2, 3]

"""python的內置函數list(tup)可以將元組轉換為列表，並返回該列表

此函數不會修改元組本身，myTuple仍是元組，本身不會變成列表"""

2、tuple(list) 將列表轉換元組

myList=[1,2,3]print(tuple(myList)) #(1, 2, 3)

"""python的內置函數tuple(list)可以將列表轉換為元組，並返回該元組

此函數不會修改列表本身，myList仍是列表，本身不會變成元組"""

這2種方法均不會修改列表、元組本身。

Ⅵ 如何成功地使用 dictionary

本文研究 Python 類型層次結構並介紹 dictionary 容器類型。與前面文章中討論的 Python tuple、string 和 list 容器類型不同，dictionary 類型是一個無序的容器，依賴於鍵-值映射。因此，要根據鍵值訪問 dictionary 中的元素，而不是根據它們在序列中的位置。dictionary 類型的獨特特性看起來可能不同尋常，但是如果使用得當，它們可以提供強大的能力。

dictionary

我們都曾經使用過語言詞典來查找不認識的單詞的定義。語言詞典針對給定的單詞（比如 python）提供一組標準的信息。這種系統將定義和其他信息與實際的單詞關聯（映射）起來。使用單詞作為鍵定位器來尋找感興趣的信息。這種概念延伸到 Python 編程語言中，就成了特殊的容器類型，稱為 dictionary。

dictionary 數據類型在許多語言中都存在。它有時候稱為關聯 數組（因為數據與一個鍵值相關聯），或者作為散列表。但是在 Python 中，dictionary 是一個很好的對象，因此即使是編程新手也很容易在自己的程序中使用它。按照正式的說法，Python 中的 dictionary 是一種異構的、易變的映射容器數據類型。

創建 dictionary

本系列中前面的文章介紹了 Python 編程語言中的一些容器數據類型，包括 tuple、string 和 list（參見 參考資料）。這些容器的相似之處是它們都是基於序列的。這意味著要根據元素在序列中的位置訪問這些集合中的元素。所以，給定一個名為 a 的序列，就可以使用數字索引（比如 a[0] ）或片段（比如 a[1:5]）來訪問元素。Python 中的 dictionary 容器類型與這三種容器類型的不同之處在於，它是一個無序的集合。不是按照索引號，而是使用鍵值來訪問集合中的元素。這意味著構造 dictionary 容器比 tuple、string 或 list 要復雜一些，因為必須同時提供鍵和相應的值，如清單 1 所示。

清單 1. 在 Python 中創建 dictionary，第 1 部分

>>> d = {0: 『zero』, 1: 『one』, 2 : 『two』, 3 : 『three』, 4 : 『four』, 5: 『five』}
>>> d
{0: 『zero』, 1: 『one』, 2: 『two』, 3: 『three』, 4: 『four』, 5: 『five』}
>>> len(d)
>>> type(d) # Base object is the dict class
<type 『dict』>
>>> d = {} # Create an empty dictionary
>>> len(d)
>>> d = {1 : 『one』} # Create a single item dictionary
>>> d
{1: 『one』}
>>> len(d)
>>> d = {『one』 : 1} # The key value can be non-numeric
>>> d
{『one』: 1}
>>> d = {『one』: [0, 1,2 , 3, 4, 5, 6, 7, 8, 9]}
>>> d
{『one』: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
復制代碼

如這個例子所示，在 Python 中創建 dictionary 要使用花括弧和以冒號分隔的鍵-值組合。如果沒有提供鍵-值組合，那麼就會創建一個空的 dictionary。使用一個鍵-值組合，就會創建具有一個元素的 dictionary，以此類推，直至您需要的任何規模。與任何容器類型一樣，可以使用內置的 len 方法查明集合中元素的數量。

前面的示例還演示了關於 dictionary 容器的另一個重要問題。鍵並不限制為整數；它可以是任何不易變的數據類型，包括 integer、float、tuple 或 string。因為 list 是易變的，所以它不能作為 dictionary 中的鍵。但是 dictionary 中的值可以是任何數據類型的。

最後，這個示例說明了 Python 中 dictionary 的底層數據類型是 dict 對象。要進一步了解如何使用 Python 中的 dictionary，可以使用內置的幫助解釋器來了解 dict 類，如清單 2 所示。

清單 2. 獲得關於 dictionary 的幫助

>>> help(dict)on class dict in mole __builtin__:
dict(object)
| dict() -> new empty dictionary.
| dict(mapping) -> new dictionary initialized from a mapping object』s
| (key, value) pairs.
| dict(seq) -> new dictionary initialized as if via:
| d = {}
| for k, v in seq：
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Methods defined here:
|
| __cmp__(…)
| x.__cmp__(y) <==> cmp(x,y)
|
| __contains__(…)
| x.__contains__(y) <==> y in x
|
| __delitem__(…)
| x.__delitem__(y) <==> del x[y]
…[/code]關於 dict 類的幫助指出，可以使用構造函數直接創建 dictionary，而不使用花括弧。既然與其他容器數據類型相比，在創建 dictionary 時必須提供更多的數據，那麼這些創建方法比較復雜也就不足為奇了。但是，在實踐中使用 dictionary 並不難，如清單 3 所示。

清單 3. 在 Python 中創建 dictionary，第 2 部分

>>> l = [0, 1,2 , 3, 4, 5, 6, 7, 8, 9]
>>> d = dict(l)(most recent call last):
File "<stdin>", line 1, in ?: can't convert dictionary
update sequence element #0 to a sequence
>>> l = [(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]
>>> d = dict(l)
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> l = [[0, 'zero'], [1, 'one'], [2, 'two'], [3, 'three']]
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d = dict(l)
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d = dict(zero=0, one=1, two=2, three=3)
>>> d
{'zero': 0, 'three': 3, 'two': 2, 'one': 1}
>>> d = dict(0=zero, 1=one, 2=two, 3=three): keyword can't be an expression
復制代碼

可以看到，創建 dictionary 需要鍵值和數據值。第一次從 list 創建 dictionary 的嘗試失敗了，這是因為沒有匹配的鍵-數據值對。第二個和第三個示例演示了如何正確地創建 dictionary：在第一種情況下，使用一個 list，其中的每個元素都是一個 tuple；在第二種情況下，也使用一個 list，但是其中的每個元素是另一個 list。在這兩種情況下，內層容器都用於獲得鍵到數據值的映射。

直接創建 dict 容器的另一個方法是直接提供鍵到數據值的映射。這種技術允許顯式地定義鍵和與其對應的值。這個方法其實用處不大，因為可以使用花括弧完成相同的任務。另外，如前面的例子所示，在採用這種方式時對於鍵不能使用數字，否則會導致拋出一個異常。

訪問和修改 dictionary

創建了 dictionary 之後，需要訪問其中包含的數據。訪問方式與訪問任何 Python 容器數據類型中的數據相似，如清單 4 所示。

清單 4. 訪問 dictionary 中的元素

>>> d = dict(zero=0, one=1, two=2, three=3)
>>> d
{'zero': 0, 'three': 3, 'two': 2, 'one': 1}
>>> d['zero']
>>> d['three']
>>> d = {0: 'zero', 1: 'one', 2 : 'two', 3 : 'three', 4 : 'four', 5: 'five'}
>>> d[0]
'zero'
>>> d[4]
'four'
>>> d[6](most recent call last):
File "<stdin>", line 1, in ?: 6
>>> d[:-1](most recent call last):
File "<stdin>", line 1, in ?: unhashable type
復制代碼

可以看到，從 dictionary 中獲取數據值的過程幾乎與從任何容器類型中獲取數據完全一樣。在容器名後面的方括弧中放上鍵值。當然，dictionary 可以具有非數字的鍵值，如果您以前沒有使用過這種數據類型，那麼適應這一點需要些時間。因為在 dictionary 中次序是不重要的（dictionary 中數據的次序是任意的），所以可以對其他容器數據類型使用的片段功能，對於 dictionary 是不可用的。試圖使用片段或者試圖從不存在的鍵訪問數據就會拋出異常，指出相關的錯誤。

Python 中的 dictionary 容器也是易變的數據類型，這意味著在創建它之後可以修改它。如清單 5 所示，可以添加新的鍵到數據值的映射，可以修改現有的映射，還可以刪除映射。

清單 5. 修改 dictionary

>>> d = {0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d[0]
'zero'
>>> d[0] = 'Zero'
>>> d
{0: 'Zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d[4] = 'four'
>>> d[5] = 'five'
>>> d
{0: 'Zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
>>> del d[0]
>>> d
{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
>>> d[0] = 'zero'
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
復制代碼

清單 5 演示了幾個重點。首先，修改數據值是很簡單的：將新的值分配給適當的鍵。其次，添加新的鍵到數據值的映射也很簡單：將相關數據分配給新的鍵值。Python 自動進行所有處理。不需要調用 append 這樣的特殊方法。對於 dictionary 容器，次序是不重要的，所以這應該好理解，因為不是在 dictionary 後面附加映射，而是將它添加到容器中。最後，刪除映射的辦法是使用 del 操作符以及應該從容器中刪除的鍵。

在清單 5 中有一個情況看起來有點兒怪，鍵值是按照數字次序顯示的，而且這個次序與插入映射的次序相同。不要誤解 —— 情況不總是這樣的。Python dictionary 中映射的次序是任意的，對於不同的 Python 安裝可能會有變化，甚至多次使用同一 Python 解釋器運行相同代碼也會有變化。如果在一個 dictionary 中使用不同類型的鍵和數據值，那麼就很容易看出這一點，如清單 6 所示。

清單 6. 異構的容器

>>> d = {0: 'zero', 'one': 1}
>>> d
{0: 'zero', 'one': 1}
>>> d[0]
'zero'
>>> type(d[0])
<type 'str'>
>>> d['one']
>>> type(d['one'])
<type 'int'>
>>> d['two'] = [0, 1, 2]
>>> d
{0: 'zero', 'two': [0, 1, 2], 'one': 1}
>>> d[3] = (0, 1, 2, 3)
>>> d
{0: 'zero', 3: (0, 1, 2, 3), 'two': [0, 1, 2], 'one': 1}
>>> d[3] = 'a tuple'
>>> d
{0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
復制代碼

如這個例子所示，可以在一個 dictionary 中使用不同數據類型的鍵和數據值。還可以通過修改 dictionary 添加新的類型。最後，產生的 dictionary 的次序並不與插入數據的次序匹配。本質上，dictionary 中元素的次序是由 Python dictionary 數據類型的實際實現控制的。新的 Python 解釋器很容易改變這一次序，所以一定不要依賴於元素在 dictionary 中的特定次序。

用 dictionary 進行編程

作為正式的 Python 數據類型，dictionary 支持其他較簡單數據類型所支持的大多數操作。這些操作包括一般的關系操作符，比如 <、> 和 ==，如清單 7 所示。

清單 7. 一般關系操作符

>>> d1 = {0: 'zero'}
>>> d2 = {'zero':0}
>>> d1 < d2
>>> d2 = d1
>>> d1 < d2
>>> d1 == d2
>>> id(d1)
>>> id(d2)
>>> d2 = d1.()
>>> d1 == d2
>>> id(d1)
>>> id(d2)
復制代碼

前面的示例創建兩個 dictionary 並使用它們測試 < 關系操作符。盡管很少以這種方式比較兩個 dictionary；但是如果需要，可以這樣做。

然後，這個示例將賦值給變數 d1 的 dictionary 賦值給另一個變數 d2。注意，內置的 id() 方法對於 d1 和 d2 返回相同的標識符值，這說明這不是復制操作。要想復制 dictionary ，可以使用 () 方法。從這個示例中的最後幾行可以看出，副本與原來的 dictionary 完全相同，但是容納這個 dictionary 的變數具有不同的標識符。

在 Python 程序中使用 dictionary 時，很可能希望檢查 dictionary 中是否包含特定的鍵或值。如清單 8 所示，這些檢查很容易執行。

清單 8. 條件測試和 dictionary

>>> d = {0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
>>> d.keys()
[0, 3, 'two', 'one']
>>> if 0 in d.keys():
... print 'True'
...
>>> if 'one' in d:
... print 'True'
...
>>> if 'four' in d:
... print 'Dictionary contains four'
... elif 'two' in d:
... print 'Dictionary contains two'
... contains two
復制代碼

測試 dictionary 中鍵或數據值的成員關系是很簡單的。dictionary 容器數據類型提供幾個內置方法，包括 keys() 方法和 values() 方法（這里沒有演示）。這些方法返回一個列表，其中分別包含進行調用的 dictionary 中的鍵或數據值。

因此，要判斷某個值是否是 dictionary 中的鍵，應該使用 in 操作符檢查這個值是否在調用 keys() 方法所返回的鍵值列表中。可以使用相似的操作檢查某個值是否在調用 values() 方法所返回的數據值列表中。但是，可以使用 dictionary 名作為簡寫表示法。這是有意義的，因為一般希望知道某個數據值（而不是鍵值）是否在 dictionary 中。

在 「Discover Python, Part 6」 中，您看到了使用 for 循環遍歷容器中的元素是多麼容易。同樣的技術也適用於 Python dictionary，如清單 9 所示。

清單 9. 迭代和 dictionary

>>> d = {0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
>>> for k in d.iterkeys():
... print d[k]
... tuple
[0, 1, 2]
>>> for v in d.itervalues():
... print v
... tuple
[0, 1, 2]
>>> for k, v in d.iteritems():
... print 'd[',k,'] = ',v
... [ 0 ] = zero[ 3 ] = a tuple[ two ] = [0, 1, 2][ one ] = 1
復制代碼

這個示例演示了遍歷 dictionary 的三種方式：使用從 iterkeys()、itervalues() 或 iteritems() 方法返回的 Python 迭代器。（順便說一下，可以通過在 dictionary 上直接調用適當方法，比如 d.iterkeys()，從而檢查這些方法是否返回一個迭代器而不是容器數據類型。）iterkeys() 方法允許遍歷 dictionary 的鍵，而 itervalues() 方法允許遍歷 dictionary 包含的數據值。另一方面，iteritems() 方法允許同時遍歷鍵到數據值的映射。

dictionary：另一種強大的 Python 容器

本文討論了 Python dictionary 數據類型。dictionary 是一種異構的、易變的容器，依賴鍵到數據值的映射（而不是特定的數字次序）來訪問容器中的元素。訪問、添加和刪除 dictionary 中的元素都很簡單，而且 dictionary 很容易用於復合語句，比如 if 語句或 for 循環。可以在 dictionary 中存儲所有不同類型的數據，可以按照名稱或其他復合鍵值（比如 tuple）訪問這些數據，所以 Python dictionary 使開發人員能夠編寫簡潔而又強大的編程語句。

Ⅶ python3種數據類型

Python3 中有六個標準的數據類型：Number（數字） + String（字元串） + List（列表） + Tuple（元組） + Sets（集合） + Dictionary（字典）。
Number（數字）
數字類型是顧名思義是用來存儲數值的，需要記住的是，有點和Java的字元串味道差不多，如果改變了數字數據類型的值，將重新分配內存空間。
可以使用del語句刪除一些數字對象的引用：del var1[,var2[,var3[....,varN]]]]。
Python 支持三種不同的數值類型：
1.整型(Int) - 通常被稱為是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，可以當作 Long 類型使用，所以 Python3 沒有 Python2 的 Long 類型。
2.浮點型(float) - 浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
3.復數( (complex)) - 復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 復數的實部a和虛部b都是浮點型。
數字類型轉換
1.int(x) 將x轉換為一個整數。
2.float(x) 將x轉換到一個浮點數。
3.complex(x) 將x轉換到一個復數，實數部分為 x，虛數部分為 0。
4.complex(x, y) 將 x 和 y 轉換到一個復數，實數部分為 x，虛數部分為 y。x 和 y 是數字表達式。
額外說明
和別的語言一樣，數字類型支持各種常見的運算，不過python的運算比別的大多數常見語言都更加豐富，此外，還有大量豐富的方法，提供更高效的開發。
String（字元串）
創建字元串
創建字元串可以使用單引號、雙引號、三單引號和三雙引號，其中三引號可以多行定義字元串，有點類似ES6中的反引號。
Python 不支持單字元類型，單字元也在Python也是作為一個字元串使用。
訪問字元串中的值
和ES一樣，可以使用方括弧來截圖字元串，例子如下：
val_str='yelloxing'

print(val_str[0]) #y

print(val_str[1:3]) #el

print(val_str[:3]) #yel

print(val_str[:5]) #yello

字元串運算符
除了上面已經說明的方括弧，還有一些別的字元串運算，具體查看文檔。
字元串格式化
temp="我叫 %s 今年 %d 歲!" % ('心葉', 7)

print('['+temp+']') #[我叫 心葉 今年 7 歲!]

如上所示，字元串支持格式化，當然，出來上面用到的%s和%d以外，還有一些別的，具體看文檔；是不是感覺有點C語言的味道。
額外說明
所有的字元串都是Unicode字元串（針對python3），有很多有用的方法，真的很有ES和C結合體的味道。
List（列表）
序列是Python中最基本的數據結構。序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
Python有6個序列的內置類型（列表、元組、字元串、Unicode字元串、buffer對象和xrange對象）。
列表其實類似數組，具體的一些操作就很像字元串（類似ES中數組和字元串的關系）。
常見運算
下面用一個例子來展示一些常見的運算：
val_arr=['Made','in','China']

del val_arr[1]

print(val_arr) #['Made', 'China']

print(len(val_arr)) #2

val_newarr=val_arr+[':information']

print(val_newarr) #['Made', 'China', ':information']

val_arr=val_arr*2

print(val_arr) #['Made', 'China', 'Made', 'China']

print('in' in val_arr) #False

print('Made' in val_arr) #True

for row in val_newarr:

print(row, end=" - ") #Made - China - :information -

print(val_newarr[-1]) #:information

print(val_newarr[1:]) #['China', ':information']

再來看一個有用的例子：
cols=3

rows=2

list_2d = [[0 for col in range(cols)] for row in range(rows)]

print(list_2d) #[[0, 0, 0], [0, 0, 0]]

嵌套列表
使用嵌套列表即在列表裡創建其它列表，例如：
loop_arr=['yelloxing','心葉']

result_arr=[loop_arr,'同級別']

print(result_arr) #[['yelloxing', '心葉'], '同級別']

列表的嵌套就很靈活，此外隨便提一下：和前面說的一樣，也有很多方法提供高效的開發。
Tuple（元組）
元組與列表類似，不同之處在於元組的元素不能修改，元組使用小括弧，列表使用方括弧。
創建
元組中只包含一個元素時，需要在元素後面添加逗號，否則括弧會被當作運算符使用
tup1 = ('Google', 'Runoob', 1997, 2000);

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

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

print(tup1) #('Google', 'Runoob', 1997, 2000)

print(tup2) #(1, 2, 3, 4, 5)

print(tup3) #('a', 'b', 'c', 'd')

基本操作
和列表的操作很相似，下面說一個幾天特殊的地方：
1.del可以刪除某個元組，不過不可以刪除元組的某個條目。
2.不可以修改，或許元組會更快，感覺的，沒有實際測試。
3.由於元組不可以修改，雖然同樣有一些方法，不過和修改相關的方法就沒有了。
Sets（集合）
回想一下數學裡面的集合，合、交、差、補等運算是不是一下子回想起來了，這里的集合也有這些方法。
和Java的集合類似，一個無序不重復元素集（與列表和元組不同，集合是無序的，也無法通過數字進行索引）。
更具體的說明，如果必要會在單獨說明。
Dictionary（字典）
字典是另一種可變容器模型，且可存儲任意類型對象。
字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括弧({})中，鍵必須是唯一的，但值則不必。
和ES中的JSON的差不多，操作也很像，不過區別也很大，內置方法很多，具體還是一樣，看文檔去。
刪除字典元素
可以用del刪除一個條目或字典，也可以用clear()方法清空字典（比如現在有欄位dict，就是：dict.clear()）。

Ⅷ Python tuple怎麼轉成字元串

用提取列表和元組值的方法,取得日期字元串就行了,具體程序如下

a=[('2019-02-22',),('2019-02-25',),('2019-02-26',),('2019-02-27',),('2019-02-28',),('2019-03-01',),('2019-03-04',)]

foriinrange(len(a)):

print(a[i][0])

源代碼(注意源代碼的縮進)

Ⅸ python的數據類型有哪些

python數據類型主要分為以下六大類：Numbers（數字）、String（字元串）、List（列表、Tuple（元組）、Dictionary（字典）、Set（集合）。

Python的六個標准數據類型中：

不可變數據（3 個）：Number（數字）、String（字元串）、Tuple（元組）。

可變數據（3 個）：List（列表）、Dictionary（字典）、Set（集合）。

字元串類型：

python的字元串或串(String)是由數字、字母、下劃線組成的一串字元。