【JulyEdu-Python基礎】第 ３ 課：容器以及容器的訪問使用

大綱

• 容器切片

  • list/tuple
    dict
    set

• 切片
• 列表推導
• 生成器
• 迭代器 

容器

list 列表

　　序列是Python中最基本的數據結構。序列中的每一個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
　　列表的數據項不須要具備相同的類型

 tuple 元組（只讀列表）

　　像Ｃ＋＋的const

dict 字典

字典的每一個鍵值(key=>value)對用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中。

set 集合　　

　　是一個無序不重複元素集, 基本功能包括關係測試和消除重複元素. 集合對象還支持union(聯合), intersection(交), difference(差)和sysmmetric difference(對稱差集)等數學運算。

 容器 - list/tuple基本操做

li = [1, 2, 3, '456', [1, 2, 3], {1: 'one', 2: 'two'}]
print(type(list))　　　　　　
print(type(li))

<class 'type'>
<class 'list'>

# 元素訪問
print(li[0])
print(li[-1])    # li[len(li) - 1]
print(li[-2])    # li[len(li) - 2]

 

# 查找元素位置
print(li.index('456'))
print(li.index([1, 2, 3]))
#print(li.index(-1))

建立
添加元素（list only）：append, extend

# 添加元素
l_a= [1, 2, 3]
l_a.append(4)
l_a.append(5)
l_b = [6, 7, 8]
l_a.extend(l_b) # 試用下append什麼結果
print(l_a)

def my_extend(li, n_li):
    for i in n_li:
        li.append(li)
# 其實就是把要添加的數組展開了

 

刪除元素（list only）：del, pop

根據索引讀寫（tuple只讀）

判斷容器是否爲空

# 判斷容器是否爲空
l_a = []
if not l_a:
    print('Empty')
if l_a is None:
    print('Empty')# 沒有分配內存,不顯示
# None和not 不是一回事
if len(l_a) == 0:
    print('Empty')

 

字符串轉換
容器元素數量
遍歷

# 遍歷
for i in li:
    print(i)# 直接遍歷
for i in range(len(li)):
    print(li[i])# 根據索引去訪問每一個元素

 

容器 - dict基本操做

初始化
訪問
添加元素
修改元素
刪除元素
判斷key是否存在
判斷容器是否爲空
容器元素數量
遍歷

# 無序的key:value數據結構

d = {'a': 1, 'b': 2, 1: 'one', 2: 'two', 3:[1, 2, 3]}

print(type(dict))
print(type(d))
print(d)

# 訪問元素
print(d['a'])
print(d[1])
print(d[3])

# 判斷元素是否存在
print('c' in d)
print(3 in d)

del(d['a'])# del(dict[key])

print(len(d))

 

#遍歷
d = {'a': 1, 'b': 2, 1: 'one', 2: 'two', 3:[1, 2, 3]}
for key in d:
    print(d[key])
print('.....')
for key, value in d.items():
    print(key, value)

keys = d.keys()
print(type(keys))
print(keys)

容器 - set基本操做

並/交/差集：|/union, &/intersection, -/difference
對稱差集：^/symmetric_difference（不一樣時出如今2個集合中的項）
包含關係：>=/issuperset
添加元素
更新元素
刪除元素
元素是否存在
容器元素數量
遍歷

print(s_a.difference(s_b))

# 對稱差(A | B) - (A & B)
print(s_a ^ s_b)
print(s_a.symmetric_difference(s_b))

# 修改元素
s_a.add('x')
s_a.update([4, 5, 60, 70])
print(s_a)

# 刪除元素 必須知道元素的值
s_a.remove(70)
print(s_a)
# s_a.remove(100)

# 遍歷
print(len(s_a))
for i in s_a:
    print(i)

 

切片

存取序列（列表，元組，字符串）的任意一部分

格式：seq[開始索引:結束索引:步長]

　　默認值
　　負數索引
　　負數步長

# python的大殺器，怎麼高效的切一個子數組，切片最大的用處
li = list(range(10))
print(li)

# 切片 [start:end:steps] >= start & < end開區間 
print(li[2:5])    # [2,3,4]
print(li[:4])     # [0,1,2,3]
print(li[5:])     # [5,6,7,8,9]
print(li[0:10:3]) # [0,3,6,9]

