python简单测试

最新推荐文章于 2025-06-09 22:59:09 发布

原创最新推荐文章于 2025-06-09 22:59:09 发布 · 530 阅读

本内容遵循CC 4.0 BY-SA版权协议

这篇博客主要介绍了Python的基础知识，包括数据类型如int、float、str、list、dict、set的特性与用途，以及线性数据结构的切片操作。此外，详细讲解了return、yield、continue、break、if-else、while-else等控制结构的用法，并探讨了列表解析式和生成器表达式的功能和特点。博客还涵盖了闭包的概念、奇数和的统计、特定条件下的集合取数、字符串编码、链接筛选、冒泡排序、随机ID生成、字典值互换以及列表去重等编程问题。

一，尽可能多的列出已学过的数据类型，对比介绍他们的特点和用途（10分）

数据类型

int: float: complex: str: bytes: byterarry: bool：
字节序bytes: 在二进制世界里只有0和1，其中每一个字节有8位，为了方便人们的理解字节序用b’string’表示，是一个不可变的数据类型，

可变字节序列byterarry：它相对于bytes而言，多了一个可修改的功能
字符串str：字符串用引号表示【‘ ’，““ ””，“““ ”””】，也是一个不可变的数据类型，和元组一样操作它也是从新生成一个全新的，全世界一半以上的算力基本都在处理字符串，在文本操作中用的都是字符串，

数据结构（只要是线性数据结构都能切片）

列表list：列表用‘[ ]’表示，是一个有序可变的引用类型数据结构，由于其在内存中开辟的存储空间是连续的，所以可以用索引快速访问他的每一个元素，也正是因为是连续的存储空间，在列表的的非末尾增删时，会引起增删点后面的元素的大量挪动，此时如果所需的连续空闲空间不足，会导致程序崩溃，但在列表末尾用append按位增加，或用pop按位弹出，亦或用extend追加iterable对象等效率都是O（1）
链表linked list：链表分为单向和双向链表，和列表一样都是有序可变序列，但是其开辟的内存空间是不连续的，可以理解为他在一个连续的内存空间里是【4，1，3，2】，但在人们操作它时，表现形式为【1，2，3，4】。就像一串珠子通过一条线连接，因此在对其中间进行插入操作时是非常方便的，只需要断开两珠子之间的线然后在连接即可，但是要在链表中用索引时就麻烦了，以为我们根本不知道这个索引对象在哪，只能从索引‘0’或‘-1’开始一个一个的找，
栈stack：栈的特点是LILO,后进后出，就像抢的弹夹一样，一发一发的压在一起，当我们要取最下面的子弹时，只能把上面的子弹全部取出，此结构多用于函数的压栈，
队列queue：队列的特点是FIFO，先进先出，只能在其首尾进行操作，
元组tuple：元组用‘（）’表示，是一个有序但不可变序列，表面上对元组的增删操作其实是生成了一个新的元组，不能对其进行增删改，但是可以迭代它。
字典dict：字典用‘｛key：value｝’表示，是一个可变,无序,不重复,的数据结构，它采用了和其他线性结构不同的对key进行hash计算，每一个可哈希的值哈希后会得到唯一的值，这就保证了字典数据不重复，hash函数在每一次shell的运行中会生成一个足够大的值用于取模运算，保证了在当次内核运行中的冥等性，当然也有极低的概率出现两个对象出现相同的哈希值，叫哈希冲突，
集合set：基本和字典一样，只有连个不同点他没有指点的value，生成空集合时不能直接用‘｛｝’，只能用set（）

二，分别简述return，yield，continue，break，if else，while else（10分）

