python3基础入门巩固94题--源自github_python程序设计题库 github-CSDN博客

本文链接：https://blog.csdn.net/weixin_43896364/article/details/120194190

前言：本篇文章适合刚入门python看完视频感觉自己还是不会敲的同学学习，都比较简单，代码量很少；这些题目题分为三个等级，但是我做到25题之后就没有分级了，后面的分级是我自己分的。

github源地址Python-programming-exercises/100+ Python challenging programming exercises.txt at master · zhiwehu/Python-programming-exercises · GitHub100+ Python challenging programming exercises. Contribute to zhiwehu/Python-programming-exercises development by creating an account on GitHub.https://github.com/zhiwehu/Python-programming-exercises/blob/master/100+%20Python%20challenging%20programming%20exercises.txt

level1:

1、写一个程序，找出[2000,3200]中所有能被7整除但不是5的倍数的数，结果以逗号分隔打印在一行中。--9.10

# 解1
num = []
for i in range(2000, 3201):
    if i % 7 == 0:
        if i % 5 != 0:
            num.append(i)
print(num)

# 解2
num = []
for i in range(2000, 3201):
    if (i%7 == 0) and (i%5 != 0):
        num.append(str(i))
print(",".join(num))

2、编写一个程序，可以计算给定数的阶乘。结果应该以逗号分隔的序列打印在一行上。（n的阶乘：nx(n-1)x...x1）

# 解1
i = int(input("input an integer:"))
sum = 1
if i <= 0:
    print("Invalid Input!")
    exit()
else:
    while True:
        if i > 0:
            sum = sum * i
            i -= 1
        else:
            break
    print(sum)

# 解2 使用递归，简直不要太方便
def fact(x):
    if x == 0:
        return 1
    return x*fact(x-1)

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}）

# 解1
dict = {}
i = int(input())
sum = 1
for num in range(1, i+1):
    sum = num * num
    dict[num] = sum
print(dict)

# 解2
dict = {}
num = int(input())
i = 1
sum = 1
while i <= num:
    sum = i*i
    dict[i] = sum
    i += 1
print(dict)

# 解3
dict = dict()
n = int(input())
for i in range(1, n+1):
    dict[i] = i*i
print(dict)

4、编写一个程序，从控制台接收逗号分隔的数字序列，并生成一个列表和包含每个数字的元组。

# 解1
num = input().split(",")
print(num)
tuples = tuple(num)
print(tuples)

# 解2 差球不多
values=input()
l=values.split(",")
t=tuple(l)
print(l)
print(t)

5、定义一个至少有两个方法的类:1.getString方法:获取控制台输入的字符串；2.printString方法:将输入字符串转换为大写字符串并打印出来，写一个简单的测试函数来测试类方法

class simpleClass():

    def __init__(self):
        self.word = ""

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

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


test = simpleClass()
test.getString()
test.printString()

level2

6、根据下面的公式编写一个程序：Q =√[(2 * C * D)/H]，其中C=50，H=30，D为键盘输入的数字；对于输出，如果接收到的输出是小数形式，则应该四舍五入到最接近的值

# 解1
d = input("input an Integer:").split(",")
output = []
for q in range(0, len(d)):
    var = int(d[q])
    temp = ((2 * 50 * var) / 30) ** 0.5
    result = round(temp)
    output.append(result)
print(",".join(str(i) for i in output))  
# 因为join处理的是字符串，所以需要将所有的元素都转换为字符串

# 解2 使用列表解析创建的输入列表，其实不用也行
import math
c,h,value = 50,30,[]
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))

# 解3 
import math

c, h, value = 50, 30, []
items = input().split(",")
for d in items:
    # value.append(str(int(round(math.sqrt((2*c*float(d))/h)))))
    result = round(math.sqrt((2 * c * int(d)) / h))
    value.append(result)  # 此时的value列表中的元素都是int类型，不能直接使用join转换

# print(type(value[0]))
print(",".join(str(i) for i in value))

7、写一个程序，取两个数字，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
recv = [int(i) for i in input().split(",")]  # 直接将输入列表转为int型
num = []
for i in range(recv[0]):
    num.append([])  # 添加三个空列表
    for j in range(recv[1]):
        num[i].append(i*j)  # 在每个空列表中写入五个值
print(num)

# 解2 我终于有一次代码写的比这个项目的官解少了233，其实我的和它差球不多
input_str = input()
dimensions = [int(x) for x in input_str]
rowNum = dimensions[0]
colNum = dimensions[1]
# 下面涉及到一个列表解析的新用法，快速创建了一个填满0的二维列表并且用参数定义了该列表的行和列
mutilist = [[o for col in range(colNum)] for row in range(rowNum)]

for row in range(rowNum):
    for col in range(colNum):
        mutilist[row][col] = row*col

8、输入几个以逗号为分隔的单词，按字母顺序排序后以逗号为分隔输出--9.10

# 解1
input_str = input().split(",")
new_str = sorted(input_str)
print(",".join(new_str))

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

9、编写一个程序，接受一系列行作为输入，并输出后面的行，将句子中的所有字符大写，示例输入：

Hello world

Practice makes perfect

