python笔试题（一）

忘是亡心i 2022-12-28 11:08 158阅读 0赞

### 目录 ###

*   *   *  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：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70]

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：正则表达式的匹配： ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70 1]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70 2]

# 使用绝对导包：两个都是这样引用。
    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：判断括号是否成对出现 ###

![在这里插入图片描述][20201216155905427.png]

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)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70]: /images/20221120/d527d91414094ca3a114541ed7785760.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70 1]: /images/20221120/43745e034a074472af47047f70557bd3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70 2]: /images/20221120/afcf354a75924de4a285938ca623b4c2.png
[20201216155905427.png]: /images/20221120/942214ba88ec4159bf18006d003eb869.png