[Python知识库]一起来学习吧~~100例python题实战提高篇（附带答案）

本文实例来自GitHub，目前已经有17.4+k star！内容偏基础，是很好的入门提高python编程能力的刷题宝典，分享给大家，大家一起进步吧！

第1题

编写一个程序，找出所有可被7整除但不是5的倍数的数字，2000年至3200年（均包括在内）。获得的数字应以逗号分隔的顺序打印在一行上。

提示：range(begin, end)

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

sep = ","
l = sep.join(l)
print(l)

说明：string.join(seq)，表示以string分割seq，且返回一个新字符串。

第2题

题目：写一个程序，可以计算给定数字的阶乘。结果应以逗号分隔的顺序打印在一行上。假设向程序提供了以下输入：8，输出：40320

提示：应该假设控制台输入数据

# 递归方案
def fact(x):
    if x == 0:
        return 1
    return x * fact(x - 1)
print('请输入一个数字：')
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}

print("请输入一个数字：")
n = int(input())
dic = {}
for i in range(1,n+1):
    dic[i]=i**2

print(dic)

第4题

编写一个程序，从控制台接受逗号分隔的数字序列，并生成包含每个数字的列表和元组。假设以下输入被提供给程序：34,67,55,33,12,98，那么输出应该是：[‘34’，‘67’，‘55’，‘33’，‘12’，‘98’]（‘34’，‘67’，‘55’，‘33’，‘12’，‘98’）

print("请输入以逗号分割的数字序列：")
values=input()
l=values.split(",")
t=tuple(l)
print(l)
print(t)

说明：string.split(str="", num=string.count(str))，表示以str为分隔符切片string，如果 num 有指定值，则仅分隔 num+1 个子字符串。

第5题

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

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

说明：

第6题

给定C = 50，H = 30，D是待输入的以逗号分隔的序列，打印$Q=\sqrt{[(2?C?D)/H]}$的值。假设输入：100，150，180 然后输出18，22，24。

import math
C = 50
H = 30
in_str = input()
seq = ","
D = in_str.split(seq) #分割,返回list
Q = []
for i in D:
    Q.append(str(int(math.sqrt(2 * C * int(i) / H))))
print(seq.join(Q))# 使用seq隔开

第7题

编写一个程序，以2位数字X和Y作为输入，生成一个二维数组。数组的第i行和第j列中的元素值应该是i*j。其中i的范围为0，1，…，X-1；j的范围为0，1,…，Y-1。

X = int(input())
Y = int(input())
row = []
ans = []
for i in range(0,X):
    for j in range(0,Y):
        row.append(i * j)
    else:
        ans.append(row)

print(ans)

第8题

编写一个程序，接受逗号分隔的单词序列作为输入，并在按字母顺序排序后按逗号分隔的顺序打印单词。假设向程序提供了以下输入：without,hello,bag,world，然后输出：bag,hello,without,world

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

第9题

编写一个程序，逐行输入序列直到遇到空行结束，并在将句子中的所有字符大写后打印行。假设向程序提供以下输入:Hello world然后输出：HELLO WORLD

lines = []
while True:
    s = input()
    if s:
        lines.append(s.upper())
    else: #空行结束
        break;

for sentence in lines: # 逐行打印
    print(sentence)

第10题

接收一组以空格分隔的一些词，打印去重后的词，并按顺序排列。比如输入：hello world and practice makes perfect and hello world again，则输出：again and hello makes perfect practice world。

words = input().split(" ")
unrepeat = set(words)
print(" ".join(sorted(list(unrepeat))))

第11题

输入4位2进制数字，检验它们能否被5整除，满足条件的用逗号分隔符打印出来。比如输入0100,0011,1010,1001，然后输出1010。

items = input().split(",")
ans = []
for p in items:
    intp = int(p, 2)
    if not intp%5:
        ans.append(p)

print(','.join(ans))

第12题

打印出[1000, 3000]中每一位都是偶数的数字，且用逗号隔开。

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

第13题

输入一组字符串，计算字符和数字的个数。假设输入： hello world! 123，输出：
LETTERS 10 DIGITS 3。

items = input()
d={"DIGITS":0, "LETTERS":0}
for c in items:
    if c.isdigit():
        d["DIGITS"]+=1
    elif c.isalpha():
        d["LETTERS"]+=1
print("LETTERS", d["LETTERS"])
print("DIGITS", d["DIGITS"])

说明：这里主要考察字符串函数的使用。

第14题

输入字符串，判断字符串是大写还是小写，并分别计算个数。假设输入：Hello world!，则输出：UPPER CASE 1 LOWER CASE 9