输出：

HELLO WORLD
PRACTICE MAKES PERFECT

# 解1
stop = " "
items = []
for i in iter(input, stop):  # 使用了一个叠加器将空格替换掉回车，运行程序
    items.append(i.upper())
print("\n".join(items))

# 解2 不用迭代器，写一个死循环一直输入，按两下回车就会结束输入。。。
lines = []
while True:
    items = input()
    if items:
        lines.append(items.upper())
    else:
        break

for sentence in lines:
    print(sentence)

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

# 解1
sentence = input().split(" ")
items = list(set(sentence))
print(" ".join(sorted(items)))

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

# 解3 直接两行一步到位，不知道为啥原解要新建一个列表
s = input().split(" ")
print(' '.join(sorted(list(set(s)))))

11、编写一个程序，接受一个由逗号分隔的4位二进制数序列作为输入，然后检查它们是否能被5整除。能被5整除的数字将以逗号分隔的序列打印。
示例输入：
0100,0011,1010,1001
输出：
1010

# 解1
binary = input().split(",")
items = []
for i in binary:
    tmp = int(i, 2)
    if tmp % 5 == 0:
        items.append(bin(tmp))

print(",".join(str(x[2:]) for x in items))

# 解2
value = []
items = [x for x in input().split(',')]
for p in items:
    intp = int(p, 2)
    if not intp %5 :
        value.append(p)

print(','.join(value))

12、写一个程序，找出[1000,3000]之间的所有这些数字，使数字的每一位都是偶数。输出的数字以逗号为分隔

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

# 解2
values = []
for i in range(1000, 3001):
    even_digits, s = 0, str(i)
    """
    map函数的原型是map(function, iterable, …)，它的返回结果是一个列表。
    参数function传的是一个函数名，可以是python内置的，也可以是自定义的。
    参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。
    """
    for digit in list(map(int, s)):
       if digit % 2 != 0:
           break
       else:
           even_digits += 1
    if even_digits == 4:
        values.append(s)  
print(','.join(values))

# 解3 看完解2自己改写的，没弄明白解2中那个s的意义
value = []
for i in range(1000, 3001):
    even_digit, s = 0, str(i)
    for digit in list(map(int, s)):
        if digit % 2 != 0:
            break
        else:
            even_digit += 1
            if even_digit == 4:
                value.append(str(i))
print(",".join(value))

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

示例输入：hello world! 123
输出：
LETTERS 10
DIGITS 3

# 解1
input_str = input()
letters = 0
digits = 0
for i in input_str:
    tmp = ord(i)
    if (65 <= tmp <= 90) or (97 <= tmp <= 122):
        letters += 1
    if 30 <= tmp <= 39:
        digits += 1

print(f"LETTERS {letters}")
print(f"DIGITS {digits}")

# 解2 python2写的 还用到了字典，写的比我的好那是必然的
s = raw_input()
d={"DIGITS":0, "LETTERS":0}  # 使用字典的键值对记录个数
for c in s:
    if c.isdigit():  # 使用isdigit判断是否为数字 
        d["DIGITS"]+=1
    elif c.isalpha():  # 使用isalpha判断是否为字母
        d["LETTERS"]+=1
    else:
        pass

print "LETTERS", d["LETTERS"]
print "DIGITS", d["DIGITS"]

# 解3 我改了个python3的 区别不大
input_str = input()
d = {'LETTERS': 0, 'DIGITS': 0}
for i in input_str:
    if i.isalpha():
        d['LETTERS'] += 1
    if i.isdigit():
        d['DIGITS'] += 1
    else:
        pass

print(f"LETTERS {d['LETTERS']}")
print(f"DIGITS {d['DIGITS']}")

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

示例输入：Hello world!，输出：
UPPER CASE 1
LOWER CASE 9

# 解1 我觉得跟上一题一样，按他的答案照葫芦画瓢了
input_str = input()
d = {'upper': 0, 'lower': 0}
for i in input_str:
    if i.isupper():
        d['upper'] += 1
    if i.islower():
        d['lower'] += 1
    else:
        pass

print(f"UPPER CASE {d['upper']}")
print(f"LOWER CASE {d['lower']}")

# 解2 python2，确实一样
s = raw_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"]

15、编写一个程序，计算a+aa+aaa+aaaa的值，并将给定的数字作为a的值。
示例输入:9；输出：11106

# 解1 搞了半天，我又给他想的太复杂了
a = int(input())
value = []
tmp = 0
for i in range(0, 4):
    num = (a * (10 ** i))
    tmp = tmp + num
    value.append(tmp)

print(sum(value))

# 解2 这个解233，我没想到这部分用法   %s  string型  表示格式化一个对象为字符
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

# 解1 我写的这个，太不简洁了。。。。
value = []
li = [i for i in input().split(",")]
for i in li:
    if int(i) % 2 != 0:
        value.append(i)

print(",".join(value))

# 解2 好好看，好好学
values = input()
li = [i for i in values.split(",") if int(i) % 2 != 0]
print(",".join(li))

17、编写一个程序，根据控制台输入的交易日志计算银行账户的净金额。
示例输入：
D 300
D 300
W 200
D 100
输出：
500
D表示存款，W表示取款

