【Python】Python零基础100题测试（附答案）

【Python】Python零基础100题测试（附答案）

Python 是一门开源免费、通用型的脚本编程语言，它上手简单，功能强大，坚持「极简主义」。

Python 类库（模块）极其丰富，这使得 Python 几乎无所不能，不管是传统的 Web 开发、PC 软件开发、Linux 运维，还是当下火热的机器学习、大数据分析、网络爬虫，Python 都能胜任。

第1题

难度：1级
问题：编写一个程序，找到2000年至3200年(包括在内)中所有可被7整除但不能被5整除的所有数字，得到的数字按逗号分隔，打印在一行上。
提示：考虑使用range(begin, end)方法

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

2002,2009,2016,2023,2037,2044,2051,2058,2072,2079,2086,2093,2107,2114,2121,2128,2142,2149,2156,2163,2177,2184,2191,2198,2212,2219,2226,2233,2247,2254,2261,2268,2282,2289,2296,2303,2317,2324,2331,2338,2352,2359,2366,2373,2387,2394,2401,2408,2422,2429,2436,2443,2457,2464,2471,2478,2492,2499,2506,2513,2527,2534,2541,2548,2562,2569,2576,2583,2597,2604,2611,2618,2632,2639,2646,2653,2667,2674,2681,2688,2702,2709,2716,2723,2737,2744,2751,2758,2772,2779,2786,2793,2807,2814,2821,2828,2842,2849,2856,2863,2877,2884,2891,2898,2912,2919,2926,2933,2947,2954,2961,2968,2982,2989,2996,3003,3017,3024,3031,3038,3052,3059,3066,3073,3087,3094,3101,3108,3122,3129,3136,3143,3157,3164,3171,3178,3192,3199

第2题

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

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

请输入一个数字：
40320

第3题

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

print('请输入一个数字：')
n=int(input())
d=dict()
for i in range(1,n+1):
    d[i]=i*i
print(d)

请输入一个数字：
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}

第4题

难度：1级
问题：编写一个程序，该程序接收控制台以逗号分隔的数字序列，并生成包含每个数字的列表和元组；
假设，向程序提供以下输入：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)
t=tuple(k)
print (k)
print (t)

请输入一组数字：
[‘34’, ‘67’, ‘55’, ‘33’, ‘12’, ‘98’]
(‘34’, ‘67’, ‘55’, ‘33’, ‘12’, ‘98’)

第5题

难度：1级
问题：定义一个至少有两个方法的类: 一、getString：从控制台输入获取字符串；二、printString：打印大写母的字符串，并写出简单的测试函数来测试类方法。
提示：使用init方法构造一些参数

class InputOutString(object):
    def __init__(self):
        self.s = ""
    def getString(self):
        print('请输入字符串：')
        self.s = input()
    def printString(self):
        print (self.s.upper())
strObj = InputOutString()
strObj.getString()
strObj.printString()

请输入字符串：
和鲸社区

第6题

难度：2级
问题：编写一个程序，根据给定的公式计算并打印值:$Q=\sqrt{[(2\ast C\ast D)/H]}$。其中，假设C=50。H=30。D是一个变量，它的值应该以逗号分隔的序列输入到程序中。
例：程序的输入序列为（以逗号分隔）：100，150，180；
则程序输出为：18，22，24；
提示：如果输出是小数，则应四舍五入到其最近的值（例输出是26.0，则应打印为26)。

import math
c=50
h=30
value = []
print('请输入一组数字：')
items=[x for x in input().split(',')]
for d in items:
    value.append(str(int(round(math.sqrt(2*c*float(d)/h)))))
print (','.join(value))

请输入一组数字：
18,22,24

第7题

难度：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]]；
提示：如果要为问题提供输入数据，应该假设它是一个控制台输入，以逗号分隔。

print('请输入两个数字：')
input_str = input()
dimensions=[int(x) for x in input_str.split(',')]
rowNum=dimensions[0]
colNum=dimensions[1]
multilist = [[0 for col in range(colNum)] for row in range(rowNum)]
for row in range(rowNum):
    for col in range(colNum):
        multilist[row][col]= row*col
print (multilist)

请输入两个数字：
[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]

第8题

难度：2级
问题：编写一个程序，以逗号分隔的单词序列作为输入，按照字母顺序对每个单词进行排序，并通过逗号分隔的序列来打印单词。
假设向程序输入：without,hello,bag,world；
则输出为：bag,hello,without,world；
提示：在为问题提供输入数据的情况下，应该假设它是控制台输入。

items=[x for x in input().split(',')]
items.sort()
print (','.join(items))

bag,hello,without,world

第9题

难度：2级
问题：编写一个程序，接收一行序列作为输入，并在将句子中的所有字符大写后打印行。
假设向程序依次输入：Hello world；Practice makes perfect；
则输出为：HELLO WORLD；PRACTICE MAKES PERFECT；
提示：在为问题提供输入数据的情况下，应该假设它是控制台输入。

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

第10题

难度：2级
问题：编写一个程序，以一系列空格分隔的单词作为输入，并在删除所有重复的单词后，按字母顺序排序后打印这些单词。
假设向程序输入：hello world and practice makes perfect and hello world again
则输出为：again and hello makes perfect practice world
提示：我们使用set容器自动删除重复的数据，然后使用sort()对数据进行排序。