return：其只在函数中出现，当函数运行时碰到return就会立即退出函数运算，并返回return值，一个函数可以没有return，此时当函数执行完所有语句时就会结束并返回一个默认值None，当然函数中也可以有多个return解释器关键字，次时函数执行到某个分支是碰到return也会返回，return后可写返回值，不写默认返回None
yield：其作为生成器函数的关键字，当函数碰到该关键字时，会暂停执行并返回yield值，生成器函数可以用for in迭代，也可以用next（iter，defalut），用next时生成器只能碰到一次yield返回一个值，没有返回值则返回None，同时python还提供了人机交互的iter.send()功能，方便我们对函数进行交互
continue：结束当层当次循环，进行当层的下一次循环
break：终止,退出当层循环
if else：当if条件为True时，不执行else语句。只有当if的条件为False时才执行了else语句
while else：当while为一个死循环时，不会执行else，只要while的条件为False时，就会执行else

三，简述列表解析式和生成器表达式功能和特点（5分）

列表解析式：[i for i in iterable]立即生成一个列表需开辟连续的内存空间，当其内部的表达式计算一个值需要大量时间时，最后输出结果需要等待一段时间
生成器表达式：（i for i in iterable）生成一个惰性求值，延迟计算的迭代器，它需要用for in，next驱动，每一次驱动才会计算一次，用next驱动但没有设置defalut时会报错，一定要注意生成器的闭包与其内部的标识符及函数的作用域，极容易出错

s = 0
a = (s+i for i in range(1))
s = 2
for j in a:
    print(j)
#输出2

最后生成器的s变成2而不是之前定义的0，生成器只是记住了变量而已

四，解释python中的闭包，并写出代码（5分）

闭包出现的情况是要有嵌套函数，内层的函数引用了外层函数的自由变量（对于内层来讲叫做自由变量）。当函数调用结束后其内层的函数使用了外层的自由变量，可是内层函数并没有释放（被其它标识符记住）导致该自由变量也不会消亡，此现象称为闭包

def foo():
    a = 0
    
    def too():
        nonlocal a
        a += 1
        return a
    return too

b = foo()
b()
#输出1

五，统计制定正整数n（包含n）以内的奇数和（5分）

def oddn_sum(x):
    sum1 = 0
    
    for i in range(1,n+1):
        if i & 1:
            sum1 += i
    return sum1

num = int(input('natural number'))
oddn_sum(num)

六，从集合numset = ｛1，9，15，60，77，21，18，6，-5，-21｝中随机取数，要求取到的数可以被3整除，但不能被5整除，一共取8位，分别打印这8个数，和他们的和（5分）

import random
def foo(iterable:set):
    count = 8
    iter1 = list(iterable)
    l1 = []
    
    while count:
        num = random.choice(iter1)
        if  not num % 3 and num % 5:
            l1.append(num)
            count -= 1
    print(l1,sum(l1))
    
numset = {1,9,15,60,77,21,18,6,-5,-21}
foo(numset)

七，写出‘马哥教育’分别用utf-8和gbk编码所占用的位数（5分）

src = '马哥教育'
print('{}GBK编码长度为{}，utf-8编码长度为{}'.\
      format(src,len(src.encode('gbk')),len(src.encode())))

八，从下面链接中找出https开头的链接并且该链接以.gz结尾，将符号要求链接的文件名顺序输出（5分）

import re
src1 = '''
http://mirrors.kernel.org/gnu/coreutils/coreutils-6.11.tar.gz
http://mirrors.kernel.org/gnu/bash/bash-5.0.tar.gz
https://wwW.baidu.com/
https://www.apache.org/dyn/closer.cgi/hadoop/common/hadoop-3.1.2/hadoop-3.1.2-src.tar.gz
https://apache.org/dist/hbase/2.1.4/apicompare_2.1.3_to_2.1.4RC1.html
https://www.apache.org/dyn/closer.lua/hbase/2.1.4/hbase-2.1.4-src.tar.gz
https://tomcat.apache.org/download-90.cgi
http://mirrors.kernel.org/gnu/grub/grub-2.02.tar.xz
http://mirrors.tuna.tsinghua.edu.cn/apache/tomcat/tomcat-9/v9.0.19/bin/apache-tomcat-9.0.19-fulldocs.tar.gz
https://archive.apache.org/dist/zookeeper/current/zookeeper-3.4.14.tar.gz
https://hub.docker.com/editions/community/docker- ce-desktop-mac
https://home.firefoxchina.cn/
http://docs.ceph.com/docs/master/
'''
target1,target2= re.compile(r'\bhttps://.*\.gz\b'),re.compile(r'/[^/]+.gz')
l1 = [i.lstrip('/') for i in target2.findall(''.join(target1.findall(src1)))]
print(l1)

