Python 中的變量 不需要聲明 。每個變量在使用前都必須賦值，變量賦值以後該變量才會被創建。
在 Python 中，變量就是變量，它 沒有類型 ，我們所說的"類型"是變量所指的內存中對象的類型。
等號（=）用來給變量賦值。
等號（=）運算符左邊是一個變量名，等號（=）運算符右邊是存儲在變量中的值。
例如：
counter = 100 # 整型變量
miles = 1000.0 # 浮點型變量
name = "runoob" # 字符串
print (counter)
print (miles)
print (name)
運行結果：
100
1000.0
runoob
Python允許你同時為多個變量賦值。例如：
a = b = c = 1
以上實例，創建一個整型對象，值為 1，從後向前賦值，三個變量被賦予相同的數值。
您也可以為多個對象指定多個變量。例如：
a, b, c = 1, 2, "runoob"
以上實例，兩個整型對象 1 和 2 分別分配給變量 a 和 b，字符串對象 “runoob” 分配給變量 c。
Python3 中有六個標准的數據類型：
Number（數字）
String（字符串）
List（列表）
Tuple（元組）
Set（集合）
Dictionary（字典）
Python3 的六個標准數據類型中：
不可變數據（3 個）：Number（數字）、String（字符串）、Tuple（元組）；
可變數據（3 個）：List（列表）、Dictionary（字典）、Set（集合）。
Python3 支持 int、float、bool、complex（復數）。
在Python 3裡，只有一種整數類型 int，表示為長整型，沒有 python2 中的 Long。
內置的 type() 函數可以用來查詢變量所指的對象類型。也可以用 isinstance 函數來判斷類型。
例：
a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
print(isinstance(a, int))
輸出結果：
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
True
isinstance 和 type 的區別在於：
例：
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> isinstance(A(), A)
True
>>> type(A()) == A
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False
注意：
True==1；False==0 會返回 True>>> issubclass(bool, int)
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False
當你指定一個值時，Number 對象就會被創建：
var1 = 1
var2 = 10
您也可以使用del語句刪除一些對象引用。
del語句的語法是：
del var1[,var2[,var3[....,varN]]]
您可以通過使用del語句刪除單個或多個對象。例如：
del var
del var_a, var_b
實例:
>>> 5 + 4 # 加法
9
>>> 4.3 - 2 # 減法
2.3
>>> 3 * 7 # 乘法
21
>>> 2 / 4 # 除法，得到一個浮點數
0.5
>>> 2 // 4 # 除法，得到一個整數
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32
注意：
Python中的字符串用單引號 ' 或雙引號 " 括起來。
字符串內可以使用反斜槓 \ 轉義特殊字符。
字符串的截取的語法格式如下：
變量[頭下標:尾下標]
索引值以 0 為開始值，-1 為從末尾的開始位置。
加號 + 是字符串的連接符， 星號 * 表示復制當前字符串，與之結合的數字為復制的次數。
例：
str = 'Runoob'
print (str) # 輸出字符串
print (str[0:-1]) # 輸出第一個到倒數第二個的所有字符
print (str[0]) # 輸出字符串第一個字符
print (str[2:5]) # 輸出從第三個開始到第五個的字符
print (str[2:]) # 輸出從第三個開始的後的所有字符
print (str * 2) # 輸出字符串兩次，也可以寫成 print (2 * str)
print (str + "TEST") # 連接字符串
執行以上程序會輸出如下結果：
Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST
Python 使用反斜槓 \ 轉義特殊字符，如果你不想讓反斜槓發生轉義，可以在字符串前面添加一個 r，表示原始字符串：
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
另外，反斜槓()可以作為續行符，表示下一行是上一行的延續。也可以使用 “”“…”“” 或者 ‘’‘…’‘’ 跨越多行。
Python 沒有單獨的字符類型，一個字符就是長度為1的字符串。
例：
>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P
與 C 字符串不同的是，Python 字符串不能被改變。向一個索引位置賦值，比如word[0] = 'm’會導致錯誤。
r 可以讓反斜槓不發生轉義。+ 運算符連接在一起，用 * 運算符重復。List（列表） 是 Python 中使用最頻繁的數據類型。
列表可以完成大多數集合類的數據結構實現。列表中元素的類型可以不相同，它支持數字，字符串甚至可以包含列表（所謂嵌套）。
列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。
和字符串一樣，列表同樣可以被索引和截取，列表被截取後返回一個包含所需元素的新列表。
列表截取的語法格式如下：
變量[頭下標:尾下標[:步長]] //截取從頭下標開始，到尾下標的前一個元素
索引值以 0 為開始值，-1 為從末尾的開始位置。
可選參數：步長
Python 列表截取可以接收第三個參數：步長，以下實例在索引 1 到索引 4 的位置並設置為步長為 2（間隔一個位置）來截取字符串：
如果第三個參數（步長）為負數表示逆向讀取。
加號 + 是列表連接運算符，星號 * 是重復操作。
例：
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list) # 輸出完整列表
print (list[0]) # 輸出列表第一個元素
print (list[1:3]) # 從第二個開始輸出到第三個元素
print (list[2:]) # 輸出從第三個元素開始的所有元素
print (tinylist * 2) # 輸出兩次列表
print (list + tinylist) # 連接列表
輸出結果：
['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
與Python字符串不一樣的是，列表中的元素是可以改變的：
例：
>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = [] # 將對應的元素值設置為 []
>>> a
[9, 2, 6]
List 內置了有很多方法，例如 append()、pop() 等等。
元組（tuple）與列表類似，不同之處在於元組的元素不能修改。元組寫在小括號 () 裡，元素之間用逗號隔開。
元組中的元素類型也可以不相同。
例：
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 輸出完整元組
print (tuple[0]) # 輸出元組的第一個元素
print (tuple[1:3]) # 輸出從第二個元素開始到第三個元素
print (tuple[2:]) # 輸出從第三個元素開始的所有元素
print (tinytuple * 2) # 輸出兩次元組
print (tuple + tinytuple) # 連接元組
輸出結果：
('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
元組與字符串類似，可以被索引且下標索引從0開始，-1 為從末尾開始的位置。也可以進行截取。
其實，可以把字符串看作一種特殊的元組。
例：
>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11 # 修改元組元素的操作是非法的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
雖然tuple的元素不可改變，但它可以包含可變的對象，比如 list 列表。
構造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規則：
tup1 = () # 空元組
tup2 = (20,) # 一個元素，需要在元素後添加逗號
string、list 和 tuple 都屬於 sequence（序列）。
注意：
Python 中的集合，和數學中的集合概念一樣，用來保存不重復的元素，即集合中的元素都是 唯一 的，互不相同。
基本功能是進行成員關系測試和刪除重復元素。
由於 Python 中的 set 集合是 無序 的，所以每次輸出時元素的排序順序可能都不相同。
從形式上看，和字典類似，Python 集合會將所有元素放在一對大括號 {} 中，相鄰元素之間用“,”分隔。
可以使用大括號 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。
創建格式：
parame = {
value01,value02,...}
或者
set(value)
例：
sites = {
'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites) # 輸出集合，重復的元素被自動去掉
# 成員測試
if 'Runoob' in sites :
print('Runoob 在集合中')
else :
print('Runoob 不在集合中')
# set可以進行集合運算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的並集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同時存在的元素
輸出結果：
{
'Google', 'Facebook', 'Runoob', 'Baidu', 'Taobao', 'Zhihu'}
Runoob 在集合中
{
'r', 'a', 'b', 'd', 'c'}
{
'b', 'r', 'd'}
{
'l', 'r', 'm', 'a', 'b', 'd', 'c', 'z'}
{
'c', 'a'}
{
'l', 'r', 'm', 'b', 'z', 'd'}
從內容上看，同一集合中，只能存儲不可變的數據類型，包括數字、字符串、元組，無法存儲列表、字典、集合這些可變的數據類型，否則 Python 解釋器會拋出 TypeError 錯誤。
例：
>>> {
{
'a':1}}
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
{
{
'a':1}}
TypeError: unhashable type: 'dict'
>>> {
[1,2,3]}
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
{
[1,2,3]}
TypeError: unhashable type: 'list'
>>> {
{
1,2,3}}
Traceback (most recent call last):
File "<pyshell#10>", line 1, in <module>
{
{
1,2,3}}
TypeError: unhashable type: 'set'
列表是有序的對象集合，字典是無序的對象集合。他們的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
字典是一種映射類型，字典用 { } 標識，它是一個 無序 的 鍵(key) : 值(value) 的集合。
鍵(key)必須使用不可變類型。
在同一個字典中，鍵(key)必須是唯一的。
字典可以用 {} 或者函數 dict() 來創建。
例：
dict = {
} # 空字典
dict['one'] = "1 - 菜鳥教程"
dict[2] = "2 - 菜鳥工具"
tinydict = {
'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 輸出鍵為 'one' 的值
print (dict[2]) # 輸出鍵為 2 的值
print (tinydict) # 輸出完整的字典
print (tinydict.keys()) # 輸出所有鍵
print (tinydict.values()) # 輸出所有值
輸出結果：
1 - 菜鳥教程
2 - 菜鳥工具
{
'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])
構造函數 dict() 可以直接從鍵值對序列中構建字典：
>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{
'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {
x: x**2 for x in (2, 4, 6)}
{
2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{
'Runoob': 1, 'Google': 2, 'Taobao': 3}
其中，{x: x**2 for x in (2, 4, 6)} 使用的是字典推導式。
另外，字典類型也有一些內置的函數，例如 clear()、keys()、values() 等。
注意：
想對數據內置的類型進行轉換，只需要將數據類型作為函數名即可。
以下幾個內置的函數可以執行數據類型之間的轉換。這些函數返回一個新的對象，表示轉換的值。