print('请输入一组字符串：')
s = input()
words = [word for word in s.split(" ")]
print (" ".join(sorted(list(set(words)))))

请输入一组字符串：
again and hello makes perfect practice world

第11题

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

value = []
print('请输入逗号分隔的4位二进制数：')
items=[x for x in input().split(',')]
for p in items:
    intp = int(p, 2)
    # print(intp)
    if not intp%5:
        value.append(p)
print (','.join(value))

请输入逗号分隔的4位二进制数：
1010

第12题

难度：2级
问题：编写一个程序，找到1000到3000之间并且所有位数均为偶数的所有数字，比如2000，2002等；获得的数字都以逗号分隔的顺序，打印在一行上。
提示：如果输入数据被提供给问题，则应该假定它是控制台输入。

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))

2000,2002,2004,2006,2008,2020,2022,2024,2026,2028,2040,2042,2044,2046,2048,2060,2062,2064,2066,2068,2080,2082,2084,2086,2088,2200,2202,2204,2206,2208,2220,2222,2224,2226,2228,2240,2242,2244,2246,2248,2260,2262,2264,2266,2268,2280,2282,2284,2286,2288,2400,2402,2404,2406,2408,2420,2422,2424,2426,2428,2440,2442,2444,2446,2448,2460,2462,2464,2466,2468,2480,2482,2484,2486,2488,2600,2602,2604,2606,2608,2620,2622,2624,2626,2628,2640,2642,2644,2646,2648,2660,2662,2664,2666,2668,2680,2682,2684,2686,2688,2800,2802,2804,2806,2808,2820,2822,2824,2826,2828,2840,2842,2844,2846,2848,2860,2862,2864,2866,2868,2880,2882,2884,2886,2888

第13题

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

print('请输入：')
s = input()
d={"DIGITS":0, "LETTERS":0}
for c in s:
    if c.isdigit():
        d["DIGITS"]+=1
    elif c.isalpha():
        d["LETTERS"]+=1
    else:
        pass
print ("字母", d["LETTERS"])
print ("数字", d["DIGITS"])

请输入：
字母 10
数字 3

第14题

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

print('请输入：')
s = input()
d={"UPPER CASE":0, "LOWER CASE":0}
for c in s:
    if c.isupper():
        d["UPPER CASE"]+=1
    elif c.islower():
        d["LOWER CASE"]+=1
    else:
        pass
print ("UPPER CASE", d["UPPER CASE"])
print ("LOWER CASE", d["LOWER CASE"])

请输入：
UPPER CASE 1
LOWER CASE 9

第15题

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

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)

请输入一个数字：
11106

第16题

难度：2级
问题：使用列表推导输出列表中的每个奇数，该列表由一系列逗号分隔的数字输入。
假设程序输入：1,2,3,4,5,6,7,8,9
输出应该是：1,3,5,7,9

print("输入:")
values = input()
numbers = [x for x in values.split(",") if int(x)%2!=0]
print (",".join(numbers))

输入:
1,3,5,7,9

第17题

难度：2级
问题：编写一个程序，根据控制台输入的事务日志计算银行帐户的净金额。 事务日志格式如下所示：
D 100 W 200
D表示存款，而W表示提款。
假设向程序依次输入：D 300；D 300；W 200；D 100；
则输出应该为：500
提示：如果输入数据被提供给问题，则应该假定它是控制台输入。

netAmount = 0
while True:
    print("请输入：")
    s = input()
    if not s:
        break
    values = s.split(" ")
    operation = values[0]
    amount = int(values[1])
    if operation=="D":
        netAmount+=amount
    elif operation=="W":
        netAmount-=amount
    else:
        pass
print (netAmount)

请输入：
请输入：
请输入：
请输入：
请输入：
500

第18题

难度：3级
问题：网站要求用户输入用户名和密码进行注册。编写程序以检查用户输入的密码有效性。
以下是检查密码的标准：
1 [a-z]之间至少有1个字母
2 [0-9]之间至少有1个数字
3 [A-Z]之间至少有一个字母
4 [$＃@]中至少有1个字符
5 最短交易密码长度：6
6 交易密码的最大长度：12
您的程序接收一系列逗号分隔的密码，并将根据上述标准进行检查，将打印符合条件的密码，每个密码用逗号分隔。
例：如果以下密码作为程序的输入：ABd1234@1,a F1#,2w3E*,2We3345
则程序的输出应该是：ABd1234@1

import re
value = []
print("请输入：")
items=[x for x in input().split(',')]
for p in items:
    if len(p)<6 or len(p)>12:
        continue
    else:
        pass
    if not re.search("[a-z]",p):
        continue
    elif not re.search("[0-9]",p):
        continue
    elif not re.search("[A-Z]",p):
        continue
    elif not re.search("[$#@]",p):
        continue
    elif re.search("\s",p):
        continue
    else:
        pass
    value.append(p)
print (",".join(value))

请输入：
ABd1234@1

第19题

难度：3级
问题：您需要编写一个程序，按升序对（名称，年龄，高度）元组进行排序，其中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’）]

提示：使用itemgetter来启用多个排序键。

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

请输入：
[(‘Tom’, ‘19’, ‘80；John’, ‘20’, ‘90；Jony’, ‘17’, ‘91；Jony’, ‘17’, ‘93；Json’, ‘21’, ‘85’)]

第20题

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

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