# 負數怎麼處理？
print(li[5:-2])   # [5,6,7]
print(li[9:0:-1]) # [9,8,7,6,5,4,3,2,1]
print(li[9::-1])  # [9,8,7,6,5,4,3,2,1,0]
print(li[::-2])   # [9,7,5,3,1]

#切片生成一個新的對象
print(li)         # 仍是保持原樣

# 切片作快速反轉
re_li = li[::-1]
print(re_li)

 

列表推導

問題的提出

• 　　快速簡單的生成一個列表

• 　　對原有的列表進行簡單的轉換

一維列表推導
二維列表推導以及注意事項

 

#生成數組對象的方法
li = list(range(10))
print(li)

li = []
for i in range(20):
    if(i % 2) == 0:
        li.append(i)

print(li)

li = [0] * 10 
print(li)

# 列表推導
li = [i * 2 for i in range(10)]
print(li)

# 淺拷貝
li_2d = [[0] * 3] * 3# ×３表明把[[0]*3]引用了３次，每一列都是同一個對象
print(li_2d)
li_2d[0][0] = 100 # 同時對這個３個都起了效果
print(li_2d)    # [[100,0,0],[100,0,0],[100,0,0]]

# 深拷貝
li_2d = [[0] * 3 for i in range(3)]
li_2d[0][0] = 100 # 同時對這個３個都起了效果
print(li_2d)    # [[100,0,0],[100,0,0],[100,0,0]]
# 1維狀況下作複製操做，多維使用的是引用

# python３字典和集合也支持列表推導操做，python2不支持
set = { x for x in range(10) if x % 2 == 0}
print(set)

dict = {x: x % 2 == 0 for x in range(10)}
print(dict)

 

生成器

問題的提出

• 建立一個巨大的列表而僅僅須要訪問其中少許幾個元素
• 若是列表元素能夠按照某種算法推算出來，那咱們是否能夠在循環的過程當中不斷推算出後續的元素呢？這樣就沒必要建立完整的list，從而節省大量的空間。

生成生成器：列表推導時用()替換[]（關於yield的使用後面再講）

遍歷：next或者for循環

 

# 平方表
square_table = []
for i in range(10000):
    square_table.append(i * i)

for i in range(10):
    print(square_table[i])

# 生成器，沒有任何初始化開銷的時間，把真正的計算推遲到你使用的時候
square_generator = (x * x for x in range(50000))
print(type(square_generator))
for i in range(10):
    print(next(square_generator))

# 在python3裏range它返回一個新的對象，不是一個list,
# 是一個<class 'range'>,定義了一個生成器
print(type(range(10)))

# 協程,可控多線程
def fib(limit):
    n, a, b = 0, 0, 1
    while n < limit:
        yield b
        a, b = b, a + b
        n += 1
    return 'done'

import traceback
f = fib(5)
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
try:
    print(next(f))
except StopIteration:
    traceback.print_exc()

for i in fib(5):
    print(i)

 

迭代器

問題的提出

• 能夠直接做用於for循環的對象統稱爲可迭代對象：Iterable
• 能夠被next()函數調用並不斷返回下一個值的對象稱爲迭代器：Iterator（表示一個惰性計算的序列）

集合數據類型如list、dict、str等是Iterable但不是Iterator，不過能夠經過iter()函數得到一個Iterator對象。

from collections import Iterable
from collections import Iterator

print(isinstance([1, 2, 3], Iterable))# 數組是可迭代的
print(isinstance([1, 2, 3], Iterator))# 但不是一個迭代器

print(isinstance({}, Iterable))       # True
print(isinstance({}, Iterator))       # False

print(isinstance(123, Iterable))      # False

print(isinstance('abc', Iterable))    # True
print(isinstance('abc', Iterator))    # False

g = (x * x for x in range(3))
print(type(g))
print(isinstance(g, Iterable))        # True
print(isinstance(g, Iterator))        # True
for i in g:
    print(i)

def fib(limit):
    n, a, b = 0, 0,1 
    while n < limit:
        yield b 
        a, b = b, a+b
        n += 1
    return 'done'
f = fib(6)
print(type(f))
print(isinstance(f, Iterable))        # True
print(isinstance(f, Iterator))        # True
for i in f:  
    print(i)