python练习题50道【答案后续会更新】

最新推荐文章于 2023-04-29 22:04:20 发布

hiyunie

最新推荐文章于 2023-04-29 22:04:20 发布

阅读量1k

点赞数 2

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/qq_45202835/article/details/123737013

版权

Python 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

写在前面

本次主要使用的语言:Python 2.7
发表目的:单纯记录
答案只是作者本人写的，有错误希望大家指出

1.我们的头像资源命名是以3位数整数如001,010,100
写个程序分别输入1,10,100的参数，输出来的结构是对应的001，010和100

res = {"1": "001", "10": "010", "100": "100"}

2.一个fload类型参数,只保留2位有效小数
输入3.1415926,输出 3.14

num = float(raw_input())
print '%.2f'%num

3.“Python” 这个字符串有两个索引可以输出o字母
请分别写出来

s = 'Python'
print(s[-2])
print(s[4])

4.字符串a为"梦幻西游",b为"真好玩",请使用+和join方法连接
这两个字符串为一个新的字符串，并回答哪个效率好，以及原理

a = '梦幻西游'
b = '真好玩'
print(a + b)
print(a.join(b))
当用操作符+连接字符串的时候，每执行一次+都会申请一块新的内存，然后复制上一个+操作的结果和本次操作的右操作符到这块内存空间，因此用+连接字符串的时候会涉及好几次内存申请和复制;而join在连接字符串的时候，会先计算需要多大的内存存放结果，然后一次性申请所需内存并将字符串复制过去.这是为什么join的性能优于+的原因。

5.time.time()可以获取当前本地时间戳,计算耗时简单的方法是在语句运行前记录时间1,语句运行结束后记录时间2
现求字符串 "梦幻西游真好玩"使用+ 和join 两种连接方法，连接10W个"梦幻西游真好玩"的耗时。

# -*- coding=utf-8 -*-
import time
def func1():
    a = '梦幻西游真好玩'
    b = '梦幻西游真好玩'
    t1 = time.time()
    for i in xrange(100000):
        a = a + b
    t2 = time.time()
    return t2 - t1

def func2():
    a = '梦幻西游真好玩'
    b = '梦幻西游真好玩'
    t1 = time.time()
    for i in xrange(100000):
        a.join(b)
    t2 = time.time()
    return t2 - t1

print(func1())
print(func2())
""" 
0.121000051498
0.0880000591278
"""

6.range 和 xrange的区别,同样写代码验证for循环遍历使用range 和xrange遍历100W次的耗时时间
并解释其原因

# -*- coding=utf-8 -*-
import time
def func1():
    t1 = time.time()
    for i in range(1000000):
        pass
    t2 = time.time()
    return t2 - t1
def func2():
    t1 = time.time()
    for i in xrange(1000000):
        pass
    t2 = time.time()
    return t2 - t1
print(func1())
print(func2())
"""
0.0260000228882
0.0090000629425
原因分析:range()和xrange()都是在循环中使用，输出结果一样。 range()返回的是一个list对象，而xrange返回的是一个生成器对象(xrange object)。 xrange()则不会直接生成一个list，而是每次调用返回其中的一个值，内存空间使用极少,因为不需要预先开辟一块很大的内存空间。
"""

7.使用for和enumerate打印出列表[‘a’,‘b’,‘c’,‘d’]的下标和对应的值

data = ['a', 'b', 'c', 'd']
for i in data:
    print(data.index(i), i)

for index, data in enumerate(data):
    print(index, data)

8.定义一个空列表，然后用for 循环向列表中依次添加0-100万以内的偶数。记录耗时t1,
使用列表生成式的方法创建这个列表，记录耗时t2,输出下t1和t2。
为什么列表生成式效率高？

import time
def func1():
    t1 = time.time()
    data = []
    for i in xrange(1000000):
        if i % 2 == 0:
            data.append(i)
    t2 = time.time()
    return t2 - t1

def func2():
    t1 = time.time()
    data = [i for i in xrange(1000000) if i % 2 == 0]
    t2 = time.time()
    return t2 - t1

