Python编程（1~6级）全部真题・点这里

一、单选题（共25题，每题2分，共50分）

第1题

对于字典infor = {“name”:“tom”, “age”:13, “sex”:“male”}，删除"age":13键值对的操作正确的是？（ ）

A：del infor[‘age’]
B：del infor[“age”:13]
C：del infor
D：infor.clear()

答案：A

选项A中的代码使用del关键字来删除字典中的指定键值对。通过指定要删除的键名age，可以将对应的键值对从字典中删除。

选项B中的代码del infor[“age”:13]是错误的语法。在字典中，使用方括号来指定要删除的键名，而不是使用冒号和值来删除键值对。

选项C中的代码del infor是将整个字典infor删除，而不是删除指定的键值对。

选项D中的代码infor.clear()是清空字典中的所有键值对，将字典变为空字典，而不是删除指定的键值对。

因此，选项A：del infor[‘age’]是正确的操作。

第2题

用Python语句计算：长方形的长和宽分别为4和5，则长方形的周长为？（ ）
A：

a=4
b=5
c=2*a+2*b
print(c)

B：

a=4
b=5
c=2*a+b
print(c)

C：

a=4
b=5
c=a*b
print(c)

D：

a=4
b=5
c=a+b*2
print(c)

答案：A

正确的选项是A，这段代码计算长方形的周长，使用了长度和宽度的公式：周长 = 2 * 长 + 2 * 宽。

在给定的代码中，a被赋值为4，表示长方形的长度是4；b被赋值为5，表示长方形的宽度是5。然后，通过计算周长的公式，将结果赋值给变量c。最后，使用print语句打印出周长的值。

第3题

下列代码输出结果是？（ ）

list1 = ['A','&','A',8,'A'] list1.remove('A')
print(list1)

A：[ ‘A’,‘&’, ‘A’, 8]
B：[‘&’, ‘A’, 8, ‘A’]
C：[ ‘&’, 8]
D：[‘A’,‘&’, 8, ‘A’]

答案：B

给定的代码中，首先创建了一个包含多个元素的列表list1。然后使用list1.remove(‘A’)移除列表中第一个出现的字符’A’。

list1.remove(‘A’)会删除列表中第一个匹配到的元素’A’。在给定的列表中，第一个出现的’A’是在索引0处，因此被删除。

最终输出的结果是移除元素后的列表，即[‘&’, ‘A’, 8, ‘A’]。

因此，选项B：[‘&’, ‘A’, 8, ‘A’]是正确的输出结果。

第4题

数学课代表将同学们的数学成绩存放在列表S1中，s1=[99,92,87,90,100,95]，如果按照成绩由低到高输出，以下哪个程序可以实现？（ ）
A：

s1=[99,92,87,90,100,95]
s2=sorted(s1) 
print(s2)

B：

s1=[99,92,87,90,100,95] 
s2=sort() 
print(s2)

C：

s1=[99,92,87,90,100,95] 
sort(reverse=True) 
print(s1)

D：

s1=[99,92,87,90,100,95] 
s2=sorted(s1,reverse=True) 
print(s2)

答案：A

正确的选项是A：

s1 = [99, 92, 87, 90, 100, 95]
s2 = sorted(s1)
print(s2)

这段代码使用了sorted()函数来对列表s1进行排序。sorted()函数会返回一个新的已排序的列表，而不会修改原始列表。

在给定的代码中，将列表s1传递给sorted()函数进行排序，并将排序后的结果赋值给s2。最后，使用print语句打印出排序后的结果s2。

因此，选项A中的代码输出的结果是按照成绩由低到高排序后的列表：[87, 90, 92, 95, 99, 100]。

第5题

执行下列语句，将输出： （ ）

>>>list1=['b','c',1,2,3,4,5] 
>>>list1.append('a') 
>>>list1

A：[‘b’, ‘c’, 1, 2, 3, 4, 5, ‘a’]
B：无任何输出
C：b
D：[‘b’,‘c’,1,2,3,4,5]

答案：A

执行下列语句，将输出：

A：[‘b’, ‘c’, 1, 2, 3, 4, 5, ‘a’]

选项A是正确的答案。

给定的代码包括以下语句：

list1 = ['b', 'c', 1, 2, 3, 4, 5]
list1.append('a')

首先，创建了一个列表list1，包含多个元素。

接下来，使用list1.append('a')将字符’a’添加到列表的末尾。

