一、知識點

１.身份運算：

２.現在計算機系統通用的字元編碼工作方式：在計算機記憶體中，統一使用Unicode編碼，當需要儲存到硬碟或者需要傳輸的時候，就轉換為UTF-8編碼。用記事本編輯的時候，從檔案讀取的UTF-8字元被轉換為Unicode字元到記憶體裡，編輯完成後，儲存的時候再把Unicode轉換為UTF-8儲存到檔案。

3.進位制轉換：

• 轉二進位制：bin()
• 轉八進位制：oct()
• 轉十六進位制：hex()

4.高精度數字處理方法：

from decimal import *
getcontext().prec 
 
= 50
a = Decimal(1)／Decimal(3)
print(a)

結果：0.33333333333333333333333333333333333333333333333333

 5.字典的常見操作

鍵、值、鍵值對
　　　　1、dic.keys() 返回一個包含字典所有KEY的列表；
　　　　2、dic.values() 返回一個包含字典所有value的列表；
　　　　3、dic.items() 返回一個包含所有（鍵，值）元祖的列表；
　　　　4、dic.iteritems()、dic.iterkeys()、dic.itervalues() 與它們對應的非迭代方法一樣，不同的是它們返回一個迭代子，而不是一個列表；
新增
　　　　
 
1、dic['new_key'] = 'new_value'；
　　　　2、dic.setdefault(key, None) ,如果字典中不存在Key鍵，由 dic[key] = default 為它賦值；_
刪除
　　　　1、dic.pop(key[,default]) 和get方法相似。如果字典中存在key，刪除並返回key對應的vuale；如果key不存在，且沒有給出default的值，則引發keyerror異常；
　　　　2、dic.clear() 刪除字典中的所有項或元素；    
修改
　　　　1、dic['key'] = 'new_value',如果key在字典中存在，'new_value
 
'將會替代原來的value值；
　　　　2、dic.update(dic2) 將字典dic2的鍵值對新增到字典dic中
檢視
　　　　1、dic['key']，返回字典中key對應的值，若key不存在字典中，則報錯；
　　　　2、dict.get(key, default = None) 返回字典中key對應的值，若key不存在字典中，則返回default的值（default預設為None）
迴圈
　　　　1、for k in dic.keys()
　　　　2、for k,v in dic.items()
　　　　3、for k in dic
長度
　　　　1、len(dic)

 6.集合中的元素有三個特徵：

• 確定性（元素必須可hash）
• 互異性（去重）
• 無序性（集合中的元素沒有先後之分），如集合{3,4,5}和{3,5,4}算作同一個集合。

7.namedtuple是一個函式，它用來建立一個自定義的tuple物件，並且規定了tuple元素的個數，並可以用屬性而不是索引來引用tuple的某個元素。

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

8.deque使用list儲存資料時，按索引訪問元素很快，但是插入和刪除元素就很慢了，因為list是線性儲存，資料量大的時候，插入和刪除效率很低。deque是為了高效實現插入和刪除操作的雙向列表，適合用於佇列和棧：

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

deque除了實現list的append()和pop()外，還支援appendleft()和popleft()，這樣就可以非常高效地往頭部新增或刪除元素。

9.Counter是一個簡單的計數器，例如，統計字元出現的個數：

>>> from collections import Counter
>>> c = Counter()
>>> for ch in 'programming':
...     c[ch] = c[ch] + 1
...
>>> c
Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})

二、練習題

1.請用程式碼實現：利用下劃線將列表的每一個元素拼接成字串，li＝['alex', 'eric', 'rain']

1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3 # @Time    : 2018/11/15 22:43
4 # @Author  : lurkerzhang
5 # @File    : 1.py
6 # @Descript: 請用程式碼實現：利用下劃線將列表的每一個元素拼接成字串，li＝['alex', 'eric', 'rain']
7 
8 li = '_'.join(['alex', 'eric', 'rain'])
9 print(li)