0
7
14
21
28
35
42
49
56
63
70
77
84
91
98

第21题

难度：3级
问题：机器人从原点（0,0）开始在平面中移动，机器人可以通过给定的步骤向上，向下，向左和向右移动。
机器人运动的痕迹如下所示：
UP 5；DOWN 3；LETF 3；RIGHT 2；方向之后的数字是步骤。

请编写一个程序，计算一系列运动和原点之后距当前位置的距离。如果距离是浮点数，则只打印最接近的整数。
例：如果程序输入：UP 5；DOWN 3；LETF 3；RIGHT 2
则程序的输出应该是：2

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

import math
pos = [0,0]
print("请输入：")
while True:
    s = input()
    if not s:
        break
    movement = s.split(" ")
    direction = movement[0]
    steps = int(movement[1])
    if direction=="UP":
        pos[0]+=steps
    elif direction=="DOWN":
        pos[0]-=steps
    elif direction=="LEFT":
        pos[1]-=steps
    elif direction=="RIGHT":
        pos[1]+=steps
    else:
        pass
print (int(round(math.sqrt(pos[1]**2+pos[0]**2))))

请输入：
2

第22题

难度：3级
问题：编写一个程序，来计算每个单词出现的频率，按字母顺序对键进行排序后输出。
假设程序输入：
New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.
则输出应该是：
2:2
3.:1
3?:1
New:1
Python:5
Read:1
and:1
between:1
choosing:1
or:2
to:1

freq = {}   # frequency of words in text
print("请输入：")
line = input()
for word in line.split():
    freq[word] = freq.get(word,0)+1
words = sorted(freq.keys())  #按key值对字典排序
for w in words:
    print ("%s:%d" % (w,freq[w]))

请输入：
2:2
3.:1
3?:1
New:1
Python:5
Read:1
and:1
between:1
choosing:1
or:2
to:1

第23题

难度：1级
问题：写一个可以计算数字平方值的方法。
提示：使用**运算符

def square(num):
    return num ** 2
print(square(2))
print(square(3))

4
9

第24题

难度：1级
问题：Python有许多内置函数，如果不知道如何使用它，可以在线阅读文档或查找一些书籍。请编写一个程序来打印一些Python内置函数文档，例如abs()，int()，input()，并为您自己的功能添加文档；
提示：内置文档方法是doc；

print(abs.__doc__)
print(int.__doc__)
print(input.__doc__)
def square(num):
    '''Return the square value of the input number.
    The input number must be integer.
    '''
    return num ** 2
print(square(2))
print(square.__doc__)
Return the absolute value of the argument.
int(x=0) -> integer
int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments
are given.  If x is a number, return x.__int__().  For floating point
numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base.  The literal can be preceded by '+' or '-' and be surrounded
by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4
Forward raw_input to frontends

        Raises
        ------
        StdinNotImplentedError if active frontend doesn't support stdin.
        
4
Return the square value of the input number.

The input number must be integer.

第25题

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

class Person:
    # Define the class parameter "name"
    name = "Person"
    def __init__(self, name=None):
        # self.name is the instance parameter
        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))

Person name is Jeffrey
Person name is Nico

第26题

问题：定义一个可以计算两个数之和的函数。
提示：定义一个带有两个数字作为参数的函数。可以在函数中计算和并返回值。

def SumFunction(number1, number2):
return number1+number2
print(SumFunction(1,2))

3

第27题

问题：定义一个可以将整数转换为字符串并在控制台中打印的函数。
提示：使用str()将数字转换为字符串。

解决方案：

def printValue(n):
    print(str(n))
printValue(3)

3

第28题

问题：定义一个可以将字符串中的数字进行相加的函数。
提示：使用int()将字符串转换为数字。

def sum_str(str1):
  len1=len(str1)
  sum = n = 0
  for i in range(len1):
    if 49 <= ord(str1[i]) <= 57:  #判断字符ascii码是否在数字ascii值范围内
      n = int(str1[i]) + n
    else:
      sum = n + sum
      n = 0
  sum = n +sum
  print(sum)
str1 = "b532x2x3c4b5"
sum_str(str1)

24

第29题

问题：定义一个函数，它可以接收两个字符串形式的整数并计算它们的和，然后在控制台中输出。
提示：使用int()将字符串转换为整数。

def printValue(s1,s2):
    print(int(s1)+int(s2))
printValue("3","4")

7

第30题

问题：定义一个函数，它可以接受两个字符串作为输入，并将它们连接起来，然后在控制台中输出。
提示：使用+连接字符串

def printValue(s1,s2):
    print(s1+s2)
printValue("3","4") #34

34

第31题

问题：定义一个函数，它可以接受两个字符串作为输入，并在控制台中以最大长度打印字符串。如果两个字符串长度相同，则函数应逐行打印所有字符串。
提示：使用len()函数获取字符串的长度。

def printValue(s1,s2):
    len1 = len(s1)
    len2 = len(s2)
    if len1>len2:
        print(s1)
    elif len2>len1:
        print(s2)
    else:
        print(s1)
        print(s2)
printValue("one","three")

three

第32题

问题：定义一个函数，它可以接受一个整数作为输入，如果这个数字是偶数，则输出“它是偶数”，否则输出“它是奇数”。
提示：使用%运算符检查一个数字是偶数还是奇数。

def checkValue(n):
    if n%2 == 0:
        print("It is an even number")
    else:
        print("It is an odd number")
