# 連結：https://juejin.cn/post/7078284540745089055

# 1、第一個字母大寫
# s = "programming is awesome"
# print(s.title())

# 2、列表合併
# 第一種方式：使用 +。
# a = [1,2,3]
# b = [4,5,6]
# print(a + b)
# 第二種方式：使用 extend 關鍵字。
# a.extend(b)
# print(a)
# 第二種種方式明顯更加優雅，推薦使用。需要說明的一點是，如果列表很大的話，+ 會比較慢，使用 extend 更好。

# 3、列表元素去重
# 使用 set() 對列表元素進行去重。
# a = [1, 2, 3, 4, 2, 3]
# b = list(set(a))
# print(b)

# 4、列表排序
# 使用 sort() 或內建函式 sorted() 對列表進行排序。它們之間的區別有兩點：
# sort() 方法是對原列表進行操作，而 sorted() 方法會返回一個新列表，不是在原來的基礎上進行操作。
# sort() 是應用在列表上的方法，而 sorted() 可以對所有可迭代的物件進行排序操作。
# sort()
# a = [1, 2, 3, 4, 2, 3]
# a.sort()
# print(a)

# a = [1, 2, 3, 4, 2, 3]
# a.sort(reverse=True)      #倒序
# print(a)

# sorted()
# a = [1, 2, 3, 4, 2, 3]
# print(sorted(a))

# a = [1, 2, 3, 4, 2, 3]
# print(sorted(a, reverse=True))

# 5、遍歷列表的索引和元素對
# 使用 enumerate() 函式可以同時輸出索引和元素值。
# a = ['python', 'go', 'java']
# for i, v in enumerate(a):
#     print(i, v)

# 6、查詢列表中出現最頻繁的元素
# 使用 max() 函式可以快速查找出一個列表中出現頻率最高的某個元素。
# a = [1, 2, 3, 4, 3, 4, 5, 4, 4, 2]
# b = max(set(a), key=a.count)
# print(b)

# 需要說明的一點是，當列表中有兩個元素出現的次數相同時，會返回第一個出現的元素。
# a = [1, 2]
# b = max(set(a), key=a.count)
# print(b)

# 7、統計列表中所有元素的出現次數
# 前面的程式碼給出了出現最頻繁的值。如果想要知道列表中所有元素的出現次數，那麼可以使用 collections 模組。
# collections 是 Python 中的一個寶藏模組，它提供了很多特性。Counter 方法正好可以完美解決這個需求。
from collections import Counter
# a = [1, 2, 3, 4, 3, 4, 5, 4, 4, 2]
# print(Counter(a))
# 返回示例：Counter({4: 4, 2: 2, 3: 2, 1: 1, 5: 1})

# 8、將兩個列表合併為字典
# 使用 zip() 函式，可以將兩個列表合併成字典。
# a = ['one', 'tow', 'three']
# b = [1, 2, 3]
# print(dict(zip(a, b)))

# 9、求兩個列表的交集，並集和差集
def main():
    list_a = [1, 2, 3, 4, 5]
    list_b = [4, 5, 6, 7, 8]

    # 求交集的兩種方式
    res_a = [i for i in list_a if i in list_b]
    res_b = list(set(list_a).intersection(set(list_b)))

    print(f"res_a is: {res_a}")
    print(f"res_b is: {res_b}")

    # 求並集
    res_c = list(set(list_a).union(set(list_b)))
    print(f"res_c is: {res_c}")

    # 求差集的兩種方式，在B中但不在A中
    res_d = [i for i in list_b if i not in list_a]
    res_e = list(set(list_b).difference(set(list_a)))

    print(f"res_d is: {res_d}")
    print(f"res_e is: {res_e}")


# if __name__ == '__main__':
#     main()

# 10、字典建立
# 10.1、建立空字典
# a = {}
# b = dict()

# 10.2、有初始值，從輸入的便利程度來說，我更喜歡第二種
# a = {'a': 1, 'b': 2, 'c': 3}
# b = dict(a=1, b=2, c=3)

# 10.3、key 來自一個列表，而 value 相同, 使用 fromkeys，那是相當的優雅
# keys = ['a', 'b', 'c']
# value = 100
# d = dict.fromkeys(keys, value)
# print(d)
# 10.4、key 來自一個列表，而 value 也是一個列表，使用 zip
# keys = ['a', 'b', 'c']
# values = [1, 2, 3]
# d = dict(zip(keys, values))

# 11、字典合併
# m = {'a': 1}
# n = {'b': 2, 'c': 3}

# 合併，兩種方式
# 11.1、使用 update
# m.update(n)
# 11.2、使用 **
# print({**m, **n})

# 12、判斷 key 是否存在
# 在 Python2 中判斷某個 key 是否存在，可以使用 has_key，但這個方法在 Python3 中已經被移除了。
# 另一種方法是使用 in 關鍵字，不僅相容 Python2 和 Python3，速度還更快，強烈推薦。
# d = {'a': 1, 'b': 2}
# if 'a' in d:
#     print('hello')

# 13、獲取字典中的值
# d = {'a': 1, 'b': 2}
# 13.1、直接用 key 取值，但這種方式不好，如果 key 不存在會報錯，推薦使用 get
# a = d['a']
# 13.2、使用 get，如果 key 不存在還可以賦預設值
# a = d.get('a')
# c = d.get('c', 3)

# 14、字典遍歷
# d = {'a': 1, 'b': 2, 'c': 3}
# 遍歷 key
# for key in d.keys():
#     pass

# 遍歷 value
# for value in d.values():
#     pass

# 遍歷 key 和 value
# for key, value in d.items():
#     pass

# 15、字典推導式
# 列表推導式和字典推導式是我相當喜歡的功能，簡潔高效。map 和 filter 我都已經快不會用了。
# l = [1, 2, 3]
# {n: n * n for n in l}
# {1: 1, 2: 4, 3: 9}

# 16、字典按 key 或 value 排序
# d = {'a': 1, 'b': 2, 'e': 9, 'c': 5, 'd': 7}
# 按 key 排序
# sorted(d.items(), key=lambda t: t[0])
# 按 key 倒序
# sorted(d.items(), key=lambda t: t[0], reverse=True)
# 按 value 排序
# sorted(d.items(), key=lambda t: t[1])

# 17、還有一個需求是我在開發過程經常碰到的，就是有一個列表，列表的元素是字典，然後按字典的 value 對列表進行排序。
# l = [{'name': 'a', 'count': 4}, {'name': 'b', 'count': 1}, {'name': 'd', 'count': 2}, {'name': 'c', 'count': 6}]
# xl = sorted(l, key=lambda e: e.__getitem__('count'))
# print(xl)
# 倒序
# xxl = sorted(l, key=lambda e: e.__getitem__('count'), reverse=True)
# print(xxl)