items = input()
dic={"UPPER":0, "LOWER":0}
for c in items:
    if c.isupper():
        dic["UPPER"]+=1
    elif c.islower():
        dic["LOWER"]+=1
print("UPPER CASE ", dic["UPPER"])
print("LOWER CASE ", dic["LOWER"])

第15题

计算形如a+aa+aaa+aaaa的值，其中a表示一个数字，a由用户输入，假设输入9，那么输出：11106。

思路：当前值 = 10**i + 上一个值

a = int(input("请输入一个数字："))
sum = 0
last = 0
tmp = 0
for i in range(0,4):
    tmp = a * (10**i) + last
    last = tmp
    sum = sum + tmp
print("计算结果为：", sum)

第16题

输入一组数字，每个数字用逗号连接，输出相应的奇数list。假设输入：1,2,3,4,5,6,7,8,9，则输出：1,3,5,7,9

a = input("请输入一组数字：").split(",")
b = [str(i) for i in a if int(i)%2 !=0]
print(",".join(b))

第17题

输入一组交易记录，输出最终的余额，比如输入:D 100 W 100 ，其中D表示存入，W表示取出，则输出为0

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)

说明：需要两个enter才能有输出

第18题

判断一组字符串是否满足密码要求，密码（密码之间用逗号隔开）要求如下：

1. 至少有一个小写字母[a-z]
2. 至少有一个数组[0-9]
3. 至少有一个大写字母[A-Z]
4. 至少有一个特殊字符[$#@]
5. 密码最大长度12，且如果输入","则只认为逗号之前的字符为密码。

比如输入：ABd1234@1,a F1#,2w3E*,2We3345，则密码为：ABd1234@1

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

输入(name, age, height) ，并对输入的元组进行排序，排序优先级为：name > age > score。比如输入：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’)]。

注意：每一组元组需要隔行输入

l = []
while True:
    s = input()
    if not s:
        break
    l.append(tuple(s.split(",")))

print(sorted(l, key=itemgetter(0,1,2)))

说明：

1. 这里用到了list转tuple
2. sorted的用法，itemgetter表示根据某个或某几个字典字段对列表进行排序。

第20题

定义一个带有生成器的class，该生成器可以迭代被7整除的数字，这些数字的范围为[0, n)

提示：考虑使用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)

第21题

机器人从原始点(0,0)开始移动，机器人可以上下左右的移动，机器人的移动轨迹类似于上5，下3，左3，右2，计算当前点距离原始点的距离，如果距离是float，只需要保留最近的int类型。比如输入下列元组，UP 5 DOWN 3 LEFT 3 RIGHT 2，输出则为2.

import math

lst = input("请输入轨迹：").split(" ")
distance = math.sqrt(((int(lst[1]) - int(lst[5]))**2 + (int(lst[3]) - int(lst[7]))**2))
print("当前点距离原始点为：",round(distance))

第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。

items = input().split()
dic = {}
for word in items:
    dic[word] = dic.get(word,0) + 1

words = list(dic.keys())
print(words,type(words))
words.sort()
for w in words:
    print(w,":",dic[w])

第23题

写一个函数，实现平方操作。

def square(num):
    return num ** 2

第24题

python有很多的内置函数，如果要使用它们，可以阅读相关的文档。请写一个程序，打印内建函数文档。比如abs()，int()，raw_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__)

第25题

写一个类，并让它可以输入一个参数。

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))#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 sum(a, b):
    return a+b
print(sum(1,2))

第27题

写一个函数，使用str将整数转化为string类型

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

printValue(3)

第28题

和27题目一样

第29题

写一个函数，接收两个字符串类型的数字，然后计算他们的和，并打印出来。

def printValue(a, b):
    print(int(a)+int(b))
printValue("2","4")

第30题

写一个函数，接收连个字符串，并对他们进行链接和打印

def printValue(a, b):
    print(a+b)
printValue("2","4")#24

第31题

写一个函数，其功能为接收2个字符串输入，并打印其中最长的一个，如果长度相同，则分行分别打印。

def printValue(str1, str2):
    a = len(str1)
    b = len(str2)
    if a > b:
        print(str1)
    elif a < b:
        print(str2)
    else:
        print(str1)
        print(str2)

第32题

定义一个函数，其功能为输入一个整数，并判断其为奇数还是偶数

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

第33题

定义一个函数，其功能为打印出一个字典，字典的key范围为[1,3]的整数类型，value为key的平方。

def printDict():
    dic = {}
    for i in range(1,4):
        dic[i] = i**2
    print(dic)

第34题

定义一个函数，其功能为打印出一个字典，字典的key范围为[1,20]的整数类型，value为key的平方。

def printDict():
    dic = {}
    for i in range(1,21):
        dic[i] = i**2
    print(dic)

第35题