最后，通过打印list1，输出列表的内容。

因此，执行完给定的代码后，输出的结果是：[‘b’, ‘c’, 1, 2, 3, 4, 5, ‘a’]，即选项A。

第6题

已知t=(88,77,95,64,85)，那么t[1:3]的结果是？（ ）
A：[88,77]
B：(88,77)
C：(77,95)
D：[77,95]

答案：C

切片操作t[1:3]表示在元组t中获取索引1到索引3（不包括索引3）之间的元素，即获取索引为1和2的元素。

在给定的元组t中，索引1对应的元素是77，索引2对应的元素是95。

因此，t[1:3]的结果是(77,95)，即选项C。

第7题

可以定义一个字典week1,用数字1-7表示中文的星期一到星期日（如1表示星期一），正确的语句是？（ ）
A：week1=(1:‘星期一’,2:‘星期二’,3:‘星期三’,4:‘星期四’,5:‘星期五’,6:‘星期六’,7:‘星期日’)
B：week1=[1:‘星期一’,2:‘星期二’,3:‘星期三’,4:‘星期四’,5:‘星期五’,6:‘星期六’,7:‘星期日’]
C：week1={‘1’;‘星期一’,‘2’;‘星期二’,‘3’;‘星期三’,‘4’;‘星期四’,‘5’;‘星期五’,‘6’;‘星期六’,‘7’;‘星期日’}
D：week1={1:‘星期一’,2:‘星期二’,3:‘星期三’,4:‘星期四’,5:‘星期五’,6:‘星期六’,7:‘星期日’}

答案：D

选项D中的语句使用了大括号{}来定义一个字典week1。字典是由键值对组成的数据结构，在这里键是数字1-7，对应着中文的星期一到星期日。值是相应的中文星期字符串。

因此，选项D中的语句是正确的方式来定义一个字典week1。

第8题

下列不会产生死循环的程序是？（ ）
A：

i=1
while True:
    i+=1
    if i%2==0:
        continue
    print(i)

B：

i=1
while True:
    if i%2==0:
        continue
    print(i)

C：

i=0
while True:
    i+=1
    if i==100:
        break
    print(i)

D：

i=1
while i==1:
    print(i)

答案：C

选项C中的代码使用了while True:来创建一个无限循环，但在循环体内，通过判断if i==100:的条件来使用break语句终止循环。当i的值等于100时，循环会被中断，不会陷入死循环。

选项A中的代码在if i%2==0:条件为真时使用continue语句，会跳过后续的代码，但循环不会被终止，因此会陷入死循环。

选项B中的代码在循环体内没有修改i的值，因此循环条件while True:永远为真，会陷入死循环。

选项D中的代码使用了while i==1:来创建循环，但并没有在循环体内修改i的值，因此循环条件i==1一直为真，会陷入死循环。

因此，选项C中的代码是不会产生死循环的程序。

第9题

下列程序运行完成时，i的值为？（ ）

for i in 'I enjoy coding.':
    if i=='c':
        break
print(i,end='')

A：‘o’
B：‘c’
C：I enjoy
D：’ ’

答案：B

在给定的程序中，使用for循环遍历字符串’I enjoy coding.'中的每个字符。

当循环到字符’i’时，执行if语句判断if i==‘c’:，由于字符’i’不等于’c’，条件为假，不会执行if语句块中的代码。

继续循环，当循环到字符’c’时，执行if语句判断if i==‘c’:，由于字符’c’等于’c’，条件为真，执行if语句块中的代码break。

break语句用于终止循环，因此循环会被中断，不再继续执行后续的循环迭代。

最后，打印输出变量i的值，即’c’。

因此，选项B中的值’c’是程序运行完成时i的值。

第10题

语句list6=[0,6]的含义是？（ ）
A、定义一个变量list6,值为0~6之间的随机值
B、定义一个变量list6,值为0.6
C、定义一个列表list6,包含两个元素：0和6
D、生成一个数字序列list6，值为0~6

答案：C

给定的语句创建了一个名为list6的列表，并将两个元素0和6作为列表的内容。

方括号[]用于定义列表，逗号,用于分隔列表中的元素。

因此，选项C中的含义是正确的，语句list6=[0,6]定义了一个列表list6，包含两个元素：0和6。

第11题

有如下Python程序段：

x=10
y=5
if x/y==x//y:
   print("相等")