# 解1
store = 0
while True:
    money = input().split(" ")
    if money[0] == 'D':
        store = store + int(money[1])
    elif money[0] == 'W':
        store = store - int(money[1])
    else:
        break
print(store)

# 解2 我自信了，我觉得我写的比他好
netAmount = 0
while True:
    s = raw_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

level3

升级了hxd！！！！

18、网站要求用户输入用户名和密码进行注册。写一个密码筛选器检查用户输入密码的有效性。以下是检查密码的标准：
1. [a-z]之间至少有一个字母
2. [0-9]之间至少有1个数字
1. [A-Z]之间至少有1个字母
3.[$#@]至少一个字符
4. 交易密码最小长度:6
5. 交易密码最大长度:

示例输入：12ABd1234@1,a F1；输出：ABd1234@1

# 解1 查了re模块，不会用，悲哀
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.search("[a-z]", p):  # 搜索密码中的a-z如果没有直接跳出循环
        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))

19、编写一个程序来对(名称、年龄、高度)元组进行排序，姓名为字符串，年龄和身高为数字，按升序排列。排序标准为：首先基于名称排序，然后根据年龄排序，最后按分数排序。

示例输入：

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

# 解1 结合网上搜到的模块自己写的代码无法很好的解决这个问题，并不能完美的按照每个元素的升序的排列，只是能输出题干要求的结果而已
from operator import itemgetter, attrgetter

values = []
while True:
    input_tuple = tuple(input().split(","))
    if input_tuple[0]:
        values.append(input_tuple)
    else:
        break

# 下面这个key后面的itemgetter方法中的0,1,2,它就对应着元组里的三个元素，刚好按照优先级name>age>height的顺序，但是这结果明显不是啊，name对上了，但age和height都对不上
print(sorted(values, key=itemgetter(0, 1, 2)))

# 解2 但还是官解更简洁，我不会活用if not语句
from operator import itemgetter, attrgetter

values = []
while True:
    s = input()
    if not s:
        break
    else:
        values.append(tuple(s.split(",")))
print(sorted(values, key=itemgetter(0, 1, 2)))

20、定义一个带有生成器的函数（带有 yield 的函数在 Python 中被称之为 generator（生成器）），该生成器可以迭代,这些数字能被7整除，在给定范围0到n之间。--9.11

# 解1 漂亮的解
# yield 是一个类似 return 的关键字，迭代一次遇到yield时就返回yield后面的值。重点是：下一次迭代时，从上一次迭代遇到的yield后面的代码开始执行



def putNumbers(n):
    i = 0
    while i < n:
        j = i
        i = i+1
        if j % 7 == 0:
            yield j  # 这里的yield可以理解为在这个循环里每次满足能够被7整除的j都会return那个j，就像是保存下来了一样


for i in putNumbers(100):
    print(i)

21、机器人从原点(0,0)开始在平面上运动。机器人可以按照给定的步骤向上、下、左、右移动。机器人的轨迹运动情况如下所示--9.12：

UP 5
DOWN 3
LEFT 3
RIGHT 2

方向后面的数字是步数。请编写一个程序来计算经过一系列运动后到当前位置和原点的距离。如果距离是一个浮点数，那么只输出与之最接近的整数。

示例输入：
UP 5
DOWN 3
LEFT 3
RIGHT 2
输出：
2

# 解1
x = 0
y = 0
while True:
    command = input().split(" ")
    if command[0] == 'UP':
        y = y + int(command[1])
    elif command[0] == 'DOWN':
        y = y - int(command[1])
    elif command[0] == 'LEFT':
        x = x - int(command[1])
    elif command[0] == 'RIGHT':
        x = x + int(command[1])
    else:
        break
result = (pow(x, 2) + pow(y, 2)) ** 0.5
print(round(result))

# 解2 我始终想不到if not。。。 它这里直接使用数组表示x，y了，不像我用了两个变量
import math
pos = [0, 0]
while True:
    input_str = input()
    if not input_str:
        break
    s = input_str.split(" ")
    direction = s[0]
    steps = int(s[1])
    if s[0] == 'UP':
        pos[0] += steps
    elif s[0] == 'DOWN':
        pos[0] -= steps
    elif s[0] == 'LEFT':
        pos[1] += steps
    elif s[0] == 'RIGHT':
        pos[1] -= steps
    else:
        pass
result = round(math.sqrt(pos[0]**2 + pos[1]**2))
print(result)

22、编写程序从输入中计算单词的频率。输出应该在按字母数字排序键之后输出。示例输入：
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

字典中的get方法：dict.get(key, default=None)key -- 字典中要查找的键。default -- 如果指定键的值不存在时，返回该默认值。

# 解1 没写出来
dic = {}
items = input().split()  # split()默认以空格为分隔读取
for word in items:
    dic[word] = dic.get(word, 0) + 1  # 字典中的get()函数，出现重复的键时其所对应的值加1

words = list(dic.keys())  # python3中sort()函数只能对列表使用，所以先要将字典中的键存在一个列表里，是keys，不是getkey
words.sort()

