#-----------------------------------------建立列表------------------------------------------
# 定義
# 直接定義
nums = [1,2,3,4,5]

# 通過range函式構造，python2 和python3 版本之間的差異；
# python3 用的時候才會去構造
nums = range(1,101)

# 列表巢狀
# 注意和C語言中陣列的區別,是否可以存放不同的資料型別
nums = [1,2,"ab","1",True,["a","b","c"]]

# 列表賦值給另外一個列表
# 原始的方式
nums = [1,2,3,4,5]
resultList = []
for num in nums:
resultList.append(num ** 2)
print(resultList) # [1, 4, 9, 16, 25]

#使用list()方法建立列表
list_1 = list([1,2,3])
print list_1

# 列表推導式
nums = [1,2,3,4,5]
# [表示式 for 變數 in 列表]
resultList = [num ** 2 for num in nums]
print(resultList) # [1, 4, 9, 16, 25]

# [表示式 for 變數 in 列表 if 條件]
resultList = [num ** 2 for num in nums if num % 2 != 0]
print(resultList) # [1, 9, 25]

#-------------------------------------------------------------列表的增，刪，改，插------------------------------------------------------------------

#-------------------------------------增------------------------------------#
# append
# 作用
# 往列表中, 追加一個新的元素
# 在列表的最後
# 語法
# l.append(object)
# 引數
# object
# 想要新增的元素
# 返回值
# None
# 注意
# 會直接修改原陣列
nums = [1, 2, 3, 4]
nums.append(5) # 無返回值 none
print(nums) # [1, 2, 3, 4, 5]

# insert
# 作用
# 往列表中, 追加一個新的元素
# 在指定索引前面
# 語法
# l.insert(index, object)
# 引數
# index
# 索引, 到時會插入到這個索引之前
# object
# 想要新增的元素
# 返回值
# None
# 注意
# 會直接修改原陣列
nums = [1, 2, 3, 4]
nums.insert(2, 5)
print(nums) # [1, 2, 5, 3, 4]
# extend
# 作用
# 往列表中, 擴充套件另外一個可迭代序列
# 語法
# l.extend(iterable)
# 引數
# iterable
# 可迭代集合
# 字串
# 列表
# 元組
# ...
# 返回值
# None
# 注意
# 會直接修改原陣列
# 和append之間的區別
# extend可以算是兩個集合的拼接

# append是把一個元素, 追加到一個集合中
nums = [1, 2, 3, 4]
nums2 = ["a", "b", "c"]
nums.extend(nums2)
print(nums) # [1, 2, 3, 4, 'a', 'b', 'c']

# 乘法運算
# ["a"] * 3
# =
# ['a', 'a', 'a']
nums = [1, 2]
print(nums * 2) # [1, 2, 1, 2]

# 加法運算
# ["a"] + ["b", "c"]
# =
# ["a", "b", "c"]
# 和extend區別
# 只能列表型別和列表型別相加

n1 = [1, 2]
n2 = ["a", "b"]
n3 = ["abc", "cdf"]
print(n1 + n2); #[1, 2, 'a', 'b']
print(n1 + n3); #[1, 2, 'abc', 'cdf']

# ------------------------------------------刪------------------------------#
# del 語句
# 作用
# 可以刪除一個指定元素(物件)
# 語法
# del 指定元素
# 注意
# 可以刪除整個列表
# 刪除一個變數
# 也可以刪除某個元素
nums = [1, 2, 3, 4]
del nums[1]
print(nums) # [1, 3, 4]

del nums[:] #刪除列表中全部元素，即清空了列表
nums = [] #可以清空列表，但不能作為函式引數執行

# pop
# 作用
# 移除並返回列表中指定索引對應元素
# 語法
# l.pop(index=-1)
# 引數
# index
# 需要被刪除返回的元素索引
# 預設是-1
# 也就對應著列表最後一個元素
# 返回值
# 被刪除的元素
# 注意
# 會直接修改原陣列
# 注意索引越界
nums = [1, 2, 3, 4]
nums.pop() #預設-1,並返回刪除的元素
nums.pop(0) #刪除指定位置的元素，並返回刪除的元素

