Python | 常见面试题

=========1、Question:问题  2、Hints:提示  3、Solution:解决方案===========

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　请多关注 

 

1、 编写一个程序，找出所有能被7整除但不是5的倍数的数，2000年到3200年(都包括在内)。  得到的数字应该以逗号分隔的顺序打印在一行上。

　   考虑使用range(#begin， #end)方法

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,.........,2884,2886,2888

 1 values = []
 2 
 3 for i in range(1000, 3001):
 4     s = str(i)
 5     if (int(s[0]) % 2 == 0) and (int(s[1]) % 2 == 0) and (int(s[2])%2==0) and (int(s[3])%2==0):
 6         values.append(s)
 7 
 8 print(','.join(values))
 9 
10 
11 
12 
13 #2000,2002,2004,.........,2884,2886,2888

2、  编写一个可以计算给定数字的阶乘的程序。  结果应该以逗号分隔的顺序打印在一行上。 假设向程序提供以下输入: 8      则输出为:    40320

　　如果向问题提供输入数据，则应该将其视为控制台输入。

def fact(x):
if x == 0:
return 1
return x*fact(x-1)

x = int(input())
print(fact(x))

1 def fact(x):
2     if x == 0:
3         return 1
4     return x*fact(x-1)
5 
6 x = int(input())
7 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类型()

 n = int(input())
2 d = dict()
3 for i in range(1, n+1):
4     d[i] = i*i
5 print(d)

1 n = int(input())
2 d = dict()
3 for i in range(1, n+1):
4     d[i] = i*i
5 print(d)

4、编写一个程序，接受来自控制台的逗号分隔的数字序列，并生成一个包含每个数字的列表和元组。 假设向程序提供以下输入: 34,67,55,33,12,98  则输出为：   ['34', '67', '55', '33', '12', '98']    ('34', '67', '55', '33', '12', '98')

　  方法可以将列表转换为元组

1 values = input()
2 l = values.split(",")
3 t = tuple(l)
4 print(l)
5 print(t)

1 values = input()
2 l = values.split(",")
3 t = tuple(l)
4 print(l)
5 print(t)

5、 定义一个至少有两个方法的类: 　　getString:从控制台输入获取字符串 　　打印字符串:打印字符串的大写字母。还请包含简单的测试函数来测试类方法。

　   使用_init__方法构造一些参数    （直接一个uppper不可以吗？？）

class InputOutString(object):
def __init__(self):
self.s = ""

def getString(self):
self.s = input()

def printString(self):
print(self.s.upper())

strObj = InputOutString()
strObj.getString()
strObj.printString()

 1 class InputOutString(object):
 2     def __init__(self):
 3         self.s = ""
 4 
 5     def getString(self):
 6         self.s = input()
 7 
 8     def printString(self):
 9         print(self.s.upper())
10 
11 
12 strObj = InputOutString()
13 strObj.getString()
14 strObj.printString()

6、 编写一个程序，计算和打印的价值根据给定的公式:　　Q =√[(2 * C * D)/H]　　以下是C和H的固定值:  C是50。H是30。　　D是一个变量，它的值应该以逗号分隔的序列输入到程序中。　　

　　例子-假设程序的输入序列是逗号分隔的: 100,150,180  则输出为：18,22,24

　   如果接收到的输出是十进制的，则应四舍五入到其最接近的值(例如，如果接收到的输出是26.0，则应打印为26)

1 # !/usr/bin/env python
 2 import math
 3 c=50
 4 h=30
 5 value = []
 6 items=[x for x in input().split(',')]
 7 for d in items:
 8     value.append(str(int(round(math.sqrt(2*c*float(d)/h)))))
 9 
10 print(','.join(value))

 1 # !/usr/bin/env python
 2 import math
 3 c=50
 4 h=30
 5 value = []
 6 items=[x for x in input().split(',')]
 7 for d in items:
 8     value.append(str(int(round(math.sqrt(2*c*float(d)/h)))))
 9 
10 print(','.join(value))

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

 1 input_str = input()
 2 dimensions=[int(x) for x in input_str.split(',')]
 3 rowNum=dimensions[0]
 4 colNum=dimensions[1]
 5 multilist = [[0 for col in range(colNum)] for row in range(rowNum)]
 6 
 7 for row in range(rowNum):
 8     for col in range(colNum):
 9         multilist[row][col]= row*col
10 
11 print(multilist)

 1 input_str = input()
 2 dimensions=[int(x) for x in input_str.split(',')]
 3 rowNum=dimensions[0]
 4 colNum=dimensions[1]
 5 multilist = [[0 for col in range(colNum)] for row in range(rowNum)]
 6 
 7 for row in range(rowNum):
 8     for col in range(colNum):
 9         multilist[row][col]= row*col
10 
11 print(multilist)

8、 编写一个程序，接受逗号分隔的单词序列作为输入，并在按字母顺序排序后以逗号分隔的序列打印单词。

　   假设向程序提供以下输入:  without,hello,bag,world    输出为: bag,hello,without,world

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

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

9、编写一个接受行序列作为输入的程序，并在将句子中的所有字符都大写后打印这些行。

　  Suppose the following input is supplied to the program: Hello world Practice makes perfect    Then, the output should be: HELLO WORLD PRACTICE MAKES PERFECT

 1 lines = []
 2 while True:
 3     s = input()
 4     if s:
 5         lines.append(s.upper())
 6     else:
 7         break;
 8 
 9 for sentence in lines:
10     print(sentence)

 1 lines = []
 2 while True:
 3     s = input()
 4     if s:
 5         lines.append(s.upper())
 6     else:
 7         break;
 8 
 9 for sentence in lines:
10     print(sentence)

10、编写一个程序，接受一系列空格分隔的单词作为输入，并在删除所有重复的单词并按字母数字排序后打印这些单词。

　　假设向程序提供以下输入:  hello world and practice makes perfect and hello world again   输出为： again and hello makes perfect practice world

　　我们使用set容器自动删除重复的数据，然后使用sort()对数据进行排序。

1 s = input()
2 words = [word for word in s.split(" ")]
3 print(' '.join(sorted(list(set(words)))))

1 s = input()
2 words = [word for word in s.split(" ")]
3 print(' '.join(sorted(list(set(words)))))

11、编写一个程序，接受一个逗号分隔的4位二进制数序列作为输入，然后检查它们是否能被5整除。能被5整除的数字要按逗号分隔的顺序打印。

　　例如：0100,0011,1010,1001   输出为：1010

1 value = []
2 items=[x for x in input().split(',')]
3 for p in items:
4     intp = int(p, 2)
5     if not intp%5:
6         value.append(p)
7 
8 print(','.join(value))

1 value = []
2 items=[x for x in input().split(',')]
3 for p in items:
4     intp = int(p, 2)
5     if not intp%5:
6         value.append(p)
7 
8 print(','.join(value))

12、编写一个程序，它将找到所有这些数字在1000和3000之间(都包括在内)，使数字的每一位都是偶数。  得到的数字应该以逗号分隔的顺序打印在一行上。

　　输出结果为：2000,2002,2004,2006,2008,2020,2022,2024,......,2866,2868,2880,2882,2884,2886,2888

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

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

13、编写一个程序，接受一个句子，并计算字母和数字的数量。

　　例如  hello world! 123 输出为: LETTERS 10    DIGITS 3

1 s = input()
 2 d={"DIGITS":0, "LETTERS":0}
 3 for c in s:
 4     if c.isdigit():
 5         d["DIGITS"]+=1
 6     elif c.isalpha():
 7         d["LETTERS"]+=1
 8     else:
 9         pass
10 print("LETTERS", d["LETTERS"])
11 print("DIGITS", d["DIGITS"])

 1 s = input()
 2 d={"DIGITS":0, "LETTERS":0}
 3 for c in s:
 4     if c.isdigit():
 5         d["DIGITS"]+=1
 6     elif c.isalpha():
 7         d["LETTERS"]+=1
 8     else:
 9         pass
10 print("LETTERS", d["LETTERS"])
11 print("DIGITS", d["DIGITS"])

14、编写一个程序，接受一个句子，并计算字母和数字的数量。编写一个程序，接受一个句子，并计算大写字母和小写字母的数量。

　　例如：I love You till the end of the World 　　UPPER CASE 3     LOWER CASE 25

 1 s = input()
 2 d={"UPPER CASE":0, "LOWER CASE":0}
 3 for c in s:
 4     if c.isupper():
 5         d["UPPER CASE"]+=1
 6     elif c.islower():
 7         d["LOWER CASE"]+=1
 8     else:
 9         pass
10 print("UPPER CASE", d["UPPER CASE"])
11 print("LOWER CASE", d["LOWER CASE"])

 1 s = input()
 2 d={"UPPER CASE":0, "LOWER CASE":0}
 3 for c in s:
 4     if c.isupper():
 5         d["UPPER CASE"]+=1
 6     elif c.islower():
 7         d["LOWER CASE"]+=1
 8     else:
 9         pass
10 print("UPPER CASE", d["UPPER CASE"])
11 print("LOWER CASE", d["LOWER CASE"])

15、编写一个程序，计算a+aa+aaa+aaaa的值与一个给定的数字作为a的值。

　　例如：2　　2468     

1 a = input()
2 n1 = int( "%s" % a )
3 n2 = int( "%s%s" % (a,a) )
4 n3 = int( "%s%s%s" % (a,a,a) )
5 n4 = int( "%s%s%s%s" % (a,a,a,a) )
6 print (n1+n2+n3+n4)

1 a = input()
2 n1 = int( "%s" % a )
3 n2 = int( "%s%s" % (a,a) )
4 n3 = int( "%s%s%s" % (a,a,a) )
5 n4 = int( "%s%s%s%s" % (a,a,a,a) )
6 print (n1+n2+n3+n4)

16、使用列表理解来对列表中的每个奇数求平方。该列表是由逗号分隔的数字序列输入的。

　　例如：1,2,3,4,5,6,7,8,9    输出为：1，3，5，7，9

1 # values = "1,2,3,4,5,6,7,8,9"
2 values = input()
3 numbers = [x for x in values.split(",") if int(x)%2!=0]
4 print(",".join(numbers))

1 # values = "1,2,3,4,5,6,7,8,9"
2 values = input()
3 numbers = [x for x in values.split(",") if int(x)%2!=0]
4 print(",".join(numbers))

17、编写一个程序，根据控制台输入的交易日志计算银行帐户的净金额。事务日志格式如下:  D 100   W 200    D表示存款，W表示取款。

假设向程序提供以下输入:   D 300 D 300 W 200 D 100   输出为：500  （越写越觉得无聊啊，继续坚持）

 1 netAmount = 0
 2 while True:
 3     s = input()
 4     if not s:
 5         break
 6     values = s.split(" ")
 7     operation = values[0]
 8     amount = int(values[1])
 9     if operation=="D":
10         netAmount+=amount
11     elif operation=="W":
12         netAmount-=amount
13     else:
14         pass
15 print(netAmount)

 1 netAmount = 0
 2 while True:
 3     s = input()
 4     if not s:
 5         break
 6     values = s.split(" ")
 7     operation = values[0]
 8     amount = int(values[1])
 9     if operation=="D":
10         netAmount+=amount
11     elif operation=="W":
12         netAmount-=amount
13     else:
14         pass
15 print(netAmount)

18、网站需要用户输入用户名和密码才能注册。编写程序检查用户输入密码的有效性。

以下是检查密码的准则:

1. [a-z]之间至少有一个字母

2. [0-9]之间至少1个数字

1. [A-Z]之间至少有一个字母

3.至少有一个字符来自[$#@]

4. 最小交易密码长度:6

5. 最大交易密码长度:12

您的程序应该接受一个逗号分隔的密码序列，并将根据上述标准检查它们。匹配条件的密码将被打印出来，每个密码之间用逗号分隔。

例子

如果下列密码作为程序的输入:

ABd1234@1 F1 # 2 w3e * 2 we3345

则程序输出为:

ABd1234@1

import re
 2 value = []
 3 items=[x for x in input().split(',')]
 4 for p in items:
 5     if len(p)<6 or len(p)>12:
 6         continue
 7     else:
 8         pass
 9     if not re.search("[a-z]",p):
10         continue
11     elif not re.search("[0-9]",p):
12         continue
13     elif not re.search("[A-Z]",p):
14         continue
15     elif not re.search("[$#@]",p):
16         continue
17     elif re.search("s",p):
18         continue
19     else:
20         pass
21     value.append(p)
22 print(",".join(value))

19、您需要编写一个程序来对(姓名、年龄、身高)元组按升序排序，其中姓名是字符串，年龄和身高是数字。元组由控制台输入。排序标准为:

1:根据名字排序;

2:然后根据年龄排序;

3:然后按分数排序。

优先级是>年龄>得分。

如果下列元组作为程序的输入:  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来启用多个排序键。

1 import operator
2 l = []
3 while True:
4     s = input()
5     if not s:
6         break
7     l.append(tuple(s.split(",")))
8 
9 print(sorted(l, key=operator.itemgetter(0,1,2)))

1 import operator
2 l = []
3 while True:
4     s = input()
5     if not s:
6         break
7     l.append(tuple(s.split(",")))
8 
9 print(sorted(l, key=operator.itemgetter(0,1,2)))

20、使用生成器定义一个类，它可以迭代给定范围0到n之间的数字，这些数字可以被7整除。

　　例如100内的：  0  7  14  21 28  35  42  49  56  63  70  77  84  91  98

1 def putNumbers(n):
 2     i = 0
 3     while i<n:
 4         j=i
 5         i=i+1
 6         if j%7==0:
 7             yield j
 8 
 9 for i in putNumbers(100):
10     print(i)

 1 def putNumbers(n):
 2     i = 0
 3     while i<n:
 4         j=i
 5         i=i+1
 6         if j%7==0:
 7             yield j
 8 
 9 for i in putNumbers(100):
10     print(i)

刷Leetcode网站力扣：https://leetcode-cn.com/problemset/all/

Python进阶：https://docs.pythontab.com/interpy/

感谢您的观看，希望对您的面试和知识提高有帮助，请点一下关注