python笔试题（一）_丰台少年宫python题库

1：一行代码实现1-100的和：

print(sum(range(1, 101)))
1

2：列出5个python的标准库：

os，sys，re，math，datetime
1

3：python实现列表去重的方法：

list1 = [1, 2, 1, 2]
print(list(set(list1)))
1
2

4：python的内置数据类型，以及哪些是可变类型？哪些是不可变类型？：

6种：数字，字符串，列表，元祖，字典，集合
可变类型：列表，字典，集合
不可变类型：数字，字符串，元祖
1
2
3

5：with方法打开处理文件帮我们做了什么？

# 关闭文件 f.close()
1

6：列表[1, 2, 3, 4, 5],使用map()函数输出[1, 4, 9, 16, 25],使用列表推导式取出大于10的数，最终结果是[16, 25]

my_list = [1, 2, 3, 4, 5]
print([i for i in map(lambda x: x*x ,my_list) if i > 10])
# 注意map，Python2返回的是列表，python3返回的是迭代器对象
# map函数参数一：匿名函数 参数二：可迭代对象
1
2
3
4

7：python生成随机整数，小数，0-1之间的小数

import random
# 1：生成随机整数[0,10]
print(random.randint(0, 10))
# 2：生成随机小数[0,1]
print(random.uniform(0, 1))
1
2
3
4
5

8: s =‘ajldjlajfdljfddd’,去重并从小到大排序输出‘adfjl’

s ='ajldjlajfdljfddd'
my_set = set([i for i in s]) # 去重
my_list = sorted(list(my_set)) # 排序
print(''.join(my_list)) # 拼接
1
2
3
4

9：使用lambda 函数实现两数相乘：

lambda  x, y : x * y
1

10: 字典根据key从小到大排序：

my_dict = {'1': 'aaa', '4': 'bbb', '0': 'ccc'}
print(dict(sorted(my_dict.items(), key=lambda  x: x[0])))
1
2

11:两个列表[1, 5, 7, 9]和[2, 2, 6, 8]合并为[1, 2, 2, 5, 6, 7, 8, 9]

# 方案一：归并算法：
i = 0
j = 0
list_1 = [1, 5, 7, 9]
list_2 = [2, 2, 6, 8]
list_3 = []
length1 = len(list_1)
length2 = len(list_2)
while True:
    if i >= length1:
        list_3.extend(list_2[j:])
        break
    elif j >= length2:
        list_3.extend(list_1[i:])
        break
    elif list_1[i] >= list_2[j]:
        list_3.append(list_2[j])
        j = j + 1
    else:
        list_3.append(list_1[i])
        i = i + 1
print(list_3)