print(nums)

# remove
# 作用
# 移除列表中指定元素
# 語法
# l.remove(object)
# 引數
# object
# 需要被刪除的元素
# 返回值
# None
# 注意
# 會直接修改原陣列
# 如果元素不存在
# 會報錯
# 若果存在多個元素
# 則只會刪除最左邊一個
# 注意迴圈內刪除列表元素帶來的坑

nums = [1, 2, 2, 3, 4]
nums.remove(2) #則只會刪除最左邊一個
print(nums) #[1, 2, 3, 4]

# ---------------------------------------------改----------------------------------------#
# names[index] = 666

nums = [1, 2, 3]
nums[1] = 5
print(nums) #[1, 5, 3]

#--------------------------------------------- 查----------------------------------------#
# 獲取單個元素
# items[index]
# 注意負索引
nums = [1, 2, 3]
print(nums[-1]) # 3

# 獲取元素索引
# index()
nums = [1, 2, 5, 3, 4]
print(nums.index(5)) # 2

# 獲取指定元素個數
# count()
nums = [1, 2, 5, 2, 3, 4]
print(nums.count(2) ) #2

# 獲取多個元素
# 切片
# items[start:end:step]
# 遍歷
# 方式1
# 根據元素進行遍歷
# for item in list:
# print(item)
# 方式2
# 根據索引進行遍歷
# for index in range(len(list)):
# print(index, list[index])
# 方式3(瞭解)
# 建立對應的列舉物件
# 概念
# 通過列舉函式, 生成的一個新的物件
# 作用
# 函式用於將一個可遍歷的資料物件(如列表、元組或字串)組合為一個索引序列
# 同時列出資料下標和資料
# 語法
# enumerate(sequence, [start=0])
# sequence -- 一個序列、迭代器或其他支援迭代物件。
# start -- 下標起始位置。
#
#如果對一個列表，既要遍歷索引又要遍歷元素時，首先可以這樣寫：
list1 = ["這", "是", "一個", "測試"]
for i in range (len(list1)):
print i ,list1[i]

#上述方法有些累贅，利用enumerate()會更加直接和優美：
list1 = ["這", "是", "一個", "測試"]
for index, item in enumerate(list1):
print index, item
>>>
0 這
1 是
2 一個
3 測試

#•enumerate還可以接收第二個引數，用於指定索引起始值
list1 = ["這", "是", "一個", "測試"]
for index, item in enumerate(list1, 1):
print index, item
>>>
1 這
2 是
3 一個
4 測試

# l = ["a", "b", "c"]
# enumerate(l, 1)
# 一個待列舉的物件
# 轉換成為list之後, 具體資料如下
# [(1, 'a'), (2, 'b'), (3, 'c')]
# 遍歷列舉物件
# for index, value in 列舉物件:
# print(index, value)
# 方式4(瞭解)
# 使用迭代器進行遍歷
# iterL = iter(list)
# for item in iterL:
# print(item)