for i in words:
    print("%s:%d" % (i, dic[i]))  # 格式化输出，%s为通过str()字符串转换来格式化，%d为有符号的十进制整数

level1

降级了呀hxd -_-!

23、编写一种计算数字平方值的方法

# 解1
def square(n):
    return n ** 2


print(square(5))

24、Python有很多内置函数，如果你不知道如何使用它，你可以在网上阅读文件或找一些书。但是Python有一个存着每个内置函数说明的文档函数。请编写一个程序来打印一些Python内置函数文档，比如abs()， int()，input()--9.12

# 解1
print(help(sum))  # 打印的更为详细
print(sum.__doc__)  # 只包含在函数的开头使用三个引号""" """定义的文档字符串

25、定义一个类，该类有一个类变量和一个相同的实例变量；提示:定义一个实例参数，需要将其添加到__init__方法中可以使用构造参数初始化对象，也可以稍后设置值 --9.13

class Cat:
    name = "Cat"

    def __init__(self, name=None):  # 构造方法
        self.name = name


jeffrey = Cat("Jeffrey")
print("%s name is %s" % (Cat.name, jeffrey.name))

nico = Cat()
nico.name = "Nico"
print("%s name is %s" % (Cat.name, nico.name))

26、定义一个可以计算两个数之和的函数。（可能因为从这开始的下面几题太简单了，作者没给详细的分级和题目序号了hxd。。。应该都还是level1）

# 解1
def plus(x, y):
    return x + y


a = int(input())
b = int(input())
print(plus(a, b))

# 解2
def SumFunction(number1, number2):
	return number1+number2

print SumFunction(1,2)

27、定义一个函数，可以将整数转换为字符串，并在控制台中打印（是不是觉得一点挑战都没有hxd）。

# 解1
def intToStr(s):
    return str(s)


num = int(input())
print(intToStr(num))

# 解2 直接打印也行
def printValue(n):
	print str(n)

printValue(3)

28、定义一个函数，该函数可以接收两个字符串形式的整数并且计算它们的总和，然后在控制台打印出来。

# 解1 我猜官解是这样式儿的
def getStr(x, y):
    print(int(x) + int(y))


getStr('1', '2')

# 解2 很好
def printValue(s1,s2):
	print int(s1)+int(s2)

printValue("3","4") #7

29、定义一个函数，该函数可以接受两个字符串作为输入并打印控制台中最大长度的字符串。如果两个字符串有相同的长度，那么函数应该逐行打印所有字符串（稍微多了点东西）。

# 解1 写的有点笨，不知道咋样用一行代码输出两行字符串，参数格式化还是不会用
def printValue(x, y):
    if len(x) == len(y):
        print(x)
        print(y)
    elif len(x) > len(y):
        print(x)
    else:
        print(y)


printValue('hello', 'world')


# 解2 行吧，一样
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")

30、定义一个函数，它可以接受一个整数作为输入，如果是偶数则打印“这是一个偶数”，否则打印“这是一个奇数”。

# 解1 我为什么不直接else呢，害
def getValue(x):
    if x % 2 == 0:
        print("This is a even number")
    elif x % 2 != 0:
        print("This is a add number")


getValue(0)

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

checkValue(7)

31、定义一个函数，该函数可以打印一个键在[1,3]之间的字典，对应的值是键的平方（你觉得枯燥不，hxd？没有挑战性对吧）。

# 解1
def printDic():
    dic = {}
    for word in range(1, 4):
        dic[word] = word ** 2
    print(dic)


printDic()

# 解2 哈哈哈你看这官解写的
def printDict():
	d=dict()
	d[1]=1
	d[2]=2**2
	d[3]=3**2
	print d

32、定义一个函数，该函数可以打印一个键在[1,20]之间的字典，对应的值是键的平方（hxd去玩csgo挑战五杀吧，比这个刺激。。。）

# 解1 这。。。
def printDic():
    dic = {}
    for word in range(1, 21):
        dic[word] = word ** 2
    print(dic)


printDic()

33、定义一个函数，该函数可以打印一个键在[1,20]之间的字典，对应的值是键的平方，函数只输出值（是不是觉得它在侮辱你的智商，相信我hxd，娱乐一下吧）。

# 解1 这样输出的是列表里面包着一个元组，一行输出
def printDic():
    dic = {}
    for word in range(1, 21):
        dic[word] = word ** 2
    print(dic.values())


printDic()

# 解2 这个循环输出值，换行输出
def printDic():
    dic = {}
    for word in range(1, 21):
        dic[word] = word ** 2
    for (key, value) in dic.items():
        print(value)


printDic()

# 解3 这也行，输出跟2一样
def printDict():
	d=dict()
	for i in range(1,21):
		d[i]=i**2
	for k in d.keys():	
		print k
		

printDict()

34、定义一个函数，它可以生成和打印列表下标在[1,20]之间的数字的平方（题目稍微正常点了）。

# 解1 我用的下面这个字符串
# New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3 Nobody knows better than me 1


def printList(s):
    li = s.split(" ")
    value = []
    for items in li[0: 21]:  # 列表片段截取，包含开头，不包含结尾。
        if items.isdigit():
            result = int(items) ** 2
            value.append(result)
    print(value)