2.查詢列表中元素，移除每個元素的空格，並查詢以a或A開頭並且以c結尾的所有元素。li = ["alec", " aric", "Alex", "Tony", "rain"]

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/15 22:48
# @Author  : lurkerzhang
# @File    : 2.py
# @Descript: 查詢列表中元素，移除每個元素的空格，並查詢以a或A開頭並且以c結尾的所有元素。
#            li = ["alec", " aric", "Alex", "Tony", "rain"]

li = ["alec", " aric", "Alex", "Tony", "rain"]
for i in li:
    i.strip()
    if i.startswith('a') or i.startswith('A') and i.endswith('c'):
        print(i)

3.寫程式碼，有如下列表，按照要求實現每一個功能

li=['alex', 'eric', 'rain']

• 計算列表長度並輸出
• 列表中追加元素“seven”，並輸出新增後的列表
• 請在列表的第1個位置插入元素“Tony”，並輸出新增後的列表
• 請修改列表第2個位置的元素為“Kelly”，並輸出修改後的列表
• 請刪除列表中的元素“eric”，並輸出修改後的列表
• 請刪除列表中的第2個元素，並輸出刪除的元素的值和刪除元素後的列表
• 請刪除列表中的第3個元素，並輸出刪除元素後的列表
• 請刪除列表中的第2至4個元素，並輸出刪除元素後的列表
• 請將列表所有的元素反轉，並輸出反轉後的列表
• 請使用for、len、range輸出列表的索引
• 請使用enumrate輸出列表元素和序號（序號從100開始）
• 請使用for迴圈輸出列表的所有元素

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/15 22:57
# @Author  : lurkerzhang
# @File    : 3.py
# @Descript: 寫程式碼，有如下列表，按照要求實現每一個功能
li=['alex', 'eric', 'rain']
# 計算列表長度並輸出
print(len(li))
# 列表中追加元素“seven”，並輸出新增後的列表
li.append('seven')
print(li)
# 請在列表的第1個位置插入元素“Tony”，並輸出新增後的列表
li.insert(0, 'Tony')
print(li)
# 請修改列表第2個位置的元素為“Kelly”，並輸出修改後的列表
li[1] = 'Kelly'
print(li)
# 請刪除列表中的元素“eric”，並輸出修改後的列表
li.remove('eric')
print(li)
# 請刪除列表中的第2個元素，並輸出刪除的元素的值和刪除元素後的列表
li_pop = li.pop(1)
print(li_pop, li)
# 請刪除列表中的第3個元素，並輸出刪除元素後的列表
del li[2]
print(li)
# 請刪除列表中的第2至4個元素，並輸出刪除元素後的列表
li = ['Tony', 'Kelly', 'eric', 'rain', 'seven']
del li[1:4]
print(li)
# 請將列表所有的元素反轉，並輸出反轉後的列表
li = ['Tony', 'Kelly', 'eric', 'rain', 'seven']
li = li[::-1]
print(li)
# 請使用for、len、range輸出列表的索引
li = ['Tony', 'Kelly', 'eric', 'rain', 'seven']
for i in range(len(li)):
    print('%s:%s' % (i, li[i]))
# 請使用enumrate輸出列表元素和序號（序號從100開始）
li = ['Tony', 'Kelly', 'eric', 'rain', 'seven']
for index, val in enumerate(li,100):
    print(index, ':', val)
# 請使用for迴圈輸出列表的所有元素
li = ['Tony', 'Kelly', 'eric', 'rain', 'seven']
for i in li:
    print(i)

4.寫程式碼，有如下列表，請按照功能要求實現每一個功能

li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]

• 請根據索引輸出“Kelly”
• 請使用索引找到'all'元素並將其修改為“ALL”，如：li[0][1][9]...

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/15 23:32
# @Author  : lurkerzhang
# @File    : 4.py
# @Descript: 寫程式碼，有如下列表，請按照功能要求實現每一個功能
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# 請根據索引輸出“kelly”
print(li[2][1][1])
# 請使用索引找到'all'元素並將其修改為“ALL”，如：li[0][1][9]...
# li[2][2].upper()
li[2][2] = 'ALL'
print(li)

5.寫程式碼，有如下元組，請按照功能要求實現每一個功能

tu＝('alex', 'eric', 'rain')