# 訪問集合的方式-迭代器
# 概念
# 迭代
# 是訪問集合元素的一種方式
# 按照某種順序逐個訪問集合中的每一項
# 可迭代物件
# 能夠被迭代的物件, 稱為可迭代物件
# 判定依據
# 能作用於for in
# 判定方法
# import collections
# isinstance(obj, collections.Iterable)
# 迭代器
# 是可以記錄遍歷位置的物件
# 從第一個元素開始, 往後通過next()函式, 進行遍歷
# 只能往後, 不能往前
# 判定依據
# 能作用於next()函式
# 判定方法
# import collections
# isinstance(obj, collections.Iterator)
# 注意
# 迭代器也是可迭代物件, 所以也可以作用於for in
# 為什麼會產生迭代器?
# 1. 僅僅在迭代到某個元素時才處理該元素
# 在此之前, 元素可以不存在
# 在此之後, 元素可以被銷燬
# 特別適合用於遍歷一些巨大的或是無限的集合
# 例如 "菲波那切數列"
# 2. 提供了一個統一的訪問集合的介面
# 可以把所有的可迭代物件, 轉換成迭代器進行使用
# iter(Iterable)
# iter(str)
# iter(list)
# iter(tuple)
# iter(dict)
# ...
# 迭代器簡單使用
# 使用next()函式, 從迭代器中取出下一個物件, 從第1個元素開始
# 因為迭代器比較常用, 所以在Python中, 可以直接作用於for in
# 內部會自動呼叫迭代器物件的next()
# 會自動處理迭代完畢的錯誤
# 注意事項
# 如果取出完畢,再繼續取, 則會報錯
# StopIteration
# 迭代器一般不能多次迭代

import collections

nums = [1, 2, 3]
result = isinstance(nums, collections.Iterable)
print(result) # True
result = isinstance(nums, collections.Iterator)
print(result) # Flase

# 轉為迭代器
it = iter(nums)

for v in it:
print(v)

# 判定
# 元素 in 列表
# 元素 not in 列表

# 比較
# cmp()
# 內建函式
# 如果比較的是列表, 則針對每個元素, 從左到右逐一比較
# 左 > 右
# 1
# 左 == 右
# 0
# 左 < 右
# -1
# Python3.x不支援
# 比較運算子
# ==
# >
# <
# ...
# 針對每個元素, 從左到右逐一比較

# 排序
# 方式1
# 內建函式
# 可以對所有可迭代物件進行排序
# 語法
# sorted(itrearble, key=None, reverse=False)
# 引數
# itrearble
# 可迭代物件
# key
# 排序關鍵字
# 值為一個函式，此函式只有一個引數且返回一個值用來進行比較
# reverse
# 控制升序降序
# 預設False
# 升序
# 返回值
# 一個已經排好序的列表
# 列表型別
s = "cdefga"
result = sorted(s);
print(result) #['a', 'c', 'd', 'e', 'f', 'g']

s = [2,3,1,4,5]
result = sorted(s, reverse = True)
print(result) #[5, 4, 3, 2, 1]

s = [("a", 16), ("a1",13), ("a2", 14)]
result = sorted(s)
print(result) #[('a', 16), ('a1', 13), ('a2', 14)]

#按元組的第一個元素來排序
def getKey(x):
return x[1]
result = sorted(s, key=getKey)
print(result) #[('a1', 13), ('a2', 14), ('a', 16)]

# 方式2
# 列表物件方法
# 語法
# list.sort(key=None, reverse=False)
# 引數
# key
# 排序關鍵字
# 值為一個函式，此函式只有一個引數且返回一個值用來進行比較
# reverse
# 控制升序降序
# 預設False
# 升序

s = [2,3,1,4,5]
res = s.sort()
print(res, s) # None [1, 2, 3, 4, 5] 注意和內建函式的方法不同點；

# 亂序
# 可以隨機打亂一個列表
# 匯入random模組
# import random
# random.shuffle(list)

import random
list = [1, 2, 3, 4, 5]
res = random.shuffle(list)
print(res, list) #None [4, 3, 5, 2, 1] 後面序列隨機，修改原序列的本身

# 反轉
# l.reverse()
list = [1, 2, 3, 4, 5]
res = list.reverse()
print(res, list) #None [5, 4, 3, 2, 1]

# 切片反轉
# l[::-1]
list = [1, 2, 3, 4, 5]
res = list[::-1]
print(res, list) #[5, 4, 3, 2, 1] [1, 2, 3, 4, 5]

#list去重

list_1 = ['s','a','d','s','a','d']
list_2 = []

for i in list_1:
if i not in list_2:
list_2.append(i)
print list_2