else:
   print("不相等")

执行程序段后，输出的结果是？（ ）
A：“相等”
B：“不相等”
C：相等
D：不相等

答案：C

在给定的程序段中，首先定义了两个变量x和y，分别赋值为10和5。

接下来，使用条件判断语句if x/y==x//y:来比较除法运算和整除运算的结果。

x/y表示x除以y得到的结果，x//y表示x整除y得到的结果。

在本例中，x除以y的结果是2.0，x整除y的结果是2。因为2.0等于2，所以条件判断为真。

因此，执行if语句块中的代码print(“相等”)，输出结果为 相等（不带双引号）。

因此，选项C中的结果：相等 是执行程序段后的输出结果。

第12题

下列代码的输出结果是？（ ）

lis=list(range(5))
print(lis)

A：0, 1, 2, 3, 4,5
B：[0, 1, 2, 3, 4]
C：0, 1, 2, 3,4
D：[0, 1, 2, 3,4,5]

答案：B

给定的代码创建了一个列表lis，使用range(5)生成了一个包含0到4的整数序列。

range(5)生成的序列包含的元素是0, 1, 2, 3, 4。

然后，通过print(lis)打印输出列表lis的内容。

因此，执行给定的代码后，输出的结果是[0, 1, 2, 3, 4]，即选项B。

第13题

执行下列语句，将输出：

>>>x=[1,2,3,4,5] 
>>>y=[2,3,5]
>>>z=[] 
>>>z.append(x[1]*y[2]) 
>>>z

A：x[1]*y[2]
B：25
C：[3]
D：[10]

答案：D

首先，创建了一个列表x，包含元素1, 2, 3, 4, 5。

接下来，创建了一个列表y，包含元素2, 3, 5。

然后，创建了一个空列表z。

使用z.append(x[1] * y[2])将x列表索引为1的元素（值为2）与y列表索引为2的元素（值为5）相乘后的结果，即2 * 5 = 10，添加到列表z中。

最后，通过打印z，输出列表的内容。

因此，执行完给定的代码后，输出的结果是：[10]，即选项D。

第14题

下列程序的运行结果是？（ ）

a=1
if a>0:
    a=a+1
if a>1:
    a=5
print(a)

A：1
B：2
C：5
D：0

答案：C

首先，将变量a赋值为1。

接下来，执行第一个if语句，判断a > 0是否为真。因为a的值为1，满足条件，所以进入if语句块。在if语句块内，将a的值加1，即a = a + 1，此时a的值变为2。

然后，执行第二个if语句，判断a > 1是否为真。因为a的值为2，满足条件，所以进入if语句块。在if语句块内，将a的值赋为5，即a = 5。

最后，通过print(a)打印输出变量a的值，即输出结果为5。

因此，选项C中的结果为5是程序运行的输出结果。

第15题

已知字符串st=‘Python’，执行语句x=st[::2]后，变量x的值为？（ ）
A：‘Pyt’
B：‘Py’
C：‘yhn’
D：‘Pto’

答案：D

切片操作[::2]表示从字符串的开头到结尾，步长为2，即每隔一个字符取一个字符。

在字符串’Python’中，按照步长为2的方式取字符，依次取得的字符为：‘P’, ‘t’, ‘o’。

因此，执行语句x=st[::2]后，变量x的值为’Pto’，即选项D的结果。

第16题

已知a=“1”，b=“2”，则表达式a+b的值为？（ ）
A：3
B：12
C：‘12’
D：‘21’

答案：C

在Python中，对于字符串变量，使用+运算符进行拼接操作。

在给定的表达式中，将字符串变量a和b相加，即进行字符串拼接。

因为a的值是字符串"1"，b的值是字符串"2"，所以将它们拼接在一起得到的结果是字符串"12"。

因此，表达式a+b的值为’12’，即选项C的结果。

第17题

list1=[1,3,4] 
list2=[3,5,2] 
(list1+list2)*2

的值为？（ ）
A：[8,16,12]
B：[1,3,4,3,5,2,1,3,4,3,5,2]
C：[1,3,4,1,3,4,3,5,2,3,5,2]
D：[2,6,8,6,10,4]

答案：B

表达式 (list1+list2)*2 的计算过程如下：

首先，将列表 list1 和 list2 进行拼接，得到 [1, 3, 4, 3, 5, 2]。