input_str = input()
printList(input_str)

# 解2 往下一看，小丑竟是我自己，英语不好，题干我翻译的有问题，其实就是计算1~20每个数字的平方然后添加到列表里就完事儿了，我非要把简单的事情搞得很复杂233，将错就错吧

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


printList()

35、定义一个函数，它可以生成一个在数字[1,20]之间值为的平方的列表。函数需要打印列表中的前5个元素。

# 解1
def printFive():
    li = []
    for i in range(1, 21):
        li.append(i ** 2)
    print(li[0: 5])  # 去掉0也行 


printFive()

36、定义一个函数，它可以生成一个在数字[1,20]之间值为的平方的列表。函数需要打印列表中的最后5个元素（唉。。。）。

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


getValue()

37、定义一个函数，它可以生成一个在数字[1,20]之间值为的平方的列表。函数需要打印列表中的除了前5个元素之后的所有数。

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


getValue()

38、定义一个函数，它可以在值所在的位置生成并打印一个元组，元组的内容是[1,20]之间数字的平方。

# 解1
def getTuple():
    li = []  # 元组不能直接添加元素啊，所以得先把数字装到列表里面去
    for i in range(1, 21):
        li.append(i ** 2)
    print(tuple(li))


getTuple()

39、对于给定的元组(1,2,3,4,5,6,7,8,9,10)，编写程序打印前一半值在一行，后一半值在另一行。

# 解1
tup = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(tup[0: 5])
print(tup[5: 10])

40、编写程序生成并打印另一个值为偶数的元组，给定元组中的数字(1,2,3,4,5,6,7,8,9,10)

# 解1 太没意思了，增加点难度
def getEven(li):
    items = []
    s = li.split(",")
    for i in s:
        if int(i) % 2 == 0:
            items.append(i)
    print(tuple(items))


input_str = input()
getEven(input_str)

# 解2 行吧，我又成小丑了，元组里的值虽然不能更改不能删除，但是可以拿出来做运算233，
# 但是我试着用python3写了一下，运行会报超出索引范围的错误
tp=(1,2,3,4,5,6,7,8,9,10)
li=list()
for i in tp:
	if tp[i]%2==0:
		li.append(tp[i])

tp2=tuple(li)
print tp2

41、编写一个程序，如果接收到的是一个字符串，如果字符串是“yes”或“YES”或“Yes”，则输出“Yes”，否则打印“No”（受不了了，太。。。）。

# 解1
s = input()
if s == 'yse' or s == 'YES' or s == 'Yes':
    print('Yes')
else:
    print('No')

42、编写一个程序，可以使用过滤函数（filter）过滤列表中的偶数。数组为[1,2,3,4,5,6,7,8,9,10]--9.13

# 解1
def is_even(n):
    return n % 2 == 0


li = filter(is_even, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])  # filter(function, iterable)    function -- 判断函数。   iterable -- 可迭代对象。
print(list(li))

# 解2 他这个看起来更简单,使用了匿名函数，简洁快速
li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evenNumbers = filter(lambda x: x % 2 == 0, li)
print(list(evenNumbers))

43、编写一个程序，该程序可以使用map()来生成一个列表，该列表的每个元素为[1,2,3,4,5,6,7,8,9,10]每个元组的平方。--9.14

map(function, iterable, ...) function -- 函数 iterable -- 一个或多个序列

# 解1 几行
def square(x):
    return x**2


result = map(square, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(result))

# 解2 或者一行
print(list(map(lambda x: x**2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])))

44、编写一个程序，可以使用map()和filter()来生成一个列表，其中的元素
是[1,2,3,4,5,6,7,8,9,10]中偶数的平方

# 解1
li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_list = filter(lambda x: x % 2 == 0, li)
final_list = list(map(lambda x: x ** 2, even_list))
print(final_list)

# 解2 俩是可以连着用的，搞忘求了
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(list(evenNumbers))

45、编写一个程序，使用filter()函数生成一个元素在[1,20]之间的偶数的列表

# 解1 233没有什么简单程序是python一行代码搞不定的（bushi
print(list(filter(lambda x: x % 2 == 0, [i for i in range(1, 21)])))

# 解2 过分了，官答好短（bushi
print(list(filter(lambda x: x % 2 == 0, range(1, 21))))

46、编写一个程序，该程序可以使用map()来生成一个列表，该列表的元素为1到20之间的数字的平方(包括两者)（我都懒的改机翻了233，这题写的，刷完这一百多道就去leecode见识见识什么叫编程题吧hxd）

# 解1
print(list(map(lambda x: x ** 2, range(1, 21))))

47、定义一个名为China的类，它有一个名为printNationality的静态方法

# 解1
class China:
    @staticmethod
    def printNationality():
        print("China")


chinese = China()
chinese.printNationality()

48、定义一个名为China的类及其子类Beijing。

# 解1
class China:
    def __init__(self):
        print("我是你爸爸")


class Beijing(China):
    def __init__(self):
        print("我是他儿子")


china = China()
beijing = Beijing()

# 解2
class American(object):
    pass

