Python內置數據結構str、list、tuple、set、dict

數據結構	可變	可迭代	有序	特性
str	✖	✔	✔
list	✔	✔	✔
tuple	✖	✔	✔
set	✔	✔	✖	key不重複，且必須可hash
dict	✔	✔	✖	同上

字符串

• 一個個字符組成的有序的序列，是字符的集合
• 使用單引號、雙引號、三引號引住的字符序列
• 字符串是不可變對象
• Python3，字符串就是Unicode類型

字符串定義 初始化

• 舉例

  s1 = 'string'
  s2 = "string2"
  s3 = '''this`s a "string" '''
  s4 = 'hello \n magedu.com'
  s5 = r"hello \n magedu.com"
  s6 = 'c:\windows\nt'
  s7 = R"c:\windows\\nt"
  s8 = 'c:\windows\\nt'
  sql = """select * from user where name='tom'"""

字符串元素訪問

• 字符串支持使用索引訪問
• 有序的字符集合，字符序列
• 可迭代

字符串join連接

• "string".join(iterable) -> str

  • 將可迭代對象連接起來，使用string作爲分隔符
  • 可迭代對象本身元素都是字符串
  • 返回一個新字符串
  • 舉例

  lst = ['1','2','3']
  print("\"".join(lst))
  print("\n".join(lst))
  
  #返回
  
  1"2"3
  1
  2
  3
  
  lst = ['1',['a','b'],'3']
  print(" ".join(lst))    #報錯，注意可迭代對象元素都是字符串

字符串 + 連接

• + > str
  
  • 將2個字符串連接在一起
  • 返回一個新字符串

字符串分割

• 分割字符串的方法分爲2類
  
  • split
    
    • 將字符串按照分隔符分割成若干字符串，並返回列表
  • partition
    
    • 將字符串按照分隔符分割成2段，返回這2段和分隔符的元組

• split(sep=None,maxsplit=-1) - > list of strings

  • 從左至右
  • sep指定分割字符串，缺省的情況下空白字符串作爲分隔符
  • maxsplit指定分割次數，-1表示遍歷整個字符串
  • 舉例

  s1 = "i`m \ta super student."
  s1.split()
  s1.split('s')
  s1.split('super')
  s1.split('super ')
  s1.split('')
  s1.split('',maxsplit=2)
  s1.split('\t',maxsplit=2)

• rsplit(sep=None,maxsplit=-1)-> list of string
  
  • 從右至左
  • sep指定分割字符串，缺省的情況下空白字符串作爲分隔符
  • maxsplit指定分割次數，-1表示遍歷整個字符串
• splitlines([keepends]) -> list of strings
  
  • 按照行來切分字符串
  • keepends指的是是否保留分隔符
  • 行分隔符包括\n、\r\n、\r等
• partition(sep) -> (head,sep,tail)
  
  • 從左至右，遇到分隔符酒吧字符串分割成兩部分，返回頭，分隔符，尾三部分；如果沒有找到分隔符，就返回頭，2個空元素的三元組
  • sep分割字符串，必須指定
• rpartiton(sep) -> (dead, sep, tail)
  
  • 從右至左，遇到分隔符酒吧字符串分割成兩部分，返回頭，分隔符，尾三部分；如果沒有找到分隔符，就返回頭，2個空元素的三元組

字符串大小寫

• upper() 全大寫
• lower() 全小寫
• swapcase() 交互大小寫

字符串排版

• title() -> str
  
  • 標題的每個單詞都大寫
• capitalize() -> str
  
  • 首個單詞大寫
• center(width[, fillchar]) -> str
  
  • width 打印寬度
  • fillchar 填充的字符
• zfill(width) -> str
  
  • width 打印寬度，居右，左邊用0填充
• ljust(width[,fillchar]) -> str 左對齊
• rjust(width[,fillchar]) -> str 右對齊

字符串修改

• replace(old, new[,count]) -> st
  
  • 字符串中找到匹配替換爲新子串，返回新字符串
  • count表示替換幾次，不指定就是全部替換
• strip([chars]) -> str
  
  • 從字符串兩端去除指定的字符集chars中的所有字符
  • 如果chars沒有指定，去掉兩端的空白字符