然后，将拼接后的列表重复两次，得到 [1, 3, 4, 3, 5, 2, 1, 3, 4, 3, 5, 2]。

因此，(list1+list2)*2 的值为 [1, 3, 4, 3, 5, 2, 1, 3, 4, 3, 5, 2]，即选项B的结果。

第18题

下列代码输出结果是？（ ）

ls=['python','2021']
print(type(ls))

A：<class ‘dict’>
B：<class ‘set’>
C：<class ‘list’>
D：<class ‘tuple’>

答案：C

给定的代码创建了一个名为ls的列表，其中包含两个元素：‘python’和’2021’。

然后，使用type(ls)获取变量ls的类型，并通过print函数打印输出。

由于ls是一个列表对象，因此它的类型是list。

因此，执行给定代码后，输出的结果是<class ‘list’>，即选项C。

第19题

已知t=(2,3,5,7,9),下列哪条指令可以求元组数据的和？（ ）
A：len(t)
B：min(t)
C：max(t)
D：sum(t)

答案：D

函数sum()用于计算可迭代对象的总和。在这种情况下，元组t是一个可迭代对象，包含了整数元素。

使用sum(t)将对元组中的所有元素求和，得到结果为2 + 3 + 5 + 7 + 9 = 26。

因此，选项D的指令sum(t)可以求元组数据的和。

第20题

已知变量stra=“IloveTX”，执行语句print(“love” in stra)的结果为？（ ）
A：True
B：False
C：1
D：0

答案：A

执行语句print(“love” in stra)会判断字符串"love"是否存在于变量stra中。

在给定的例子中，变量stra的值为"IloveTX"。我们可以看到该字符串中包含子字符串"love"。

因此，判断结果为True。

因此，执行语句print(“love” in stra)的结果为True，即选项A

第21题

有如下Python程序段：

lista=[1,2,3,4,5,6,7,8,9,10]
s=0
for i in range(0,len(lista),2):
    s=s+lista[i]
print("s=",s)

执行程序段后，输出的结果为？（ ）
A：25
B：s=25
C：s=30
D：s=55

答案：B

执行给定的程序段后，通过print(“s=”,s)语句打印输出结果。

根据程序段的逻辑，对列表lista中索引为偶数的元素进行求和，并将结果保存在变量s中。

在每次循环中，将索引为偶数的元素加到变量s上。

最后，通过print语句打印输出结果，格式为"s="加上变量s的值。

根据给定的列表lista，索引为偶数的元素分别是1、3、5、7、9。

将这些元素相加得到：1 + 3 + 5 + 7 + 9 = 25。

因此，执行程序段后，输出的结果为s=25，即选项B。

第22题

运行下列程序语句后，字典a是空值的是？（ ）
A：

a={'职业':'警察','年龄':25,'姓名':'李四'}
a.clear()

B：

a={'职业':'警察','年龄':25,'姓名':'李四'}
c={'职业':'教师'}
a=c.copy()

C：

a={'职业':'警察','年龄':25,'姓名':'李四'}
del a['职业']

D：

a={'职业':'警察','年龄':25,'姓名':'李四'}
a.popitem()

答案：A

在选项A代码中，首先创建了字典a，包含了键值对{‘职业’:‘警察’,‘年龄’:25,‘姓名’:‘李四’}。

然后，使用a.clear()方法清空字典a的内容。

调用clear()方法后，字典a中的所有键值对都被移除，使其成为空值。

因此，执行完该代码后，字典a为空值。

因此，选项A中的代码可以使字典a成为空值。

第23题

下列程序的运行结果是？（ ）

L=[1,2,3,4,5,2,1]
L.pop(3)
L.pop(2)
print(L)

A：[1,2,4,5,1]
B：[1,2,3,5,2]
C：[1,2,5,2,1]
D：[1,2,3,5,1]

答案：C

给定的程序段依次执行了以下操作：

创建了列表 L，包含元素 [1, 2, 3, 4, 5, 2, 1]。
执行 L.pop(3)，移除索引为 3 的元素，即移除列表中的元素 4。
执行 L.pop(2)，移除索引为 2 的元素，即移除列表中的元素 3。
使用 print(L) 打印输出列表 L。
因此，执行完该程序后，列表 L 的内容为 [1, 2, 5, 2, 1]。

因此，选项 C [1, 2, 5, 2, 1] 是程序的运行结果。

第24题