class NewYorker(American):
    pass

anAmerican = American()
aNewYorker = NewYorker()
print(anAmerican)
print(aNewYorker)

49、定义一个名为Circle的类，它可以通过一个半径来构造。Circle类有一个可以计算面积的方法。

# 解1 我这个写的很不好
class Circle:

    @staticmethod
    def area(r):
        print(3.14 * r ** 2)


circle = Circle()
circle.area(r=4)

# 解2
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()

50、定义一个名为Rectangle的类，它可以通过长度和宽度来构造。这个类有一个可以计算面积的方法

# 解1
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height


rec = Rectangle(5, 6)
print(rec.area())

51、定义一个名为Shape的类及其子类Square。Square类有一个以长度为参数的初始化函数。两个类都有一个area函数，该函数可以打印Shape的面积，其中shape的面积默认为0。

# 解1 我类与对象还是学的不够熟，这么简单还想了一会儿
class Shape:
    def __init__(self, length):
        self.length = length

    def area(self):
        return 0


class Square(Shape):
    def area(self):
        return self.length ** 2


shape = Shape(5)
print(shape.area())

square = Square(5)
print(square.area())

# 解2 官解看起来就很正规
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())

52、请抛出RuntimeError异常

# 解
raise RuntimeError('Something Wrong with that')

53、编写一个函数来计算5/0，并使用try/except来捕获异常

# 解1
def wrong():
    return 5 / 0


try:
    wrong()
except ZeroDivisionError:
    print('分母不得为0！')
else:
    print("正常执行")
finally:
    print('程序结束了！')

54、定义一个以字符串消息作为属性的自定义异常类。

# 解 创建一个类继承Exception就行了
class MyError(Exception):
    def __init__(self, string):
        self.string = string


error = MyError('hello')

55、假设我们有“username@companyname.com”格式的电子邮件地址，请编写程序打印给定电子邮件地址的用户名。用户的名字和公司名称只由字母组成。

# 解1 这个解不答题意；这题是考验使用正则表达式筛选指定字符串，我理解错了题意
username = input()
company_name = input()
for i in username, company_name:
    if i.isalpha():
        print(f"{username}@{company_name}.com")
    else:
        print("您输入的格式有误")

# 解2
import re

address = input()
check = "(\w+)@((\w+\.)+(com))"  # \w+表示字符串，这里使用括号分了两个组，group(0)表示全部规则，group(1)表示第一个括号里的规则，group(2)表示第二个括号里的规则
result = re.match(check, address)  # 使用re模块匹配规则，前面是规则，后面是输入字符串，不能弄反了
print(result.group(1))

56、假设我们有“username@companyname.com”格式的电子邮件地址，请编写程序打印给定电子邮件地址的公司名称。用户名和公司名都是由字母组成的。

# 解1 跟前面一题差不多，学会了
import re

address = input()
check = "(\w+)@(\w+)(\.+com)"
result = re.match(check, address)
print(result.group(2))

57、编写一个接受由空格分隔的单词序列的程序作为输入，只能打印由数字组成的字。示例输入：2 cats and 3 dogs
输出：['2','3']

# 解1 简单粗暴点 不想按他标准来了
li = []
for i in input():
    if i.isdigit():
        li.append(i)

print(",".join(str(i) for i in li))

# 解2 但是没想到我还是错的离谱了，人这个直接筛选出来就完事儿了，效率很高，又是正则
import re
result = input()
re.findall("\d+", result)  # \d+匹配数字，findall()函数找出规定类型的值存进列表

58、打印一个unicode字符串"hello world"。

# 解1 看起来没有变化233
print(u"hello world!")

59、编写程序读取ASCII字符并将其转换为utf-8编码的unicode字符串

# 解1 py2和py3在编码这部分有差异，不知道题目是不是这个意思
s = input()
result = s.encode('utf-8')
print(result)

# 解2 官解是这样
s = raw_input()
u = unicode( s ,"utf-8")
print u

60、写一个程序，计算1/2+2/3+3/4+…+n/n+1的值，n的值从控制台输入；示例输入：5；输出3.55。--9.14（题做的太慢了）

# 解1 开始写了个求和的时候没加括号。。。一直输出2
n = int(input())
s = 0
for i in range(1, n+1):
    s = s + (i / (i+1))
print(round(s, 2))

# 解2 官解用的浮点数
n=int(raw_input())
sum=0.0
for i in range(1,n+1):
    sum += float(float(i)/(i+1))
print sum

level2

61、定义一个函数f使得其满足f(n)=f(n-1)+100 when n>0 and f(0)=1。--9.15

示例输入：5
输出：501

# 解1
def f(n):
    if n > 0:
        return f(n-1) + 100
    if n == 0:
        return 1


s = int(input())
print(f(s))

# 解2
def f(n):
    if n==0:
        return 0
    else:
        return f(n-1)+100

n=int(raw_input())
print f(n)

62、斐波那契数列是基于以下公式计算的：
f(n)=0 if n=0
f(n)=1 if n=1
f(n)=f(n-1)+f(n-2) if n>1
请编写程序计算f(n)的值给定n输入通过控制台。示例输入：7；输出：13