print(func1())
print(func2())

#原因分析
"""
在列表解析中只有一次函数调用xrange(),且列表解析可以取代内建的map()/lambda，效率更高
"""

9.如何判断2个对象是否为同一个对象,以及如何判断2个对象的值相等

# is是判断2个变量是否引用的是同一个对象，如果是的话，则返回true，否则返回false。
# ==用来判断两个对象的值是否相等
a = 123
b = 123
print(id(a))
print(id(b))
print(a is b)
print(a == b)
"""
49178208
49178208
True
True
"""

10.type和isinstance的区别是？

type可以得到特定对象的类型信息
isinstance判断一个对象是否是另一个类给定类的实例

11.数字，字符串，列表，元组，字典，哪些是容器,哪些属于可变类型,哪些属于直接访问，顺序访问和映射访问

# 容器:列表、元组、字典
# 可变类型:列表、字典
# 映射访问:字典
# 顺序访问:列表、元组

12.使用round函数使得 3.49999返回为3.5和3.0,要怎么对round传参

round()用于对浮点型进行四舍五入运算。它有一个可选的小数位数参数。如果不提供小数位参数，它返回与第一个参数最接近的整型(但仍然是浮点类型)。第二个参数告诉round函数将结果精确到小数点后指定位数。
data = 3.49999
print(round(data))  # 3.0
print(round(data, 1))  # 3.5

13.random模块，随机1-100的随机整数, 随机1.0-100.0的随机浮点数，0.0-1.0的随机浮点数，
以及给定序列lst = [1,3,5,7,9]随机返回这个序列的一个元素

import random

data1 = [random.randint(1, 100) for i in xrange(10)]
data2 = [random.uniform(1.0, 100.0)for i in xrange(10)]
data3 = [random.uniform(0.0, 1.0) for i in xrange(10)]

month =2,day = 18,hour = 5 输出 '02/18/5

month, day, hour = 2, 18, 5
print('0{}/{}/{}'.format(month, day, hour))

15.列表lst =[1,2,3],lst2=[4,5,6],把lst和lst2 合并。

lst = [1, 2, 3]
lst2 = [4, 5, 6]
lst.extend(lst2)
print(lst)

16.列表lst=[1,2,3,4,5] 倒序输出

lst = [1, 2, 3, 4, 5]
print lst[::-1]

def appendValue(f,lst=[]):
if f not in lst:
lst.append(f)
return lst
print appendValue(1)
print appendValue(2)
发现输出的是[1,2]改写代码使得输出的是[1],[2]

def appendValue(f, lst=[]):
	if f not in lst:
		lst.append(f)
	return lst

print(appendValue(1))
print(appendValue(2,[]))

a = [1,2,3]
b = a
a[1] = 6
打印出来b也更新为[1,6,3].
改写程序 a[1]被更新但是b保持不变

import copy

a = [1, 2, 3]
b = copy.deepcopy(a)
a[1] = 6
print(a)
print(b)
"""
    [1, 6, 3]
    [1, 2, 3]
"""

a = [1, [2,3], 4]
b = a
a[1][0] = 6
打印出来b也更新为[1,[6,3],4]
改写程序使得a[1]被更新但是b保持不变

import copy
a = [1, [2, 3], 4]
b = copy.deepcopy(a)
a[1][0] = 6
print(a)
print(b)
"""
[1, [6, 3], 4]
[1, [2, 3], 4]
"""

20对于字典类型，判定某个对象是否在字典中,has_key和 in哪个效率高,
请分别写出100W个键的字典对应查找100W次所需要的耗时。

# in的效率高于has_key，has_key在2.2版本后被舍弃了
import time
my_dict = {i: i + 1 for i in xrange(1000000)}

def dict_has_key():
	t1 = time.time()
	for i in xrange(1000000):
		if my_dict.has_key(i):
			pass
	t2 = time.time()
	return t2 - t1