checkValue(7)

It is an odd number

第33题

问题：定义一个函数，它可以打印一个字典，其中键是1到3之间的数字(包括在内)，值是键的平方。
提示：使用dict[key]=value模式将条目放入字典中。
使用**运算符得到一个数字的幂。

def printDict():
    d=dict()
    d[1]=1
    d[2]=2**2
    d[3]=3**2
    print(d)
printDict()

{1: 1, 2: 4, 3: 9}

第34题

问题：定义一个函数，它可以打印一个字典，其中键是1到20之间的数字(包括在内)，值是键的平方。
提示：使用dict[key]=value模式将条目放入字典中。使用**操作符获取＊一个数的幂。对循环使用range()。

def printDict():
d=dict()
for i in range(1,21):
d[i]=i**2
print(d)
printDict()

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289, 18: 324, 19: 361, 20: 400}

第35题

问题：定义一个函数，它可以生成一个字典，其中键是1到20之间的数字(包括在内)，值是键的平方。函数只输出值即可。
提示：使用dict[key]=value模式将条目放入字典中。使用**操作符获取＊一个数的幂。对于循环使用range()。使用keys()迭代字典中的键。我们还可以使用item()来获取键/值对。

def printDict():
d=dict()
for i in range(1,21):
d[i]=i**2
for (k,v) in d.items():
print(v)
printDict()

1
4
9
16
25
36
49
64
81
100
121
144
169
196
225
256
289
324
361
400

第36题

问题：定义一个函数，它可以生成一个字典，其中键是1到20之间的数字(包括在内)，值是键的平方。函数只打印键即可；
提示：使用dict[key]=value模式将条目放入字典中。使用**运算符得到一个数字的幂，对循环使用range()，使用keys()迭代字典中的键，我们还可以使用item()来获取键/值对。

def printDict():
d=dict()
for i in range(1,21):
d[i]=i**2
for k in d.keys():
print(k)
printDict()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

第37题

问题：定义一个函数，它可以生成和打印一个列表，其中的值是1到20之间的数的平方(包括这两个数)。
提示：使用**运算符得到一个数字的幂，对于循环使用range()，使用list.append()向列表中添加值。

def printList():
li=list()
for i in range(1,21):
li.append(i**2)
print(li)
printList()

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]

第38题

问题：定义一个函数，它可以生成一个列表，其中的值是1到20之间的数的平方(包括这两个数)，然后函数需要打印列表中的前5个元素。
提示：使用**运算符得到一个数字的幂。对循环使用range()，使用list.append()向列表中添加值，使用[n1:n2]对列表进行切片；

def printList():
li=list()
for i in range(1,21):
li.append(i**2)
print(li[:5])
printList()

[1, 4, 9, 16, 25]

第39题

问题：定义一个函数，它可以生成一个列表，其中的值是1到20之间的数的平方(包括这两个数)。然后函数需要打印列表中的最后5个元素。
提示：使用**运算符得到一个数字的幂。对循环使用range()。使用list.append()向列表中添加值。使用[n1:n2]对列表进行切片。

def printList():
li=list()
for i in range(1,21):
li.append(i**2)
print(li[-5:])
printList()

[256, 289, 324, 361, 400]

第40题

问题：定义一个函数，它可以生成一个列表，其中的值是1到20之间的数的平方(包括这两个数)。然后，该函数需要打印列表中除前5个元素外的所有值。
提示：使用**运算符得到一个数字的幂。对循环使用range()。使用list.append()向列表中添加值。使用[n1:n2]对列表进行切片；

def printList():
li=list()
for i in range(1,21):
li.append(i**2)
print(li[5:])
printList()

[36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]

第41题

问题：定义一个函数，它可以生成并打印一个元组，其中的值是1到20之间的数的平方(包括这两个数)。
提示：使用**运算符得到一个数字的幂。对循环使用range()。使用list.append()向列表中添加值。使用tuple()从列表中获取一个元组。

def printTuple():
li=list()
for i in range(1,21):
li.append(i**2)
print(tuple(li))
printTuple()

(1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400)

第42题

问题：对于给定的元组(1,2,3,4,5,6,7,8,9,10)，编写一个程序，在一行中输出前半部分值，在一行中输出后半部分值。
提示：使用[n1:n2]表示法从元组中获取切片。

tp=(1,2,3,4,5,6,7,8,9,10)
tp1=tp[:5]
tp2=tp[5:]
print(tp1)
print(tp2)

(1, 2, 3, 4, 5)
(6, 7, 8, 9, 10)

第43题

问题：编写程序生成并输出另一个元组，其值是给定元组(1,2,3,4,5,6,7,8,9,10)中的偶数。
提示：使用“for”来迭代元组，使用tuple()从列表中生成一个tuple。

tp=(1,2,3,4,5,6,7,8,9,10)
li=list()
for i in range(len(tp)):
if tp[i]%2==0:
li.append(tp[i])
tp2=tuple(li)
print(tp2)

(2, 4, 6, 8, 10)
第44题
问题：写一个程序，接受一个字符串作为输入，如果字符串是“yes”或“YES”或“Yes”，否则打印“No”。
提示：使用if语句判断条件。

s= input()
if s=="yes" or s=="YES" or s=="Yes":
    print("Yes")
else:
    print("No")

Yes

第45题