# 解1
def f(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    elif n > 1:
        return(f(n-1) + f(n-2))


s = int(input())
print(f(s))

63、请编写一个程序使用列表理解打印斐波那契数列，序列以逗号分隔的形式，由给定的n个控制台输入。示例输入：7；输出：0,1,1,2,3,5,8,13

# 解1
def f(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    elif n > 1:
        return f(n - 1) + f(n - 2)


s = int(input())
li = [str(f(x)) for x in range(0, s+1)]
print(",".join(li))

64、请编写一个程序使用生成器打印之间的偶数，0和n以逗号分隔，n由控制台输入。

# 解1 我不知道这么简单的程序用yield干啥。。。
def even_generator(n):
    for i in range(0, n+1):
        if i % 2 == 0:
            yield str(i)
        i += 1


print(",".join(list(even_generator(10))))

# 解2
def even_generator(n):
    for i in range(0, n+1):
        if i % 2 == 0:
            yield str(i)
        i += 1


n = int(input())
value = []
for i in even_generator(n):
    value.append(str(i))
print(",".join(value))

65、请编写一个程序，使用生成器打印可以在0和n之间以逗号分隔的形式被5和7整除，n是由控制台输入的。

# 解1
def even_generator(n):
    for i in range(0, n+1):
        if i % 5 == 0 and i % 7 == 0:
            yield str(i)
        i += 1


n = int(input())
print(",".join(list(even_generator(n))))

# 解2
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))

66、请编写assert语句来验证列表[2,4,6,8]中的每个数字都是偶数。

# 解
li = [2, 4, 6, 8]
for i in li:
    assert i % 2 == 0, 'False'  # 只有在结果为false的时候才会输出定义的字符串

67、请编写一个接受基本数学表达式的程序，控制并打印评估结果，示例输入：35+3；输出：38（额|-_-说难也难说简单也简单）。

# 解1 毫无疑问我选择了我觉得的最笨最简单的解法，其实不是
expression = list(input().split())
if expression[1] == '+':
    print(int(expression[0]) + int(expression[2]))

# 解2 使用了eval()函数 eval() 函数用来执行一个字符串表达式，并返回表达式的值。python真方便
result = eval(input())
print(result)

68、请编写一个二元搜索函数，它在一个排序列表中搜索一个项目。该函数应该返回列表中要搜索的元素的索引。

# 解1
def search(x, y):
    for i in x:
        if i == y:
            return x.index(i)


string = [2, 4, 6, 8, 10]
print(search(string, 8))
print(len(string))

#  解2 官解就很细致
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))

69、请使用Python的random模块生成一个值在10到100之间的随机浮点数。

# 解1
import random

print(random.random() * 100)

70、请使用Python的random模块生成一个值在5到95之间的随机浮点数

# 解1
import random
print(random.uniform(5, 95))  # 打印定区间随机浮点数

# 解2
import random
print random.random()*100-5

71、请编写一个程序输出一个0到10之间的随机偶数,包含使用随机模块和列表。

# 解1
import random
li = []
for i in range(random.randint(0, 10)):
    if i % 2 == 0:
        li.append(i)
print(random.choice(li))

# 解2
import random
print(random.choice([i for i in range(11)]))

72、请写一个程序输出一个可被5和7整除的随机数，使用随机模块和列表理解。

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

73、请编写一个程序来生成一个列表，其中有5个随机数字，范围在100到200之间。

# 解1
import random

li = []
for i in range(5):
    i = random.randint(100, 201)
    li.append(i)
print(li)

# 解2
import random
print(random.sample(range(100, 201), 5))

74、请编写一个程序，随机生成一个列表，其中5个是100到200之间的随机偶数。

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

75、请编写一个程序，随机生成一个包含5个数字的列表，这些数字可以被5和7整除，范围在1到1000之间。

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

76、请编写一个程序，随机输出一个7到15(含7到15)之间的整数

# 解1
import random
print(random.randrange(7, 16))

77、请编写一个程序来压缩和解压字符串“hello world!hello world!hello world!hello world!”（使用zlib.compress()和zlib.decompress()）

# 解1
import zlib
string = b"hello world!hello world!hello world!hello world!"
entry = zlib.compress(string)
print(entry)
print(zlib.decompress(entry))

78、请编写一个程序，打印“1+1”执行100次的运行时间。（使用timeit()函数）

# 解1 这个解不对
import timeit
print(timeit.timeit('output = (1+1)*100'))

# 解2
from timeit import Timer


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

79、请编写一个程序来洗牌并打印列表[3,6,7,8]。（使用shuffle()方法）

# 解1
import random
li = [3, 6, 7, 8]
random.shuffle(li)
print(li)

80、请编写一个程序来生成所有主语所在的句子，在["I"， "You"]中，动词在["Play"， "Love"]中，宾语在["Hockey"，"Football"]中。

# 解1 我写的很蠢，我知道
import random

sub = ["I", "You"]
verb = ["Play", "Love"]
obj = ["Hockey", "Football"]
i = random.choice(range(2))
j = random.choice(range(2))
k = random.choice(range(2))
print(f'{sub[i]} {verb[j]} {obj[k]}')

