內置數據結構

一，list

1，列表的一些特性 ：

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

2，列表的定義 ：

• lst = list()()可以是itertable
• lst = []

3，對列表的一些操作 ：

• index(value,[start,[stop]])正負索引（正索引從0開始，負索引從-1開始），索引不可越界，否則回報indexerror
  2.列表的索引訪問用lst[ ]

3.count(value)?返回列表中匹配value的次數

4.時間復雜度index和count方法都是O(n)
5.隨著列表數據規模的增大，而效率下降

6.元素個數查看用len()

7.列表修改 list[] = value 索引不可超界

1.增加元素 append()在尾部增加一個元素，就地修改，列表最常用的操作，時間復雜度是O(1)
2. insert(index, object) -> None
在指定的索引index處插入元素object
返回None就意味著沒有新的列表產生，就地修改
時間復雜度是O(n)
索引能超上下界嗎？
超越上界，尾部追加
超越下界，頭部追加
3.extend(iteratable) -> None
將可迭代對象的元素追加進來，返回None
就地修改
+ ->??list
連接操作，將兩個列表連接起來
產生新的列表，原列表不變
本質上調用的是__add__()方法
* ->??list
重復操作，將本列表元素重復n次，返回新的列表

在此要特別注意的是如果是*list其中還有列表如[1, [2,3 ],4 ]

那么復制的工程中套在其中的列表只會復制地址
4.remove(value) -> None
從左至右查找第一個匹配value的值，移除該元素，返回None
就地修改
效率？O（n）
pop([index]) -> item?#常用
不指定索引index，就從列表尾部彈出一個元素
指定索引index，就從索引處彈出一個元素，索引超界拋出 IndexError錯誤
效率？指定索引的的時間復雜度？不指定索引呢？
clear() -> None
清除列表所有元素，剩下一個空列表
5.reverse() -> None
將列表元素反轉，返回None
就地修改
sort(key=None, reverse=False) -> 對列表元素進行排序，就地修改，默認 升序
reverse為True，反轉，降序
key一個函數，指定key如何排序
lst.sort(key=functionname)
in
[3,4] in [1, 2, [3,4]]
for x in [1,2,3,4]

• 列表的復制分為 shadowcopy（影子拷貝，又稱淺拷貝）

deepcopy（深拷貝）#
copy模塊提供了deepcopy
import copy

• 隨機數 random模塊
  randint(a, b) 返回[a, b]之間的整數
  2.choice(seq) 從非空序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數。random.choice([1,3,5,7])
  3.randrange ([start,] sto[,step]) 從指定范圍內，按指基數遞增的集合中獲取一個隨機數，基數缺省值random.randrange(1,7,2)
  random.shuffle(list) ->None 就地打亂列表元素
  4.sample(population, k) 從樣本空間或總體（序列或者集合類型）中隨機取出k個不同的元素，返回一個新的列表

二，tuple

• 元組和列表的區別 ：
  1. 元組是不可變的
  2. 元組用()表示
• 命名元組 ：
  1. 幫助文檔中，查閱namedtuple，有使用例程namedtuple(typename, field_names, verbose=False,rename=False)
     命名元組，返回一個元組的子類，并定義了字段
     field_names可以是空白符或逗號分割的字段的字符串，可以是字段的列表
     from collections import namedtuple
     Point = namedtuple(‘_Point’,[‘x’,’y’]) # Point為返回的類

= Point(11, 22)

Student = namedtuple(‘Student’, ‘name age’)

tom = Student(‘tom’, 20)

jerry = Student(‘jerry’, 18)tom.name

三，字符串（str）

• 使用單引號、雙引號、三引號引住的字符序列
• Python3起，字符串就是Unicode類型
• 字符串是不可變對象
• join連接
• “string”.join(iterable) -> str
  b）將可迭代對象連接起來，使用string作為分隔符
  c）可迭代對象本身元素都是字符串
  d）返回一個新字符串
• +連接

拼接起來返回一個新的字符串

• 字符串分割
  1. （r）split系將字符串按照分隔符分割成若干字符串，并返回列表
  2. （r）partition系將字符串按照分隔符分割成2段，返回這2段和分隔符的元組

7. 字符串大小寫
   1. upper
   2. lower

• 字符串排版
  1. title() -> str標題的每個單詞都大寫
  2. capitalize() -> str首個單詞大寫
  3. center(width[, fillchar]) -> str
     width 打印寬度
     fillchar 填充的字符
  4. zfill(width) -> strwidth 打印寬度，居右，左邊用0填充
  5. ljust(width[, fillchar]) -> str 左對齊
  6. rjust(width[, fillchar]) -> str 右對齊
• 字符串修改
  1. replace(old, new[, count]) -> str
     字符串中找到匹配替換為新子串，返回新字符串
     ount表示替換幾次，不指定就是全部替換
  2. strip([chars]) -> str
     從字符串兩端去除指定的字符集chars中的所有字符
     如果chars沒有指定，去除兩端的空白字符
  3. find(sub[, start[, end]]) -> int
     在指定的區間[start, end)，從左至右，查找子串sub。找到返回索引，沒找到返回-1
  4. rfind(sub[, start[, end]]) -> int
     在指定的區間[start, end)，從右至左，查找子串sub。找到返回索引，沒找到返回-1

10.字符串查找

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

