Python學習筆記2：基本資料型別

Python中的變數不需要宣告。每個變數在使用前都必須賦值，變數賦值以後該變數才會被建立。
在 Python 中，變數就是變數，它沒有型別，我們所說的"型別"是變數所指的記憶體中物件的型別。
等號（=）用來給變數賦值。
等號（=）運算子左邊是一個變數名,等號（=）運算子右邊是儲存在變數中的值。

Python中有六個標準的資料型別：

資料型別	定義	可變性
Number（數字）	int, bool, float, complex，long(python2)	不可變資料
String（字串）	單引號 ' 或雙引號 " 括起來，同時使用反斜槓 \ 轉義特殊字元	不可變資料
List（列表）	寫在方括號 [] 之間、用逗號分隔開的元素列表	可變資料型別
Tuple（元組）	寫在小括號 () 裡，元素之間用逗號隔開	不可變資料
Set（集合）	使用大括號 { } 或者 set() 函式建立集合	可變資料型別
Dictionary（字典）	字典是一種對映型別，字典用 { } 標識，它是一個無序的 鍵(key) : 值(value) 的集合	可變資料型別

注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典；
對於字典：鍵(key)必須使用不可變型別。在同一個字典中，鍵(key)必須是唯一的。

Number（數字）
Python的數字型別有int整型、long長整型(python2)、float浮點數、complex複數、以及布林值（0和1）。
可以通過內建的 type() 函式可以用來查詢變數所指的物件型別，還可以用 isinstance 來判斷型別：

var_int=123
print(type(var_int))

var_float=1.01
print(type(var_float))

var_bool=True
print(type(var_bool))

var_complex=1+2j
print(type(var_complex))


print(isinstance(var_int, int))
print(isinstance(var_float, float))

輸出結果如下：

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'complex'>
True
True

isinstance 和 type 的區別在於：
type()不會認為子類是一種父類型別。
isinstance()會認為子類是一種父類型別。

注意：
1、在 Python2 中是沒有布林型的，它用數字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定義成關鍵字了，但它們的值還是 1 和 0，它們可以和數字相加。
2、Python可以同時為多個變數賦值，如a, b = 1, 2。
3、一個變數可以通過賦值指向不同型別的物件。
4、數值的除法包含兩個運算子：/ 返回一個浮點數，// 返回一個整數。
5、在混合計算時，Python會把整型轉換成為浮點數。

String（字串）
Python中的字串用單引號 ' 或雙引號 " 括起來，同時使用反斜槓 \ 轉義特殊字元。也可以字串前面加r，表示的意思是禁止字串轉義。
字串是不可修改的。所有關於字元我們可以從 索引、切片、長度、遍歷、刪除、分割、清除空白、大小寫轉換、判斷以什麼開頭等方面對字串進行介紹。
建立字串

#字串的形式：使用‘’或者“”來建立字串
var_str1='temp_string1'
print(var_str1)

var_str2="temp_string2"
print(var_str2)

1) 索引/切片
字串也可以被擷取(檢索)。類似於C ，字串的第一個字元索引為0 。Python沒有單獨的字元型別；一個字元就是一個簡單的長度為1的字串。
索引也可以是負數，這將導致從右邊開始計算。除了索引，還支援切片。索引用於獲得單個字元，切片讓你獲得一個子字串。
如下，第一行數字給出字串中的索引點 0…6。第二行給出相應的負索引。切片是從 i 到 j 兩個數值標示的邊界之間的所有字元。

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

索引也可以是負數，這將導致從右邊開始計算。

>>> var_str='temp_string'
>>> var_str[1]
'e'
>>> var_str[-1]
'g'
>>> var_str[0:-2] # 從第一個到倒數第二個，不包含倒數第二個
'temp_stri'

注意，包含起始的字元，不包含末尾的字元。這使得 s[:i] + s[i:] 永遠等於 s。
切片的索引有非常有用的預設值；省略的第一個索引預設為零，省略的第二個索引預設為切片的字串的大小。

>>> var_str='temp_string'
>>> var_str[2:]
'mp_string'
>>> var_str[:2]
'te'
>>> 

2) 長度
內建函式 len() 返回字串長度:

>>> s='thisisatestlongstring'
>>> len(s)
21

3) 刪除

>>> s='python'
>>> del(s)

4) 大小寫轉換

>>> s='this is a string'
>>> print(s.capitalize())
This is a string
>>> print(s.title())
This Is A String

List（列表）
列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。
列表可以完成大多數集合類的資料結構實現。列表中元素的型別可以不相同，它支援數字，字串甚至可以包含列表（所謂巢狀）。
和字串一樣，列表同樣可以被索引和擷取，列表被擷取後返回一個包含所需元素的新列表。
列表中的每個值都有對應的位置值，稱之為索引，第一個索引是 0，第二個索引是 1，依此類推。-1 為從末尾的開始位置。

