阿尔法python 第六章 组合数据类型

集合运算

已知某公司的职员有经理(manager)和技术员(technician)。

请用集合解决以下问题:

1. 将既是经理又是技术员的职员保存到集合 set1 中,并输出
2. 将是经理但不是技术员的职员保存到集合 set2 中,并输出
3. 将是技术员但不是经理的职员保存到集合 set3 中,并输出
4. 将身兼一职的职员保存到集合 set4 中,并输出
5. 判断 张飞 是否是经理,如果是经理,输出「yes」;如果不是经理,输出「no」
6. 求出经理和技术员有几人,并将结果输出

注意:集合 manager 与 technician 已存在,可以直接使用

# 将既是经理又是技术员的职员保存到集合 set1 中,并输出
set1 = manager & technician
print(set1)

# 将是经理但不是技术员的职员保存到集合 set2 中,并输出
set2 = manager - technician
print(set2)

# 将是技术员但不是经理的职员保存到集合 set3 中,并输出
set3 =technician - manager
print(set3)

# 将身兼一职的职员保存到集合 set4 中,并输出
set4 = manager ^ technician
print(set4)

# 判断 张飞 是否是经理
set5 = {"张飞"}
if set5 < manager:
    print("「yes」")
else:
    print("「no」")

# 求出经理和技术员有几人,并将结果输出
print("经理和技术员有{}人".format(len(manager | technician)))


集合的关系

分别创建两个集合set1和set2,并判断两个集合是否满足超集关系真子集关系

set1 = {1, 2, 3, 5}
set2 = {2, 4, 6}

将判断超集关系的结果保存到 superset 中,将判断真子集关系的结果保存到 true_subset 中。

# 创建两个集合
set1 = {1, 2, 3, 5}
set2 = {2, 4, 6}
superset = set1.issuperset(set2)
true_subset = set1.issubset(set2)
# 判断两集合关系,并保存到变量中。


集合综合练习

已知某学校的某次考试成绩分班级保存在集合 score1, score2, score3, score4, score5 中。

请用集合解决以下问题:

1.突然发现 score1 的数据格式为列表,请将 score1 转换为集合,并将集合 score1 输出
2. 使用 add() 方法将数据 10 添加到集合 score2 中,并将集合 score2 输出
3. 使用 update() 方法将数据 {11, 12, 13} 添加到集合 score3 中,并将集合 score3 输出
4. 使用 remove() 方法将数据 83 从集合 score4 中删除,并将集合 score4 输出
5. 使用 clear() 方法将集合 score5 中的数据清空,并将集合 score5 输出

# 将 score1 转换为集合
score1 = set(score1)
print(score1)

# 将 10 添加到 score2 中
score2.add(10)
print(score2)

# 将 {11, 12, 13} 添加到 score3 中
score3.update({11, 12, 13})
print(score3)

# 将 83 从 score4 中删除
score4.remove(83)
print(score4)

# 将 score5 清空
score5.clear()
print(score5)

元组元素抓7

请用程序实现:找出元组 tuple_pre 中元素是 7 的倍数或个位为 7 的数,并将计算结果输出。

注意:元组 tuple_pre 已存在,可以直接使用 tuple_pre。

# 打印输出 tuple_pre
print(tuple_pre)

# 请计算元组 tuple_pre 中元素是7的倍数及个位为7的数,并将计算结果输出
for i in tuple_pre:
    if i % 7 == 0 or i % 10 == 7:
        print(i)


元组解包

"*" 的使用。在对一个元组进行解包时,变量的数量必须和元组中的元素数量一致,也可以在变量前边添加一个 * 号,这样变量将会获取元组中所有剩余的元素。

点击运行,查看结果。

my_tuple = 10, 20, 30, 40

# 在对一个元组进行解包时,变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*,这样变量将会获取元组中所有剩余的元素
a, b, *c = my_tuple
print('1. a =', a, 'b =', b, 'c =', c)

a, *b, c = my_tuple
print('2. a =', a, 'b =', b, 'c =', c)

*a, b, c = my_tuple
print('3. a =', a, 'b =', b, 'c =', c)

a, b, *c = [1, 2, 3, 4, 5, 6, 7]
print('4. a =', a, 'b =', b, 'c =', c)

a, b, *c = 'hello world'
print('5. a =', a, 'b =', b, 'c =', c)