定义一个函数，其功能为生成一个字典，字典的key范围为[1,20]的整数类型，value为key的平方，并打印字典的values值。

def printDict():
    dic = {}
    for i in range(1,21):
        dic[i] = i**2
    print(dic.values())

printDict()

第36题

定义一个函数，其功能为生成一个字典，字典的key范围为[1,20]的整数类型，value为key的平方，并打印字典的keys值。

def printDict():
    dic = {}
    for i in range(1,21):
        dic[i] = i**2
    print(dic.keys())

printDict()

第37题

定义一个函数，其功能为生成一个list，它的值为[1, 20]的平方，并打印这个列表。

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

printList()

第38题

定义一个函数，其功能为生成一个list，它的值为[1, 20]的平方，并打印这个列表的前5个元素。

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

printList()

第39题

定义一个函数，其功能为生成一个list，它的值为[1, 20]的平方，并打印这个列表的后5个元素。

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

printList()

第40题

定义一个函数，其功能为生成一个list，它的值为[1, 20]的平方，并打印这个列表中除了前5各元素的其他元素。

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

printList()

第41题

定义一个函数，其功能为生成一个tuple，它的值为[1, 20]的平方，并打印这个元组的所有元素。

def printTuple():
    tup1 = ()
    tup1 = tuple(i**2 for i in range(1,21))
    print(tup1)

printTuple()

第42题

给定一个元组(1,2,3,4,5,6,7,8,9,10),将前五个元素打印在一行，最后的元素打印在另外一行。

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

第43题

写一个程序，生成并打印给定元组 (1,2,3,4,5,6,7,8,9,10)中的偶数部分。

tup = (1,2,3,4,5,6,7,8,9,10)
list1 = []
for i in tup:
    if i%2==0:
        list1.append(i)

tup1 = tuple(list1)
print(tup1)

第44题

写一个程序，输入一个string类型，如果输入为"yes" or “YES” or “Yes”，那么打印出“Yes”，否则打印出"No"

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

第45题

写一个程序，使用filter函数过滤掉给定列表的奇数，该列表为[1,2,3,4,5,6,7,8,9,10]。

lst = [1,2,3,4,5,6,7,8,9,10]
lst = list(filter(lambda x:x%2==0,lst))
print(lst)

第46题

写一个程序，使用map生成一个列表，它的元素为[1,2,3,4,5,6,7,8,9,10]元素平方。

lst = [1,2,3,4,5,6,7,8,9,10]
lst = list(map(lambda x:x**2,lst))
print(lst)

第47题

结合map和filter方法，提取列表中[1,2,3,4,5,6,7,8,9,10]偶数的平方。

lst = [1,2,3,4,5,6,7,8,9]
lst = list(filter(lambda x:x%2 == 0,lst))
lst = list(map(lambda x:x**2,lst))
print(lst)

第48题

写一个程序，使用filter函数过滤掉给定列表的奇数，该列表范围为[1,20]。

lst = list(range(1,21))
lst = list(filter(lambda x:x%2==0,lst))
print(lst)

第49题

写一个程序，使用map生成一个列表，它的元素为range[1,20]元素平方。

lst = list(range(1,21))
lst = list(map(lambda x:x**2,lst))
print(lst)

第50题

定义一个名为American的类，该类有一个名为printNationality的静态方法。

提示：用 @staticmethod修饰器来定义静态方法。

class American:
    @staticmethod
    def printNationality():
        print('nation is american')

第51题

定义一个名为American的类及其子类NewYorker

class American:
    @staticmethod
    def printNational():
        print('nation is american')

class NewYorker(American):
    pass

第52题

定义一个类Circle，传入半径，它有一个计算面积方法area。

import math

class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return math.pi * self.r * self.r    

第53题

定义一个矩阵类，它由长和宽组成，并且有一个计算面接的方法。

class Rectangle:
    def __init__(self,length,width):
        self.length = length
        self.width = width
    def area(self):
        return self.width * self.length

第54题

定义一个父类Shape和子类Square，他们均有一个打印面积的方法，父类默认打印的面积为0.

class Shape:
    def __init__(self):
        pass
    def printArea(self):
        print(0)
class Square(Shape):
    def __init__(self,r):
        Shape.__init__(self)
        self.r = r
    def printArea(self):
        print( self.r ** 2 )

第55题

写一个raise a RuntimeError的异常。

raise RuntimeError('something wrong')

第56题

写一个5/0的函数， 并使用try/except捕获异常。

def throws():
    return 5/0

try:
    throws()
except ZeroDivisionError:
    print("division by zero!")
except Exception, err:
    print('Caught an exception')
finally:
    print('In finally block for cleanup')

第57题

自定义一个异常类

第58题

58、59和60为正则表达式

