一、知识点
１.身份运算：
２.现在计算机系统通用的字符编码工作方式：在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件。
3.进制转换：
- 转二进制：bin()
- 转八进制：oct()
- 转十六进制：hex()
4.高精度数字处理方法：
from decimal import *
getcontext().prec =
a = Decimal()／Decimal()
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']
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/11/15 22:43
# @Author : lurkerzhang
# @File : 1.py
# @Descript: 请用代码实现：利用下划线将列表的每一个元素拼接成字符串，li＝['alex', 'eric', 'rain'] li = '_'.join(['alex', 'eric', 'rain'])
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 = {"": 0, "": 0, "": 0, "": 0, "": 0}
# 库存商品初始化
good_repertory = {"":
{"e_name": "apple",
"c_name": "苹果",
"g_price": 6,
"g_storage": 200
},
"":
{"e_name": "pear",
"c_name": "梨",
"g_price": 5,
"g_storage": 300,
},
"":
{"e_name": "orange",
"c_name": "桔子",
"g_price": 4,
"g_storage": 250,
},
"":
{"e_name": "dragon",
"c_name": "火龙果",
"g_price": 8,
"g_storage": 150,
},
"":
{"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() == "":
show_car()
elif s.strip() == "":
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- -*-
# @Time : // :
# @Author : lurkerzhang
# @File : .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)