# 不能同时出现两个或以上的*变量
# *a , *b , c = my_tuple

运行结果:
在这里插入图片描述


升序降序

编写程序,将列表中的前10个元素升序排列,后10个元素降序排列,并输出结果。
注意:列表 list_pre 已存在,可以直接使用 list_pre。

# 打印输出 list_pre
print(list_pre)

# 请对上面列表中的元素进行排序

y = list_pre[0:10]
y.sort()
list_pre[0:10] = y
y = list_pre[10:20]
y.sort(reverse=True)
list_pre[10:20] = y
print(list_pre)

截取部分元素

请用程序实现
将列表list_pre中的部分元素截取到列表list_new中。

输入格式

在两行中分别输入两个非负整数,表示需要截取的索引段,且第一个数小于第二个数。

输出格式

将截取出的列表输出即可。

示例 1

输入输出
3
5
[53, 36, 42]

示例 2

输入输出
2
6
[54, 53, 36, 42, 2]
list_pre = [23, 7, 54, 53, 36, 42, 2, 24, 76, 70, 18, 35, 44, 1, 9, 6, 8, 75, 49]

# 请使用 input() 输入两个正整数 begin, end
begin = int(input('请输入第一个索引: '))
end = int(input('请输入第二个索引: '))

# 将列表 list_pre 中下标从 begin(含) 到 end(含) 的元素截取到列表 list_new 中,并将 list_new 输出
list_new = list_pre[begin:end+1]
print(list_new)

判断元素是否在列表中存在

请用程序实现:判断指定元素是否存在于列表 list_test 中。

注意:要求分别用 for 循环与 in 关键字完成练习,列表 list_test 已存在,可以直接使用 list_test。

运行你的程序,使控制台显示如下内容:

查看 4 是否在列表中(使用循环):
存在
查看 4 是否在列表中(使用 in 关键字):
存在

# 打印输出 list_test
print(list_test)

# 使用for循环判断元素 4 是否存在于 list_test 列表中
print("查看 4 是否在列表中(使用循环): ") 
for i in list_test: 
    if(i == 4) : 
        print ("存在") 

# 使用in关键字判断元素 4 是否存在于 list_test 列表中
print("查看 4 是否在列表中(使用 in 关键字): ") 
if (4 in list_test): 
    print ("存在")


头尾对调

请用程序实现:将列表 list_ht 中的头尾两个元素对调,并将对调的结果输出。
注意:列表 list_ht 已存在,可以直接使用 list_ht。

# 打印输出 list_ht
print(list_ht)

# 将列表 list_ht 中的头尾两个元素对调,并将对调的结果输出
temp = list_ht[0]
list_ht[0]=list_ht[-1]
list_ht[-1]=temp

print(list_ht)

翻转列表

请用程序实现,将列表 list_reverse 翻转,并将翻转后的列表输出。
注意:列表 list_reverse 已存在,可以直接使用 list_reverse。

通过下面的例子来解释翻转列表。

翻转前 : list = [10, 11, 12, 13, 14, 15]
翻转后 : list = [15, 14, 13, 12, 11, 10]

# 打印输出 list_reverse
print(list_reverse)

# 将列表翻转
#list_reverse=list(map(int,input().split()))
list_reverse.reverse()
print(list_reverse)

指定元素对调

请用程序实现,将列表list_swap 中所指定的元素对调到列表的尾部,并输出对调后的列表,如下图所示。
注意:列表 list_swap 已存在,可以直接使用 list_swap。

在这里插入图片描述

# 打印输出 list_swap
print(list_swap)

# 将列表 list_swap 中的第1、2个元素对调到列表的尾部

print(list_swap[2:] + list_swap[:2])    


约瑟夫生者死者小游戏

一条船上有 num 个人(num为偶数),超载了,需要一半的人下船。于是人们排成一排,排队的位置即为他们的编号。他们从头开始从 1 开始报数,数到某个数字的人下船,并且下一个人又从 1 开始报数,如此循环,直到船上只有原来一半人为止。

请用程序实现:输入表示船上总人数的偶数 num 和需要下船的特殊数字 special_num,输出下船人的编号。

运行你的程序,使控制台显示如下内容:

请输入船上的总人数: 30
请输入需要下船的特殊数字: 9
9
18
27
6
16
26
7
19
30
12
24
8
22
5
23

