基础习题

习题1

请用代码验证'name'是否在字典的键中
info = {'name': '王刚蛋', 'hobby': '铁锤', 'age': '18'}

info = {'name': '王刚蛋', 'hobby': '铁锤', 'age': '18'} if info.get('name'):
    print('在字典键中') else:
    print('不在字典键中') # 运行结果: # 在字典键中 

习题2

请用代码验证'alex'是否在字典的值中
info = {'name': '王刚蛋', 'hobby': '铁锤', 'age': '18'}

info = {'name': '王刚蛋', 'hobby': '铁锤', 'age': '18'} if info.get('alex'):
    print('在字典键中') else:
    print('不在字典键中') # 运行结果 # 不在字典键中 

习题3

v1 = {'武沛齐', '李杰', '太白', '景女神'}
v2 = {'李杰', '景女神'}
请得到v1和v2的交集并输出
请得到v1和v2的并集并输出
请得到v1和v2的差集并输出
请得到v2和v1的差集并输出

v1 = {'武沛齐', '李杰', '太白', '景女神'}
v2 = {'李杰', '景女神'}

print(v1 & v2) # {'李杰', '景女神'} print(v1 | v2) # {'太白', '李杰', '武沛齐', '景女神'} print(v1 - v2) # {'太白', '武沛齐'} print(v2 - v1) # set() 

习题4

循环提示用户输入,并将输入内容追加到列表中(如果输入N或n则停止循环)

info_list = [] while True:
    info = input('输入信息:') if info.upper() == 'N':
        print('已退出输入模式') break info_list.append(info)
print('输出结果:{}'.format(info_list)) # 输出结果： # 输入信息:123fs65 # 输入信息:12f # 输入信息:qfd # 输入信息:q # 输入信息:n # 已退出输入模式 # 输出结果:['123fs65', '12f', 'qfd', 'q'] 

习题5

循环提示用户输入，并将输入内容添加到集合中(如果输入N或n则停止循环)

info_set = set() while True:
    info = input('输入信息:') if info.upper() == 'N':
        print('已退出输入模式') break info_set.add(info)
print('输出结果:{}'.format(info_set)) # 输出结果： # 输入信息:321 # 输入信息:123 # 输入信息:321 # 输入信息:666 # 输入信息:world # 输入信息:hello # 输入信息:N # 已退出输入模式 # 输出结果:{'666', 'world', 'hello', '321', '123'} 

习题6

写代码实现
v1 = {'alex', '武sir', '肖大'}
v2 = []
循环提示用户输入,如果输入值在v1中存在,则追加到v2中,如果v1中不存在,则添加到v1中(如果输入N或n则停止循环)

v1 = {'alex', '武sir', '肖大'}
v2 = [] while True:
    info = input('输入信息:') if info.upper() == 'N':
        print('已退出输入模式') break if info in v1:
        v2.append(info) else:
        v1.add(info)
print('v1:{}'.format(v1))
print('v2:{}'.format(v2)) # 运行结果 # 输入信息:alex # 输入信息:321 # 输入信息:123 # 输入信息:n # 已退出输入模式 # v1:{'alex', '武sir', '肖大', '321', '123'} # v2:['alex'] 

习题7

判断以下值哪个能做字典key?哪个能做集合的元素?

• 1
• -1
• ""
• None
• [1, 2]
• (1,)
• {11, 22, 33, 4}
• {'name': 'wupeiq', 'age': 18}

字典key:1, -1, "", None, (1,)

集合set:1, -1, "", None, (1,),

习题8

is 和 ==的区别

通过例子可以看出：

在同一模块中：

==比较为真:基本类型都为真

is比较为真:int、str、元组

可以发现is的比较为真的都是不可变类型数据（若元组中包含列表则为False）