def dict_in():
	t1 = time.time()
	for i in xrange(1000000):
		if i in my_dict:
			pass
	t2 = time.time()
	return t2 - t1

print('time_in_dict:%.6f' % dict_in())
print('time_has_key:%.6f' % dict_has_key())
"""
	time_in_dict:0.051000
	time_has_key:0.072000
"""

21 tuple1 = (100, 200)
tuple2 = (‘逍遥生’, ‘剑侠客’)
使用zip方法对tuple1和tuple2 进行操作，建立字典{100:‘逍遥生’,200:‘剑侠客’}

# -*- coding= GBK -*-
tuple1 = (100, 200)
tuple2 = ('逍遥生', '剑侠客')
a = dict(zip(tuple1, tuple2))
print(a)

22 d = {100:‘逍遥生’,200:‘剑侠客’}
遍历字典d分别使用items() 和 keys(),要求每次循环打印出key和对应的value,使用values()每次打印对应的value
遍历字典d分别使用iteritems() 和 iterkeys(), itervalues() 做以上的同样的需求

d = {100:'逍遥生',200:'剑侠客'}
# 打印key和value
for key in d.keys():
	print(key, d[key])
# 打印value
for value in d.values():
	print(value)
# 打印key
for k in d.iterkeys():
	print(k)
# 打印value
for v in d.itervalues():
	print(v)
# 打印key和value
for item in d.iteritems():
	print(item)

23:
n = 1000000
d = {i:’%d’, for i in xrange(n)}
请分别打印出用和不用iter版本的迭代的耗时比较,效率差距的原因是什么？

# -*- coding: GB18030 -*-
import time
n = 1000000
d = {i: '%d' for i in xrange(n)}
def print_iter1():
	t1 = time.time()
	for i in d.keys():
		pass
	t2 = time.time()
	return t2 - t1

def print_iter2():
	t1 = time.time()
	for i in d.iterkeys():
		pass
	t2 = time.time()
	return t2 - t1

def print_without_iter():
	t1 = time.time()
	for i in d:
		pass
	t2 = time.time()
	return t2 - t1

print "total_time1:%.4f" % print_iter1() #total_time:0.0260
print "total_time2:%.4f" % print_iter2() #total_time:0.0140
print "total_time3:%.4f" % print_without_iter() #total_time:0.0140
# 分析:keys()会生成一个list，耗内存又耗时间；iterkeys是迭代key，不会生成list;

24:
nameLst = [“狐美人”,“剑侠客”,“逍遥生”,“剑侠客”]
nameLst2 = [“舞天姬”,“巨魔王”,“逍遥生”]
1.求创建一个新列表nameLst1,其列表元素为nameLst的不重复元素,不允许使用遍历。
2.求创建一个集合其值为nameLst和nameLst2的并集Lst3
3.求创建一个集合其值为nameLst和nameLst2的交集Lst4
4.判断set([“狐美人”,“剑侠客”])是set([“狐美人”,“剑侠客”,“逍遥生”,“剑侠客”])的子集
5.使用集合的方法求在nameLst中但不在nameLst2中的元素列表

#1
my_name_list = list(set(nameLst))
#2
nameLst.extend(nameLst2)
my_name_list = set(nameLst)
#3
def is_both_in(data):
	if data in nameLst and data in nameLst2:
		return data
my_name_list = filter(is_both_in, nameLst)
#3-----或者----
my_name_list = nameLst & nameLst2
#4
nameLst = set(["狐美人", "剑侠客"])
nameLst2 = set(["狐美人", "剑侠客", "逍遥生", "剑侠客"])
print('True' if nameLst<nameLst2 else 'False')
#5
my_name_list = nameLst-nameLst2

25:使用三元操作符列表生成式来生成一个10000以内的偶数

data = [i for i in xrange(10000) if i % 2 == 0]
print(data)

26：lst = [1, 2, 3, 4, 5, 3, 7, 8] 使用while-else语句完成遍历判定如果lst里面没有负数则返回True,否则返回False