第59题

59和60为正则表达式

第60题

第61题

写一个unicode 字符串，它为 “hello world”。

ustr = u'hello world'

第62题

写一个程序，读取ASCII 字符串，并将其转化为utf-8编码的字符串。

s = input()
u = unicode( s ,"utf-8")
print(u)

第63题

写出使用unicode的注释

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

第64题

输入一个n（n > 0）,并计算 1/2+2/3+3/4+…+n/n+1。

n = int(input())
sum = 0
i = 1
while i<=n:
    sum += i/(i+1)
    i+=1

print('sum is :', sum)

第65题

输入一个n(n>0)，计算f(n)=f(n-1)+100 ，其中 f(0)=1。

n = int(input())
sum = 1
for i in range(1,n+1):
    sum += 100

print('sum is :', sum)

第66题

写一个程序计算斐波那契数列。
其中：
f(n)=0 if n=0
f(n)=1 if n=1
f(n)=f(n-1)+f(n-2) if n>1。

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

第67题

写一个程序计算斐波那契数列。
其中：
f(n)=0 if n=0
f(n)=1 if n=1
f(n)=f(n-1)+f(n-2) if n>1。

并且用都好打印出这个数列。

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

第68题

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

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

第69题

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

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

第70题

写一个assert，判断[2,4,6,8] 的元素全部为偶数

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

第71题

从控制台接收一个数学表达式，并使用eval计算它的值。

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

第72题

请编写一个二进制搜索函数，用于搜索排序列表中的项目。函数应该返回列表中要搜索的元素的索引。

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

第73题

和72题目一样。。。。

第74题

请使用Python数学模块生成一个值介于10和100之间的随机浮点。

import random
print(random.uniform(10,100))

第75题

请使用Python数学模块生成一个值介于5和95之间的随机浮点。

import random
print(random.uniform(5,95))

第76题

请编写一个程序，使用随机模块和列表理解输出0到10之间的随机偶数。

import random
print(random.randrange(2,11,2))

第77题

请编写一个程序来输出一个随机数，它可以被5和7整除，范围在（0,200）之间。

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

第78题

请编写一个程序，生成一个包含5个100到200之间的随机数的列表。

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

第79题

请编写一个程序，随机生成一个列表，其中5个偶数介于100和200之间（含100和200）。

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

第80题

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

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

第81题

请编写一个程序，随机打印一个介于7和15之间（含7和15）的整数。

import random
print(random.randrange(7,16)) #不包含16

第82题

写一个程序压缩和解压缩字符串"hello world!hello world!hello world!hello world!"

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题

请编写一个程序，打印出执行“1+1”运行100次的时间。

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

输出：

1.1106285939986265

第84题

随机打乱列表 [3,6,7,8]

import random
lst = [3,6,7,8]
random.shuffle(lst)
print(lst)

第85题目与第84题重复了！

第86题

打印所有句子，句子的主语为[“I”, “You”] ，谓语为 [“Play”, “Love”] 宾语为 [“Hockey”,“Football”]。

subjects=["I", "You"]
verbs=["Play", "Love"]
objects=["Hockey","Football"]

for s in subjects:
    for v in verbs:
        for o in objects:
            print(s + ' ' + v + ' ' + o)

第87题

打印出 [5,6,77,45,22,12,24]中删除偶数之后的列表。

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

第88题

选出列表[12,24,35,70,88,120,155]中，不能被5和7整除的数组成的列表。

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

第89题

删除列表[12,24,35,70,88,120,155]中第0,2,4,6个元素。

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

第90题

使用列表推导式生成一个3*5*8的列表，并且列表的元素为0.

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号位置的元素。

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

第92题

使用列表推导式删除[12,24,35,24,88,120,155]列表中为24的元素。

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]的交集。

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

set3 = set1&set2
print(set3)

第94题

删除列表[12,24,35,24,88,120,155,88,120,155]中重复的元素，并且保留原有的顺序。

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

第95题

写出一个父类Person，和两个子类Male和Female，可以通过getGender方法获取他们的性别。

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

第96题

从控制台获取一组字符串，并计算每个字符的个数。比如输入：abcdefgabc，然后输出：a,2 c,2 b,2 e,1 d,1 g,1 f,1。

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

第97题

从控制台接收一组字符串，并打印它的相反顺序。比如输入：rise to vote sir，输出则为：ris etov ot esir。

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

第98题

从控制台接收一组字符串，并打印出它的偶数索引的字符串。

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

第99题

写出列表 [1,2,3]所有的排列组合。

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

第100题

写一个程序，解决一个经典的数学题：在农场中只有鸡和兔子，其中有35个头和94条腿，计算农场有多少只鸡和多少只兔子。

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)