python六種標準的數據類型分別是Number（數字）String（字符串）List（列表）Tuple（元組）Set（集合）Dictionary（字典）
不可以變數據：Number（數字）、String（字符串）、Tuple（元組）
可變數據：List（列表）、Dictionary（字典）、Set（集合）
和C不同，Python 中的變量不需要聲明。每個變量在使用前都必須賦值，變量賦值以後該變量纔會被創建
目錄
1.數字
支持整型(Int)，浮點型(float)，複數( (complex))三種數值類型
類型說明：
整型，Python3 整型是沒有限制大小的，可以當作 Long 類型使用
浮點型，浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
複數，複數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型
數字類型轉換：
int(x)，將x轉換爲整數
a = 100.0
b = int(a)
print(a)
print(b)
..........................
結果如下：
100.0
100
float(x)，將x轉換爲浮點數
a = 100.0
b = float(a)
print(a)
print(b)
........................
結果如下：
100
100.0
complex(x)和complex(x,y)將x(x,y)轉換爲複數
print(complex(100))
print(complex(100,10))
........................
結果如下：
(100+0j)
(100+10j)
數字運算：
| 運算符 | 語法 | 意義 |
|---|---|---|
| + | a+b | 加法運算，和C語言的一樣 |
| - | a-b | 減法運算，和C語言的一樣 |
| * | a*b | 乘法運算，和C語言一樣 |
| / | a/b | 除法運算，總返回一個浮點數結果 |
| // | a//b | 除法運算，丟棄小數部分，返回一個整數結果 |
| % | a%b | 取餘運算，和C語言一樣 |
| ** | a**n | 冪運算，n爲冪 |
注意：
不同類型的數混合運算時會將整數轉換爲浮點數
print(10/2*3)
........................
結果如下：
15.0
常用的隨機函數：
| 函數名 | 語法 | 意義 |
|---|---|---|
| choice | choice(seq) | 從序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數 |
| randrange | randrange ([start,] stop [,step]) | 從指定範圍內，按指定基數遞增的集合中獲取一個隨機數，基數默認值爲 1 |
| random | random() | 隨機生成下一個實數，它在[0,1)範圍內 |
注意：以上幾個隨機函數輸入random模塊內置函數，需要import random
2.字符串
字符串是 Python 中最常用的數據類型，可以使用單引號（’’）或者雙引號（""）來創建字符串
var1 = 'Hello World!'
var2 = "https://blog.csdn.net/muchong123"
print(var1)
print(var2)
........................
結果如下：
Hello World!
https://blog.csdn.net/muchong123
訪問字符串中的值
Python 不支持單字符類型，單字符在 Python 中也是作爲一個字符串使用
Python 訪問子字符串，可以使用方括號來截取字符串
var = 'Hello World!'
print(var[0]) #下標從0開始，表示從字符串的第一個字符開始算起
print(var[:5])
print(var[6:])
print(var[2:5])
print(var[-1:]) #下標從-1開始，表示從字符串的最後一個字符開始算起
print(var[-6:-2])
........................
結果如下：
H
Hello
World!
llo
!
Worl
字符串拼接
使用符號+可以進行字符串拼接
var = 'Hello World!'
print ("已更新字符串 : ", var[:6] + "every day!")
........................
結果如下：
已更新字符串 : Hello every day!
常見字符串轉義
在需要在字符中使用特殊字符時，python用反斜槓()轉義字符，如果不需要轉義，可在字符串前面加符號r
| 轉義符 | 意義 |
|---|---|
| (在行尾時) | 續行符 |
| \ | 反斜槓符號 |
| ’ | 單引號 |
| " | 雙引號 |
| \n | 換行 |
| \r | 回車 |
字符串運算符
下表實例變量a值爲字符串 “Hello”，b變量值爲 “Python”：
| 操作符 | 意義 | 實例 |
|---|---|---|
| + | 字符串連接 | a + b 輸出結果： HelloPython |
| * | 重複輸出字符串 | a*2 輸出結果：HelloHello |
| [] | 通過索引獲取字符串中字符 | a[1] 輸出結果 e |
| [ : ] | 截取字符串中的一部分，遵循左閉右開原則，str[0,2] 是不包含第 3 個字符的 | a[1:4] 輸出結果 ell |
| in | 成員運算符 - 如果字符串中包含給定的字符返回 True | ‘H’ in a 輸出結果 True |
| not in | 成員運算符 - 如果字符串中不包含給定的字符返回 True | ‘M’ not in a 輸出結果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符。 原始字符串除在字符串的第一個引號前加上字母 r（可以大小寫）以外，與普通字符串有着幾乎完全相同的語法 | print( r’\n’ ) print( R’\n’ ) |
| % | 格式字符串 | 內容涉及比較多詳細使用，後一節講 |
字符串格式化
Python 支持格式化字符串的輸出 。儘管這樣可能會用到非常複雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中，在 Python 中，字符串格式化使用與 C 中 sprintf 函數一樣的語法
| 符號 | 意義 |
|---|---|
| %c | 格式化字符及其ASCII碼 |
| %s | 格式化字符串 |
| %d | 格式化整數 |
| %u | 格式化無符號整型 |
| %o | 格式化無符號八進制數 |
| %x | 格式化無符號十六進制數 |
| %X | 格式化無符號十六進制數（大寫） |
| %f | 格式化浮點數字，可指定小數點後的精度 |
| %e | 用科學計數法格式化浮點數 |
| %E | 作用同%e，用科學計數法格式化浮點數 |
| %g | %f和%e的簡寫 |
| %G | %f 和 %E 的簡寫 |
| %p | 用十六進制數格式化變量的地址 |
python三引號
python三引號允許一個字符串跨多行，字符串中可以包含換行符、製表符以及其他特殊字符
para_str = """這是一個多行字符串的實例
多行字符串可以使用製表符
TAB ( \t )。
也可以使用換行符 [ \n ]。
"""
print (para_str)
........................
結果如下：
這是一個多行字符串的實例
多行字符串可以使用製表符
TAB ( )。
也可以使用換行符 [
]。
3.列表
列表是最常用的Python數據類型，它可以作爲一個方括號內的逗號分隔值出現，列表的數據項不需要具有相同的類型，創建一個列表，只要把逗號分隔的不同的數據項使用方括號括起來即可
list1 = ['john', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
訪問列表中的值
使用下標索引來訪問列表中的值，同樣你也可以使用方括號的形式截取字符
list1 = ['john', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])
........................
結果如下：
list1[0]: john
list2[1:5]: [2, 3, 4, 5]
列表更新
對列表的數據項可以進行修改或更新，也可以使用append()方法來添加列表項
list = ['john', 'Runoob', 1997, 2000]
print ("第三個元素爲 : ", list[2])
list[2] = 2001
list.append('新增項目')
print ("更新後的第三個元素爲 : ", list[2])
print("更新後的列表爲："， list)
........................
結果如下：
第三個元素爲 : 1997
更新後的第三個元素爲 : 2001
更新後的列表爲： ['john', 'Runoob', 2001, 2000, '新增項目']
刪除列表元素
可以使用 del 語句來刪除列表的的元素
list = ['john', 'Runoob', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("刪除第三個元素後 : ", list)
........................
結果如下：
原始列表 : ['john', 'Runoob', 1997, 2000]
刪除第三個元素後 : ['john', 'Runoob', 2000]
列表腳本操作符
| 表達式 | 結果 | 意義 |
|---|---|---|
| en([1, 2, 3]) | 3 | 長度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 組合 |
| [‘Hi!’] * 4 | [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] | 重複 |
| 3 in [1, 2, 3] | True | 元素是否存在於列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
列表拼接
L=['Google', 'Baidu', 'Taobao']
print("列表拼接前：", L)
L += ['Tengxun', 'Jingdong']
print("列表拼接後：", L)
........................
結果如下：
列表拼接前： ['Google', 'Baidu', 'Taobao']
列表拼接後： ['Google', 'Baidu', 'Taobao', 'Tengxun', 'Jingdong']
列表函數&方法
| 函數 | 意義 |
|---|---|
| len(list) | 列表元素個數 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 將元組轉換爲列表 |
| 方法 | 意義 |
|---|---|
| list.append(obj) | 在列表末尾添加新的對象 |
| list.count(obj) | 統計某個元素在列表中出現的次數 |
| list.extend(seq) | 在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表） |
| list.index(obj) | 從列表中找出某個值第一個匹配項的索引位置 |
| list.insert(index, obj) | 將對象插入列表 |
| list.pop([index=-1]) | 移除列表中的一個元素（默認最後一個元素），並且返回該元素的值 |
| list.remove(obj) | 移除列表中某個值的第一個匹配項 |
| list.reverse() | 反向列表中元素 |
| list.sort( key=None, reverse=False) | 對原列表進行排序 |
| list.clear() | 清空列表 |
| list.copy() | 複製列表 |
4.元組
Python 的元組與列表類似，不同之處在於元組的元素不能修改
元組使用小括號，列表使用方括號，
元組創建很簡單，只需要在括號中添加元素，並使用逗號隔開即可
創建元組
元組中只包含一個元素時，需要在元素後面添加逗號，否則括號會被當作運算符使用
tup1 = (50)
print(type(tup1)) # 不加逗號，類型爲整型
tup2 = (50,)
print(type(tup2)) # 加上逗號，類型爲元組
........................
結果如下：
<class 'int'>
<class 'tuple'>
訪問元組
元組可以使用下標索引來訪問元組中的值
tup1 = ('john', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
........................
結果如下：
tup1[0]: john
tup2[1:5]: (2, 3, 4, 5)
修改元組
元組中的元素值是不允許修改的，但我們可以對元組進行連接組合
tup1 = ('Taobao', 'Tengxun', 'Baidu')
tup2 = ('Geogle', 'Jingdong')
# 以下修改元組元素操作是非法的。
# tup1[0] = 'Wangyu'
# 創建一個新的元組
tup3 = tup1 + tup2
print (tup3)
........................
結果如下：
('Taobao', 'Tengxun', 'Baidu', 'Geogle', 'Jingdong')
刪除元組
元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組
tup = ('Taobao', 'Tengxun', 'Baidu', 'Geogle', 'Jingdong')
print (tup)
del tup
print ("刪除後的元組 tup : ", tup)
........................
結果如下：
('Taobao', 'Tengxun', 'Baidu', 'Geogle', 'Jingdong')
Traceback (most recent call last):
File "E:\tup.py", line 4, in <module>
print ("刪除後的元組 tup : ", tup)
NameError: name 'tup' is not defined
元組運算符
| 表達式 | 結果 | 意義 |
|---|---|---|
| len((1, 2, 3)) | 3 | 計算元素個數 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 連接 |
| (‘Hi!’,) * 4 | (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) | 複製 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print (x,) | 1 2 3 | 迭代 |
元組內置函數
| 函數 | 意義 |
|---|---|
| len(tuple) | 計算元組元素個數 |
| max(tuple) | 返回元組中元素最大值 |
| min(tuple) | 返回元組中元素最小值 |
| tuple(iterable) | 將可迭代系列轉換爲元組 |
5.字典
字典是另一種可變容器模型，且可存儲任意類型對象
字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中，格式如下：
d = {key1 : value1, key2 : value2 }
注意：
鍵必須是唯一的，但值則不必，值可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組
創建字典
dict = {'Alice': '16', 'Beth': '18', 'Cecil': '21'}
print(dict)
........................
結果如下：
{'Alice': '16', 'Beth': '18', 'Cecil': '21'}
訪問字典裏的值
dict = {'Name': 'Ben', 'Age': 15, 'Class': 'First'}
print ("dict[Name]: ", dict['Name'])
print ("dict[Age]: ", dict['Age'])
........................
結果如下：
dict[Name]: Ben
dict[Age]: 15
修改字典
向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值
dict = {'Name': 'Ben', 'Age': 15, 'Class': 'First'}
dict['Age'] = 16 # 更新 Age
dict['School'] = "xx Meddle School" # 添加信息
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
........................
結果如下：
dict['Age']: 16
dict['School']: xx Meddle School
刪除字典元素
能刪單一的元素也能清空字典，清空只需一項操作
顯示刪除一個字典用del命令
dict = {'Name': 'Ben', 'Age': 15, 'Class': 'First'}
del dict['Name'] # 刪除鍵 'Name'
dict.clear() # 清空字典
del dict # 刪除字典
print ("dict['Age']: ", dict['Age'])
........................
結果如下：
Traceback (most recent call last):
File "E:\dict.py", line 5, in <module>
print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
字典內置函數&方法
| 函數 | 意義 |
|---|---|
| len(dict) | 計算字典元素個數，即鍵的總數 |
| str(dict) | 輸出字典，以可打印的字符串表示 |
| type(variable) | 返回輸入的變量類型，如果變量是字典就返回字典類型 |
| 方法 | 意義 |
|---|---|
| radiansdict.clear() | 刪除字典內所有元素 |
| radiansdict.copy() | 返回一個字典的淺複製 |
| radiansdict.fromkeys() | 創建一個新字典，以序列seq中元素做字典的鍵，val爲字典所有鍵對應的初始值 |
| radiansdict.get(key, default=None) | 返回指定鍵的值，如果值不在字典中返回default值 |
| key in dict | 如果鍵在字典dict裏返回true，否則返回false |
| radiansdict.items() | 以列表返回可遍歷的(鍵, 值) 元組數組 |
| radiansdict.keys() | 返回一個迭代器，可以使用 list() 來轉換爲列表 |
| radiansdict.setdefault(key, default=None) | 和get()類似, 但如果鍵不存在於字典中，將會添加鍵並將值設爲default |
| radiansdict.update(dict2) | 把字典dict2的鍵/值對更新到dict裏 |
| radiansdict.values() | 返回一個迭代器，可以使用 list() 來轉換爲列表 |
| pop(key[,default]) | 刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key值必須給出。 否則，返回default值。 |
| popitem() | 隨機返回並刪除字典中的最後一對鍵和值 |