• lstrip([chars]) -> str
  
  • 從左開始
• rstrip([chars]) -> str
  
  • 從右開始

字符串查找

• find(sub[, strat[, end]]) -> int
  
  • 在指定的區間[start, end],從左至右，查找子串sub。找到返回索引，沒找到返回-1
• rfind(sub[, strat[, end]]) -> int
• index(sub[, start[, end]]) -> int
  
  • 在指定的區間[start,end),從左至右，查找子串sub。找到返回索引，沒找到拋出異常ValueError
• rindex(sub[, start[, end]]) -> int
  
  • 在指定的區間[start,end),從右至左，查找子串sub。找到返回索引，沒找到拋出異常ValueError
• 時間複雜度
  
  • index和count方法都是O(n)
  • 隨着列表數據規模的增大，而效率下降
• len(string)
  
  • 返回字符串的長度，即字符的個數
• count(sub[,start[, end]]) -> int
  
  • 在指定區間[start, end),從左至右，統計子串sub出現的次數

字符串判斷

• endswith(suffix[, start[, end]]) -> bool
  
  • 在指定的區間[start, end),字符串是否是suffix結尾
• startswith（prefix[,start[, end]]）-> bool
  
  • 在指定的區間[start, end),字符串是否是suffix開頭

字符串判斷is系列

• isalnum() -> bool 是否是字母和數字組成
• isalpha() 是否是字母
• isdecimal() 是否只包含十進制數字
• isdigit()是否包含全部數字(0-9)
• isidentifer()是不是字母和下劃線開頭，其他嗾使字母、數字、下劃線
• islower()是否都是小寫
• isupper()是否全部大寫
• isspace() 是否只包含空白字符

字符串格式化

• 字符串的格式化是一種拼接字符串輸出樣式的手段，更靈活方便
  
  • join拼接只能使用分隔符，且要求被拼接的是可迭代的對象
  • + 拼接字符串還算方便，但是非字符串需要先轉化爲字符串才能呢個拼接
• format函數格式字符串語法
  
  • ”{} {xxx}”.format(*args,**kwargs) -> str
  • args是位置參數，是一個元組
  • kwargs是關鍵字參數，是一個字典
  • 花括號表示佔位符
  • {}表示按照順序匹配位置參數，{n}表示取位置參數索引爲n的值
  • {xxx}表示在關鍵字參數中搜索名稱一致的
  • {{}}表示打印花括號

• 位置參數

  "{}:{}".format('192.168.1.100',8888)
  這就是按照位置順序用位置參數替換前面的格式字符串的佔位符中

• 關鍵字參數或命名參數

  "{server} {1}:{0}".format(8888,'192.168.1.100', server='Web Server Info:')
  位置參數按照序號匹配，關鍵字參數按照名詞匹配

• 訪問參數

  "{0[0]}.{0[1]}".format(('magedu','com'))

• 對象屬性訪問

  from collections import namedttuple
  Point = namedtuple('Point','x y')
  p = Point(4,5)
  "{{{0,x},{0,y}}}".format(p)

• 對齊

  '{0}*{1}={2:<2}'.format(3,2,2*3)
  '{0}*{1}={2:<02}'.format(3,2,2*3)
  '{0}*{1}={2:>02}'.format(3,2,2*3)
  '{:^30}'.format('centered')
  '{:*^30}'.format('centered')

• 進制

  "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
  "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
  octets = [192, 168, 0, 1]
  '{:02X}{:02X}{:02X}{:02X}'.format(*octets)

列表list

• 一個排列整齊的隊列
• 列表內的個體稱爲元素，由若干個元素組成列表
• 元素可以是任意對象（數字、字符串、對象、列表等）
• 列表內元素有順序，可以使用索引
• 線性數據結構
• 使用[]表示
• 列表是可變的

列表list定義 初始化

• list() 生成一個新列表
• list(iterable) 可將可循環結構轉化爲列表
• 列表不能一開始就定義大小
• 舉例
  
  • lst=list()
  • lst=[]
  • lst=[2,3,’adfa’]
  • lst=list(range(5))

列表索引訪問