def is_true_number():
    lst = [1, 2, 3, 4, 5, -1, 3, 7, 8]
    total = len(lst)
    i = 0
    while total:
        if lst[i] < 0:
            return False
        i += 1
        total -= 1
    else:
        return True
print(is_true_number())
#False

27：使用for else完成上面要求

def is_true_number():
    lst = [1, 2, 3, 4, 5, 3, 7, 8]
    for i in lst:
        if i < 0:
            return False
    else:
        return True
print(is_true_number())
#True

28:
def func(name,lv=1,color=“R”,*vipInfo,**moreinfo):
print name
print lv
print color
print vipInfo
print moreinfo
请问,name,lv,color,vipInfo,moreinfo分别是属于什么类型的函数参数
请对函数传参，使得

1)传入name的值为'a',其余为默认的参数
2)传入name的值为'a'，lv为10，其余为默认参数
3)传入name的值为'a'，clolor为'H',其余为默认参数
4)传入name的值为'a'，lv为10,'color为H',以及在传入一个扩展参数数值为T1
5)传入name的值为'a'，以及传入一个参数使得,moreinfo里面打印出来有信息 ishero的值为True

name:位置参数
lv,color:默认参数
vipinfo:非关键字可变长参数(元组)
moreinfo:关键字变量参数(字典)
#-----
(1)func('a')
(2)func('a', lv=10)
(3)func('a', color='H')
(4)func('a', 10, 'H', 'T1')
(5)func('a', 10, 'H', ishero=True)

29:写一个装饰器,要求对原函数进行装饰,额外输出原函数的名字。（函数的名字可以用func.__name__输出）

def print_name(func):
    def wrapper(*args):
        res = func(*args)
        return "function_name:{}, result:{}".format((func.__name__), res)
    return wrapper

@print_name
def add(a, b):
    return a + b

@print_name
def sub(a, b):
    return a - b

print add(2, 1)
print sub(2, 4)

30：
多层装饰器的执行顺序是？
@g
@f
def foo():
pass
请写代码验证结果

# 执行顺序:f->g,即由内至外
# an example of python decorator
def g(func):
    print(1)
    def wrapper1():
        print(2)
        func()
        print(3)

    print(4)
    return wrapper1

def f(func):
    print(5)

    def wrapper2():
        print(6)
        func()
        print(7)

    print(8)
    return wrapper2

@g
@f
def foo():
    print('foo')
if __name__ == '__main__':
    foo()
"""
5
8
1
4
2
6
foo
7
3
"""

31: 改写use_logging 装饰器函数,支持参数level,如果level大于0,才输出函数的名字 is running，否则不输出
def use_logging():
def decorator(func):
def wrapper():
logging.warn("%s is running" % func.name)
return func()
return wrapper
return decorator

@use_logging()
def foo(name=‘foo’):
print(“i am %s” % name)

foo()

import logging

def use_logging(level):
	def decorator(func):
		def wrapper(**kwargs):
			if level > 0:
				logging.warn("%s is running" % func.__name__)
			return func(**kwargs)
		return wrapper
	return decorator

@use_logging(10)
def foo(name='foo'):
	print("i am %s" % name)

foo(name='f')

32:用lambada函数实现2个数的加法

add = lambda a,b:a+b
print add(3,2)

33:
def func(ctrl, idx):
print “===”, idx

funLst = []
for i in xrange(3):
funLst.append(lambda ctrl : func(ctrl, i + 1))

for f in funLst:
f(None)
运行上面这段程序,为什么idx打印出来不是1,2,3。以及改写上面的程序使得运行出来达到预期的1,2,3

# -*- coding: GB18030 -*-
def func(idx):
	print("===", idx)

def get_res(num):
	return func(num + 1)

funLst = []
for i in xrange(3):
	funLst.append(get_res(i))

34: filter是内建函数
filter(lamda i:return i%2==0,[1, 2, 3, 4, 5])
上面这个函数的功能是什么，请自己用普通函数实现类似fileter的功能,要求传参1个是返回布尔值的函数，一个是列表，输出
经过函数验证返回为True的元素列表
map函数