有如下Python程序段： tup1=(1,2,3,4,5) x=tup1[1]+tup1[-1] print(“x=”,x) 执行上述程序段后，输出的结果为？（ ）
A：3
B：x= 3
C：7
D：x= 7

答案：D

该程序段的功能是从元组 tup1 中获取索引为 1 和索引为 -1 的元素，并将它们相加赋值给变量 x，然后打印输出结果。

根据给定的元组 tup1，索引为 1 的元素是 2，索引为 -1 的元素是 5。

将这两个元素相加得到 2 + 5 = 7，赋值给变量 x。

最后，通过 print 语句打印输出结果，格式为 “x=” 加上变量 x 的值。

因此，执行程序段后，输出的结果是 D：x= 7。

第25题

下列程序运行的结果是？（ ）

infor = {"name":"tom", "age":13, "sex":"male"} print(len(infor))

A：6
B：3
C：4
D：1

答案：B

在程序中，创建了一个名为 infor 的字典，包含了三个键值对。

然后，通过 len(infor) 获取字典 infor 的长度，即键值对的数量。

由于字典 infor 中有三个键值对，所以它的长度为 3。

因此，执行程序后，输出的结果是 B：3。

二、判断题（共10题，每题2分，共20分）

第26题

下列程序的输出结果是(‘A’,‘p’,‘p’,‘l’,‘e’)。（ ）

vowels=('a','p','p','l','e')
vowels[0]='A'
print(vowels)

答案：错误

在给定的程序中，尝试将元组 vowels 的索引为0的元素 ‘a’ 修改为 ‘A’，但是元组是不可变（immutable）的数据类型，无法直接修改其中的元素。

因此，当执行 vowels[0]=‘A’ 这一语句时，会引发 TypeError 错误。

修改元组中的元素需要重新创建一个新的元组。

因此，给定的程序会产生错误，输出结果是程序执行时引发的 TypeError 错误，而不是 (‘A’,‘p’,‘p’,‘l’,‘e’)。

第27题

Python语句的循环结构中for循环是条件循环。（ ）

答案：错误

Python语句的循环结构中，for循环属于计数循环，而不是条件循环。

for循环用于遍历可迭代对象（如列表、元组、字符串等）中的元素，按照顺序执行循环体内的代码，每次迭代处理一个元素，直到遍历完所有元素。

for循环的迭代次数是根据可迭代对象的元素个数确定的，与条件无关。

第28题

字典中的元素称为键值对，包括一个键和一个值，键和值中间用逗号隔开。（ ）

答案：错误

字典中的元素称为键值对，每个键值对由一个键和一个值组成，它们之间使用冒号:进行分隔，而不是逗号,。

键值对的表示形式为 键: 值，键和值之间使用冒号进行分隔。

第29题

在循环语句中break语句的作用是提前结束所有循环。（ ）

答案：错误

在循环语句中，break语句的作用是提前结束当前所在的循环，而不是结束所有循环。

当代码执行到break语句时，循环立即终止，程序会跳出当前循环，继续执行循环之后的代码或者程序的其他部分。

break语句只会结束当前所在的循环，而不会影响其他嵌套的循环。

第30题

若s=‘春眠不觉晓，处处闻啼鸟。’，则s[2:4]的值是’不觉’。（ ）

答案：正确

若字符串 s 的取值为 ‘春眠不觉晓，处处闻啼鸟。’，则 s[2:4] 表示从索引位置 2（包含）到索引位置 4（不包含）的子字符串。

在这个例子中，索引位置 2 对应的字符是 ‘不’，索引位置 3 对应的字符是 ‘觉’。

因此，s[2:4] 的值是 ‘不觉’。

第31题

元组是可变的，可以通过下标索引访问元素。（ ）

答案：错误

元组是不可变（immutable）的数据类型，表示一组有序的元素。它的元素不能被修改，也不能添加或删除。

因此，元组是不可变的，无法通过下标索引来修改元素。

可以通过下标索引访问元组中的元素，但不能对元组中的元素进行修改。

第32题

“好好学习”+“天天向上” 的输出结果是"好好学习" “天天向上”。（ ）

答案：错误

在Python中，使用加号运算符（+）可以将两个字符串拼接在一起。

给定的字符串拼接表达式是：“好好学习” + “天天向上”。

执行这个表达式后，会将两个字符串拼接在一起，得到结果：“好好学习天天向上”。

第33题

当使用循环时，有时候在满足某个条件时，想要退出循环，我们可以使用break语句。（ ）