九，随机生成20个1到100的整数然后请使用冒泡排序进行排序（5分）

import random

def bubbling(ite):
    length = len(ite)
    
    for i in range(length):
        for j in range(1,length-i):
            if ite[j-1] > ite[j]:
                ite[j],ite[j-1] = ite[j-1],ite[j]
    return ite
    
l1 = [i for i in (random.randrange(1,101) for j in range(20))]
bubbling(l1)

十，生成6个ID，字符串，格式为随机（3小写字母，4个大写，5五个数字）组成（5分）

l1 = [('{}.{}.{}'.format(''.join((chr(random.randrange(97,123))for j in range(3))),\
                         ''.join((chr(random.randrange(65,91))for j in range(4))),\
                         ''.join((str(random.randint(0,9)) for j in range(5)))))\
                         for x in range(6)]
print(l1)

十一，已知一个字典的值都有不同，请重新生成一个新字典，要求其kv值位值互换用zip（5分）

d1 = {k:v for k,v in zip(range(10,20),range(10))}
d2 = {}
for k,v in d1.items():
    d2[v] = k
print(d1)
print(d2)

十二，输入1-9的数打印出对应长度的十字架图案

def number(x):
    div,mod = divmod(x,2)
    if not mod:
        for i in range(1, x+1):
            if i == div or i == div+1:
                print(str(x)*x)
            else:
                print(" "*((x-2)//2), str(x)*2, sep="")
    else:
        for i in range(1, x+1):
            if i == div+1:
                print(str(x)*x)
            else:
                print(" "*div, str(x), sep="")
while True:
    num = int(input())
    number(num)

十三，对列表去重，并保持列表第一次出现元素的相对位置

l1 = [6,5,15,6,7,'a',5,9,9,6,7,'a',9,]
s1 = set()
index = 0

for i in l1:
    if i not in s1:
        s1.add(i)
        l1[index] = i
        index += 1
        
l1[index:] = []
print(l1)

十四，解释什么是装饰器，请写一个日志记录（开始执行时间是耗时）的装饰器，并通过文件操作记录到本地，文件名为｛函数名｝+.log

from functools import wraps
import datetime,time

def log(mane,start,time):
    with open(f'{mane}+.log','a',encoding='gbk') as f:
        f.write(f'开始时间{start}\n')
        f.write(f'耗时{time}\n')
        f.close()
        
def logger(fn):
    @wraps(fn)
    def wrapper(*args,**kwargs):
        start = datetime.datetime.now()
        ret = fn(*args,**kwargs)
        delat = (datetime.datetime.now()-start).total_seconds()
        log(fn.__name__,start,delat)
        return ret
    return wrapper
    
@logger
def add(x, y):
    time.sleep(5)
    return x + y
    
add(2,3)

十五，一下代码输出结果是（0，2，4，6）么？如果不是，如果不是，是说明原因，你将会怎么做，让他变成（0，2，4，6）

def testfun():
    temp = [lambda x: i*x for i in range(4)]
    return temp
for ev in testfun():
    print(ev(2))

对于函数lambda来讲，它使用的i是外层函数的自由变量，由于只是生成了函数并没有当即执行，最后列表解析式中的4个lambda所使用得标识符i的值都是3，当给lambda函数传入实参2时，结果都是666！

def testfun():
    temp = (lambda x: i*x for i in range(4))
    return temp
for ev in testfun():
    print(ev(2))