# 方案二：投机取巧，合并再排序：
list_1 = [1, 5, 7, 9]
list_2 = [2, 2, 6, 8]
list_1.extend(list_2)
print(sorted(list_1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

12: list1 = [2, 3, 5, 4, 9, 6],从小到大排序，不许用sort ,输出[2, 3, 4, 5, 6, 9]

# 方案一：冒泡排序,等其他排序算法
list1 = [2, 3, 5, 4, 9, 6]

for i in range(len(list1)-1):
    for j in range(len(list1)-i-1):
        if list1[j] > list1[j+1]:
            list1[j], list1[j+1] = list1[j+1], list1[j]
print(list1)

# 方案二：使用sorted:
list1 = [2, 3, 5, 4, 9, 6]
print(sorted(list1))
1
2
3
4
5
6
7
8
9
10
11
12

13: python是如何进行内存管理的？

# 引用计数，垃圾回收，内存池。
1

14: range的用法：

注意：range函数，第一个表示起始下标，第二个表示不会有的末尾下标，第三个是步幅。
print(list(range(10)))
print(list(range(1, 10)))
print(list(range(0, 9, 2)))
print(list(range(10, 1, -1)))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# [0, 2, 4, 6, 8]
# [10, 9, 8, 7, 6, 5, 4, 3, 2]
1
2
3
4
5
6
7
8
9

15: python的多线程编程和多进程编程有什么区别？使用哪些接口？

多线程使用threading模块
多进程使用multiprocessing模块
区别：
1：线程是CPU调度的基本单位，进程是资源分配的基本单位。
2：多线程共享全局变量，进程与进程之间自己有自己的全局变量。
1
2
3
4
5

16：import 和from import 的区别

1： import xxx导入的是一个模块，并将整个模块执行一遍，但是 if __main__ == "__main__"里面的没有执行。
2： import,当需要导入XXX中的函数、变量、类，等需要使用 XXX.YYY的方式导入。
3： from XXX import YYY 是将函数名，变量名，类都导入到当前的命名空间中，因此可以之间使用YYY。
1
2
3

17：获取命令行参数

sys.argv # 获取命令行参数列表
1

18：字符串格式化：

1： 使用 % 和 format格式化字符串：用数字变量num统计数量，用字符串变量style统计类型，打印"There is $sum $style birds"

print("There is ${} ${} birds".format('1', 'style'))
print("There is $%d $%s birds" %(1, 'style'))
1
2

2：

pi = 3.1415926
m = 100
n = 100000

print("%.2f..%+6d..%-6d..%06d" % (pi, m, m, m))
# 3.14..  +100..100   ..000100
print("{0:>6.3f}..{1:*<+6}..{2:,d}".format(pi, m, n))
#  3.142..+100**..100,000
1
2
3
4
5
6
7
8

19：测试字典键值是否存在有哪些方法？

my_dict = {'name': 'renshanwen', 'age': 18}
print('name' in my_dict.keys())
# 注意python2的时候可以使用hasin(),但是python3就没有了。
1
2
3

20：解释yield的基本用法？

1：携带yield关键字的函数是个生成器。
2：yield关键字是暂停返回，当使用next再次调用生成器时，可以在yiled关键字之后继续执行。
1
2

21：简述python3中 / 与 //的区别：

/ 除法 ： 得到一个小数
//整除 ： 向下取整。
1
2

22：简述 trunc 与floor除法有什么区别？

math.floor 是返回 小于或者等于当前值的`最大整数` 例如：3.2 得到3 ，-3.2 得到 -4
math.trunc 是截断后面的部分 3.2 得到 3 ，-3.2 得到 -3
两者的区别在于处理负数上。
1
2
3

23：python如何查看模块中的方法？如何查看方法的使用说明？

# 1： 查看函数的帮助信息：
dir(模块名)
# 2：查看方法的使用说明
help(方法名)
1
2
3
4

24：利用分片操作逆向遍历列表lista = '123456789’得到结果‘876543’

lista = '123456789'
print(lista[-2:1:-1])
1
2

25：列出自己常用的python库以及API:

1:time,json,pickle,random
2:os,sys
3:threading
4:Django
5:Flask
6:math
1
2
3
4
5
6

26: 递归求解5！

def my_func(m):
    return m if m == 1 else m * my_func(m-1)
print(my_func(5))
1
2
3

27：一个球从100米高度自由下落，每次落地后反跳回原来高度的一半，再次落地，求第10次落地，共经过多少米？第十次反弹多高？

# 反弹 50 25 12.5 
# 经过距离： 100 100+50*2  100+50*2+25*2
tan = 100
distance = 100
for i in range(1, 11):
    tan = tan / 2
    if i == 10:
        break
    distance += tan * 2
print("第10次落地经过{}米，第十次反弹{}高".format(distance, tan))
# 第10次落地经过299.609375米，第十次反弹0.09765625高
1
2
3
4
5
6
7
8
9
10
11

28：输入一行字符，分别统计出其中的字母，空格，数字，以及其他字符的个数。

my_str = 'aAC666 & / 1 345'
count_num = 0
count_mul = 0
count_str = 0
count_nnn = 0
for i in my_str:
    if (i >= 'a' and i <='z') or (i >= 'A' and i <= 'Z'):
        count_str += 1
    elif i >= '0' and i <= '9':
        count_num += 1
    elif i == ' ':
        count_nnn += 1
    else:
        count_mul += 1

print("字母的数量：{}".format(count_str))
print("数字的数量：{}".format(count_num))
print("空格的数量：{}".format(count_nnn))
print("其他的数量：{}".format(count_mul))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

29：输入某年某月某日，判断这一天是这一年的第几天？

# 导入日历模块
import calendar
year = int(input('请输入年份：'))
month = int(input("请输入月份: "))
day = int(input('请输入日：'))
sum_day = 0 # 这一年的第几天
if calendar.isleap(year):
    days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
else:
    days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
for i in range(1, 13):
    if i == month:
        sum_day = sum_day + day
        break
    else:
        sum_day = sum_day + days[i]
print(sum_day)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

30：矩阵的转置：

list1 = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]
def trans_list(m):
    list_zip = zip(*m)
    list1 = [list(i) for i in list_zip]
    return list1
print(trans_list(list1))
1
2
3
4
5
6
7
8
9
10

31：不带括号的四则运算：

案例：3 * 6 -2 * 5 得到结果：8

1

32：手写单例模式：

class Single_Class(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Single_Class, cls).__new__(cls, *args, **kwargs)
        return cls._instance
1
2
3
4
5

33：生成器实现，斐波那锲数列

# 生成一个生成器对象
def feibonaqie(max_num):
    a, b = 0, 1
    flag = 0
    while flag < max_num:
        yield a
        a, b = b, a+b
        flag += 1

obj = feibonaqie(100)
print([o for o in obj])
1
2
3
4
5
6
7
8
9
10
11

34：反转字符串：

str = 'abcdefg'
print(str[::-1])
1
2

35: 现在有models模块中有model1.py model2.py model3.py 我要使用form models import * 只导入 model1.py 和 model2.py 如何操作？

在包中增加 __init__.py文件，然后在文件中增加：
__all__ = ['mod1', 'mod2']
1
2

36：Python2中下面代码有什么隐患？

def strtest1(num):
    str = 'first'
    for i in range(num):
        str += 'X'
    return str
1
2
3
4
5

# 隐患1:python2中range是直接生成一个列表，如果num足够大，则列表会占用大量的内存空间。
# 隐患2: str是不可迭代对象，如果num太大，将创建很多str对象，也会占用大量的内存空间。
1
2

37: 请问如何修改以下python代码，使得下面的代码调用类A的show方法？

class A():

    def show(self):
        print("base show")
class B(A):

    def show(self):
        print("derived show")
obj = B()
obj.show()

# 答案：
obj.__class__ = A
1
2
3
4
5
6
7
8
9
10
11
12
13

38: 请问如何修改以下python代码，使得代码能够运行？

考察点：__call__方法的用途：对象能够直接被调用。

class A():
    def __init__(self, a, b):
        self.__a = a
        self.__b = b

    def myprint(self):
        print('a =', self.__a, 'b =', self.__b)
a1 = A(10, 20)
a1.myprint()
a1(80) # 问题出在这里，对象可以直接被调用？

# 答案：需要实现__all__方法：
 def __call__(self, num):
        print('call:', num + self.__a)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

39:下面代码的输出是什么?

考察点：__init__方法和__new__方法的作用：

class B():
    def fn(self):
        print('B fn')
    def __init__(self):
        print('B INIT')
class A():
    def fn(self):
        print('A fn')
    def __new__(cls, a):
        print("NEW", a)
        if a > 10:
            return super(A, cls).__new__(cls)
        return B()
    def __init__(self, a):
        print("INIT", a)

a1 = A(5)
a1.fn()
a2 = A(20)
a2.fn()
# 输出结果：
NEW 5
B INIT
B fn
NEW 20
INIT 20
A fn
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

40: 下面这段代码输出什么?

考点：局部变量和全局变量：

num = 9

def f1():
    num = 20

def f2():
    print(num)

f2() 
f1() # 这里没有打印，并且num只作用于f1这个函数。
f2()
# 输出
9
9
1
2
3
4
5
6
7
8
9
10
11
12
13
14

41: 如何添加代码，使得没有定义的方法都调用mydefault方法？

考点：__getattr__的用法：异常属性的时候被调用。

class A():
    def __init__(self, a, b):
        self.a1 = a
        self.b1 = b
        print('init')
    def mydefault(self):
        print('default')
a1 = A(10, 20)
a1.fn1()
a1.fn2()
a1.fn3()

# 答案：
def __getattr__(self, item):
        return self.mydefault
# 解释：我的a1对象，并没有fn1和fn2这些属性，此时可以使用 __getattr__，这个是当对象没有这个属性的时候会调用它。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

42：求列表的交集，并集，差集：

list1 = [1, 2, 3, 4]
list2 = [3, 4,  5, 6, 7]

print("交集是：", list(set(list1) & set(list2))) # 两个共有的
print("并集是：", list(set(list1) | set(list2))) # 两个都有的
print("差集是：", list(set(list1) ^ set(list2))) # 全部的去除共有的
1
2
3
4
5
6

43： 手写一个装饰器：

def check(fn):
    def inner():
        print("请先登录")
        fn()
    return inner
    
def comment():
    print("发表评论")

comment = check(comment)
comment()
1
2
3
4
5
6
7
8
9
10
11

44：给出下面的打印结果：

def funcA(num):
    if len(num) == 0:
        return 0
    for i in range(len(num)):
        num[i] = float(num[i]) # 转变成float类型
    return max(num) # 

def funcB(num):
    if len(num) == 0:
        return 0
    for i in range(len(num)):
        num[i] = float(num[i])
    return sum(num) / len(num) # 拿到的是整形

x = [4, 4, 6, 8, 2, 12]
print(funcA(x)) # 12.0
print(funcB(x)) # 6.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

45：字典如何删除键，如何合并两个字典？

my_dict = {'name': 'renshanwen', 'age': 20}
del my_dict['name'] # 删除字典的key
print(my_dict) #{'age': 20}
1
2
3

# 方案一：
my_dict = {'name': 'renshanwen', 'age': 20}
my_dict2 = {'name': 'shanwen', 'age':30, 'sex': '男'}
my_dict2.update(my_dict) # 使用update方法，但是后者会覆盖前者
print(my_dict2) # {'name': 'shanwen', 'age': 20, 'sex': '男'}


# 方案二：
my_dict = {'name': 'renshanwen', 'age': 20}
my_dict2 = {'name': 'shanwen', 'age':30, 'sex': '男'}
my_dict3 = {**my_dict, **my_dict2} # 利用拆包，后者覆盖前者
print(my_dict3) # {'name': 'shanwen', 'age': 30, 'sex': '男'} 
1
2
3
4
5
6
7
8
9
10
11
12

46：正则表达式的匹配：

1

47：文件路径的引用：(考察相对导包)

# 使用绝对导包：两个都是这样引用。
from subpackage1.module_y import hello_word
1
2

48：给一组从小到大的数字，从中找到一个丢失的数字

例如：[0, 0, 1, 3, 4] ,输出2

my_list = [0, 0, 2, 4, 5]

flag_num = my_list.pop()
while my_list:
    flag_num2 = my_list.pop()
    if flag_num2 != flag_num and flag_num2 != (flag_num -1):
        print(flag_num - 1)
        break
    else:
        flag_num = flag_num2
1
2
3
4
5
6
7
8
9
10

59：判断括号是否成对出现

def stack_list(my_str):
    length = len(my_str)
    if length % 2 != 0:
        return False
    my_stack = []
    for i in my_str:
        if i == '(' or i == '{':
            my_stack.append(i)
        elif i == ')' and len(my_stack) != 0:
            flag = my_stack.pop()
            if flag != '(':
                return False
        elif i == '}' and len(my_stack) != 0:
            flag = my_stack.pop()
            if flag != '{':
                return False
    if len(my_stack) != 0:
        return False
    else:
        return True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

50: 指出下列程序是否会报错：

url = "http://www.qq.com"
def func():
    print(url)
    url = url.split(".")[1]
    print(url)
if __name__ == "__main__":
    func()
    
# url在局部没有定义，如果在局部修改全局变量，需要使用global指定。

url = "http://www.qq.com"
def func():
    global url
    print(url)
    url = url.split(".")[1]
    print(url)
if __name__ == "__main__":
    func()
    print(url)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19