# 功能:筛选列表中的偶数
def is_even(num):
	return True if num % 2 == 0 else False

res = filter(is_even, xrange(10))
print(res) # [0, 2, 4, 6, 8]
#-------------------
def is_even(num):
	return True if num % 2 == 0 else False

res = map(is_even, xrange(10))
print(res)

35.使用reduce函数实现1到100的整数总和

res = reduce(lambda a, b: a + b, [i for i in xrange(1, 101)])
print(res)

36.使用partial函数定义一个函数add1,使得传入一个参数返回参数+1的结果。再定义一个函数mul100使得传入一个参数返回参数*100的结果

from functools import partial
def add1(*args):
	return sum(args)
add_100  = partial(add1,100)
print add_100(12) # 112

def mul(n,m):
	return n*m

mul_100 = partial(mul,100)
print mul_100(100) #10000

37.全局变量什么时候被载入和删除,函数内的局部变量呢？变量的读取顺序是？

变量的读取顺序:先从局部作用域开始搜索，如果在局部作用域没有找到，则在全局作用域搜索。
全局变量:除非被删除，否则它将存活到脚本运行结束.python从import语句开始执行，执行到全局变量时就被初始化了。
局部变量:依赖于定义它们的函数现阶段是否处于活动状态，当函数被调用时，其局部变量就进入声明它们的作用域。一旦函数完成，框架被释放，变量将会离开作用域。

a = 1
def f():
#global a #有这一句和没有这一句的区别是？
a = 2

a = 1
def f():
    global a
    a = 2

f()
print(a) # a=2
"""
分析:当调用函数f时,加上global可以对全局变量a进行修改；不加global时，两个a分别是不同的对象
"""

39.什么是自由变量，以及什么是闭包？

闭包:在一个内部函数里，对在外部作用域(但不是在全局作用域)的变量进行引用，那么内部函数就被认为是闭包。
自由变量:定义在外部函数内的但由内部函数引用或者使用的变量被称为自由变量。

40.以下代码运行为什么出错,要怎么改写使得每运行一次count()返回值就+1
def counter(start_at=0):
count = start_at
def incr():
count+=1
return count
return incr
count = counter(5)
print count()
print count()

# -*- coding: GB18030 -*-
def counter(start_at=0):
	global cnt
	cnt = start_at
	def incr():
		global cnt
		cnt += 1
		return cnt
	return incr
count = counter(5)
print(count())
print(count())
"""
解决方法:使用两次global来定义cnt
"""
# -*- coding: GB18030 -*-
def counter(start_at=0):
	counter.cnt = start_at

	def incr():
		counter.cnt += 1
		return counter.cnt

	return incr


count = counter(5)
print(count())
print(count())
"""
解决方法:使用函数的属性
"""

import 一个模块的时候，python的路径搜索的顺序是？

现在局部名称空间中查找。如果没有找到再查找全局名称空间。如果失败，将在内建名称空间里查找。

什么是bound和unbound method？

bound:定义在类中的普通函数，绑定了instance
unbound:定义在类中的普通函数未绑定instance

定义一个COpBase类,含有静态方法staticmethod Add 返回两个数的运算和,含有类方法classmethod Sub返回两个数的差,静态方法和类方法是绑定还是非绑定的方法？

class COpBase(object):
	@staticmethod
	def Add(a, b):
		return a + b

	@classmethod
	def Sub(cls, a, b):
		return a - b
#在调用类方法时，只需要将类型本身传递给类方法，因此，既可以通过类也可以通过实例来调用类方法。类方法是绑定方法。

#对于静态方法，Python 并不需要传递类或者实例，因此，既可以使用类也可以使用实例来调用静态方法。静态方法是非绑定方法。

isinstance() 与 type()的区别是？请写出代码验证