• 索引，也叫下標
• 正索引：從左至右，從0開始，爲列表中的每一個元素編號
• 負索引：從右至左，從-1開始
• 正負索引不可以越界，否則引發異常indexError
• 列表通過索引訪問
  
  • list[index],index就是索引，使用中括號訪問

列表查詢

• index(value,[start,[stop]])
  
  • 通過值valaue，從指定區間查找列表內的元素是否匹配
  • 匹配第一個就立即返回索引
  • 匹配不到，拋出異常ValueError
• count（value）
  
  • 返回列表中匹配value的次數
• 時間複雜度
  
  • index和count方法都是O(n)
  • 隨着列表數據規模的增大，效率下降
• len()

列表元素修改

• 索引訪問修改
  
  • list[index] = value
  • 索引不要越界

列表增加、插入元素

• append(object) -> None
  
  • 列表尾部追加元素，返回None
  • 不產生新列表，就地修改
  • 時間複雜度O(1)
• insert(index,object) -> None
  
  • 在指定的索引index處插入object
  • 不產生新的列表，就地修改
  • 時間複雜度是O(n)
  • 索引超出上下界
    
    • 超越上屆，尾部追加
    • 超越下屆，頭部追加
• extend(iteratable) -> None
  
  • 將可迭代對象的元素追加進來，返回None
  • 就地修改
• + > list
  
  • 連接操作，將兩個列表連接起來
  • 產生新的列表，原來列表不變
  • 本質上是調用add()方法

列表*重複的問題

pass

列表刪除元素

• remove(value) -> None
  
  • 從左至右查找第一個匹配value的值，移除該元素，返回None
  • 就地修改
  • 時間複雜度是O(n)

• pop([index]) -> item

  • 不指定索引index，就從尾部彈出一個元素
  • 指定索引index，就從索引處彈出一個元素，索引超界拋出IndexError錯誤
  • 時間複雜度
    
    • 指定索引是O(n)
    • 不指定是O(1)

• clear() -> None

  • 清除列表內所有的元素

列表其他操作

• reverse() -> None
  
  • 將列表元素反轉，返回None,就地修改
• sort(key=None,reverse=False) -> None
  
  • 對列表元素進行排序，就地修改，默認升序
  • reverse爲True,反轉，降序
  • key一個函數，指定key如何排序
• in
  
  • [3,4] in [1,2,[3,4]]
  • for x in [1,2,3,4]

列表複製

• copy() -> List
  
  • shadow copy 影子拷貝，也叫淺拷貝，遇到引用類型，只是複製了一個引用而已。
• 深拷貝
  
  • copy 模塊提供了deepcopy

隨機數

• random模塊
• randint(a,b) 返回a，b之間的整數
• choice(seq)從非空序列的元素中隨機挑選一個元素
• randrange([start,] stop [,step])從指定範圍內，按指定基數遞增的集合中獲取一個隨機數
• random.shuffle(list) ->None 就地打亂列表元素
• sample(population, k)從樣本空間或總體中隨機取出k個不同的元素，返回一個新的列表

元組 tuple

• 一個有序的元素組成的集合
• 使用小括號() 表示
• 元組是不可變對象

元組的定義 初始化

• 定義

  • tuple() -> empty tuple
  • tuple(iterable) -> tuple initialized from iterable’s items
  • 舉例

  t = tuple()
  t = ()
  t = tuple(range(1,7,2)
  t = (2,3,4,6,7)
  t = (1,)
  t = (1,2,3) * 6

元組元素的訪問

• 支持索引
• 正索引：從左至右，從0開始，爲列表中每一個元素編號
• 負索引：從右至左，從-1開始
• 正負索引不可以超界，否則引發異常IndexError
• 元組通過索引訪問
  
  • tuple[insex],index就是索引，使用中括號訪問

元組查詢

• index(value,[start,[stop]])
  
  • 通過值value，從指定區域查找列表內的元素是否匹配
  • 匹配第一個就立即返回索引
  • 匹配不到，拋出異常ValueErroe
• count(value)
  
  • 返回列表中匹配value的次數
• 時間複雜度
  
  • index和count方法都是O(n)
  • 隨着列表數據規模的增大，而效率下降
• len(tuple)
  
  • 返回元素的個數

元組其他操作

• 元組是隻讀的，所以增、改、刪的方法都沒有

---

字典dict

• key-value鍵值對的數據集合
• 可變的、無序的、key不重複

字典dict定義 初始化

d = dict() 或者 d = {}
dict(**kwargs) 使用name=value對初始化一個字典
dict(iterable, **kwarg) 使用可迭代對象和name=value 對結構字典，不過可迭代對象的元素必須是一個二元結構
d = dict(((1, 'a'), (2, 'b'))) 或者 d = dict(([1, 'a'], [2, 'b'])))
dict(mapping, **kwarg) 使用一個字典構建另一個字典
d = {'a':10, 'b':20, 'c':None, 'd':[1,2,3]}
類方法dict.fromkeys(iterable, value)
d = dict.fromkeys(range(5))
d = dict.fromkeys(range(5), 0)