答案：正确

在循环中，当满足某个条件时，我们可以使用 break 语句来提前结束循环并跳出循环体。

break 语句的作用是立即终止当前所在的循环，并跳出循环体，不再执行循环中剩余的代码。

使用 break 语句可以在满足特定条件时退出循环，从而避免继续执行循环体中的代码。

第34题

程序设计的三种基本结构为：顺序结构、选择结构和分支结构。（ ）

答案：错误

程序设计的三种基本结构为：顺序结构、选择结构和循环结构，而不是分支结构。

顺序结构是按照代码的顺序依次执行的结构，逐条执行代码。

选择结构是根据条件的真假选择不同的执行路径，使用条件语句（如 if 语句）来决定程序的执行流程。

循环结构是重复执行一段代码，直到满足特定条件才退出循环，使用循环语句（如 for 循环、while 循环）来实现。

第35题

count() 方法用于统计某个元素在列表中出现的次数。（ ）

答案：正确

在Python中，列表（list）是一种有序的数据类型，可以包含多个元素。列表提供了一系列的方法来操作和处理列表中的数据。

其中，列表的 count() 方法用于统计某个元素在列表中出现的次数。它接受一个参数，即要统计的元素，返回该元素在列表中出现的次数。

例如，对于一个列表 my_list = [1, 2, 2, 3, 2]，调用 my_list.count(2) 将返回 3，因为数字 2 在列表中出现了 3 次。

三、编程题（共2题，共30分）

第36题

设计一个停车场收费计算器（收费规则，2小时以内收费5元，超出部分每小时加收2元），要求如下：
（1) 设计的程序要能输入停车时间（单位为小时，输入的小时数为整数）；
（2) 程序可以根据输入的停车时间自动计算出停车费，并且显示出来；
（3) 程序可以重复使用。

下面是一个实现停车场收费计算器的Python程序示例：

def calculate_parking_fee(hours):
    base_fee = 5  # 2小时以内的基本收费
    additional_fee_per_hour = 2  # 超出2小时每小时的额外收费

    if hours <= 2:
        total_fee = base_fee
    else:
        additional_hours = hours - 2
        additional_fee = additional_hours * additional_fee_per_hour
        total_fee = base_fee + additional_fee

    return total_fee


while True:
    try:
        parking_time = int(input("请输入停车时间（单位：小时）："))
        if parking_time < 0:
            raise ValueError
        fee = calculate_parking_fee(parking_time)
        print("停车费用为：{}元".format(fee))
    except ValueError:
        print("输入无效，请输入一个非负整数作为停车时间。")
    except Exception as e:
        print("发生错误：", str(e))

该程序中，calculate_parking_fee() 函数用于计算停车时间对应的停车费用。根据题目要求，如果停车时间小于等于2小时，则收取基本费用5元；如果停车时间超过2小时，则在基本费用上加收每小时2元的额外费用。

在主程序部分，使用一个无限循环来接受用户输入的停车时间，并调用 calculate_parking_fee() 函数计算停车费用，最后将结果打印出来。如果用户输入的停车时间为负数或者其他无效输入，程序会进行适当的错误处理。

这样设计的程序可以满足题目要求，能够输入停车时间，自动计算停车费用，并且可以重复使用。

第37题

用户输入一个半径r，求该半径下的圆的面积s与周长c。要求如下：
（1) 输出的面积与周长都保留俩位小数；
（2) 输出的格式为：“圆的周长是**，面积是**”；
（3) pi取3.14；
（4) 使用print()格式化输出(%方法)。

下面是一个实现用户输入半径并计算圆的面积和周长的Python程序示例：

pi = 3.14
radius = float(input("请输入圆的半径："))

# 计算圆的周长
circumference = 2 * pi * radius
# 计算圆的面积
area = pi * radius * radius

print("圆的周长是%.2f，面积是%.2f" % (circumference, area))

在这个程序中，我们首先定义了一个变量 pi 并赋值为3.14，表示圆周率。

用户输入的半径通过 float() 函数转换为浮点数。

然后，根据圆的周长公式和面积公式使用变量 pi 进行计算。

最后，使用 % 方法进行格式化输出，保留两位小数，并按照指定格式输出结果。

这样设计的程序可以根据用户输入的半径计算圆的面积和周长，并按照要求的格式输出结果，并且使用了指定的变量 pi。