本文主要是介绍大厂Python招聘面试100题，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
看着教程会敲代码，自己敲就不会了？如果你也遇到和我初学python是一样的问题，不妨把一下题目都自己动手敲一遍吧！
问题 1
1级
问题：编写一个程序，找出所有可以被 7 整除但不是 5 倍数的数字，介于 2000 和 3200 之间（都包括在内）。获得的数字应以逗号分隔的顺序打印在一行上。
提示：考虑使用 range(#begin, #end) 方法
解决方案：
l = [] for i in range ( 2000 , 3201 ): if ( i % 7 == 0 ) and ( i % 5 != 0 ): l。附加（str（i）） 打印（'，'。加入（l））
问题2
1级
问题：编写一个程序，可以计算给定数字的阶乘。结果应以逗号分隔的顺序打印在一行上。假设向程序提供以下输入：8 那么，输出应该是：40320
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
def fact ( x ): if x == 0 : return 1 return x * fact ( x - 1 ) x = int (输入()) 打印(事实( x ))
问题 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()
解决方案：
n = int ( input ()) d = dict () for i in range ( 1 , n + 1 ): d [ i ] = i * i 打印( d )
问题 4
1级
问题：编写一个程序，从控制台接受逗号分隔的数字序列，并生成一个列表和一个包含每个数字的元组。假设向程序提供以下输入：34,67,55,33,12,98 那么，输出应该是：['34', '67', '55', '33', '12', ' 98'] ('34', '67', '55', '33', '12', '98')
提示：如果向问题提供输入数据，则应假定它是控制台输入。tuple() 方法可以将列表转换为元组
解决方案：
值=输入（） l =值。拆分( "," ) t =元组( l ) 打印( l ) 打印( t )
问题 5
1级
问题：定义一个至少有两个方法的类： getString：从控制台输入获取字符串 printString：以大写形式打印字符串。还请包括简单的测试功能来测试类方法。
提示：使用init方法构造一些参数
解决方案：
类 InputOutString (对象): def __init__ ( self ): self。s = "" def getString（自我）： 自我。s = 输入() def printString ( self ) : print ( self.s.upper ( ) ) _ strObj = InputOutString () strObj。getString () strObj。打印字符串()
问题 6
2级
问题：编写一个程序，根据给定的公式计算并打印该值： Q = [(2 * C * D)/H] 的平方根 以下是 C 和 H 的固定值：C 为 50。H 为 30 . D 是变量，其值应以逗号分隔的顺序输入到您的程序中。示例让我们假设给程序以下逗号分隔的输入序列：100,150,180 程序的输出应该是：18,22,24
提示：如果收到的输出是十进制形式，则应四舍五入到最接近的值（例如，如果收到的输出为 26.0，则应打印为 26）应假定为控制台输入。
解决方案：
导入 数学 c = 50 h = 30 value = [] items = [ x for x in input (). split ( ',' )] for d in items : value . 附加（str（int（round（数学。sqrt （2 * c * float （ d ）/ h ） ）））） 打印（'，'。加入（值））
问题 7
2级
问题：编写一个程序，输入 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]]
提示：注意：如果向问题提供输入数据，则应假定它是逗号分隔形式的控制台输入。
解决方案：
input_str = input () dimensions = [ int ( x ) for x in input_str。split ( ',' )] rowNum =维度[ 0 ] colNum =维度[ 1 ] multilist = [[ 0 for col in range ( colNum )] for row in range ( rowNum )] 对于 范围内的行 （rowNum）： 对于 范围内的col （ colNum ）： 多列表[ row ][ col ] = row * col 打印（多列表）
问题 8
2级
问题：编写一个程序，接受逗号分隔的单词序列作为输入，并在按字母顺序排序后以逗号分隔的序列打印单词。假设向程序提供以下输入：without,hello,bag,world 那么，输出应该是：bag,hello,without,world
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
items = [ x for x in input (). 拆分（'，'）] 项目。sort () print ( ',' . join ( items ))
问题 9
2级
问题：编写一个程序，接受行序列作为输入，并在将句子中的所有字符大写后打印行。假设向程序提供以下输入： Hello world 熟能生巧 那么，输出应该是： HELLO WORLD PRACTICE MAKES PERFECT
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
lines = [] while True : s = input () if s : lines。append ( s.upper ( ) ) else : break ; 对于 行中的句子 ： 打印（句子）
问题 10
2级
问题：编写一个程序，该程序接受一系列空格分隔的单词作为输入，并在删除所有重复单词并按字母数字排序后打印单词。假设向程序提供了以下输入：hello world and practice make perfect and hello world again 那么，输出应该是：again and hello make perfect practice world
提示：如果向问题提供输入数据，则应假定它是控制台输入。我们使用 set container 自动删除重复数据，然后使用 sorted() 对数据进行排序。
解决方案：
s = input ( ) words = [ s中的单词 。split ( " " )] print ( " " . join ( sorted ( list ( set ( words )))))
问题 11
2级
问题：编写一个程序，它接受一系列逗号分隔的 4 位二进制数作为输入，然后检查它们是否能被 5 整除。可被 5 整除的数字将以逗号分隔的顺序打印。示例：0100,0011,1010,1001 那么输出应该是：1010 注意：假设数据是控制台输入的。
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
value = [] items = [ x for x in input (). split ( ',' )] for p in items : intp = int ( p , 2 ) if not intp % 5 : value。附加( p ) 打印（'，'。加入（值））
问题 12
2级
问题：编写一个程序，找出所有介于 1000 和 3000 之间的数字（都包括在内），使得该数字的每个数字都是偶数。获得的数字应以逗号分隔的顺序打印在一行上。
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
values = [] for i in range ( 1000 , 3001 ): s = str ( i ) if ( int ( s [ 0 ]) % 2 == 0 ) and ( int ( s [ 1 ]) % 2 == 0 )和( int ( s [ 2 ]) % 2 == 0 )和( int ( s [ 3 ]) % 2 == 0 ): 值。append ( s ) print ( "," . join ( values ))
问题 13
2级
问题：编写一个程序，接受一个句子并计算字母和数字的个数。假设向程序提供以下输入：hello world！123 那么，输出应该是：LETTERS 10 DIGITS 3
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
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 ( "LETTERS" , d [ "LETTERS"]) 打印（“数字”，d [ “数字” ]）
问题 14
2级
问题：编写一个程序，接受一个句子，计算大写字母和小写字母的个数。假设向程序提供以下输入：Hello world！然后，输出应该是： UPPER CASE 1 LOWER CASE 9
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
s = input () d = { "UPPER CASE" : 0 , "LOWER CASE" : 0 } for c in s : if c . isupper (): d [ "大写" ] += 1 elif c。islower (): d [ "LOWER CASE" ] += 1 else : pass print ( "UPPER CASE" , d ["大写" ]) 打印( "小写" , d [ "小写" ])
问题 15
2级
问题：编写一个程序，以给定数字作为 a 的值，计算 a+aa+aaa+aaaa 的值。假设向程序提供以下输入：9 那么，输出应该是：11106
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
a = 输入() 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 ) ) 打印( n1 + n2+ n3 + n4 )
问题 16
2级
问题：使用列表推导对列表中的每个奇数求平方。该列表由逗号分隔的数字序列输入。假设向程序提供以下输入：1,2,3,4,5,6,7,8,9 那么，输出应该是：1,3,5,7,9
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
values = input () numbers = [ x for x in values。split ( "," ) if int ( x ) % 2 != 0 ] print ( "," . join ( numbers ))
问题 17
2级
问题：编写一个程序，根据控制台输入的交易日志计算银行账户的净金额。事务日志格式如下： D 100 W 200
D 表示存款，W 表示取款。假设向程序提供以下输入： D 300 D 300 W 200 D 100 那么，输出应该是： 500
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
netAmount = 0 while True: 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)
Question 18
Level 3
Question: A website requires the users to input username and password to register. Write a program to check the validity of password input by users. Following are the criteria for checking the password:
- At least 1 letter between [a-z]
- At least 1 number between [0-9]
- At least 1 letter between [A-Z]
- At least 1 character from [$#@]
- Minimum length of transaction password: 6
- Maximum length of transaction password: 12 Your program should accept a sequence of comma separated passwords and will check them according to the above criteria. Passwords that match the criteria are to be printed, each separated by a comma. Example If the following passwords are given as input to the program: ABd1234@1,a F1#,2w3E*,2We3345 Then, the output of the program should be: ABd1234@1
Hints: In case of input data being supplied to the question, it should be assumed to be a console input.
Solutions:
import re value = [] 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 . 搜索（“[az]”，p）： 继续 不 重。_ 搜索( "[0-9]" , p ): 继续elif not re。搜索（“[AZ]”，p）： 继续elif not re。搜索( "[$#@]" , p ): 继续elif re。搜索（“\s”，p）： 继续否则： 传递值。附加( p） 打印（“，”。连接（值））
问题 19
3级
问题：您需要编写一个程序来按升序对 (name, age, height) 元组进行排序，其中 name 是字符串，age 和 height 是数字。元组由控制台输入。排序标准为： 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'), ('汤姆', '19', '80')]
提示：如果向问题提供输入数据，则应假定它是控制台输入。我们使用 itemgetter 来启用多个排序键。
解决方案：从算子导入itemgetter、attrgetter
l = [] while True : s = input () if not s : break l。附加（元组（s.split（“，” ））） 打印（排序（l，key = itemgetter（0，1，2）））_ _
问题 20
3级
问题：定义一个具有生成器的类，该生成器可以在给定范围 0 和 n 之间迭代可被 7 整除的数字。
提示：考虑使用产量
解决方案：
def putNumbers ( n ): i = 0 而 i < n : j = i i = i + 1 如果 j % 7 == 0 : 产量 j for i in reverse ( 100 ): 打印( i )
问题 21
3级
问题 机器人从原点 (0,0) 开始在平面上移动。机器人可以按照给定的步数向上、向下、向左和向右移动。机器人运动轨迹如下： UP 5 DOWN 3 LEFT 3 RIGHT 2 ¡ 方向后面的数字为步数。请编写一个程序来计算经过一系列运动后到当前位置与原点的距离。如果距离是浮点数，则只打印最接近的整数。示例：如果给定以下元组作为程序的输入： UP 5 DOWN 3 LEFT 3 RIGHT 2 那么程序的输出应该是： 2
提示：如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
import math pos = [ 0 , 0 ] while True : s = input () if not s : break movement = s。拆分（“”） 方向 = 运动[ 0 ] 步 = int（运动[ 1 ]） 如果 方向== “向上”： pos [ 0 ]+=步 elif 方向== "DOWN" : pos [ 0 ] -=步 elif 方向== "LEFT" : pos [ 1 ] -=步 elif 方向== "RIGHT" : pos [ 1 ] +=其他步 ： 经过 print ( int ( round ( math . sqrt ( pos [ 1 ] ** 2 + pos [ 0 ] ** 2 ))))
问题 22
3级
问题：编写一个程序来计算输入中单词的频率。输出应在按字母数字对键进行排序后输出。假设向程序提供了以下输入：Python 新手还是在 Python 2 和 Python 3 之间进行选择？读取 Python 2 或 Python 3。然后，输出应为： 2:2 3.:1 3?:1 New:1 Python:5 Read:1 and:1 between:1 choose:1 or:2 to:1
提示 如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
freq = {} # 文本 行中单词的频率 = input () for word in line . 拆分（）： 频率[字] = 频率。得到(字, 0 ) + 1 词 = 频率。键（） 字。排序（） 对于 w 字： print ( "%s:%d" % ( w , freq [ w ] ))
问题 23
1级
问题：编写一个计算数字平方值的方法
提示：使用 ** 运算符
解决方案：
def square ( num ): 返回 num ** 2 打印（正方形（2）） 打印（正方形（3））
问题 24
1级
问题：
Python内置了很多函数，如果你不知道怎么用，可以上网看文档或者找一些书。但是 Python 对每个内置函数都有一个内置的文档函数。
请编写程序打印一些Python内置函数文档，如abs()、int()、raw_input()
并为自己的函数添加文档提示：内置的文档方法是doc
解决方案：
打印( abs . __doc__ ) 打印( int . __doc__ ) 打印(输入. __doc__ ) def square ( num ): '''返回输入数字的平方值。 输入数字必须是整数。 '''返回数字** 2 打印（正方形（2）） 打印（正方形。__ doc__）
问题 25
1级
问题：定义一个类，它有一个类参数和一个相同的实例参数。
提示：定义一个实例参数，需要在init方法中添加你可以用construct参数初始化一个对象或稍后设置值
解决方案：
class Person : # 定义类参数 "name" name = "Person" def __init__ ( self , name = None ): # self.name 是实例参数 self。名字 = 名字 jeffrey = Person ( "Jeffrey" ) print ( "%s name is %s" % ( Person . name , jeffrey . name )) 尼科 = 人（） 尼科。name = "Nico" print ( "%s name is %s" % ( Person . name , nico . name ))
问题 26：
定义一个可以计算两个数字之和的函数。
提示：用两个数字作为参数定义一个函数。您可以在函数中计算总和并返回值。
解决方案
def SumFunction ( number1 , number2 ): 返回 number1 + number2 打印( SumFunction ( 1 , 2 ))
问题 27
定义一个可以将整数转换为字符串并在控制台打印的函数。
提示：
使用 str() 将数字转换为字符串。
解决方案
def printValue ( n ): 打印( str ( n )) 打印值( 3 )
问题 28
定义一个可以将整数转换为字符串并在控制台打印的函数。
提示：
使用 str() 将数字转换为字符串。
解决方案
def printValue ( n ): 打印( str ( n )) 打印值( 3 )
问题 29
定义一个函数，它可以接收两个字符串形式的整数并计算它们的总和，然后在控制台中打印出来。
提示：
使用 int() 将字符串转换为整数。
解决方案
def printValue ( s1 , s2 ): 打印( int ( s1 ) + int ( s2 )) 打印值（“3”，“4”）
问题 30
定义一个可以接受两个字符串作为输入并将它们连接起来然后在控制台中打印的函数。
提示：
使用 + 连接字符串
解决方案
def printValue ( s1 , s2 ): 打印( s1 + s2 ) 打印值（“3”，“4”）#34
问题 31
定义一个可以接受两个字符串作为输入的函数，并在控制台中打印最大长度的字符串。如果两个字符串的长度相同，则该函数应逐行打印所有 l 个字符串。
提示：
使用 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 ( "一" , "三" )
问题 32
定义一个可以接受整数作为输入的函数，如果数字是偶数，则打印“It is an even number”，否则打印“It is anodd number”。
提示：
使用 % 运算符检查数字是偶数还是奇数。
解决方案
def checkValue ( n ): if n % 2 == 0 : print ( "It is an even number" ) else : print ( "It is anodd number" ) 校验值( 7 ) ### 问题 33 定义一个 可以 打印字典的函数， 其中 键是1到3之间的数字（都包括在内），值是键的平方。 提示： 使用 dict [ key ] = value 模式 将 条目放入 字典中。 _ 使用**运算符获得数字的幂。_ 解决方案 ` `` python def printDict (): d = dict () d [ 1 ] = 1 d [ 2 ] = 2 ** 2 d [ 3 ] = 3 ** 2 print ( d ) 打印字典()
问题 34
定义一个可以打印字典的函数，其中键是 1 到 20 之间的数字（都包括在内），值是键的平方。
提示：
使用 dict[key]=value 模式将条目放入字典中。使用 ** 运算符获取数字的幂。使用 range() 进行循环。
解决方案
def printDict (): d = dict () for i in range ( 1 , 21 ): d [ i ] = i ** 2 print ( d ) 打印字典()
问题 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。项目(): 打印( v ) 打印字典()
问题 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。键(): 打印( k ) 打印字典()
问题 37
定义一个函数，该函数可以生成和打印一个列表，其中的值是 1 到 20 之间的数字的平方（都包括在内）。
提示：
使用 ** 运算符获取数字的幂。使用 range() 进行循环。使用 list.append() 将值添加到列表中。
解决方案
def printList (): li = list () for i in range ( 1 , 21 ): li . 附加( i ** 2 ) 打印( li ) 打印列表()
问题 38
定义一个函数，它可以生成一个列表，其中的值是 1 到 20 之间的数字的平方（都包括在内）。然后该函数需要打印列表中的前 5 个元素。
提示：
使用 ** 运算符获取数字的幂。使用 range() 进行循环。使用 list.append() 将值添加到列表中。使用 [n1:n2] 对列表进行切片
解决方案
def printList (): li = list () for i in range ( 1 , 21 ): li . 附加（i ** 2） 打印（li [：5 ]） 打印列表()
问题 39
定义一个函数，它可以生成一个列表，其中的值是 1 到 20 之间的数字的平方（都包括在内）。然后该函数需要打印列表中的最后 5 个元素。
提示：
使用 ** 运算符获取数字的幂。使用 range() 进行循环。使用 list.append() 将值添加到列表中。使用 [n1:n2] 对列表进行切片
解决方案
def printList (): li = list () for i in range ( 1 , 21 ): li . 附加( i ** 2 ) 打印( li [ - 5 :]) 打印列表()
问题 40
定义一个函数，它可以生成一个列表，其中的值是 1 到 20 之间的数字的平方（都包括在内）。然后该函数需要打印除列表中前 5 个元素之外的所有值。
提示：
使用 ** 运算符获取数字的幂。使用 range() 进行循环。使用 list.append() 将值添加到列表中。使用 [n1:n2] 对列表进行切片
解决方案
def printList (): li = list () for i in range ( 1 , 21 ): li . 附加( i ** 2 ) 打印 li [ 5 :] 打印列表()
问题 41
定义一个函数，该函数可以生成和打印一个元组，其中值是 1 到 20 之间的数字的平方（都包括在内）。
提示：
使用 ** 运算符获取数字的幂。使用 range() 进行循环。使用 list.append() 将值添加到列表中。使用 tuple() 从列表中获取元组。
解决方案
def printTuple (): li = list () for i in range ( 1 , 21 ): li . 追加( i ** 2 ) 打印(元组( li )) 打印元组()
问题 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 :] 打印( tp1 ) 打印( tp2 )
问题 43
编写一个程序来生成并打印另一个元组，其值为给定元组 (1,2,3,4,5,6,7,8,9,10) 中的偶数。
提示：
使用“for”来迭代元组 使用 tuple() 从列表中生成一个元组。
解决方案
tp = ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ) li = list () for i in tp : if tp [ i ] % 2 == 0 : li。附加（tp [ i ]） tp2 =元组( li ) 打印( tp2 )
问题 44
编写一个接受字符串作为输入的程序，如果字符串是“yes”或“YES”或“Yes”，则打印“Yes”，否则打印“No”。
提示：
使用 if 语句判断条件。
解决方案
s = raw_input () if s == "yes" or s == "YES" or s == "Yes" : print "Yes" else : print "No"
问题 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 = 过滤器( lambda x : x % 2 == 0 , li ) 打印( evenNumbers )
问题 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 )
问题 47
编写一个程序，它可以 map() 和 filter() 创建一个列表，其元素是 [1,2,3,4,5,6,7,8,9,10] 中的偶数平方。
提示 使用 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 )) 打印（偶数）
问题 48
编写一个程序，它可以 filter() 来创建一个列表，其元素是 1 到 20 之间的偶数（都包括在内）。
提示：
使用 filter() 过滤列表的元素。使用 lambda 定义匿名函数。
解决方案
evenNumbers = filter ( lambda x : x % 2 == 0 , range ( 1 , 21 )) 打印( evenNumbers )
问题 49
编写一个程序，它可以 map() 创建一个列表，其元素是 1 到 20 之间的数字的平方（都包括在内）。
提示 使用 map() 生成列表。使用 lambda 定义匿名函数。
解决方案
squaredNumbers = map ( lambda x : x ** 2 , range ( 1 , 21 )) 打印( squaredNumbers )
问题 50
定义一个名为 American 的类，它有一个名为 printNationality 的静态方法。
提示：使用@staticmethod 装饰器来定义类的静态方法。
解决方案
class American ( object ): @ staticmethod def printNationality (): print ( "America" ) anAmerican = American () anAmerican。printNationality () 美国。打印国籍()
问题 51
定义一个名为 American 的类及其子类 NewYorker。
提示：
使用 class Subclass(ParentClass) 来定义一个子类。
解决方案：
美国类（对象）： 通过 类 NewYorker（美国）： 通过 anAmerican = American () aNewYorker = NewYorker () print ( anAmerican ) print ( aNewYorker )
问题 52
定义一个名为 Circle 的类，该类可以由半径构造。Circle 类有一个可以计算面积的方法。
提示：
使用 def methodName(self) 定义一个方法。
解决方案：
类 Circle ( object ): def __init__ ( self , r ): self。半径 = r def area ( self ): 返回 self。半径** 2 * 3.14 aCircle = Circle ( 2 ) 打印 aCircle。面积()
问题 53
定义一个名为 Rectangle 的类，它可以由长度和宽度构成。Rectangle 类有一个可以计算面积的方法。
提示：
使用 def methodName(self) 定义一个方法。
解决方案：
类 Rectangle ( object ): def __init__ ( self , l , w ): self。长度 = l 自我。宽度 = w def area ( self ): 返回 self。长度*自我。宽度 aRectangle = Rectangle ( 2 , 10 ) 打印( aRectangle . area ())
问题 54
定义一个名为 Shape 的类及其子类 Square。Square 类有一个以长度为参数的 init 函数。这两个类都有一个 area 函数，可以打印默认情况下 Shape 的面积为 0 的形状的面积。
提示：
要覆盖超类中的方法，我们可以在超类中定义一个同名的方法。
解决方案：
类 形状（对象）： 定义__init __（自我）： 通过 def 区域( self ): 返回 0 类 Square ( Shape ): def __init__ ( self , l ): Shape。__init__（自我） 自我。长度 = l def area ( self ): 返回 self。长度*自我。长度 aSquare = Square ( 3 ) 打印( aSquare . area ())
问题 55
请引发 RuntimeError 异常。
提示：
使用 raise() 引发异常。
解决方案：
引发 RuntimeError ( '出了点问题' )
问题 56
编写一个函数来计算 5/0 并使用 try/except 来捕获异常。
提示：
使用 try/except 捕获异常。
解决方案：
def throws (): 返回 5 / 0 try : throws () except ZeroDivisionError : print ( "除以零！" ) except Exception , err : print ( 'Caught an exception' ) finally : print ( 'In finally block for cleanup' )
问题 57
定义一个自定义异常类，它将字符串消息作为属性。
提示：
要定义自定义异常，我们需要定义一个继承自 Exception 的类。
解决方案：
class MyError ( Exception ): """我自己的异常类 属性： msg -- 错误解释 """ def __init__ ( self , msg ): self。味精 = 味精 错误 = MyError ( “出错了” )
问题 58
假设我们有一些“ username@companyname.com ”格式的电子邮件地址，请编写程序打印给定电子邮件地址的用户名。用户名和公司名均仅由字母组成。
示例：如果将以下电子邮件地址作为程序的输入提供：
john@google.com
那么，程序的输出应该是：
约翰
如果向问题提供输入数据，则应假定它是控制台输入。
提示：
使用 \w 匹配字母。
解决方案：
重新 导入emailAddress = raw_input () pat2 = "(\w+)@((\w+\.)+(com))" r2 = re . 匹配（pat2，emailAddress） 打印（r2。组（1））
问题 59
假设我们有一些“ username@companyname.com ”格式的电子邮件地址，请编写程序打印给定电子邮件地址的公司名称。用户名和公司名均仅由字母组成。
示例：如果将以下电子邮件地址作为程序的输入提供：
john@google.com
那么，程序的输出应该是：
谷歌
如果向问题提供输入数据，则应假定它是控制台输入。
提示：
使用 \w 匹配字母。
解决方案：
导入 重新 emailAddress = raw_input () pat2 = "(\w+)@(\w+)\.(com)" r2 = re。匹配（pat2，emailAddress） 打印（r2。组（2））
问题 60
编写一个程序，接受由空格分隔的单词序列作为输入，以打印仅由数字组成的单词。
示例：如果将以下单词作为程序的输入给出：
2 只猫和 3 只狗。
那么，程序的输出应该是：
['2', '3']
如果向问题提供输入数据，则应假定它是控制台输入。
提示：
使用 re.findall() 使用正则表达式查找所有子字符串。
解决方案：
导入 re s = raw_input () print ( re . findall ( "\d+" , s ))
问题 61
打印一个 unicode 字符串“hello world”。
提示：
使用 u'strings' 格式定义 unicode 字符串。
解决方案：
unicodeString = u"你好世界！" 打印（unicodeString）
问题 62
编写一个程序来读取 ASCII 字符串并将其转换为 utf-8 编码的 unicode 字符串。
提示：
使用 unicode() 函数进行转换。
解决方案：
s = 输入() u = unicode ( s , "utf-8" ) 打印( u )
问题 63
写一个特殊的注释来表明一个 Python 源代码文件是 unicode 格式的。
提示：
解决方案：
# -*- 编码：utf-8 -*- #----------------------------------------#
问题 64
编写一个程序来计算 1/2+2/3+3/4+...+n/n+1，其中给定的 n 输入来自控制台 (n>0)。
示例：如果给定以下 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 )
问题 65
编写程序计算：
当 n>0 且 f(0)=1 时，f(n)=f(n-1)+100
通过控制台（n>0）输入给定的 n。
示例：如果给定以下 n 作为程序的输入：
5
那么，程序的输出应该是：
500
如果向问题提供输入数据，则应假定它是控制台输入。
提示：我们可以在 Python 中定义递归函数。
解决方案：
def f ( n ): if n == 0 : return 0 else : return f ( n - 1 ) + 100 n = int (输入()) 打印( f ( n ))
问题 66
斐波那契数列是根据以下公式计算的：
f(n)=0 如果 n=0 f(n)=1 如果 n=1 f(n)=f(n-1)+f(n-2) 如果 n>1
请编写一个程序，通过控制台输入给定的 n 来计算 f(n) 的值。
示例：如果给定以下 n 作为程序的输入：
7
那么，程序的输出应该是：
13
如果向问题提供输入数据，则应假定它是控制台输入。
提示：我们可以在 Python 中定义递归函数。
解决方案：
def f ( n ): 如果 n == 0 :返回 0 elif n == 1 :返回 1 else :返回 f ( n - 1 ) + f ( n - 2 ) n = int (输入()) 打印( f ( n ))
问题 67
斐波那契数列是根据以下公式计算的：
f(n)=0 如果 n=0 f(n)=1 如果 n=1 f(n)=f(n-1)+f(n-2) 如果 n>1
请使用列表理解编写一个程序，以逗号分隔的形式打印斐波那契数列，并通过控制台输入给定的 n。
示例：如果给定以下 n 作为程序的输入：
7
那么，程序的输出应该是：
0,1,1,2,3,5,8,13
提示：我们可以在 Python 中定义递归函数。使用列表推导从现有列表生成列表。使用 string.join() 加入字符串列表。
如果向问题提供输入数据，则应假定它是控制台输入。
解决方案：
def f ( n ): 如果 n == 0 :返回 0 elif n == 1 :返回 1 else :返回 f ( n - 1 ) + f ( n - 2 ) n = int ( input ()) values = [ str ( f ( x )) for x in range ( 0 , n + 1 )] print ( "," . join ( values ))
问题 68
请使用生成器编写程序，以逗号分隔的形式打印 0 和 n 之间的偶数，而 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。附加（str（i）） 打印（“，”。连接（值））
问题 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。附加（str（i）） 打印（“，”。连接（值））
问题 70
请编写断言语句来验证列表 [2,4,6,8] 中的每个数字是否为偶数。
提示：使用“断言表达式”进行断言。
解决方案：
li = [ 2 , 4 , 6 , 8 ] for i in li : 断言 i % 2 == 0
问题 71
请编写一个从控制台接受基本数学表达式的程序并打印评估结果。
示例：如果将以下字符串作为程序的输入给出：
35+3
那么，程序的输出应该是：
38
提示：使用 eval() 来计算表达式。
解决方案：
表达式 = raw_input () 打印( eval (表达式))
问题 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 )) 如果 li [中] ==元素： 索引 = 中间 elif li [中间] >元素： 顶部 = 中间- 1 其他： 底部 = 中间+ 1 回报 指数 li = [ 2 , 5 , 7 , 9 , 11 , 17 , 222 ] 打印( bin_search ( li , 11 )) 打印( bin_search ( li , 12 ))
问题 73
请编写一个二分搜索函数，在排序列表中搜索项目。该函数应返回要在列表中搜索的元素的索引。
提示：使用 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 )) 如果 li [中] ==元素： 索引 = 中间 elif li [中间] >元素： 顶部 = 中间- 1 其他： 底部 = 中间+ 1 回报 指数 li = [ 2 , 5 , 7 , 9 , 11 , 17 , 222 ] 打印( bin_search ( li , 11 )) 打印( bin_search ( li , 12 ))
问题 74
请使用 Python 数学模块生成一个随机浮点数，其值在 10 到 100 之间。
提示：使用 random.random() 在 [0,1] 中生成随机浮点数。
解决方案：
导入 随机 打印（随机。随机（）* 100）
问题 75
请使用 Python 数学模块生成一个随机浮点数，其值在 5 到 95 之间。
提示：使用 random.random() 在 [0,1] 中生成随机浮点数。
解决方案：
导入 随机 打印（随机。随机（）* 100 - 5）
问题 76
请编写一个程序，使用随机模块和列表推导式输出 0 到 10 之间的随机偶数。
提示：对列表中的随机元素使用 random.choice()。
解决方案：
导入 随机 打印（随机。选择（[ i for i in range ( 11 ) if i % 2 == 0 ])）
问题 77
请编写一个程序，使用随机模块和列表推导输出一个可被 5 和 7 整除的随机数，介于 0 和 10 之间。
提示：对列表中的随机元素使用 random.choice()。
解决方案：
导入 随机 打印（随机。选择（[ i for i in range ( 201 ) if i % 5 == 0 and i % 7 == 0 ])）
问题 78
请编写一个程序来生成一个包含 5 个介于 100 和 200 之间的随机数的列表。
提示：使用 random.sample() 生成随机值列表。
解决方案：
导入 随机 打印（随机。样本（范围（100），5））
问题 79
请编写一个程序，随机生成一个包含 100 到 200 之间的 5 个偶数的列表。
提示：使用 random.sample() 生成随机值列表。
解决方案：
导入 随机 打印（随机。样本（[ i for i in range ( 100 , 201 ) if i % 2 == 0 ], 5 )）
问题 80
请编写一个程序，随机生成一个包含 5 个数字的列表，这些数字可以被 5 和 7 整除，介于 1 和 1000 之间。
提示：使用 random.sample() 生成随机值列表。
解决方案：
导入 随机 打印（随机。样本（[ i for i in range ( 1 , 1001 ) if i % 5 == 0 and i % 7 == 0 ], 5 )）
问题 81
请编写一个程序来随机打印 7 到 15 之间的整数。
提示：对给定范围内的随机整数使用 random.randrange()。
解决方案：
导入 随机 打印( random .randrange ( 7 , 16 ) )
问题 82
请编写一个程序来压缩和解压字符串“hello world!hello world!hello world!hello world!”。
提示：使用 zlib.compress() 和 zlib.decompress() 来压缩和解压一个字符串。
解决方案：
import zlib s = b'你好世界！你好世界！你好世界！你好世界！' t = zlib。压缩( s ) 打印( t ) 打印( zlib .解压缩( t ))
问题 83
请编写程序打印“1+1”执行100次的运行时间。
提示：使用 timeit() 函数来测量运行时间。
解决方案：
from timeit import Timer t = Timer ( "for i in range(100):1+1" ) print ( t .timeit ( ))
问题 84
请编写一个程序来打乱和打印列表 [3,6,7,8]。
提示：使用 shuffle() 函数对列表进行随机播放。
解决方案：
from random import shuffle li = [ 3 , 6 , 7 , 8 ] shuffle ( li ) print ( li )
问题 85
请编写一个程序来打乱和打印列表 [3,6,7,8]。
提示：使用 shuffle() 函数对列表进行随机播放。
解决方案：
from random import shuffle li = [ 3 , 6 , 7 , 8 ] shuffle ( li ) print ( li )
问题 86
请编写一个程序来生成所有句子，其中主语在 ["I", "You"] 中，动词在 ["Play", "Love"] 中，宾语在 ["Hockey","Football"] 中。
提示：使用 list[index] 表示法从列表中获取元素。
解决方案：
主题= [ "I" , "You" ] 动词= [ "Play" , "Love" ] 对象= [ "Hockey" , "Football" ] for i in range ( len ( subjects )): for j in range ( len（动词））： 对于 范围内的k （len（对象））： 句子= “%s %s %s。” %（主语[ i ]，动词[ j ]，宾语[ k ]） 打印（句子）
问题 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)
问题 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)
问题 89
通过使用列表推导，请编写一个程序，在删除 [12,24,35,70,88,120,155] 中的第 0、2、4、6 个数字后打印列表。
提示：使用列表推导从列表中删除一堆元素。使用 enumerate() 获取 (index, value) 元组。
解决方案：
li = [ 12 , 24 , 35 , 70 , 88 , 120 , 155 ] li = [ x for ( i , x ) in enumerate ( li ) if i % 2 != 0 ] print ( li )
问题 90
通过使用列表推导，请编写一个程序生成一个每个元素为 0的 3 5 8 3D 数组。
提示：使用列表推导来创建一个数组。
解决方案：
array = [[ [0 for col in range(8)] for col in range(5)] for row in range(3)] print(array)
问题 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 )] 打印( li )
问题 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 )
问题 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 (李)
问题 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 . 添加（项目） 新利。附加（项目） 返回 新利 li = [ 12 , 24 , 35 , 24 , 88 , 120 , 155 , 88 , 120 , 155 ] 打印( removeDuplicate ( li ))
问题 95
定义一个 Person 类及其两个子类：Male 和 Female。所有类都有一个方法“getGender”，它可以为男性类打印“男性”，为女性类打印“女性”。
提示：使用 Subclass(Parentclass) 定义子类。
解决方案：
类 人（对象）： def getGender（自我）： 返回 “未知” 男类（人）： def getGender（自我）： 返回 “男” 类 女性（人）： def getGender（自我）： 返回 “女性” aMale = 男() aFemale = 女() 打印( aMale .getGender ( )) 打印( aFemale .getGender ( ) )
问题 96
请编写一个程序，计算并打印控制台输入的字符串中每个字符的个数。
示例：如果将以下字符串作为程序的输入给出：
abcdefgabc
那么，程序的输出应该是：
a,2 c,2 b,2 e,1 d,1 g,1 f,1
提示：使用 dict 存储键/值对。使用 dict.get() 方法查找具有默认值的键。
解决方案：
dic = {} s = raw_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 ()]))
问题 97
请编写一个从控制台接受字符串并以相反顺序打印的程序。
示例：如果将以下字符串作为程序的输入给出：
起来投票先生
那么，程序的输出应该是：
ris etov ot esir
提示：使用 list[::-1] 以相反的顺序迭代列表。
解决方案：
s = raw_input () s = s [:: - 1 ] 打印( s )
问题 98
请编写一个从控制台接受字符串并打印具有偶数索引的字符的程序。
示例：如果将以下字符串作为程序的输入给出：
H1e2l3l4o5w6o7r8l9d
那么，程序的输出应该是：
你好世界
提示：使用 list[::2] 按步骤 2 迭代列表。
解决方案：
s = raw_input () s = s [:: 2 ] 打印( s )
问题 99
请编写一个打印 [1,2,3] 的所有排列的程序
提示：使用 itertools.permutations() 获取列表的排列。
解决方案：
导入 itertools print ( list ( itertools . permutations ([ 1 , 2 , 3 ])))
问题 100
编写一个程序来解决一个经典的中国古代谜题：我们数一个农场的鸡和兔子有 35 个头和 94 个腿。我们有多少只兔子和多少只鸡？
提示：使用 for 循环迭代所有可能的解决方案。
解决方案：
def solve ( numheads , numlegs ): ns = '没有解决方案！' 对于 范围内的i ( numheads + 1 ): j = numheads - i if 2 * i + 4 * j == numlegs : return i , j return ns , ns numheads = 35 numlegs = 94个 解决方案= solve ( numheads , numlegs ) 打印( solutions )
这篇关于大厂Python招聘面试100题的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
