python笔试题（一）

目录

• • 
    
• ​​1：一行代码实现1-100的和：​​
• ​​2：列出5个python的标准库：​​
• ​​3：python实现列表去重的方法：​​
• ​​4：python的内置数据类型，以及哪些是可变类型？哪些是不可变类型？：​​
• ​​5：with方法打开处理文件帮我们做了什么？​​
• ​​6：列表[1, 2, 3, 4, 5],使用map()函数输出[1, 4, 9, 16, 25],使用列表推导式取出大于10的数，最终结果是[16, 25]​​
• ​​7：python生成随机整数，小数，0-1之间的小数​​
• ​​8: s ='ajldjlajfdljfddd',去重并从小到大排序输出‘adfjl’​​
• ​​9：使用lambda 函数实现两数相乘：​​
• ​​10: 字典根据key从小到大排序：​​
• ​​11:两个列表[1, 5, 7, 9]和[2, 2, 6, 8]合并为[1, 2, 2, 5, 6, 7, 8, 9]​​
• ​​12: list1 = [2, 3, 5, 4, 9, 6],从小到大排序，不许用sort ,输出[2, 3, 4, 5, 6, 9]​​
• ​​13: python是如何进行内存管理的？​​
• ​​14: range的用法：​​
• ​​15: python的多线程编程和多进程编程有什么区别？使用哪些接口？​​
• ​​16：import 和from import 的区别​​
• ​​17：获取命令行参数​​
• ​​18：字符串格式化：​​
• ​​19：测试字典键值是否存在有哪些方法？​​
• ​​20：解释yield的基本用法？​​
• ​​21：简述python3中 / 与 //的区别：​​
• ​​22：简述 trunc 与floor除法有什么区别？​​
• ​​23：python如何查看模块中的方法？如何查看方法的使用说明？​​
• ​​24：利用分片操作逆向遍历列表lista = '123456789'得到结果‘876543’​​
• ​​25：列出自己常用的python库以及API:​​
• ​​26: 递归求解5！​​
• ​​27：一个球从100米高度自由下落，每次落地后反跳回原来高度的一半，再次落地，求第10次落地，共经过多少米？第十次反弹多高？​​
• ​​28：输入一行字符，分别统计出其中的字母，空格，数字，以及其他字符的个数。​​
• ​​29：输入某年某月某日，判断这一天是这一年的第几天？​​
• ​​30：矩阵的转置：​​
• ​​31：不带括号的四则运算：​​
• ​​32：手写单例模式：​​
• ​​33：生成器实现，斐波那锲数列​​
• ​​34：反转字符串：​​
• ​​35: 现在有models模块中有model1.py model2.py model3.py 我要使用form models import * 只导入 model1.py 和 model2.py 如何操作？​​
• ​​36：Python2中下面代码有什么隐患？​​
• ​​37: 请问如何修改以下python代码，使得下面的代码调用类A的show方法？​​
• ​​38: 请问如何修改以下python代码，使得代码能够运行？​​
• ​​39:下面代码的输出是什么?​​
• ​​40: 下面这段代码输出什么?​​
• ​​41: 如何添加代码，使得没有定义的方法都调用mydefault方法？​​
• ​​42：求列表的交集，并集，差集：​​
• ​​43： 手写一个装饰器：​​
• ​​44：给出下面的打印结果：​​
• ​​45：字典如何删除键，如何合并两个字典？​​
• ​​46：正则表达式的匹配：​​
• ​​47：文件路径的引用：(考察相对导包)​​
• ​​48：给一组从小到大的数字，从中找到一个丢失的数字​​
• ​​59：判断括号是否成对出现​​
• ​​50: 指出下列程序是否会报错：​​
  • 
    

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

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

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

os，sys，re，math，datetime

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

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

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

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

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

# 关闭文件 f.close()

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函数参数一：匿名函数 参数二：可迭代对象

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

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

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

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

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

lambda  x, y : x * y

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

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

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

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

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

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

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]

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

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

16：import 和from import 的区别

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

17：获取命令行参数

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

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

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

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

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

20：解释yield的基本用法？

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

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

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

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

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

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

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

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

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

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

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

26: 递归求解5！

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

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高

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

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)

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

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

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

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

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

34：反转字符串：

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

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

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

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

def strtest1(num):
    str = 'first'
    for i in range(num):
        str += 'X'
    return str

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

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

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)

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

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

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

num = 9

def f1():
    num = 20

def f2():
    print(num)

f2() 
f1() # 这里没有打印，并且num只作用于f1这个函数。
f2()
# 输出
9
9

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__，这个是当对象没有这个属性的时候会调用它。

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))) # 全部的去除共有的

43： 手写一个装饰器：

def check(fn):
    def inner():
        print("请先登录")
        fn()
    return inner

def comment():
    print("发表评论")

comment = check(comment)
comment()

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

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

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

# 方案一：
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': '男'}

46：正则表达式的匹配：

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

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

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

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

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)