字典元素的訪問

• d[key]
  返回key對應的值value
  key不存在拋出KeyError異常
• get(key[, default])
  返回key對應的值value
  key不存在返回缺省值，如果沒有設置缺省值就返回None
• setdefault(key[, default])
  返回key對應的值value
  key不存在，添加kv對，value爲default，並返回default，如果default沒有設置，缺省爲None

字典增加和修改

• d[key] = value
  將key對應的值修改爲value
  key不存在添加新的kv對
• update([other]) -> None
  使用另一個字典的kv對更新本字典
  key不存在，就添加
  key存在，覆蓋已經存在的key對應的值
  就地修改

d.update(red=1)
d.update((('red', 2),))
d.update({'red':3})

字典刪除

• pop(key[, default])
  key存在，移除它，並返回它的value
  key不存在，返回給定的default
  default未設置，key不存在則拋出KeyError異常
• popitem()
  移除並返回一個任意的鍵值對
  字典爲empty，拋出KeyError異常
• clear()
  清空字典
• del語句
  del a[‘key’]
  本質是刪除對象引用

字典遍歷

for … in dict

遍歷key
for k in d:
    print(k)

for k in d.keys():
    print(k)

遍歷value
for k in d:
    print(d[k])

for k in d.keys():
    print(d.get(k))

for v in d.values():
    print(v)

遍歷item
for item in d.items():
    print(item)

for item in d.items():
    print(item[0], item[1])

for k,v in d.items():
    print(k, v)

for k,_ in d.items():
    print(k)

for _,v in d.items():
    print(v)

總結

python3中,keys、values、items方法返回一個類似一個生成器的可迭代對象，不會吧函數的返回值複製到內存中

字典的遍歷移除

錯誤做法
d = dict(a=1,b=2,c='abc')
for k,v in d.items():
    d.pop(k) #拋出異常，不能在遍歷中改變字典長度

正確做法
d = dict(a=1,b=2,c='abc')
key = []
for k,v in d.items():
    if isinstance(v,str):
        keys.append(k)

for k in keys:
    d.pop(k)
print(d)

字典的key

• key的要求和set的元素要求一致
• set的元素可以看作key，set可以看作是dict的簡化版
• hashable可哈希纔可以作爲key，可以使用hash()測試

deaultdict

• collections.defaultdict([default_factory[, ...]])
  第一個參數是default_factory，缺省是None，它提供一個初始化函數，當key不存在的時候，會調用這個共產函數來生成key對應的value

import random 

d1 = {}
for k in 'abcdef':
    for i in range(random.randint(1,5)):
        if k not in d1.keys():
            d1[k] = []
        d1[k].append(i)
print(d1)


form collections import defaultdict
import random

d1 = defaultdict(list)
for k in 'abcdef':
    for i in range(random.randint(1, 5)):
        d1[k].append(i)

print(d1)

OrderedDict

• collections.OrderedDict([items])
  key並不是按照加入的順序排列，可以使用OrderedDict記錄順序

from collections import OrderedDict
import random

d = {'banana':3, 'apple':4, 'pear':1, 'orangr':2}
print(d)
keys = list(d.keys())
random.shuffle(keys)
print(keys) 89
od = OrderedDict()
for key in keys:
    od[key] = d[key]
print(od)
print(od.keys())