• 計算元組長度並輸出
• 獲取元組的第2個元素，並輸出
• 獲取元組的第1-2個元素，並輸出
• 請使用for輸出元組的元素
• 請使用for、len、range輸出元組的索引
• 請使用enumrate輸出元祖元素和序號（序號從10開始）

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/15 23:17
# @Author  : lurkerzhang
# @File    : 5.py
# @Descript: 寫程式碼，有如下元組，請按照功能要求實現每一個功能
tu = ('alex', 'eric', 'rain')
# 計算元組長度並輸出
print(len(tu))
# 獲取元組的第2個元素，並輸出
print(tu[1])
# 獲取元組的第1-2個元素，並輸出
print(tu[0:2])
# 請使用for輸出元組的元素
for i in tu:
    print(i)
# 請使用for、len、range輸出元組的索引
for i in range(len(tu)):
    print('%s:%s' % (i, tu[i]))
# 請使用enumrate輸出元祖元素和序號（序號從10開始）
for index, val in enumerate(tu, 10):
    print('%s:%s' % (index, val))

6.有如下變數，請實現要求的功能

tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])

• 講述元祖的特性

1、有序的集合
2、通過偏移來取資料
3、屬於不可變的物件，不能在原地修改內容，沒有排序，修改等操作。

• 請問tu變數中的第一個元素“alex”是否可被修改？

不可修改

• 請問tu變數中的"k2"對應的值是什麼型別？是否可以被修改？如果可以，請在其中新增一個元素“Seven”
• 請問tu變數中的"k3"對應的值是什麼型別？是否可以被修改？如果可以，請在其中新增一個元素“Seven”

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/15 23:37
# @Author  : lurkerzhang
# @File    : 6.py
# @Descript: 有如下變數，請實現要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
# 請問tu變數中的"k2"對應的值是什麼型別？是否可以被修改？如果可以，請在其中新增一個元素“Seven”
# k2對應的值是列表，k2對應的列表是可以修改的
tu[1][2]['k2'].append('Seven')
print(tu)
# 請問tu變數中的"k3"對應的值是什麼型別？是否可以被修改？如果可以，請在其中新增一個元素“Seven”
# k3對應的值是元組，不可以修改

7.字典dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}

• 請迴圈輸出所有的key
• 請迴圈輸出所有的value
• 請迴圈輸出所有的key和value
• 請在字典中新增一個鍵值對，"k4": "v4"，輸出新增後的字典
• 請在修改字典中“k1”對應的值為“alex”，輸出修改後的字典
• 請在k3對應的值中追加一個元素44，輸出修改後的字典
• 請在k3對應的值的第1個位置插入個元素18，輸出修改後的字典

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/15 23:46
# @Author  : lurkerzhang
# @File    : 7.py
# @Descript: 字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# 請迴圈輸出所有的key
print(dic.keys())
# 請迴圈輸出所有的value
print(dic.values())
# 請迴圈輸出所有的key和value
print(dic.items())
# 請在字典中新增一個鍵值對，"k4": "v4"，輸出新增後的字典
dic['k4'] = 'v4'
print(dic)
# 請在修改字典中“k1”對應的值為“alex”，輸出修改後的字典
dic['k1'] = 'alex'
# 請在k3對應的值中追加一個元素44，輸出修改後的字典
dic['k3'].append(44)
print(dic)
# 請在k3對應的值的第1個位置插入個元素18，輸出修改後的字典
dic['k3'].insert(0, 18)
print(dic)

8.轉換

• 將字串s = "alex"轉換成列表
• 將字串s = "alex"轉換成元祖
• 將列表li = ["alex", "seven"]轉換成元組
• 將元祖tu = ('Alex', "seven")轉換成列表
• 將列表li = ["alex", "seven"]轉換成字典且字典的key按照10開始向後遞增

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/16 9:51
# @Author  : lurkerzhang
# @File    : 8.py
# @Descript: 轉換
# 將字串s = "alex"轉換成列表
s = 'alex'
print(list(s))
# 將字串s = "alex"轉換成元祖
print(tuple(s))
# 將列表li = ["alex", "seven"]轉換成元組
li = ['alex', 'seven']
print(tuple(li))
# 將元祖tu = ('Alex', "seven")轉換成列表
tu = ('Alex', 'seven')
print(list(tu))
# 將列表li = ["alex", "seven"]轉換成字典且字典的key按照10開始向後遞增
li = ['alex', 'seven']
dic = dict(zip([i for i in range(10, 10 + len(li))], li))
print(dic)

