第一二章：练习题汇总
小节练习
练习1：猜年龄游戏
要求：
- 允许用户最多尝试3次，3次都没猜对的话，就直接退出，如果猜对了，打印恭喜信息并退出
guess_age=24 count = 0 while count < 3: age = int(input("请输入年龄")) if guess_age > age: print ("你猜小了") elif guess_age < age: print ("你猜大了") else: print("恭喜你回答正确") count += 1 else: print("游戏结束")
练习2：猜年龄游戏升级版
要求：
- 允许用户最多尝试3次
- 每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y或y, 就继续让其猜3次，以此往复，如果回答N或n，就退出程序
- 如何猜对了，就直接退出
count = 0 age = 24 while True: guess_age = input('请输入您猜测的年龄： ') if guess_age == age: print('恭喜你，猜对啦！') break else: print('猜错啦，请重新输入') count += 1 if count == 3: print('您是否想重新玩，回答Y/y或者N/n') ans = input('请输入您内心的想法： ') if ans == 'Y' or ans == 'y': print('请继续您的游戏吧!') elif ans == 'N' or ans == 'n': print('谢谢您参与游戏！') break
第一章练习题
- 简述编译型与解释型语言的区别，且分别列出你知道的哪些语言属于编译型，哪些属于解释型 答：编译类：先翻译成二进制，产生两个文件，运行的时候是二进制文件。程序执行效率高，编译后程序运行时不需要重新翻译，直接使用编译的结果就可以了，但是跨平台性能差。如C\C++、Delphi等。
解释型：“同声翻译”，一边翻译成目标代码即机器语言一边执行，运行效率比较低且不能生成可独立执行的可执行文件，应用程序不能脱离解释器，这种方式比较灵活，可以动态调整、修改应用程序。可以跨平台，开发效率高。如：java、python等
- 执行 Python 脚本的两种方式是什么 答：一进入解释器的交互式模式：调试方便，无法永久保存代码；二脚本文件的方式（使用nodpad++演示）：永久保存代码，但是不方便调试
- Pyhton 单行注释和多行注释分别用什么? 答：单行注释用#，多行注释用 ‘’’ '''
- 布尔值分别有什么? 答：布尔值有True 和False
- 声明变量注意事项有那些? 答：一数字、字母和下划线的组合；二是数字不能开头；三是以下关键字不能声明为变量名['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']。
- 如何查看变量在内存中的地址? 答：
id（变量名）#查看内存地址。 - 写代码
- 实现用户输入用户名和密码,当用户名为 seven 且 密码为 123 时,显示登陆成功,否则登陆失败!
_username = "seven" _passworld = "123" username = input("username:") passworld = input("passworld:") if username == _username and passworld == _passworld: print("登录成功") - 实现用户输入用户名和密码,当用户名为 seven 且 密码为 123 时,显示登陆成功,否则登陆失败,失败时允许重复输入三次
_username = "seven" _passworld = "123" count = 0 while count < 3: username = input("username:") passworld = input("passworld:") if username == _username and passworld == _passworld: print("登录成功") break else: print("登录失败，请重新输入") count += 1 - 实现用户输入用户名和密码,当用户名为 seven 或 alex 且 密码为 123 时,显示登陆成功,否则登陆失败,失败时允许重复输入三次
#_username = ["seven" , "alex"] #运用列表
_username = "seven" or "alex"
_passworld = "123"
count = 0
while count < 3:
username = input("username:")
passworld = input("passworld:")
if username == "seven" or "alex" and passworld == _passworld:
#if username in _username and passworld == _passworld: #判断
print("登录成功")
break
else:
print("登录失败，请重新输入")
count += 1
- 实现用户输入用户名和密码,当用户名为 seven 且 密码为 123 时,显示登陆成功,否则登陆失败!
-
写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
i = 2 total_1 = 0 total_2 = 0 while i <=100: if i%2 == 0: total_1 += i else: total_2 += -i i += 1 total = total_1 + total_2 print(total)b. 使用 while 循环实现输出 1,2,3,4,5, 7,8,9, 11,12
count = 1 while count <= 12: if count == 10 or count==6: pass else: print("loop",count) count +=1c. 使用while 循环输出100-50，从大到小，如100，99，98...，到50时再从0循环输出到50，然后结束
i = 101 while i >= 51: i -=1 print(i) i = 0 while i <= 50: print(i) i +=1d. 使用 while 循环实现输出 1-100 内的所有奇数
i = 1 while i <= 100: if i %2==1: print(i) i+=1e. 使用 while 循环实现输出 1-100 内的所有偶数
i = 0 while i <= 100: if i %2==0: print(i) i+=1 -
现有如下两个变量,请简述 n1 和 n2 是什么关系?
n1 = 123456 n2 = n1 关系是给数据123456起了另外一个别名n2，相当于n1和n2都指向该数据的内存地址 -
制作趣味模板程序（编程题）
需求：等待用户输入名字、地点、爱好，根据用户的名字和爱好进行任意显示
如：敬爱可爱的xxx，最喜欢在xxx地方干xxxusername = input("name:") place = input("place:") love = input("love:") info = ''' 敬爱的%s最喜欢在 %s干 %s '''% (username,place,love) print(info) -
输入一年份，判断该年份是否是闰年并输出结果。（编程题）
注：凡符合下面两个条件之一的年份是闰年。 （1） 能被4整除但不能被100整除。 （2） 能被400整除。year = int(input("please input a year:")) if (year %2==0 and year %100!=0) or (year %400==0): print(year,"是闰年") else: print(year,"不是闰年") -
假设一年期定期利率为3.25%，计算一下需要过多少年，一万元的一年定期存款连本带息能翻番？（编程题）
money = 10000 year = 0 while money <= 20000: year +=1 money = money * (1+0.0325) print(year,money) print(year,"年以后，一万元的一年定期存款连本带息能翻番")
第二章练习题
列表练习题：
打印索引值：
#10 打印每个索引值和元素
names = ['alex','jack','rain','mack','racheal','shanshan']
count = 0
for i in names:
print(count,i)
count += 1
for i in enumerate(names):#枚举
print(i)
for index,i in enumerate(names):#枚举
print(index,i)
#输出
0 alex
1 jack
2 rain
3 mack
4 racheal
5 shanshan
(0, 'alex')
(1, 'jack')
(2, 'rain')
(3, 'mack')
(4, 'racheal')
(5, 'shanshan')
0 alex
1 jack
2 rain
3 mack
4 racheal
5 shanshan
#11题 names = ['alex','jack','rain','mack','racheal','shanshan'] for index,i in enumerate(names):#枚举 if index%2 ==0: #偶数 names[index] = -1 print(index,i) print(names)
#12题 names = ['alex','jack','peiqi',2,'rain','mack',2,'racheal','shanshan',2,'longting'] first_index = names.index(2) new_list = names[first_index+1:] second_index = new_list.index(2) second_val = names[first_index + second_index +1] print(new_list,first_index,second_index) print('second values:',second_val)
#13 products = [['iphone8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]] print('-------------商品列表--------------') for index,i in enumerate(products):#枚举 print("%s.%s %s" %(index,i[0],i[1]) )
#14 products = [['iphone8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]] shopping_cart = [] run_flag = True #标志位 while run_flag: #exit_flag = False #while not exit_flag: #while True: print('-------------商品列表--------------') for index,i in enumerate(products):#枚举 print("%s.%s %s" %(index,i[0],i[1]) ) choice = (input("输入你想买的商品编号或者输入q退出:")) if choice.isdigit(): choice = int(choice) if choice >=0 and choice <= len(products): shopping_cart.append(products[choice]) print("Added product %s into shopping cart."%(products[choice])) else: print("此商品不存在") elif choice == 'q': if len(shopping_cart) > 0: print("----------您已购买以下商品-------") for index,i in enumerate (shopping_cart): print("%s.%s %s" % (index,i[0],i[1])) run_flag =False #exit_flag = True #break
字典练习题
写代码，有如下字典，按照要求实现每一个功能。dic = {'k1':'v1','k2':'v2','k3':'v3'}
1.请循环遍历出所有的key
for k in dic: print(k)
2请循环遍历出所有的value
for k in dic: print(dic[k])
3请循环遍历初所有的KEY和VALUE
for k in dic: print(k,dic[k])
4请在字典中添加一个键值对，'k4':'v4',输出添加后的字典
dic['k4'] = 'v4' print(dic)
5请删除字典中键值对'k1','v1',并输出删除后的字典
dic.pop('k1') print(dic)
6请删除字典中键'k5'对应的键值对，如果字典中不存在键'k5'，则不报错，并且让其返回none
if 'k5' in dic: dic.pop('k5') else: print(dic.get('k5'))
7请获取字典中'k2'对应的值
print(dic.get('k2'))
8请获取字典中'k6'对应的值，如果'k6'不存在，则不报错，并且让其返回Nnoe
print(dic.get('k6'))
9现有dic2 = {'k1':'v111','a':'b'}请通过一行操作使dic2 = {'k1':'v1','k2':'v2','k3':'v3','a':'b'}
dic = {'k1':'v1','k2':'v2','k3':'v3'}
dic2 = {'k1':'v111','a':'b'}
dic2.update(dic)
print(dic2)
10.组合嵌套题，写代码，有如下列表，按照要求实现每一个功能 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
10.1.将列表lis 中的'tt'变成大写（用两种方式）
#方法1 print(lis[0][1][2].get('k1')[0].upper()) #方法2 print(lis[0][1][2].get('k1')[0].swapcase())
10.2.将列表中的数字3 变成字符串'100'(用两种方式）
#方法1 print(lis) lis[0][1][2].get('k1')[1] = '100' print(lis) #方法2 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']] dic3 = {'k1':['tt','100','1']} print(lis) lis[0][1][2].update(dic3) print(lis)
10.3 将列表中的字符串'1'变成数字101（用两种方式）
#方法1 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']] print(lis) lis[0][1][2].get('k1')[2] = 101 print(lis) #方法2 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']] dic3 = {'k1':['tt',3,101]} print(lis) lis[0][1][2].update(dic3) print(lis)
11 按照要求实现以下功能：
现有一个列表li = [1,2,3,'a','b',4,'c']，有一个字典（此字典是动态生成的，你并不知道他里卖弄有多少键值对，所以
用dic = {}模拟此字典）；现在需要完成这样的操作：如果该字典没有'k1'这个键，那就创建'k1'键和其对应的值(该键对应的值设置为空列表）
并将列表li 中的 索引为奇数的对应元素，添加到'k1'这个键对应的空列表中。如果该字典有'k1'这个键，且'k1'对应的value
是列表类型，那就将li中的索引为奇数的对应元素，添加到'k1'这个键对应的键中
dic = {'k2':2,'k3':3}#1. dic{}字典中 没有 'k1'
#dic = {'k1':['we','tt'],'k2':2}#2 dic{}字典中有'k1'
#dic = {'k1':1,'k2':33} # 有'k1'但'k1'value 非列表
li = [1,2,3,'a','b',4,'c']
if not 'k1' in dic:
dic.setdefault('k1',[])
for i in li :
if li.index(i) % 2 == 1:
dic['k1'].append(i)
else:
if type(dic['k1']) == type([]):
for i in li:
if li.index(i) % 2 == 1:
dic['k1'].append(i)
else:
print("字典K1,VALUE 不是列表，无法追加")
print(dic)
第二章总结-练习
1、请用代码实现：利用下划线将列表的每一个元素拼接成字符串，li＝['alex', 'eric', 'rain']
>>> li = ['alex','eric','rain']
>>> '_'.join(li)
'alex_eric_rain'
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 = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
list1 = list(tu)
list2 = list(dic.values())
new_list = li + list1 + list2
for i in new_list:
ret = i.strip() # i.strip():删除字符串当前行首尾的的空格
if (ret.startswith('a') or ret.startswith('A') or ret.endswith('c')): #startswith查看是否已什么开始，endswith查看是否已什么结尾
print(ret)
3、写代码，有如下列表，按照要求实现每一个功能
li＝['alex', 'eric', 'rain']
- 计算列表长度并输出
- 列表中追加元素“seven”，并输出添加后的列表
- 请在列表的第1个位置插入元素“Tony”，并输出添加后的列表
- 请修改列表第2个位置的元素为“Kelly”，并输出修改后的列表
- 请删除列表中的元素“eric”，并输出修改后的列表
- 请删除列表中的第2个元素，并输出删除的元素的值和删除元素后的列表
- 请删除列表中的第3个元素，并输出删除元素后的列表
- 请删除列表中的第2至4个元素，并输出删除元素后的列表
- 请将列表所有的元素反转，并输出反转后的列表
- 请使用for、len、range输出列表的索引
- 请使用enumrate输出列表元素和序号（序号从100开始）
- 请使用for循环输出列表的所有元素
a
>>> li = ['alex','eric','rain']
>>> v = len(li)
>>> v
3
b
>>> li.append('seven')
>>> li
['alex', 'eric', 'rain', 'seven']
c
>>> li.insert(0,'Tony')
>>> li
['Tony', 'alex', 'eric', 'rain', 'seven']
d
>>> li[1] = 'Kelly'
>>> li
['Tony', 'Kelly', 'eric', 'rain', 'seven']
e
>>> li.remove('eric')
>>> li
['Tony', 'Kelly', 'rain', 'seven']
f
>>> del li[1]
> K = del.li[1]
>>> li
['Tony', 'rain', 'seven']
g
>>> del li[2]
>>> li
['Tony', 'rain']
h
>>> del li[1:3]
>>> li
['Tony']
i
>>> li = ['alex','eric','rain']
>>> li
['alex', 'eric', 'rain']
>>> li.reverse()
>>> li
['rain', 'eric', 'alex']
j
li = ['alex','eric','rain']
for i in range(len(li)):
print(i)
k
li = ['alex','eric','rain']
for k ,v in enumerate(li,100):
print(k,v)
l
li = ['alex','eric','rain']
for i in li :
print(i)
4、写代码，有如下列表，请按照功能要求实现每一个功能
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- 请根据索引输出“Kelly”
- 请使用索引找到'all'元素并将其修改为“ALL”，如：li[0][1][9]...
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
li[2][2] = 'All'
print(li)
5、写代码，有如下元组，请按照功能要求实现每一个功能
tu＝('alex', 'eric', 'rain')
- 计算元组长度并输出
- 获取元组的第2个元素，并输出
- 获取元组的第1-2个元素，并输出
- 请使用for输出元组的元素
- 请使用for、len、range输出元组的索引
- 请使用enumrate输出元祖元素和序号（序号从10开始）
>>> tu = ('alex','eric','rain') >>> len(tu) 3
>>> tu
('alex', 'eric', 'rain')
>>> tu[1]
'eric'
>>> tu ('alex', 'eric', 'rain') >>> tu[0:2] ('alex', 'eric')
tu = ('alex', 'eric', 'rain') for i in tu: print(i)
tu = ('alex','eric','rain') for i in range(len(tu)): print(i)
tu = ('alex','eric','rain') for k,v in enumerate(tu,10): print(k,v)
6、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
- 讲述元祖的特性
- 请问tu变量中的第一个元素“alex”是否可被修改？
- 请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素“Seven”
- 请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素“Seven”
a 特性： 1.可存放多个值； 2.不可变； 3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序
b 不可被修改。
c k2对应的值是列表，可以被修改。
>>> tu ('alex', [11, 22, {'k1': 'v1', 'k2': ['age', 'name'], 'k3': (11, 22, 33)}, 44]) >>> tu[1][2]['k2'].append('seven') >>> tu ('alex', [11, 22, {'k1': 'v1', 'k2': ['age', 'name', 'seven'], 'k3': (11, 22, 33)}, 44])
d k3对应的是元组，不能被修改。
7、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
- 请循环输出所有的key
- 请循环输出所有的value
- 请循环输出所有的key和value
- 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
- 请在修改字典中“k1”对应的值为“alex”，输出修改后的字典
- 请在k3对应的值中追加一个元素44，输出修改后的字典
- 请在k3对应的值的第1个位置插入个元素18，输出修改后的字典
a
dic = {'k1':'v1','k2':'v2','k3':[11,22,33]}
for k in dic:
print(k)
b
dic = {'k1':'v1','k2':'v2','k3':[11,22,33]}
for k in dic.values():
print(k)
# for k in dic:
# print(dic[k])
c
dic = {'k1':'v1','k2':'v2','k3':[11,22,33]}
for k,v in dic.items(): #items 是把字典转换成列表
print(k,v)
# for k in dic:
# print(k,dic[k])
e
>>> dic {'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33]} >>> dic['k4'] = 'v4' >>> dic {'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
f
{'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
>>> dic['k1'] = 'alex'
>>> dic
{'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
g
>>> dic['k3'].append(44) >>> dic {'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'}
k
>>> dic {'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'} >>> dic['k3'].insert(0,18) >>> dic {'k1': 'alex', 'k2': 'v2', 'k3': [18, 11, 22, 33, 44], 'k4': 'v4'}
8、转换
- 将字符串s = "alex"转换成列表
- 将字符串s = "alex"转换成元祖
- 将列表li = ["alex", "seven"]转换成元组
- 将元祖tu = ('Alex', "seven")转换成列表
- 将列表li = ["alex", "seven"]转换成字典且字典的key按照10开始向后递增
>>> s = "alex" >>> list(s) ['a', 'l', 'e', 'x']
>>> tuple(s) ('a', 'l', 'e', 'x')
>>> li = ["alex","seven"] >>> tuple(li) ('alex', 'seven')
>>> tu = ('Alex','seven') >>> list(tu) ['Alex', 'seven']
li = ["alex","seven"] dic ={} for k ,v in enumerate (li,10): dic[k] = v #列表转换成字典 print(dic)
9、元素分类
有如下值集合[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] li.sort() #排序 z = li.index(66) l = len(li) dict = {'k1':li[z+1:l],'k2':li[:z]} print(dict)
10、输出商品列表，用户输入序号，显示用户选中的商品
商品li = ["手机", "电脑", '鼠标垫', '游艇']
- 允许用户添加商品
- 用户输入序号显示内容
li = ["手机", "电脑", '鼠标垫', '游艇'] for k,i in enumerate(li): print(k,i) num = int(input("please input your number:")) print(li[int(num)]) choice = input('是否添加商品(y|Y):') if choice == 'y' or choice == 'Y': goods = input("请输入商品:") li.append(goods) #添加商品 for k,i in enumerate(li): print(k, i) s = input("是否查找商品(y|Y):") if s == 'y' or s == 'Y' : n = int(input('请输入要查询的序号:')) print(li[n])
11、用户交互显示类似省市县N级联动的选择
- 允许用户增加内容
- 允许用户选择查看某一个级别内容
city = {"北京":{"朝阳":["大望路","国贸"],
"昌平":["沙河","昌平"]},
"河北":{"张家口":["沙城","宣化"],
"石家庄":["某某路","某某街"]}
}
go = True
while go:
cc = []
dq = []
print("\33[31;1m一级列表\33[1m".center(40,"="))
for i,v in enumerate(city,1):
print(i,v)
cc.append(v)
print("\33[35;1m插入数据 i 退出按Q\33[1m")
u_c1 = str(input(">>>"))
if u_c1.isdigit():#进二级之前判断
u_c1 = int(u_c1)
if u_c1 >0 and u_c1 <=len(cc):
while go:
print("\33[32;1m二级列表\33[1m".center(40, "="))
for i1,v1 in enumerate(city[cc[u_c1-1]],1):
print(i1,v1)
dq.append(v1)
print("\33[35;1m退出按Q 返回 B\33[1m")
u_c2 = input(">>>")
if u_c2.isdigit():#进三级之前判断
u_c2 = int(u_c2)
if u_c2 >0 and u_c2<=len(dq):
while go:
print("\33[32;1m三级列表\33[1m".center(40, "="))
for s in city[cc[u_c1-1]][dq[u_c2-1]]:
print(s)
print("\33[35;1m退出按Q 返回 B\33[1m")
u_c3 = input(">>>")
if u_c3 == "q" or u_c3 == "Q":
go = False
break
if u_c3 == "b" or u_c3 =="B":
del dq[:]
break
else:
print("\33[31;1m输入不正确\33[1m")
else:
print("\33[31;1m输入超出范围！\33[1m")
elif u_c2 == "q" or u_c2 == "Q":
go = False
break
elif u_c2 == "b" or u_c2 == "B":
del cc[:]
del dq[:]
break
else:
print("\33[31;1m输入格式不对！\33[1m")
elif u_c1.isalpha():
if u_c1 == "q" or u_c1 == "Q":
break
elif u_c1 == "i" or u_c1 == "I":
print("\33[32;1m添加信息\33[1m".center(40,"="))
ct_name = input("省：")
if ct_name == "Q" or ct_name == "q":
break
else:
if city.get(ct_name,0) == 0:
city[ct_name] = {}
dq_name = input("市：")
if dq_name == "Q" or dq_name == "q":
break
else:
if city[ct_name].get(dq_name,0) == 0:
city[ct_name][dq_name]=[]
while True:
print("\33[31;1m循环添加，退出请按Q！\33[1m")
s = input("县：")
if s == "q" or s == "Q":
break
else:
city[ct_name][dq_name].append(s)
else:
print("\33[31;1m输入超出范围！\33[1m")
else:
print("\33[31;1m输入格式不对！\33[1m")
12、列举布尔值是False的所有值
1 None "" () [] {} 0
13、有两个列表
l1 = [11,22,33]
l2 = [22,33,44]
- 获取内容相同的元素列表
- 获取l1中有，l2中没有的元素列表
- 获取l2中有，l1中没有的元素列表
- 获取l1和l2中内容都不同的元素
l1 = [11,22,33]
l2 = [22,33,44]
print(list(set(l1) & set(l2)))
print(list(set(l1) - set(l2)))
print(list(set(l2) - set(l1)))
print(list(set(l2) ^ set(l1)))
14、利用For循环和range输出
- For循环从大到小输出1 - 100
- For循环从小到到输出100 - 1
- While循环从大到小输出1 - 100
- While循环从小到到输出100 - 1
for i in range(100,0,-1): print(i) for i in range(1,101): print(i) while True: a = 100 for i in range(100): print(a - i) break while True: for i in range(100): print(i+1) break
15、利用for循环和range输出9 * 9乘法表
#方法一 for x in range(1,10): for y in range(1,x+1): print("{0} * {1} = {2}".format(x,y,x*y),end = " ") #end = " " 作用就是：不换行 print('\n',end = " ") #方法二： for i in range(1,10): for j in range(1,i+1): print("%d*%d=%2d" % (i,j,i*j),end=" ") #%d是数值整型对应的格式通配符 print(" ")
16、求100以内的素数和。（编程题）
解题思路：
- 求出100以内除了1的所有整数（1不是素数）。
- 用每一个整数分别除以比他小的整数，判断是否可以整除。
- 定义一个空列表，用以储存素数。
- 设定一个判断条件。
#1
L=[]
for i in range(2,101):
flg=True
for j in range(2,i):
if (i%j==0):
flg=False
break
if flg:
L.append(i)
print(L)
#2
for i in range(2,101):
fg = 0
for j in range(2,i-1):
if i%j == 0:
fg = 1
break
if fg == 0:
print i
17、将[1,3,2,7,6,23,41,24,33,85,56]从小到大排序（冒泡法）（编程）
li = [1,3,2,7,6,23,41,24,33,85,56] for i in range(len(li)-1): # i的范围0-9 if li[i] > li[i+1]: # 相邻的两个数比较 li[i],li[i+1] = li[i+1],li[i] print(li)
18、分页显示内容
a.通过for循环创建301条数据，数据类型不限，如：
alex-‐1alex1@live.compwd1
alex-‐2alex2@live.compwd2
alex-‐3alex3@live.compwd3
....
1 for i in range(301): 2 a = "alex- - %salex%s@live.com pwd%s"%(i+1,i+1,i+1) 3 print(a)
b.提示用户请输入要查看的页码，当用户输入指定页码，则显示指定数据
注意：
-‐每页显示10条数据
-‐用户输入页码是非十进制数字，则提示输入内容格式错误
while True: u = [] for i in range(301): a = "alex{0} alex{0}@live.com pwd{0}".format(i+1) x = [a] u = u + x # print(u[0:10]) s = input("请输入您想查看的页码：") v3 = s.isnumeric() #检测字符串是否只由数字组成,如果字符串中只包含数字字符，则返回 True，否则返回 False if v3 == False : print("输入内容格式错误") elif int(s) < 1 or int(s) > 31: print("输入页码错误") else: s = int(s) a = (s-1)*10 b = s*10 j = (u[a:b]) for g in j: print(g) A =input("是否继续查看（y or Y）") if A =="y" or A =="Y": continue else: break
19、有1、2、3、4、5、6、7、8、8个数字，能组成多少个互不相同且无重复数字的3位数？
count = 0 for i in range(1, 9): for x in range(1, 9): for y in range(1, 9): if i != x and x != y and i != y: print(i, x, y) count += 1 print(count)
20、有一下列表，
nums=[2,7,11,15,1,8,7]
请找到列表中任意两个元素相加能够等于9的元素集合，如：[(0,1),(4,5)]
nums = [2, 7, 11, 15, 1, 8, 7] li = [] n1 = [] for i in nums: for x in nums: y = i + x if y == 9: v = [i, x] x =(i,x) if v not in li: v.reverse() if v not in li: n1.append(x) li.append(v) print(n1)
21、用Python开发程序自动计算方案：
公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱，用100文钱买100只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱？
for x in range(1, 100): for y in range(1, 100): for z in range(1, 100): if x + y + z == 100 and 5 * x + 3 * y + z / 3 == 100: # 小鸡 1/3 print(x, y, z)
执行结果：
1 4 18 78 2 8 11 81 3 12 4 84
补加练习题：
分别用append、extend方法，给一个序列增加一个元素
>>> lst1 = [4,2,'rs','name'] >>> lst1.append(9) >>> print(lst1) [4, 2, 'rs', 'name', 9] >>> lst1.extend([1,2,3]) >>> print(lst1) [4, 2, 'rs', 'name', 9, 1, 2, 3]
x.append([1,2,3])和x.extend([1,2,3])的区别
x.append('abc')和x.extend('abc')的区别
>>> lst1.append([1,2,3]) >>> print(lst1) [4, 2, 'rs', 'name', 9, 1, 2, 3, [1, 2, 3]] >>> lst1.extend([1,2,3]) >>> print(lst1) [4, 2, 'rs', 'name', 9, 1, 2, 3, [1, 2, 3], 1, 2, 3] >>> lst1.append('abc') >>> print(lst1) [4, 2, 'rs', 'name', 9, 1, 2, 3, [1, 2, 3], 1, 2, 3, 'abc'] >>> lst1.extend('abc') >>> print(lst1) [4, 2, 'rs', 'name', 9, 1, 2, 3, [1, 2, 3], 1, 2, 3, 'abc', 'a', 'b', 'c'] >>>
sort()和sorted()什么区别
>>> lst1.sort() >>> print(lst1) [2, 4, 5, 8, 9] >>> lst1.sort(reverse=True) >>> print(lst1) [9, 8, 5, 4, 2] >>> lst2 = sorted(lst1) >>> print(lst2) [2, 4, 5, 8, 9] >>>
m=[4,5,6,73,4,4,4,4,2]，删除所有的4
#方法一 set（）方法 >>> m [4, 5, 6, 73, 4, 4, 4, 4, 2] >>> list(set(m)) [2, 4, 5, 6, 73] #方法二 set() 方法会改变列表顺序，使用sort()使之与原来的相同； >>> z = list(set(m)) >>> z.sort(key = m.index) >>> z [4, 5, 6, 73, 2] #方法三 >>> m=[4,5,6,73,4,4,4,4,2] >>> n={}.fromkeys(m).keys() #fromkeys（）用于创建一个字典；dict.fromkeys(iterable[,value=None])>>> n dict_keys([4, 5, 6, 73, 2]) #方法四： m=[4,5,6,73,4,4,4,4,2] n=[] for i in m: if i not in n: n.append(i) print(n) 打印： [4, 5, 6, 73, 2]