a = 10 b = 10 c = '123asd!@#fd1212fd' * 3 d = '123asd!@#fd1212fd' * 3 e1 = [1, 2, 3]
e2 = [1, 2, 3]
f1 = (1, 2, 3)
f2 = (1, 2, 3)
g1 = {'name': '黎明', 1: 2}
g2 = {'name': '黎明', 1: 2}
h1 = {1, 3, 5}
h2 = {1, 3, 5}
print('==比较：')
print(a == b) # True print(c == d) # True print(e1 == e2) # True print(f1 == f2) # True print(g1 == g2) # True print(h1 == h2) # True print('is比较：')
print(a is b) # True print(c is d) # True print(e1 is e2) # False print(f1 is f2) # True print(g1 is g2) # False print(h1 is h2) # False f1 = (1, 2, 3, [1])
f2 = (1, 2, 3, [1])
print(f1 == f2) # True print(f1 is f2) # False 

习题9

type使用方式及作用

type(对象):主要判断对象的类型 返回值是对象的类型

习题10

id的使用方式及作用

id(对象):主要为了获取对象的内存地址 返回值是十进制的值

习题11
看代码写结果并解释原因

v1 = {'k1': 'v1', 'k2': [1, 2, 3]}
v2 = {'k1': 'v1', 'k2': [1, 2, 3]}
result1 = v1 == v2
result2 = v1 is v2
print(result1)
print(result2)

结果:
result1:True
result2:False
== 比较对象的指向的值
is 比较内存的地址 字典是可变数据类型 所以地址不同

习题12

看代码写结果并解释原因

v1 = {'k1': 'v1', 'k2': [1, 2, 3]}
v2 = v1

result1 = v1 == v2
result2 = v1 is v2
print(result1)
print(result2)

结果:
result1:True
result2:True
== 比较对象的指向的值
is 比较内存的地址 v2和v1都指向了同一个对象所以内存地址相同

习题13

看代码写结果并解释原因

v1 = {'k1': 'v1', 'k2': [1, 2, 3]}
v2 = v1
print('1', id(v1.get('k1'))) # 1 36181616 v1['k1'] = 'wupeiqi' print(v2)
print('2', id(v1.get('k1'))) # 2 37135664 

结果:

v2:{'k1': 'v1', 'k2': [1, 2, 3]}

首先可以看出他们指向了同一个对象，

然后v1['k1']键的值为不可变类型，所以修改不可变的数据类型那么内存地址都会改变，所以这个时候的v1['k1']的值已经改变了内存地址，原先v1['k1']的指向没有变更过。所以还是原值!

通过我增加的

print('1', id(v1.get('k1'))) # 1 36181616

print('2', id(v1.get('k1'))) # 2 37135664

也可以看出来！

习题14
看代码写结果并解释原因

v1 = '人生苦短,我用Python' v2 = [1, 2, 3, 4, v1]

v1 = '人生苦短,用毛线Python' print(v2)

结果：
v2:[1, 2, 3, 4, '人生苦短,我用Python']

v1的值是不可变类型的字符串

所以更改了v1的值只会导致v1的内存地址变化

不会导致原有v1的值

习题15

看代码写结果并解释原因

info = [1, 2, 3]
userinfo = {'account': info, 'num': info, 'money': info}

info.append(9)
print(userinfo)

info = '题怎么这么多' print(userinfo)

结果:
{'account': [1, 2, 3, 9], 'num': [1, 2, 3, 9], 'money': [1, 2, 3, 9]}
userinfo字典的值都是info的列表，然后列表是可变类型的，所以追加的9，会继续在原有上追加，内存地址没有改变!
第二次打印之前info的指向变成了字符串，那么它跟原先的指向已经无关联了，所以原先的值不会被改变

习题16
看代码写结果并解释原因

info = [1, 2, 3]
userinfo = [info, info, info, info, info]

info[0] = '不仅多,还特么难呢' print(info, userinfo)