• 字符串判斷
  1. endswith(suffix[, start[, end]]) -> bool
     在指定的區間[start, end)，字符串是否是suffix結尾
  2. startswith(prefix[, start[, end]]) -> bool
     在指定的區間[start, end)，字符串是否是prefix開頭
  3. is系列
     isalnum() -> bool 是否是字母和數字組成
     isalpha() 是否是字母
     isdecimal() 是否只包含十進制數字
     isdigit() 是否全部數字(0~9)
     isidentifier() 是不是字母和下劃線開頭，其他 都是字母、數字、下劃線
     islower() 是否都是小寫
     isupper() 是否全部大寫
     isspace() 是否只包含空白字符
• 字符串格式化
  1. format函數格式字符串語法——Python鼓勵使用
     “{} {xxx}”.format(*args, **kwargs) -> str
     args是位置參數，是一個元組
     kwargs是關鍵字參數，是一個字典
     花括號表示占位符
     {}表示按照順序匹配位置參數，{n}表示取位置參數索引為n的值
     {xxx}表示在關鍵字參數中搜索名稱一致的
     {{}} 表示打印花括號
  2. 位置參數
     “{}:{}”.format(‘192.168.1.100’,8888)，這就是按照位置順序用位置參數替換前面的格式字符串的占位符中
  3. 關鍵字參數或命名參數
     “{server} {1}:{0}”.format(8888, ‘192.168.1.100’, server=’Web Server Info : ‘) ，位置參數按照序號匹配，關鍵字參數按照名詞匹配
  4. 訪問元素
     “{0[0]}.{0[1]}”.format((‘magedu’,’com’))
  5. 對象屬性訪問
     from collections import namedtuple
     Point = namedtuple(‘Point’,’x y’)
     = Point(4,5)
     “{{{0.x},{0.y}}}”.format(p)
  6. 對齊
     ‘{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’)
  7. 進制
     “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)

四，bytes和bytearray

• bytes
  不可變字節序列
  bytearray
  字節數組
  可變

五，set

• 約定
  set 翻譯為集合
  collection 翻譯為集合類型，是一個大概念
• set
  可變的、無序的、不重復的元素的集合
• 定義
  set() {a,} #注意：{}空的花括號是字典所以空set定義為set()
• set的元素要求必須可以hash
  目前學過的不可hash的類型有list、set
  元素不可以索引
  set可以迭代
• add(elem)
  增加一個元素到set中
  如果元素存在，什么都不做
  update(*others)
  合并其他元素到set集合中來
  參數others必須是可迭代對象
  就地修改
• remove(elem)
  從set中移除一個元素
  元素不存在，拋出KeyError異常。為什么是KeyError？
  discard(elem)
  從set中移除一個元素
  元素不存在，什么都不做
  pop() -> item
  移除并返回任意的元素。為什么是任意元素？
  空集返回KeyError異常
  clear()
  移除所有元素
• set無法查詢修改
• 集合運算符

1. 并集 |
2. 交集 &
3. 差集 –
4. 對稱差集 ^
5. <= 判斷set1是否是set2的子集
6. <判斷set1是否是set2的真子集
7. >=判斷set1是否是set2的超集
8. > 判斷set1是否是set2的真超集

六，切片

• 要求 ：
  a)線性結構
  可迭代 for … in
  len()可以獲取長度
  通過下標可以訪問
  可以切片
  b)學過的線性結構
  列表、元組、字符串、bytes、bytearray
• 切片
  通過索引區間訪問線性結構的一段數據
  sequence[start:stop] 表示返回[start, stop)區間的子序列
  支持負索引
  start為0，可以省略
  stop為末尾，可以省略
  超過上界（右邊界），就取到末尾；超過下界（左邊界），取到開頭
  start一定要在stop的左邊
  [:] 表示從頭至尾，全部元素被取出，等效于copy()方法

七，封裝和結構

• 封裝
  封裝
  將多個值使用逗號分割，組合在一起
  本質上，返回一個元組，只是省掉了小括號
  python特有語法，被很多語言學習和借鑒
  t1 = (1,2) # 定義為元組
  t2 = 1,2 # 將1和2封裝成元組
  type(t1)
  type(t2)
• 封裝和解構
  舉例
  a = 4
  b = 5
  tem= a
  a = b
  b = temp
  等價于
  a, b = b, a
  上句中，等號右邊使用了封裝，而左邊就使用了解構
• 解構
  把線性結構的元素解開，并順序的賦給其它變量
  左邊接納的變量數要和右邊解開的元素個數一致
  舉例
  lst = [3, 5]
  first, second = lst
  print(first, second)
• Python3的解構
  使用 *變量名 接收，但不能單獨使用
  被 *變量名 收集后組成一個列表
  舉例
  lst = list(range(1, 101, 2))
  head, *mid, tail = lst
  *lst2 = lst
  *body, tail = lst
  head, *tail = lst
  head, *m1, *m2, tail = lst
  head, *mid, tail = “abcdefghijklmn”
  type(mid)
• 丟棄變量
  這是一個慣例，是一個不成文的約定，不是標準
  如果不關心一個變量，就可以定義改變量的名字為_
  _是一個合法的標識符，也可以作為一個有效的變量使用，但是定義成下劃線就是希望不要被使用，除非你明確的知道這個數據需要使用

八，冒泡法

• 注意冒泡法優化的方法以及打標記的位置