python习题,关于python基础强化练习

标签：class   基本类型   while   怎么   作用   保存   没有   返回值   form   

基础习题

习题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 

python习题,关于python基础强化练习

标签：class   基本类型   while   怎么   作用   保存   没有   返回值   form   

原文地址：https://www.cnblogs.com/YXFate/p/14612690.html