结果:
['不仅多,还特么难呢', 2, 3] [['不仅多,还特么难呢', 2, 3], ['不仅多,还特么难呢', 2, 3], ['不仅多,还特么难呢', 2, 3], ['不仅多,还特么难呢', 2, 3], ['不仅多,还特么难呢', 2, 3]

因为userinfo存放的是对象info，info对象的内存地址没有变更，所以修改了info对象里面的值，那么在列表中的info的指向的内容也会变成新的内容！

习题17
看代码写结果并解释原因

info = [1, 2, 3]
userinfo = [info, info, info, info, info]

userinfo[2][0] = '闭嘴' print(info, userinfo)

结果:
['闭嘴', 2, 3] [['闭嘴', 2, 3], ['闭嘴', 2, 3], ['闭嘴', 2, 3], ['闭嘴', 2, 3], ['闭嘴', 2, 3]]

首先第四行代码中修改的是info的列表的中的值，但是info的地址未改变，所以info是修改后包含'闭嘴'的列表,userinfo列表里面保存的info对象的内存没变，那么改变了指向的值只会导致值变化，所以userinfo里面的保存的对象info的内存没变，那么值就是它所指向的也即是新的变更的值

习题18
看代码写结果并解释原因

info = [1, 2, 3]
user_list = [] for item in range(10):
    user_list.append(info)

info[1] = '是谁说Python好学的?' print(user_list)

结果:

[[1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3], [1, '是谁说Python好学的?', 3]]

首先通过代码可以看出遍历了10次，也即是添加了10次的列表对象info，info[1]只是改变了第二个元素的值和地址，但是仍然不影响info本身的内存地址，所以最后的打印结果就是info对象的指向的值，即是修改后的值

习题19
看代码写结果并解释原因

date = {} for i in range(10):
    date['user'] = i
print(date)

结果:
{'user': 9}

字典的键是唯一的，如果后面出现相同的key会替换原先的key所以最后打印的字典只会保留最后一次的值

习题20
看代码写结果并解释原因

data_list = []
data = {} for i in range(10):
    data['user'] = i
    data_list.append(data)
print(data)

结果:
[{'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}]

首先data_list总共添加了10个对象，而这10个对象都是data，然后字典data因为遍历的键相同，后面值都覆盖前面的，所以最后的值是9，这样data的键值就是'user': 9,那么data_list保存的是这10个data的对象，内存也无变化，只是字典里面的值的变化，所以最后的内容就是这字典指向的新的内容的值也即是上述答案

习题21
看代码写结果并解释原因

data_list = [] for i in range(10):
    data = {}
    data['user'] = i
    data_list.append(data)
print(data_list)

结果:
[{'user': 0}, {'user': 1}, {'user': 2}, {'user': 3}, {'user': 4}, {'user': 5}, {'user': 6}, {'user': 7}, {'user': 8}, {'user': 9}]

每次for循环遍历的时候data对象都会变更内存，所以每次列表添加的data对象都是新的对象

习题22

使用循环打印出以下效果

*
**
***
****
*****

****
***
**
*

*
***
*****
*******
*********

for i in range(1, 6):
    print('*' * i)

print() for i in range(5, 0, -1):
    print('*' * i)

print()
j = 1 for i in range(1, 6):
    print('*' * j)
    j += 2 

习题23-敲七游戏

从1开始数数，遇到7或者7的倍数（不包含17,27这种数），要在桌上敲一下,编程来完成
敲七。给出一个任意的数字n,从1开始数，数到n结束,把每个数字都放在列表中,在数的过
程中出现7或者7的倍数（不包含17,27这种数）,则向列表中添加一个'咣'
例如,输入10,lst = [1, 2, 3, 4, 5, 6, '咣', 8, 9, 10]

seven_game = []
n = input('游戏的终止数:') if n.isdigit():
    n = int(n) if 1 <= n: for i in range(1, n + 1): if i % 7 == 0:
                seven_game.append('咣') else:
                seven_game.append(i)
print(seven_game) # 运行结果: # 游戏的终止数:24 # [1, 2, 3, 4, 5, 6, '咣', 8, 9, 10, 11, 12, 13, '咣', 15, 16, 17, 18, 19, 20, '咣', 22, 23, 24]