9.元素分類:有如下值集合[11,22,33,44,55,66,77,88,99,90]，將所有大於66的值儲存至字典的第一個key中，將小於66的值儲存至第二個key的值中。

即：{'k1':大於66的所有值, 'k2':小於66的所有值}

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/16 10:08
# @Author  : lurkerzhang
# @File    : 9.py
# @Descript: 有如下值集合[11,22,33,44,55,66,77,88,99,90]，將所有大於66的值儲存至字典的第一個key中，將小於66的值儲存至第二個key的值中。
#            即：{'k1':大於66的所有值, 'k2':小於66的所有值}
li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dic = {'k1': [], 'k2': []}
for i in li:
    if i > 66:
        dic['k1'].append(i)
    elif i < 66:
        dic['k2'].append(i)
print(dic)

10.購物車程式

需求：

• 啟動程式後，讓使用者輸入工資，然後列印商品列表；
• 允許使用者根據商品編號購買商品；
• 使用者選擇商品後，檢測餘額是否夠，夠就直接扣款，不然就提醒；
• 使用者可一直購買商品，也可隨時退出，退出時，列印購買的商品和餘額。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/16 10:28
# @Author  : lurkerzhang
# @File    : 10.py
# @Descript: 購物車程式
#            需求：
#            1.啟動程式後，讓使用者輸入工資，然後列印商品列表；
#            2.允許使用者根據商品編號購買商品；
#            3.使用者選擇商品後，檢測餘額是否夠，夠就直接扣款，不然就提醒；
#            4.使用者可一直購買商品，也可隨時退出，退出時，列印購買的商品和餘額。

import re

# 購物車狀態初始化
shopping_car = {"001": 0, "002": 0, "003": 0, "004": 0, "005": 0}
# 庫存商品初始化
good_repertory = {"001":
                      {"e_name": "apple",
                       "c_name": "蘋果",
                       "g_price": 6,
                       "g_storage": 200
                       },
                  "002":
                      {"e_name": "pear",
                       "c_name": "梨",
                       "g_price": 5,
                       "g_storage": 300,
                       },
                  "003":
                      {"e_name": "orange",
                       "c_name": "桔子",
                       "g_price": 4,
                       "g_storage": 250,
                       },
                  "004":
                      {"e_name": "dragon",
                       "c_name": "火龍果",
                       "g_price": 8,
                       "g_storage": 150,
                       },
                  "005":
                      {"g_name": "banana",
                       "c_name": "香蕉",
                       "g_price": 5.5,
                       "g_storage": 300,
                       }
                  }


# 列印選擇選單
def show_menu():
    print('''
========選擇選單=========
[1]----------->顯示購物車
[2]----------->顯示庫存
[B]----------->購買商品
[C]----------->查餘額
[Q]----------->退出
    ''')


# 顯示庫存
def show_goods():
    print('''
=================商品清單=================
  序號     商品名稱     單價     庫存(斤)  
 ''')
    for good in good_repertory:
        print('''   {0}      {1:8}   {2:.2f}    {3:.2f}   
        '''.format(good, good_repertory[good]["c_name"], good_repertory[good]["g_price"],
                   good_repertory[good]["g_storage"]))


# 顯示購物車
def show_car():
    print("==========購物車===========")
    for good_id in shopping_car:
        if shopping_car[good_id]:
            print(good_repertory[good_id]["c_name"], " : ", shopping_car[good_id], "斤")
    print("餘額:", salary)


# 購買指定商品
def buy(b_id, b_weight):
    global salary
    b_price = float(good_repertory[b_id]["g_price"])
    # 查庫存
    if good_repertory[b_id]["g_storage"] < b_weight:
        code = 101
    else:
        # 查餘額
        if salary < b_weight * b_price:
            code = 102
        else:
            # 加入購物車
            shopping_car[b_id] += b_weight
            # 扣除餘額
            salary -= b_weight * b_price
            # 減少庫存
            good_repertory[b_id]["g_storage"] -= b_weight
            code = 103
    return code