问题：编写一个程序，可以使用过滤函数过滤列表中的偶数。列表是:[1,2,3,4,5,6,7,8,9,10]。
提示：使用filter()过滤列表中的一些元素。使用lambda定义匿名函数。

li = [1,2,3,4,5,6,7,8,9,10]
evenNumbers = filter(lambda x:x%2==0, li)
for even in evenNumbers:
    print(even)

2
4
6
8
10

第46题

问题：编写一个程序，可以使用map()构造一个列表，其中的元素是[1,2,3,4,5,6,7,8,9,10]中元素的平方。
提示：使用map()生成列表。使用lambda定义匿名函数。

li = [1,2,3,4,5,6,7,8,9,10]
squaredNumbers = map(lambda x:x**2, li)
print(squaredNumbers)
<map object at 0x7f9e0e718390>

第47题

问题：编写一个程序，它可以map()和filter()生成一个列表，其中的元素是[1,2,3,4,5,6,7,8,9,101中的偶数的平方。
提示：使用map()生成列表。使用filter()来过滤列表中的元素。使用lambda定义匿名函数。

li = [1,2,3,4,5,6,7,8,9,10]
evenNumbers = map(lambda x: x**2, filter(lambda x: x%2==0, li))
print(evenNumbers)
<map object at 0x7f9e0e7185c0>

第48题
问题：编写一个程序，它可以filter()生成一个列表，其中的元素是1到20之间的偶数(包括两个元素)。
提示：使用filter()来过滤列表中的元素。使用lambda定义匿名函数。

evenNumbers = filter(lambda x: x%2==0, range(1,21))
for even in evenNumbers:
    print(even)

2
4
6
8
10
12
14
16
18
20

第49题

问题：编写一个程序，它可以使用map()生成一个列表，其中的元素是1到20之间的数的平方(包括两个数)。
提示：使用map()生成列表。使用lambda定义匿名函数。

squaredNumbers = map(lambda x: x**2, range(1,21))
print(squaredNumbers)
<map object at 0x7f9e0e704630>

第50题

问题：定义一个名为American的类，它有一个名为printNationality的静态方法。
提示：使用@staticmethod装饰器来定义类的静态方法。

class American(object):
    @staticmethod
    def printNationality():
        print("America")
anAmerican = American()
anAmerican.printNationality()
American.printNationality()

America
America

第51题

问题：定义一个名为American的类及其子类NewYorker。
提示：使用类子类(ParentClass)来定义子类。

class American(object):
    pass
class NewYorker(American):
    pass
anAmerican = American()
aNewYorker = NewYorker()
print(anAmerican)
print(aNewYorker)
<__main__.American object at 0x7f9e0e718518>
<__main__.NewYorker object at 0x7f9e0e718160>

第52题

问题：定义一个名为Circle的类，可以用半径来构造。Circle类有一个可以计算面积的方法。
提示：使用def methodName(self)定义一个方法。

class Circle(object):
    def __init__(self, r):
        self.radius = r
    def area(self):
        return self.radius**2*3.14
aCircle = Circle(2)
print(aCircle.area())

12.56

第53题

问题：定义一个名为Rectangle的类，它可以由长度和宽度构造。矩形类有一个方法可以计算面积。
提示：使用def methodName(self)定义一个方法。

class Rectangle(object):
    def __init__(self, l, w):
        self.length = l
        self.width  = w
    def area(self):
        return self.length*self.width
aRectangle = Rectangle(2,10)
print(aRectangle.area())

20

第54题

问题：定义一个名为Shape的类及其子类Square。Square类有一个init函数，它以长度作为参数。这两个类都有一个area函数，可以打印形状的区域，形状的区域默认为0。
提示：要覆盖父类中的方法，可以在父类中定义一个同名的方法。

class Shape(object):
    def __init__(self):
        pass
    def area(self):
        return 0
class Square(Shape):
    def __init__(self, l):
        Shape.__init__(self)
        self.length = l
    def area(self):
        return self.length*self.length
aSquare= Square(3)
print(aSquare.area())

9

第55题

问题：请引发RuntimeError异常。
提示：使用raise()引发异常。

raise RuntimeError('something wrong')
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
<ipython-input-56-53fba0153627> in <module>
----> 1 raise RuntimeError('something wrong')

RuntimeError: something wrong

第56题

问题：编写一个函数来计算5/0，并使用try/except来捕获异常。
提示：使用try/exexception捕获异常。

def throws():
    return 5/0
try:
    throws()
except ZeroDivisionError:
    print("division by zero!")
except ExceptionError:
    print('Caught an exception')
finally:
    print('In finally block for cleanup')
division by zero!
In finally block for cleanup

第57题

问题：定义一个自定义异常类，它将字符串消息作为属性。
提示：要定义一个自定义异常，我们需要定义一个继承自exception的类。

class MyError(Exception):
    """My own exception class
    Attributes:
        msg  -- explanation of the error
    """
    def __init__(self, msg):
        self.msg = msg
error = MyError("something wrong")

第58题

问题：假设我们有一些’username@companyname.com '格式的电子邮件地址，请编写程序打印给定电子邮件地址的用户名，用户名和公司名都只由字母组成。
示例：如果下面的电子邮件地址作为程序的输入：john@google.com.
那么，程序的输出应该是：john
在向问题提供输入数据的情况下，应该假定它是控制台输入。
提示：使用\w来匹配字母。

import re
emailAddress = input()
pat2 = "(\w+)@((\w+\.)+(com))"
r2 = re.match(pat2,emailAddress)
print(r2.group(1))

john

第59题

问题：假设我们有一些“username@companyname.com”格式的电子邮件地址，请编写程序打印给定的电子邮件地址的公司名称；用户名和公司名都只由字母组成。
示例：如果下面的电子邮件地址作为程序的输入：john@google.com
那么，程序的输出应该是：google
在向问题提供输入数据的情况下，应该假定它是控制台输入。
提示：使用\w来匹配字母。

import re
emailAddress = input()
pat2 = "(\w+)@(\w+)\.(com)"
r2 = re.match(pat2,emailAddress)
print(r2.group(2))

google

第60题

问题：编写一个程序，接收一个由空格分隔的单词序列作为输入，打印只由数字组成的单词。
示例：如果下面的单词作为程序的输入：2 cats and 3 dogs；
那么，程序的输出应该是：[‘2’, ‘3’]
在向问题提供输入数据的情况下，应该假定它是控制台输入。
提示：使用re.findall()使用正则表达式查找所有子字符串。

import re
s = input()
print(re.findall("\d+",s))

[‘2’, ‘3’]

第61题

问题：打印unicode字符串“hello world”。
提示：使用u’strings’格式来定义unicode字符串；

解决方案：

unicodeString = u"hello world!"
print(unicodeString)

hello world!

第62题

问题：python中的解码与编码;
提示：使用encode()与decode()函数进行转换。

s = '和鲸社区'
enc = s.encode('utf-8')
dec = enc.decode('utf-8')
print(enc)
print(dec)

b’\xe5\x92\x8c\xe9\xb2\xb8\xe7\xa4\xbe\xe5\x8c\xba’

第63题

问题：编写一个特殊注释来表明Python源代码文件是unicode格式的。

# -*- coding: utf-8 -*-
#----------------------------------------#

第64题

问题：写一个程序来计算1/2+2/3+3/4+…+n/(n+1)。
示例：如果下面的n作为程序的输入：5；
那么，程序的输出应该是：3.55；
提示：使用float()将整数转换为浮点数。

n=int(input())
sum=0.0
for i in range(1,n+1):
    sum += float(float(i)/(i+1))
print(sum)

3.5500000000000003

第65题

问题：编写程序计算：当n>0和F(0)=1时，F(n)=F(n-1)+100通过控制台输入一个给定的n (n>0)。
示例：如果下面的n作为程序的输入：5，
那么，程序的输出应该是：500；
提示：我们可以在Python中定义递归函数。

def f(n):
    if n==0:
        return 0
    else:
        return f(n-1)+100
n=int(input())
print(f(n))

500

第66题

问题：斐波那契数列的计算公式如下：如果n=0，f(n)=0；如果n=1，f(n)=1；如果n>1，f(n)=f(n-1)+f(n-2)；请编写一个程序，在控制台输入给定n的情况下计算f(n)的值。
示例：如果下面的n作为程序的输入：7；
那么，程序的输出应该是：13；
提示：我们可以在Python中定义递归函数。

def f(n):
    if n == 0: return 0
    elif n == 1: return 1
    else: return f(n-1)+f(n-2)
n=int(input())
print(f(n))

13

第67题

问题：斐波那契数列的计算公式如下：如果n=0，f(n)=0；如果n=1，f(n)=1；如果n>1，f(n)=f(n-1)+f(n-2)；请编写一个程序使用列表理解输出逗号分隔的Fibonacci序列，并通过控制台输入给定的n。
示例：如果下面的n作为程序的输入：7；
那么，程序的输出应该是：0,1,1,2,3,5,8,13；
提示：我们可以在Python中定义递归函数。使用列表理解从现有列表生成列表。使用string.join()连接字符串列表。

def f(n):
    if n == 0: return 0
    elif n == 1: return 1
    else: return f(n-1)+f(n-2)
n=int(input())
values = [str(f(x)) for x in range(0, n+1)]
print(",".join(values))

0,1,1,2,3,5,8,13

第68题

问题：请使用generator编写一个程序，当n由控制台输入时，以逗号分隔的形式输出0和n之间的偶数；
示例：如果下面的n作为程序的输入10；
那么，程序的输出应该是：0,2,4,6,8,10；
提示：使用yield生成生成器中的下一个值。

def EvenGenerator(n):
    i=0
    while i<=n:
        if i%2==0:
            yield i
        i+=1
n=int(input())
values = []
for i in EvenGenerator(n):
    values.append(str(i))
print(",".join(values))

0,2,4,6,8,10

第69题

问题：请编写一个生成器程序，以逗号分隔的形式输出0到n之间可以被5和7整除的数字，而n是通过控制台输入的。
示例：如果下面的n作为程序的输入：100；
那么，程序的输出应该是：0,35,70；
提示：使用yield生成生成器中的下一个值。

def NumGenerator(n):
    for i in range(n+1):
        if i%5==0 and i%7==0:
            yield i
n=int(input())
values = []
for i in NumGenerator(n):
    values.append(str(i))
print(",".join(values))

0,35,70

第70题

问题：请写assert语句来验证列表[2,4,6,8]中的每个数字都是偶数。
提示：使用“断言表达式”进行断言。

li = [2,4,6,8]
for i in li:
    assert i%2==0

第71题

问题：请编写一个程序，从控制台接收基本数学表达式，并输出计算结果。
示例：如果下面的字符串作为程序的输入：35 + 3；
那么，程序的输出应该是：38；
提示：使用eval()计算表达式。

expression = input()
print(eval(expression))

38

第72题

问题：请编写一个二分搜索函数，搜索排序列表中的项。函数应该返回要在列表中搜索的元素的索引。
提示：使用if/elif来处理条件。

import math
def bin_search(li, element):
    bottom = 0
    top = len(li)-1
    index = -1
    while top>=bottom and index==-1:
        mid = int(math.floor((top+bottom)/2.0))
        if li[mid]==element:
            index = mid
        elif li[mid]>element:
            top = mid-1
        else:
            bottom = mid+1
    return index
li=[2,5,7,9,11,17,222]
print(bin_search(li,11))
print(bin_search(li,12))

4
-1

第73题

问题：随机生成1,100内的一个整数；
提示：random.randint()

import random
random.randint(a=1,b=100)

88

第74题

问题：请使用Python math模块生成一个值在10到100之间的随机浮点数。
提示：使用random.random()在[0,1]中生成一个随机浮点数。

import random
print(random.random()*100)

35.22621015478949

第75题

问题：请使用Python math模块生成一个值在5到95之间的随机浮点数。
提示：使用random.random()在[0,1]中生成一个随机浮点数。

import random
print(random.random()*100-5)

41.74885550710126

第76题

问题：请编写一个程序输出O和10之间的随机偶数使用随机模块和列表理解。
提示：对列表中的随机元素使用random.choice()。

import random
print(random.choice([i for i in range(11) if i%2==0]))

10

第77题

问题：请编写一个程序输出一个随机数，它可以被5和7整除，在0和10之间，使用随机模块和列表理解。
提示：对列表中的随机元素使用random.choice()。

import random
print(random.choice([i for i in range(201) if i%5==0 and i%7==0]))

105

第78题

问题：请编写一个程序生成一个包含100到200之间的5个随机数的列表。
提示：使用random.sample()生成一个随机值列表。

import random
print(random.sample(range(100), 5))

[8, 92, 40, 48, 41]

第79题

问题：请编写一个程序随机生成一个列表，其中包含100到200之间的5个偶数。
提示：使用random.sample()生成一个随机值列表。

import random
print(random.sample([i for i in range(100,201) if i%2==0], 5))

[172, 108, 158, 136, 116]

第80题

问题：请编写一个程序，随机生成一个列表，从1到1000(含1000)，有5个数字，可以被5和7整除。
提示：使用random.sample()生成一个随机值列表。

import random
print(random.sample([i for i in range(1,1001) if i%5==0 and i%7==0], 5))

[420, 210, 175, 700, 560]

第81题

问题：请写一个程序来随机打印一个7到15之间的整数(包括15)。
提示：使用random.randrange()到一个给定范围内的随机整数。

import random
print(random.randrange(7,16))

9

第82题

问题：请编写一个程序来压缩和解压字符串"hello world!hello world!hello world!hello world!"。
提示：使用zlib.compress()和zlib.decompress()来压缩和解压缩字符串。

import zlib
s = b'hello world!hello world!hello world!hello world!'
t = zlib.compress(s)
print(t)
print(zlib.decompress(t))

b’x\x9c\xcbH\xcd\xc9\xc9W(\xcf/\xcaIQ\xcc \x82\r\x00\xbd[\x11\xf5’
b’hello world!hello world!hello world!hello world!’

第83题

问题：请编写一个程序打印100次“1+1”执行的运行时间。
提示：使用timeit()函数测量运行时间。

from timeit import Timer
t = Timer("for i in range(100):1+1")
print(t.timeit())

1.2503450869999142

第84题

问题：请编写一个程序洗牌和打印列表[3,6,7,8]。
提示：使用shuffle()函数洗牌列表。

from random import shuffle
li = [3,6,7,8]
shuffle(li)
print(li)

[3, 7, 8, 6]

第85题

问题：请编写一个程序洗牌和打印列表[3,6,7,8]。
提示：使用shuffle()函数洗牌列表。

from random import shuffle
li = [3,6,7,8]
shuffle(li)
print(li)

[8, 7, 3, 6]

第86题

问题：请编写一个程序，生成主语在 [“I”, “You”]，动词在[“Play”, “Love”]中，对象在[“Hockey”,“Football”]中的所有句子.
提示：使用list[index]表示法从列表中获取元素。

subjects=["I", "You"]
verbs=["Play", "Love"]
objects=["Hockey","Football"]
for i in range(len(subjects)):
    for j in range(len(verbs)):
        for k in range(len(objects)):
            sentence = "%s %s %s." % (subjects[i], verbs[j], objects[k])
            print(sentence)

I Play Hockey.
I Play Football.
I Love Hockey.
I Love Football.
You Play Hockey.
You Play Football.
You Love Hockey.
You Love Football.

第87题

问题：请写一个程序打印列表，删除后删除偶数[5,6,77,45,22,12,24]。
提示：使用列表理解从列表中删除一组元素。

li = [5,6,77,45,22,12,24]
li = [x for x in li if x%2!=0]
print(li)

[5, 77, 45]

第88题

问题：使用列表理解，请编写程序，删除[12,24,35,70,88,120,155]中可被5和7整除的删除数后，打印列表。
提示：使用列表理解从列表中删除一组元素。

li = [12,24,35,70,88,120,155]
li = [x for x in li if x%5!=0 and x%7!=0]
print(li)

[12, 24, 88]

第89题

问题：使用列表理解法，请编写一个程序，去掉[12,24,35,70,88,120,155]中的第0,2,4,6位置上的元素后打印列表。
提示：使用列表理解从列表中删除一组元素。使用enumerate()来获取(索引，值)元组。

li = [12,24,35,70,88,120,155]
li = [x for (i,x) in enumerate(li) if i%2!=0]
print(li)

[24, 70, 120]

第90题

问题：使用列表理解，编写一个程序生成一个358三维数组，每个元素为0。
提示：使用列表理解来创建数组。

array = [[ [0 for col in range(8)] for col in range(5)] for row in range(3)]
print(array)

[[[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]]]

第91题

问题：利用列表理解，请编写一个程序，去掉[12,24,35,70,88,120,155]中的第0，第4，第5个数字后，将列表打印出来。
提示：使用列表理解从列表中删除一组元素。使用enumerate()来获取(index, value)元组。

li = [12,24,35,70,88,120,155]
li = [x for (i,x) in enumerate(li) if i not in (0,4,5)]
print(li)

[24, 35, 70, 155]

第92题

问题：通过使用列表理解，请编写一个程序，在[12,24,35,24,88,120,155]中删除值24后打印列表。
提示：使用列表的remove方法删除一个值。

li = [12,24,35,24,88,120,155]
li = [x for x in li if x!=24]
print(li)

[12, 35, 88, 120, 155]

第93题

问题：对于两个已知链表[1,3,6,78,35,55]和[12,24,35,24,88,120,155]，编写一个程序来生成一个元素为上述两个链表交集的链表。
提示：使用set()和"&="进行集合相交操作。

set1=set([1,3,6,78,35,55])
set2=set([12,24,35,24,88,120,155])
set1 &= set2
li=list(set1)
print(li)

[35]

第94题

问题：对于给定的列表[12,24,35,24,88,120,155,88,120,155]，编写一个程序来打印这个列表-删除所有重复的值与原始顺序保留。
提示：使用set()来存储一些没有重复的值。

def removeDuplicate( li ):
    newli=[]
    seen = set()
    for item in li:
        if item not in seen:
            seen.add( item )
            newli.append(item)
    return newli
li=[12,24,35,24,88,120,155,88,120,155]
print(removeDuplicate(li))

[12, 24, 35, 88, 120, 155]

第95题

问题：定义一个类Person和它的两个子类：Male和Female。所有的类都有一个方法“getGender”，它可以打印“Male”为男性类，“Female”为女性类。
提示：使用子类(Parentclass)来定义子类。

class Person(object):
    def getGender( self ):
        return "Unknown"
class Male( Person ):
    def getGender( self ):
        return "Male"
class Female( Person ):
    def getGender( self ):
        return "Female"
aMale = Male()
aFemale= Female()
print(aMale.getGender())
print(aFemale.getGender())

Male
Female

第96题

问题：请编写一个程序，计算并打印由控制台输入的字符串中的每个字符的数量。
示例：如果下面的字符串作为程序的输入：abcdefgab；
那么，程序的输出应该是：a,2 c,2 b,2 e,1 d,1 g,1 f,1；
提示：使用dict存储键/值对。使用dict.get()方法查找具有默认值的键。

dic = {}
s=input()
for s in s:
    dic[s] = dic.get(s,0)+1
print('\n'.join(['%s,%s' % (k, v) for k, v in dic.items()]))

a,2
b,2
c,1
d,1
e,1
f,1
g,1

第97题

问题：请编写一个程序，从控制台接收一个字符串，并以相反的顺序打印出来。
示例：如果下面的字符串作为程序的输入：rise to vote sir；
那么，程序的输出应该是:ris etov ot esir；
提示：使用list[::-1]以相反的顺序迭代一个列表。

s=input()
s = s[::-1]
print(s)

ris etov ot esir

第98题

问题：请编写一个程序，从控制台接收一个字符串，并打印具有偶数索引的字符；
示例：如果下面的字符串作为程序的输入：H1e2l3l4o5w6o7r8l9d
那么，程序的输出应该是：Helloworld；
提示：使用list[:2]来迭代第2步中的列表。

s=input()
s = s[::2]
print(s)

Helloworld

第99题

问题：请写一个程序，打印[1,2,3]的所有排列；
提示：使用itertools.permutations)得到list的排列。

import itertools
print(list(itertools.permutations([1,2,3])))

[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

第100题

问题：写一个程序来解决一个中国古代的经典难题:我们数农场里的鸡和兔子中有35个头和94条腿。我们有多少只兔子和多少只鸡?
提示：使用for循环来迭代所有可能的解决方案。

def solve(numheads,numlegs):
    ns='No solutions!'
    for i in range(numheads+1):
        j=numheads-i
        if 2*i+4*j==numlegs:
            return i,j
    return ns,ns

numheads=35
numlegs=94
solutions=solve(numheads,numlegs)
print(solutions)
(23, 12)

本文参考：
Github：100+ Python challenging programming exercises

原文地址：https://blog.csdn.net/qq_41562897/article/details/143790844

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！