Python之路——基本数据类型练习

基本数据类型习题

1、元素分类

有如下值集合 [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)
    else :
        dic['k2'].append(i)
print(dic)

2、查找

#查找列表中元素，移除每个元素的空格，并查找以a或A开头并且以c结尾的所有元素。
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}

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

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

dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
for i in dic.values():
    new_i = i.strip()
    if new_i.endswith('c') and (new_i.startswith('a') or new_i.startswith('A')):
        print(new_i)

3、输出商品列表，用户输入序号，显示用户选中的商品

商品 li = ["手机", "电脑", '鼠标垫', '游艇']

li = ["手机", "电脑", '鼠标垫', '游艇']
for k,v in enumerate(li,1) :
    print(k,v)
r = int(input("请输入商品序号："))
len_li = len(li)
if r > 0 and r <= len_li:
    print(li[r-1])
else:
    print("商品不存在。")

 4、简易购物车

要求用户输入总资产，例如：2000
显示商品列表，让用户根据序号选择商品，加入购物车购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。附加：可充值、某商品移除购物车
goods = [
	{"name": "电脑", "price": 1999},
	{"name": "鼠标", "price": 10},
	{"name": "游艇", "price": 20},
	{"name": "美女", "price": 998},
]

asset_all = 0
car_list = []
goods = [
        {"name": "电脑", "price": 1999},
        {"name": "鼠标", "price": 10},
        {"name": "游艇", "price": 20},
        {"name": "美女", "price": 998},
    ]
i1 = input("请输入您的总资产：")
asset_all = int(i1)
for v in goods:
    print(v['name'],v['price'])
while True:
    i2 = input("请选择商品（Y/y结算）:")
    if i2.lower() == "y":
        break
    for j in goods:
        if j['name'] == i2:
            car_list.append(j)
print(car_list)
all_price = 0
for item in car_list:
    p = item['price']
    all_price = all_price + p
print('总资产：',asset_all,'总价格：',all_price)
if all_price>asset_all:
    print('穷逼，请充值！')
else:
    balance = asset_all - all_price
    print('购买成功')
    print('余额为：',balance)

asset_all = 0
i1 = input("请输入您的总资产：")
asset_all = int(i1)

goods = [
        {"name": "电脑", "price": 1999},
        {"name": "鼠标", "price": 10},
        {"name": "游艇", "price": 20},
        {"name": "美女", "price": 998},
    ]
for i in goods:
    print(i['name'],i['price'])
car_dict = {}

while True:
    i2 = input("请选择商品(Y/y结算)：")
    # 循环所有商品，查找需要的商品
    if i2.lower() == 'y':
        break
    for item in goods:
        if item['name'] == i2:
            name = item['name']
            #判断购物车中是否已经有该商品，有，num+1
            if name in car_dict.keys():
                car_dict[name]['num'] = car_dict[name]['num'] + 1
            else:
                car_dict[name] = {"num":1,"single_price":item['price']}
    print(car_dict)

all_price = 0
for k,v in car_dict.items():
    n = v['single_price']
    m = v['num']
    all_sum = m * n
    all_price = all_price + all_sum

if all_price>asset_all:
    print('穷逼，请充值！')
else:
    balance = asset_all - all_price
    print('购买成功')
    print('总资产：',asset_all,'总价格：',all_price,'余额为：',balance)

5、三级菜单

打印省、市、县三级菜单
可返回上一级
可随时退出程序

menu = {
    '北京':{
        '海淀':{
            '五道口':{
                'soho':{},
                '网易':{},
                'google':{}
            },
            '中关村':{
                '爱奇艺':{},
                '汽车之家':{},
                'youku':{},
            },
            '上地':{
                '百度':{},
            },
        },
        '昌平':{
            '沙河':{
                '老男孩':{},
                '北航':{},
            },
            '天通苑':{},
            '回龙观':{},
        },
        '朝阳':{},
        '东城':{},
    },
    '上海':{
        '闵行':{
            "人民广场":{
                '炸鸡店':{}
            }
        },
        '闸北':{
            '火车战':{
                '携程':{}
            }
        },
        '浦东':{},
    },
    '山东':{},
}

#part1（初步实现）：能够一层一层进入
exit_tag=True
current_layer=menu

while exit_tag:
    for k in current_layer:
        print(k)
    choice=input('>>: ').strip()

    if choice == 'quit': break

    if choice not in current_layer:continue

    current_layer=current_layer[choice]

#part2（改进）：在进入下一层之前，记录下当前层（在用户一层一层退出时使用）
current_layer=menu
layers=[]

while True:
    for k in current_layer:
        print(k)
    choice=input('>>: ').strip()

    if choice == 'quit':break

    if choice == 'b':
        if len(layers) == 0:break
        current_layer=layers.pop()
        continue

    if choice not in current_layer:continue

    layers.append(current_layer) #记录好当前层
    current_layer=current_layer[choice]