>>> list=['abcd', 123, 4.56, "python", 789]
>>> print(list)
['abcd', 123, 4.56, 'python', 789]
>>> print(list[0])
abcd
>>> print(list[1:3])
[123, 4.56]
>>> print(list[2:])
[4.56, 'python', 789]
>>> print(list[:-1])
['abcd', 123, 4.56, 'python']

與字串不一樣的是，列表中的元素是可以改變的：

>>> list=['abcd', 123, 4.56, "python", 789]
>>> print(list[2])
4.56
>>> list[2]=100.1  #更新列表中第三個元素
>>> print(list)
['abcd', 123, 100.1, 'python', 789]
>>> del list[1] #刪除列表中第二個元素
>>> print(list)
['abcd', 100.1, 'python', 789]

與字串擷取不同，列表擷取可以接收第三個引數，引數作用是擷取的步長。如果第三個引數為負數表示逆向讀取。
以下例項在索引 1 到索引 8 的位置並設定為步長為 2（間隔一個位置）來擷取字

>>> list=[1,2,3,4,5,6,7,8,9,0]
>>> print(list[1:8:2])
[2, 4, 6, 8]
>>> print(list[-3:-10:-2]) #逆向擷取，從倒數第三個元素開始到倒數第十個，逆向擷取步長為2
[8, 6, 4, 2]

還可以使用巢狀列表即在列表裡建立其它列表：

>>> list=[1, ['a','b'], 2]
>>> print(list[1])
['a', 'b']
>>> print(list[1][1])
b

Tuple（元組）
元組（tuple）與列表類似，不同之處在於元組的元素不能修改。
元組寫在小括號 () 裡，元素之間用逗號隔開。元組中的元素型別也可以不相同。
元組與字串類似，可以被索引且下標索引從0開始，-1 為從末尾開始的位置。
元組中只包含一個元素時，需要在元素後面新增逗號，否則括號會被當作運算子使用：

>>> tup=(50)
>>> type(tup)
<class 'int'>
>>> tup1=(50,) # 一個元素，需要在元素後新增逗號
>>> type(tup1)
<class 'tuple'>

Set（集合）
集合（set）是一個無序的不重複元素序列。
可以使用大括號 { } 或者 set() 函式建立集合。
注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典。

建立格式：

>>> s={1, 2, 3}
>>> print(s)
{1, 2, 3}

>>> s=set((1, 2, 3))
>>> print(s)
{1, 2, 3}

Dictionary（字典）
字典是另一種可變容器模型，且可儲存任意型別物件。
字典的每個鍵值 key=>value 對用冒號 : 分割，每個對之間用逗號(,)分割，整個字典包括在花括號 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

列表是有序的物件集合，字典是無序的物件集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
鍵(key)必須使用不可變型別。
在同一個字典中，鍵(key)必須是唯一的。

>>> dict1={}
>>> dict1['name']='Python'
>>> dict1['age']=18
>>> print(dict1)
{'name': 'Python', 'age': 18}

>>> dict2={'name':'python', 'age':18}
>>> print(dict2)
{'name': 'python', 'age': 18}

>>> print(dict2.keys())
dict_keys(['name', 'age'])
>>> print(dict2.values())
dict_values(['python', 18])

>>> dict3=dict([('name', 'python'), ('age', 1)]) #(key, value)元組序列建立字典
>>> print(dict3)
{'name': 'python', 'age': 1}

>>> dict4=dict(name='python', age=18) # 關鍵字建立字典
>>> print(dict4)
{'name': 'python', 'age': 18}

刪除字典元素，能刪單一的元素也能清空字典：

>>> dict={'name': 'python', 'age': 18}
>>> del dict['age']
>>> print(dict)
{'name': 'python'}
>>> dict.clear()
>>> print(dict)
{}
>>> del dict

字典值可以是任何的 python 物件，既可以是標準的物件，也可以是使用者定義的，但鍵不行。

兩個重要的點需要記住：
1）不允許同一個鍵出現兩次。建立時如果同一個鍵被賦值兩次，後一個值會被記住，如下例項：

>>> dict={'name': 'python', 'age': 18, 'name':'lily'}
>>> print(dict)
{'name': 'lily', 'age': 18}

2）鍵必須不可變，所以可以用數字，字串或元組充當，而用列表就不行，如下例項：

>>> dict={['name']: 'python', 'age': 18}
Traceback (most recent call last):
  File "<pyshell#57>", line 1, in <module>
    dict={['name']: 'python', 'age': 18}
TypeError: unhashable type: 'list'