# 解2 打印出所有的可能
sub = ["I", "You"]
verb = ["Play", "Love"]
obj = ["Hockey", "Football"]

for i in range(len(sub)):
    for j in range(len(verb)):
        for k in range(len(obj)):
            sentence = "%s %s %s." % (sub[i], verb[j], obj[k])
            print(sentence)

81、请编写程序打印出删除[5,6,77,45,22,12,24]中的偶数后的列表

# 解1
items = [5, 6, 77, 45, 22, 12, 24]
li = [i for i in items if i % 2 != 0]
print(li)

82、使用列表解析式，请编写一个程序，在[12,24,35,70,88,120,155]中删除能被5和7整除的数字后打印出列表

# 解1
items2 = [12, 24, 35, 70, 88, 120, 155]
li2 = [i for i in items2 if i % 5 != 0 and i % 7 != 0]
print(li2)

83、使用列表解析，编写一个程序打印除去[12,24,35,70,88,120,155]中第0,2,4,6个数字后的列表。（使用enumerate()获取(index, value)元组）

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

84、通过使用列表解析，请编写一个程序生成一个3*5*8的三维数组，每个元素为0

# 解1
li = [[[0 for col in range(8)] for col in range(5)] for row in range(3)]
print(li)

85、使用列表解析，编写一个程序打印除去[12,24,35,70,88,120,155]中第0,2,5个数字后的列表。（使用enumerate()获取(index, value)元组）

# 解1
items = [12, 24, 35, 70, 88, 120, 155]
li2 = [index for (x, index) in enumerate(items) if index not in (0, 4, 5)]
print(li2)

86、使用列表解析，编写一个程序打印除去[12,24,35,70,88,120,155]中数字24后的列表。

# 解1
items = [12, 24, 35, 70, 88, 120, 155]
li3 = [i for i in items if i != 24]
print(li3)

87、已知两个列表[1, 3, 6, 78, 35, 55] [12, 24, 35, 24, 88, 120, 155]编写程序生成一个列表，其元素为上述给定列表的交集。

# 解1
li1 = [1, 3, 6, 78, 35, 55]
li2 = [12, 24, 35, 24, 88, 120, 155]
print(list(set(li1) & set(li2)))

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

88、使用给定的列表[12,24,35,24,88,120,155,88,120,155]，在删除所有保留原始顺序的重复值后，编写程序打印该列表。

# 解1
new_li = 12, 24, 35, 24, 88, 120, 155, 88, 120, 155]
print(list(sorted(set(new_li), key=new_li.index)))

# 解2 这个好详细
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))

89、定义一个类Person及其两个子类:Male和Female。所有的类都有一个方法"getGender"，它可以给男性班打印"Male"给女性班打印“Female”。

# 解1 我写了很多余的代码
class Person:
    def __init__(self):
        pass

    def getGender(self):
        pass


class Male(Person):
    def __init__(self):
        pass

    @staticmethod
    def getGender():
        print("Male")


class Female(Person):
    def __init__(self):
        pass

    @staticmethod
    def getGender():
        print("Female")


man = Male
man.getGender()

woman = Female
woman.getGender()

# 解2 这个多好
class Person(object):
    def getGender(self):
        return "Unknown"


class Male(Person):
    def getGender(self):
        return "Male"


class Female(Person):
    def getGender(self ):
        return "Female"


man = Male()
print(man.getGender())

woman = Female()
print(woman.getGender())

90、请编写一个程序，计算并打印由控制台输入的字符串中每个字符的数量示例输入：abcdefgabc；输出：
a,2
c,2
b,2
e,1
d,1
g,1
f,1

# 解1
dic = {}
s = input()
for i in s:
    dic[i] = dic.get(i, 0) + 1  # 以输入字符为键，字符的个数为值，如果有相同的字符就加一
print('\n'.join('%s %s' % (k, v)for k, v in dic.items()))  # 格式化输出 字典解析

91、请编写一个从控制台接收字符串的程序，然后倒序打印出来。示例输入：rise to vote sir；输出：ris etov ot esir

# 解1
sentence = input()
sentence = sentence[:: -1]
print(sentence)

92、请编写一个程序，接受一个字符串从控制台并且输出具有偶数索引的字符。

# 解1
sentence = input()
sentence = sentence[::2]
print(sentence)

93、请编写一个程序，输出[1,2,3]的所有排列

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

94、解决鸡兔同笼问题：一共有35个头和94条腿，求兔子和鸡的数量

# 解1
for x in range(0, 36):
    y = 35 - x
    if 4 * x + 2 * y == 94:
        print(f'兔子：{x}只 鸡：{y}只')


# 解2 题目做完了，我写的代码感觉还是没官解规范
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)

小做总结：做完了，少了几题才到一百，原因是我看到有几个题目好像重复了，就没再做了，总体来说题目真的简单，适合刚学了基础语法和一点点类与对象知识的人做，方便巩固知识点加强记忆，github上的原题是使用python2解答的，我把语法都改成python3的了（其实也就输出部分要改改，其他的没啥）。前前后后拖了快一星期才做完，拖延癌晚期啊。