1.初级

问题:编写一个程序，它将找到所有这些数字，可被7整除，但不是5的倍数，2000年至3200 年(包括在内)。得到的数字应按逗号分隔的顺序打印在一行上。 提示:考虑使用 range(#begin， #end)方法

l=[]
for k in range(2000, 3200):
    if k%7==0 and k%5!=0:
        l.append(str(k))
print(','.join(l))

注意：join（）的用法，用于将序列中的元素以指定的字符连接生成一个新的字符串。其是一个字符串，所以保证l必须是一个字符串，才有l.append(str(k))的用法。

2.初级

问题：编写一个可以计算给定数的阶乘的程序。结果应该以逗号分隔的顺序打印在一行上。假 设向程序提供以下输入:8 则输出为:40320 提示:在为问题提供输入数据的情况下，应该假设它 是控制台输入。 解决方案:

我的方案：利用循环来进行计算

import time
s=time.time()
sum=1
k = int(input('请输入数字：'))
if k == 0:
    print(1)
while(k!=1) :
    sum=sum*k
    k = k - 1
print(sum)
o=time.time()
print(str(o-s))

题目给的方案：巧妙利用迭代，先定义一个函数，在利用迭代进行计算

总结：在看到这些比较重复的操作时，一定可以想到用到迭代

def fact(x):
    if x == 0:
        return 1
    return x * fact(x - 1)
print('请输入一个数字：')    ##或者x=int(input('请输入一个数字：'))
x=int(input())
print (fact(x))
​

3.初级

问题:使用给定的整数n，编写一个程序生成一个包含(i, i*i)的字典，该字典包含1到n之间的整 数(两者都包含)。然后程序应该打印字典。 假设向程序提供以下输入:8 则输出为: {1:1， 2:4，3:9，4:16，5:25，6:36，,7:49，8:64} 提示:在为问题提供输入数据的情况下，应该假 设它是控制台输入。考虑使用dict类型() 解决方案:

l={}
k=int(input('请输入一个数字：'))
for i in range(1,k+1):
    l[i]=i*i
print(l)

注意：对于字典类型的操作要熟悉。l[i]表示的就是字典l之中的i位置上的键值。

4.初级

问题:编写一个程序，该程序接受控制台以逗号分隔的数字序列，并生成包含每个数字的列表 和元组。假设向程序提供以下输入: 34岁,67年,55岁,33岁,12日,98年 则输出为:['34'， '67'， '55'， '33'， '12'， '98'] ('34'， '67'， '55'， '33'， '12'， '98') 提示:在为问题提供输入 数据的情况下，应该假设它是控制台输入。方法可以将列表转换为元组 解决方案:

import re
print('请输入一组数字：')
values=input()
l=values.split(",")  ##表示以逗号进行分割，返回的是一个列表
k=re.findall(r'[0-9]+',values)   ###r'[0-9]+'表示只识别数字，识别的内容是后面的values，并且以列表的形式进行返回
t=tuple(k)      ###此处将列表k转换为元组的形式
print (k)
print (t)
​

注意：要特别注意re这个模块，它可以的调用的正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

re.finditer(pattern, string, flags=0)

import re
 
it = re.finditer(r"\d+","12a32bc43jf3") 
for match in it: 
    print (match.group() )

输出结果：

 

各种匹配的方式，见下：

 

参考网址： https://www.runoob.com/python3/python3-reg-expressions.html

5.初级

问题:定义一个至少有两个方法的类: getString:从控制台输入获取字符串 printString::打印大 写母的字符串。 还请包含简单的测试函数来测试类方法。 提示:使用_init__方法构造一些参数 解决方案:

关于 _ init _ 方法的使用，可以参考:

class InputOutString(object):
    def __init__(self):   ##定义传入的参数，这里是一个字符串类型
        self.s = ""
    def get_string(self):
        print('请输入字符串：')  ##或者这样写：self.s=input('请输入字符串：')
        self.s = input()
    def print_string(self):
        print (self.s.upper())  ##充分印证了成员变量（属性）也可以是对象
strObj = InputOutString()
strObj.get_string()
strObj.print_string()
​

6.中级

问题:编写一个程序，以2位数字，X,Y作为输入，生成一个二维数组。数组的第i行和第j列中的 元素值应该是i*j。 注意:i= 0,1 . .,X - 1; j = 0, 1,Y-1。 例子假设程序有以下输入:3、5 则程序 输出为:[[0,0,0,0,0],[0,1,2,3,4],[0,2,4,6,8]] 提示:注意:如果要为问题提供输入数据，应该假设 它是一个控制台输入，以逗号分隔。 解决方案:

str=input('请输入数字，并用逗号隔开：')
dimensions=[int(x) for x in str.split(',')]#遍历用逗号分割的数字，然后将其转换为整数
rowd=dimensions[0]
cold=dimensions[1]
array=[[0 for k in range(cold)] for x in range(rowd)]  ##创建二维数组，第一个for是创建行，第二个for是创建的列，用0占位
for row in range(rowd):    ##遍历二维数组
    for col in range(cold):
        array[row][col]=row*col
print(array)

利用多重列表推导创建了二维数组：

array=[[0 for k in range(cold)] for x in range(rowd)]
这一句相当于两个for循环嵌套：
array = []
for row in range(rowd):
	list1 = []
	multilist.append(list1)
	for col in range(cold):
		list1.append(0)

第一个for：0 for k in range(cold)创建的是行，第二个for创建的是列，这个地方只是创建了一个二维数组，然后用0占位。顺序是先由第一个for：0 for k in range(cold)创建了元素全是0的列表，然后再由第二个for根据第一个for创建的列表创建了包含三个相同列表的列表。换句话说就是，第二个for是创建和第一个for所创建东西相同的几个东西

7.中级

问题:编写一个程序，接受逗号分隔的单词序列作为输入，按字母顺序排序后按逗号分隔的序 列打印单词。假设向程序提供以下输入: without,hello,bag,world 则输出为: bag,hello,without,world 提示:在为问题提供输入数据的情况下，应该假设它是控制台输入。 解决方案:

t=[x for x in input('请输入单词:').split(',')]  ##首先将以逗号分割输入的几个单词整成一个列表，
                        # 即input('请输入单词:').split(',')生成的是一个以输入单词为字符串构建组成的一个列表，
                        # 然后再遍历这个列表里的每一个单词，再组建成一个新的列表
t.sort()
print(','.join(t))      #输出t里边的每一个对象，并用，隔开，此处需要注意：t里边的序列必须是字符串，必要时可以用str（）来进行转换

其中，

t=input('qing:').split(',')
print(t)

结果如下：

 

8.中级

问题: 编写一个程序，根据给定的公式计算并打印值:。以下是C和H的固定值:C是50。H是 30。D是一个变量，它的值应该以逗号分隔的序列输入到程序中。 例子假设程序的输入序列 是逗号分隔的:100，150，180， 程序输出为:18，22，24 提示:如果接收到的输出是小数， 则应四舍五入到其最近的值(例如，如果接收到的输出是26.0，则应打印为26)。在为问题提供 输入数据的情况下，应该假设它是控制台输入。 解决方案:

import math
C=50
H=30
item=[]
t=[x for x in input('请输入数字：').split(',')]
for d in t:
    item.append(str(int(round(math.sqrt(2*C*float(d)/H)))))  ##注意：此处最后要将其转换为字符串的形式，因为
                                                        #','.join(item)要求的item里边的东西要是字符串的形式   
    
print(','.join(item))

结果如下所示：

 

9.中级

问题:编写一个程序，接受一行序列作为输入，并在将句子中的所有字符大写后打印行。 假设 向程序提供以下输入: Hello world Practice makes perfect 则输出为: HELLO WORLD PRACTICE MAKES PERFECT 提示:在为问题提供输入数据的情况下，应该假设它是控制台输 入。 解决方案:

t=[x for x in input('请输入单词：').split('/n')]  #'/n'表示的是使得输出的结果在一行，不换行
for d in t:
    print(d.upper())

结果：

 

但如果换成split（），即下面：

t=[x for x in input('请输入单词：').split()]  ##或者split(' ')，或者split(" ")
for d in t:
    print(d.upper())

结果：

 

另一种比较好的方法如下：

lines = []
while True:
    s = input()
    if s:
        lines.append(s.upper())
    else:
        break
for sentence in lines:
    print(sentence)

这里用到了一个无限循环的函数，好处是可以随意输入，可以实现换行输入，结果：

 

10.中级

问题:编写一个程序，接受一系列空格分隔的单词作为输入，并在删除所有重复的单词并按字 母数字排序后打印这些单词。 假设向程序提供以下输入: hello world and practice makes perfect and hello world again 则输出为: again and hello makes perfect practice world 提 示:在为问题提供输入数据的情况下，应该假设它是控制台输入。 我们使用set容器自动删除重 复的数据，然后使用sort()对数据进行排序。 解决方案:

t=[x for x in input('请输入单词：').split(' ')]
print(' '.join(sorted(list(set(t)))))

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

但是set返回的是一个字典类型的东西，咱们要将其转换为列表类型，如下：

t=[x for x in input('请输入单词：').split(' ')]##列表里面是字符串的形式
# print(' '.join(sorted(list(set(t)))))
print(set(t))

结果：

 

11.中级

问题：编写一个程序，接受一系列逗号分隔的4位二进制数作为输入，然后检查它们是否可被 5整除。 可被5整除的数字将以逗号分隔的顺序打印。 例： 0100,0011,1010,1001 那么输出 应该是： 1010 注意：假设数据由控制台输入。 提示：如果输入数据被提供给问题，则应该假定它是控制台输入。

item=[]
t=[x for x in input('请输入四位二进制数:').split(',')]
for d in t:
    intd=int(d,2)  ##int() 函数用于将一个字符串或数字转换为整型。
    print(intd)
    if intd%5==0:
        item.append(d)
print(','.join(item))

结果：

 

其中，int（）的描述如下：

 

 

12.中级

题：编写一个程序，它将找到1000到3000之间的所有这些数字（均包括在内），这样数字的 每个数字都是偶数。 获得的数字应以逗号分隔的顺序打印在一行上。 提示：如果输入数据被提供给问题，则应该假定它是控制台输入。

我之前的方法：

item=[]
for i in range(1000,3001):
    if i%2==0:
        item.append(str(i))
print(','.join(item))

结果：

 

但是我理解错了题目意思，"它将找到1000到3000之间的所有这些数字（均包括在内），这样数字的 每个数字都是偶数"，所以应该这样写：

values = []
for i in range(1000, 3001):
    s = str(i)
    if (int(s[0])%2==0) and (int(s[1])%2==0) and (int(s[2])%2==0) and (int(s[3])%2==0):
        values.append(s)
print (",".join(values))

结果：

 

13.中级

题：编写一个接受句子并计算字母和数字的程序。假设为程序提供了以下输入： Hello world! 123 然后，输出应该是： 字母10 数字3 提示：如果输入数据被提供给问题，则应该假定它是控制台输入。

t=input('请输入内容：')
d={'数字':0,'单词':0}
for x in t:
    if x.isdigit():
        d['数字']+=1
    if x.isalpha():
        d['单词']+=1
    else：
    	pass
print("数字",d['数字'])
print("单词",d['单词'])

像这种明显的有”键“和”值“的提示，肯定要自己设置字典类型的数据结构

14.中级

题：编写一个接受句子的程序，并计算大写字母和小写字母的数量。 假设为程序提供了以下 输入： Hello world! 然后，输出应该是： 大写实例 1 小写实例 9 提示：如果输入数据被提供给问题，则应该假定它是控制台输入。

t=input("请输入内容：")
item={'da xie':0,'xiao xie':0}
for x in t:
    if x.isupper():
        item['da xie']+=1
    if x.islower():
        item['xiao xie']+=1
    else:
        pass
print('da xie',item['da xie'])
print('xiao xie',item['xiao xie'])

结果：

 

注意：熟练运用字典类型的数据结构

15.中级

题：编写一个程序，计算a + aa + aaa + aaaa的值，给定的数字作为a的值。假设为程序提供 了以下输入： 9 然后，输出应该是： 11106 提示：如果输入数据被提供给问题，则应该假定它是控制台输入。

t=input("请输入内容：")
sum=0
x=0
t1=int(t)
while(x<4):
    sum=sum+t1
    t1=int(t)+t1*10
    x+=1
print(sum)

但是还有一种比较简单且直接的方法：

print('请输入一个数字：')
a = input()
n1 = int( "%s" % a )
n2 = int( "%s%s" % (a,a) )
n3 = int( "%s%s%s" % (a,a,a) )
n4 = int( "%s%s%s%s" % (a,a,a,a) )
print (n1+n2+n3+n4)

16.中级

题：使用列表推导来对列表中的每个奇数。 该列表由一系列逗号分隔的数字输入。 假设为程 序提供了以下输入： 1,2,3,4,5,6,7,8,9 然后，输出应该是： 1,3,5,7,9

t=[x for x in input('请输入内容：').split(',') if int(x)%2!=0]
print(','.join(t))

需要注意的是：在列表t中，对于里边的每一个x，其是一个字符类型对象，需要对其int取整之后再对2取余

17.中级

题：编写一个程序，根据控制台输入的事务日志计算银行帐户的净金额。 事务日志格式如下 所示： D 100 W 200 D表示存款，而W表示提款。 假设为程序提供了以下输入： D 300 D 300 W 200 D 100 然 后，输出应该是： 500

amount=0
while True:
    t = input()     ##在这里不能加上input.split(),因为加上之后就变成一个内部为字符串的列表了，就不好判断空输入，也就无法出发循环
    if not t:
        break
    t=t.split(' ')
    operation = t[0]
    value = int(t[1])
    print(value)
    if operation=="D":
        amount+=value
    elif operation=="W":
        amount-=value
    else:
        pass
print (amount)

18.高级

 

提示：如果输入数据被提供给问题，则应该假定它是控制台输入。

import re
item=[]
t=[x for x in input("请输入内容：").split(',')]
for x in t:
    if len(x)<6 or len(x)>12:
        continue
    else:
        pass
    if not re.search("[a-z]",x):
        continue
    elif not re.search("[A-Z]",x):
        continue
    elif not re.search("[$#@]",x):
        continue
    elif not re.search("[0-9]",x):
        continue
    elif not re.search("\s",x):   ##表示匹配任意空白字符，等价于 [\t\n\r\f]。其实我到感觉这句如果不写其实也行
        continue
    else:
        pass
    item.append(x)
print(','.join(item))

输出结果：

 

 

 

 

 

 

19.高级

题：您需要编写一个程序，按升序对（名称，年龄，高度）元组进行排序，其中name是字符 串，age和height是数字。 元组由控制台输入。 排序标准是： 1：根据名称排序; 2：然后根 据年龄排序; 3：然后按分数排序。 优先级是name> age>得分。 如果给出以下元组作为程序 的输入： Tom,19,80 John,20,90 Jony,17,91 Jony,17,93 Json,21,85 然后，程序的输出应该 是： [（'John'，'20'，'90'），（'Jony'，'17'，'91'），（'Jony'，'17'，'93'）， （'Json'，'21 '，'85'），``（'Tom'，'19'，'80'）]

from operator import itemgetter
l=[]
while 1:
    t=input("请输入内容：")
    if not t:
        break
    r=t.split(',')
    l.append(tuple(r))
print(sorted(l,key=itemgetter(0,1,2)))

sort 与 sorted 区别：

①sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

②list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

operator模块中的itemgetter()函数：是获取对象指定域中的值

>>> from operator import itemgetter
>>> a = [1,2,3,4,5]
>>> b = itemgetter(0)
>>> b(a)
1
>>> c = itemgetter(0,1,2)
>>> c(a)
(1, 2, 3)
>>> 

20.高级

题：使用生成器定义一个类，该生成器可以在给定范围0和n之间迭代可被7整除的数字。 提示：考虑使用yield。

l=[]
def yiel (n):
    def __init__(self):
        self.n=n
    for i in range(0,n+1):
        if i%7==0:
            l.append(i)
    print(l)
yiel(908)

使用构造方法，还有一种方式，使用yield：

def put_numbers(n):
    i = 0
    while i<n:
        j=i
        i=i+1
        if j%7==0:
            yield j
for i in put_numbers(908):
    print (i)		

yield 的作用：

简单地讲，就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用 fab(5) 不会执行 fab 函数，而是返回一个 iterable 对象！在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。

21.高级

机器人从原点（0,0）开始在平面中移动。 机器人可以通过给定的步骤向上，向下，向左和向 右移动。 机器人运动的痕迹如下所示： UP 5 DOWN 3 LETF 3 RIGHT 2 方向之后的数字是 步骤。 请编写一个程序来计算一系列运动和原点之后距当前位置的距离。如果距离是浮点 数，则只打印最接近的整数。 例：如果给出以下元组作为程序的输入： UP 5 DOWN 3 LETF 3 RIGHT 2 然后，程序的输出应该是：2 提示：如果输入数据被提供给问题，则应该假定它是 控制台输入。

import math
l=[]
x = 0
y = 0
while(1):
    t=input("请输入内容：")
    if not t:
        break
    m=t.split(" ")
    operation=m[0]
    value=int(m[1])
    if operation=='UP':
        x+=value
    if operation=='DOWN':
        x-=value
    if operation=='LEFT':
        y+=value
    if operation=='RIGHT':
        y-=value
print(int(round(math.sqrt(x**2+y**2)))) ###这里**表示的就是指数的形式

22.高级

 

l={}
m=input("请输入内容：").split()
for i in m:
    l[i]=l.get(i,0)+1  ##get（）的用法见下面，”get(i,0)“表示的意思是如果找不到键值i，则返回0
word =sorted(l.keys())  ##按键值对字典进行排序
for i in word:
    print('%s:%d'% (i,l[i]))

结果：

 

 

实例
#!/usr/bin/python
dict = {'Name': 'Runoob', 'Age': 27}

print "Value : %s" %  dict.get('Age')
print "Value : %s" %  dict.get('Sex', "Not Available")

23.初级

def caculate(n):
    print(n**2)       ##或者说可以写成return (n**2)
caculate(3)

24.初级

题：Python有许多内置函数，如果您不知道如何使用它，您可以在线阅读文档或查找一些书 籍。 但是Python为每个内置函数都有一个内置的文档函数。 请编写一个程序来打印一些 Python内置函数文档，例如abs（），int（），raw_input（）并为您自己的功能添加文档 提示：内置文档方法是 __ doc__

def square (num):
    ''''##必须得是三个点以上，六个点；以下
    fasjkljgal;gjafklasjflkasjf
    '''
    return num**2
print(square(3))
print(square.__doc__)

结果：

 

25.初级

题：定义一个类，它具有类参数并具有相同的实例参数。 提示：定义一个实例参数，需要在init方法中添加它。您可以使用构造参数初始化对象， 也可以稍后设置该值

class Person:
# Define the 类参数 "name"
    name = "Person"
    def __init__(self, name=None):
# self.name is the 实例参数（即实例化后的参数）
        self.name = name
jeffrey = Person("Jeffrey")
print("%s name is %s" % (Person.name, jeffrey.name))
nico = Person()
nico.name = "Nico"
print("%s name is %s" % (Person.name, nico.name))

结果如下：