共同点:type和isinstance都可以判断变量是否属于某个内建类型
不同点:type只接收一个参数，不但可以判断变量是否属于某个类型，而且可以得到参数变量未知的所属的类型；而isinstance只能判断是否属于某个已知类型，不能直接得到变量未知的所属的类型
class A(object):
    pass
class B(object):
    pass
class C(A):
    pass

a = A()
b = B()
c = C()
print(isinstance(a, A))  # True
print(isinstance(a, B))  # False
print(isinstance(c, A))  # True
print(type(3))  # <type 'int'>

判定一个对象是否是函数的内建函数是？

def test():
	print('test...')
print('True' if 'test' in dir(__builtins__) else 'False')  # False

46.第二代身份证是18位数字组成的，请用正则表达式实现判断输入的字符串是否为身份证格式号码
str1 = ‘445122198905110000’
str2 = ‘4451221989051100’
并使用str1和str2来判断
返回判断结果

import re

str1 = '445122198905110000'
str2 = '4451221989051100'

print('True' if re.match('\d{18}',str1) else 'False') #True
print('True' if re.match('\d{18}',str2) else 'False') #False

47.由开始然后紧接着具体的网址然后以作为结尾，表示这是具体的网址地址，求使用
正则表达式判断出字符串中是否包含了网址。

str1 = ‘梦幻官网是https://xyq.163.com/这个地址’
str2 = ‘梦幻官网是https://xyq.163.com/这个地址’
并使用str1和str2来判断
返回判断结果

import re

str1 = '梦幻官网是<url>https://xyq.163.com/</url>这个地址'
str2 = '梦幻官网是<url>https://xyq.163.com/<url>这个地址'

if re.match('^梦幻官网是<url>\w.*</url>这个地址$', str1):
	print('true')
else:
	print('false')

48.改2的代码使之匹配更严格,只允许发一个网址的格式开始然后紧接着具体的网址然后以过来
str1 = ‘梦幻官网是https://xyq.163.com/这个地址’
str2 = ‘https://xyq.163.com/’
并使用str1和str2来判断
返回判断结果

# -*- coding: GB18030 -*-
import re
str1 = '梦幻官网是<url>https://xyq.163.com/</url>这个地址'
str2 = '<url>https://xyq.163.com/<url>'
str3 = '<url>https://xyq.163.com/</url>'
def is_true_url(url):
	if re.match('^<url>\w.*</url>$',url):
		return 1
	return 0

print is_true_url(str1) #0
print is_true_url(str2) #0
print is_true_url(str3) #1

我们的富文本若是#C后面接着严格的6位颜色码则会在引擎解析为对应颜色,同事#W,#R,#G,#B,#K,也会翻译为白红绿蓝黑
求写一个正则匹配,把对应的下面str1-3中的字符串都去掉颜色格式符。
str1 = “这个是#C223413有颜色的字符”
str2 = “这个是#W有颜色的字符”
str3 = “这个是#C1234有颜色的字符”

# -*- coding: GB18030 -*-
import re
str1 = "这个是#C223413有颜色的字符"
str2 = "这个是#W有颜色的字符"
str3 = "这个是#C1234有颜色的字符"

s = re.sub('#[A-Za-z]|[0-9]','',str2)
print s

50.对于多重继承C3算法解决了MRO算法的什么问题?两者的查找顺序是什么？

mro:在经典类遵循深度优先原则，在新式类采用先广度在深度的原则。
c3：类似与拓扑排序,先确定一个线性序列,然后查找路径由，由序列中类的顺序决定
c3算法解决了mro算法多继承的问题。

hiyunie

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python练习题50道【答案后续会更新】

写在前面本次主要使用的语言:Python 2.7发表目的:单纯记录答案只是作者本人写的，有错误希望大家指出1.我们的头像资源命名是以3位数整数如001,010,100写个程序分别输入1,10,100的参数，输出来的结构是对应的001，010和100res = {"1": "001", "10": "010", "100": "100"}2.一个fload类型参数,只保留2位有效小数输入3.1415926,输出 3.14num = float(raw_input())print '%
复制链接

扫一扫