6、统计单词次数

统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

s='hello alex alex say hello sb sb'

l=s.split()
dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)

s='hello alex alex say hello sb sb'
dic={}
words=s.split()
print(words)
for word in words: #word='alex'
    dic[word]=s.count(word)
    print(dic)

#利用setdefault解决重复赋值
'''
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) #返回1

d={'a':2222}
print(d.setdefault('a',1)) #返回2222
'''
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
for word in words: #word='alex'
    dic.setdefault(word,s.count(word))
    print(dic)

#利用集合，去掉重复，减少循环次数
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
    dic[word]=s.count(word)
    print(dic)

7、字符串练习  

name = " aleX"
1)    移除 name 变量对应的值两边的空格,并输出处理结果
2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果
3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果
4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
6)    将 name 变量对应的值变大写,并输出结果
7)    将 name 变量对应的值变小写,并输出结果
8)    请输出 name 变量对应的值的第 2 个字符
9)    请输出 name 变量对应的值的前 3 个字符
10)   请输出 name 变量对应的值的后 2 个字符
11)   请输出 name 变量对应的值中 “e” 所在索引位置
12)   获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

8、列表练习  

1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

2. 用列表模拟队列

3. 用列表模拟堆栈

4. 有如下列表，请按照年龄排序（涉及到匿名函数）
l=[
    {'name':'alex','age':84},
    {'name':'oldboy','age':73},
    {'name':'egon','age':18},
]

集合练习    

# 数据库中原有
old_dict = {
	"#1" :{ 'hostname' :c1, 'cpu_count': 2, 'mem_capicity': 80 },
	"#2" :{ 'hostname' :c1, 'cpu_count': 2, 'mem_capicity': 80 },
	"#3" :{ 'hostname' :c1, 'cpu_count': 2, 'mem_capicity': 80 },
}
# cmdb 新汇报的数据
new_dict = {
	"#1" :{ 'hostname' :c1, 'cpu_count': 2, 'mem_capicity': 800 },
	"#3" :{ 'hostname' :c1, 'cpu_count': 2, 'mem_capicity': 80 },
	"#4" :{ 'hostname' :c2, 'cpu_count': 2, 'mem_capicity': 80 },
}

old_keys = old_dict.keys()
new_keys = new_dict.keys()

   1,#2,#3
old_set = set(old_keys)
  1,#3,#4
new_set = set(new_keys)

del_set = old_set.difference(new_set)
add_set = new_set.difference(old_set)
update_set = old_set.intersection(new_set)

 

m=[]
n=[]
for i in old_dict:
    m.append(i)
for i in new_dict:
    n.append(i)

old_set=set(m)
new_set=set(n)
#更新
updata_set=old_set.intersection(new_dict)   #取交集
#删除
del_set=old_set.symmetric_difference(updata_set)
#新建
new=new_set.symmetric_difference(updata_set)

 

一.关系运算

有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合

1. 求出即报名python又报名linux课程的学员名字集合
    p = set(pythons)
    l = set(linuxs)
    ret = p & l
    print(ret)

2. 求出所有报名的学生名字集合
    p = set(pythons)
    l = set(linuxs)
    ret = p | l
    print(ret)

3. 求出只报名python课程的学员名字
p = set(pythons)
l = set(linuxs)
ret = p - l
print(ret)

4. 求出没有同时这两门课程的学员名字集合
p = set(pythons)
l = set(linuxs)
ret = p ^ l
print(ret)

二.去重

1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
2.在上题的基础上，保存列表原来的顺序
3.去除文件中重复的行，肯定要保持文件内容的顺序不变
4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
	l=[
		{'name':'egon','age':18,'sex':'male'},
		{'name':'alex','age':73,'sex':'male'},
		{'name':'egon','age':20,'sex':'female'},
		{'name':'egon','age':18,'sex':'male'},
		{'name':'egon','age':18,'sex':'male'},
	]

#去重,无需保持原来的顺序
l=['a','b',1,'a','a']
print(set(l))

#去重,并保持原来的顺序
#方法一:不用集合
l=[1,'a','b',1,'a']

l1=[]
for i in l:
    if i not in l1:
        l1.append(i)
print(l1)
#方法二:借助集合
l1=[]
s=set()
for i in l:
    if i not in s:
        s.add(i)
        l1.append(i)

print(l1)


#同上方法二,去除文件中重复的行
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

#列表中元素为可变类型时,去重,并且保持原来顺序
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
# print(set(l)) #报错:unhashable type: 'dict'
s=set()
l1=[]
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)

print(l1)

#定义函数,既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
    s=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in s:
            s.add(val)
            yield item

print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))