# 查餘額
def check_account():
    print('餘額：', salary)


# 提示輸入工資
salary = float(input("input your salary:"))
while True:
    # 列印選擇選單
    show_menu()
    s = input()
    if s.strip() == "Q" or s.strip() == "q":
        print("再見！")
        break
    elif s.strip() == "1":
        show_car()
    elif s.strip() == "2":
        show_goods()
    elif s.strip() == 'C' or s.strip() == 'c':
        check_account()
    elif s.strip() == "B" or s.strip() == "b":
        show_goods()
        # 提示輸入按商品ID
        print("請輸入需要購買的商品ID和重量（如：001,3）[輸入Q退出]：")
        while True:
            s = input()
            if s.strip() == "Q" or s.strip() == "q":
                break
            to_buy = re.split('[^0-9.]+', s.strip())
            id_buy = to_buy[0]
            weight_buy = float(to_buy[1])
            result = buy(id_buy, weight_buy)
            if result == 101:
                message = "購買失敗，庫存不足[%s庫存%s斤]" % (good_repertory[id_buy]['c_name'], good_repertory[id_buy]['g_storage'])
            elif result == 102:
                message = "購買失敗，餘額不足[%s元]" % salary
            else:
                message = '''購買成功：
購買商品：{0}
購買數量(斤)：{1}'''.format(good_repertory[id_buy]["c_name"], weight_buy)
            print(message)
            print("繼續購買請輸入商品ID和重量(按Q返回主介面)")

 11.使用者互動顯示類似省市縣N級聯動的選擇

• 允許使用者增加內容
• 允許使用者選擇檢視某一個級別內容

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/16 16:09
# @Author  : lurkerzhang
# @File    : 11.py
# @Descript: 使用者互動顯示類似省市縣N級聯動的選擇
#            允許使用者增加內容
#            允許使用者選擇檢視某一個級別內容

menu = {
    '重慶': {
        '主城區': {
            '渝北': {
            },
            '渝中': {},
            '江北': {},
            '巴南': {},
            '南岸': {}
        },
        '萬州': {},
        '石柱': {},
        '萬盛': {},
    },
    '湖北': {}
}


def tips():
    print('''
'a':增加內容
'b':返回上層
'q':退出
    ''')


def show_menu(menu):
    while True:
        if not menu:
            print('此類目下為空')
            tips()
        else:
            for i in menu.keys():
                print(i)
        choice = input('你的選擇：')
        if choice == 'q' or choice == 'b':
            return choice
        elif choice == 'a':
            add = input('增加內容：')
            menu[add] = {}
        elif choice in menu:
            re = show_menu(menu[choice])
            if re == 'q':
                return 'q'


show_menu(menu)

12.列舉布林值是False的所有值

 None ""  () []  {} 0

13.有兩個列表

​ l1 = [11,22,33]

​ l2 = [22,33,44]

• 獲取內容相同的元素列表
• 獲取l1中有，l2中沒有的元素列表
• 獲取l2中有，l3中沒有的元素列表
• 獲取l1和l2中內容都不同的元素

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/11/16 22:09
# @Author  : lurkerzhang
# @File    : 13.py
# @Descript: 有兩個列表
l1 = [11, 22, 33]
l2 = [22, 33, 44]
#
# 獲取內容相同的元素列表
s1 = []
for i in l1:
    if i in l2:
        s1.append(i)
print(s1)
# 獲取l1中有，l2中沒有的元素列表
s2 = []
for i in l1:
    if i not in l2:
        s2.append(i)
print(s2)
# 獲取l2中有，l1中沒有的元素列表
s3 = []
for i in l2:
    if i not in l1:
        s3.append(i)
print(s3)
# 獲取l1和l2中內容都不同的元素
s4 = []
for i in l1:
    if i not in l2:
        s4.append(i)
for j in l2:
    if j not in l1:
        s4.append(j)
print(s4)