# 请使用 input() 输入 num 和 special_num
num = int(input())
special_num = int(input())
print("请输入船上的总人数: %d"%num)
print("请输入需要下船的特殊数字: %d"%special_num)

# 请输出下船人的编号
ls = list(range(1,num+1))
i = 1
while(len(ls) > num // 2):
    if (i != special_num):
        a = ls.pop(0)
        ls.append(a)
        i += 1
    else:
        print(ls.pop(0))
        i = 1

计算列表元素之和

请用程序实现
计算列表list_sum中的所有元素之和,并将计算结果输出。
注意: 列表list_sum已存在,可以直接使用list_sum

# 打印输出 list_sum
print(list_sum)

# 请计算列表 list_sum 中的所有元素之和,并将计算结果输出
print("列表元素之和为: ", sum(list_sum))

计算总分和平均分

小明刚结束期末考试,他将自己各科的分数保存到了列表scores中,现在,请帮他进行一些计算:

计算总分,并将计算结果保存到变量total_score
计算平均分,并将计算结果保存到变量avg_score

# 小明的期末考试成绩分数如下:
scores = [95, 69, 98, 74, 64, 72, 53, 92, 83]

# 请计算小明的总分、平均分,并保存至变量 total_score, avg_score 中
total_score = sum(scores)
avg_score = sum(scores)/len(scores)


添加用户

这里有一个保存用户账户信息的「字典」,字典的 key 是用户名,value 是明文密码,形式如下:

users = {
“user1”: “password1”,
“user2”: “123456”
}

请编写程序,向用户字典中添加如下账户:

用户名密码
zhangsanzs123456
lisisi123456

提示: dict[key] = value可以向字典中添加新的键/值对,也可以修改已有的键/值对。

users = {
    "alpha": "alpha123",
    "beta": "betaisverygood",
    "gamma": "1919191923"
}
users['zhangsan'] = 'zs123456'
users['lisi'] = 'si123456'


模拟用户登录

这里有一个保存用户账户信息的字典,请用程序模拟系统的登录验证过程。
请用程序实现
用键盘模拟用户输入,判断输入的用户名或密码是否正确,并输出登录信息。

  • 如果输入的用户名存在,且密码正确,则输出success
  • 如果输入的用户名存在,但密码不正确,则输出password error
  • 如果输入的用户名不存在,则输出not found

输入格式
分两行输入,第一行为用户名,第二行为密码。

示例

输入输出
zhangsan
123456
success
users = {
    "alpha": "alpha123",
    "beta": "betaisverygood",
    "gamma": "1919191923",
    "zhangsan": "123456",
    "lisi": "123456",
    "admin": "ADMIN",
    "root": "Root123"
}

username = input()
password = input()

# 请在下面编写代码,判断输入的用户名或密码是否正确

key_list=list(users.keys())
value_list=list(users.values())
for i in range(len(key_list)):
    if username == key_list[i]:
        if password == value_list[i]:
            print("success")
        else:
            print("password error")
    if username not in key_list:
        print("not found")

某公司雇员(Employee)包括经理(Manager),技术人员(Technician)和销售员(Salesman)。开发部经理(DeveloperManger),既是经理也是技术人员。销售部经理(SalesManager),既是经理也是销售员。 以Employee类为虚基类派生出Manager,Technician和Salesman类;再进一步派生出Developermanager和Salesmanager类。 Employee类的属性包括姓名、职工号、工资级别,月薪(实发基本工资加业绩工资)。操作包括月薪计算函数(pay()),该函数要求输入请假天数,扣去应扣工资后,得出实发基本工资。 Technician类派生的属性有每小时附加酬金和当月工作时数,及研究完成进度系数。业绩工资为三者之积。也包括同名的pay()函数,工资总额为基本工资加业绩工资。 Salesman类派生的属性有当月销售额和酬金提取百分比,业绩工资为者之积。也包括同名的pay()函数,工资总额为基本工资加业绩工资。 Manager类派生属性有固定奖金额和业绩系数,业绩工资为者之积。工资总额也为基本工资加业绩工资。 而DeveloperManager类,pay()函数是将作为经理和作为技术人员业绩工资之和的一半作为业绩工资。 SalesManager类,pay()函数则是经理的固定奖金额的一半,加上部门总销售额与提成比例之积,这是业绩工资。 编程实现工资管理。特别注意pay()的定义和调用方法:先用同名覆盖,再用运行时多态。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值