Python常见问题详解2

花开盛夏^.^

已于 2022-09-19 22:48:30 修改

阅读量198

点赞数

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

于 2022-09-19 22:48:19 首次发布

本文链接：https://blog.csdn.net/weixin_45639224/article/details/126943172

版权

Python 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Python常见问题详解2

（一）python中map函数特点？

map函数是python中一个内置函数，称为映射。它返回的是一个新的迭代器对象，不会改变原有对象。
简单说：它的作用将函数映射作用于序列上。

语法格式：

map(function, iterable)
#function -- 函数
#iterable -- 序列

示例：
（1）利用map()结合split()进行输入

a,b,c = map(int,input().split(","))#此处function为int，序列即输入
print(a,b,c)
>>>1,2,3
>>>1 2 3

（2）map()返回迭代器

l = [2,0,0,2,0,2,2,2]
result = map(lambda x: x*x,l)
print(result)#返回一个迭代器
>>><map object at 0x000001DC51E22EC8>
print(list(result))#使用 list() 转换为列表
>>>[4, 0, 0, 4, 0, 4, 4, 4]
print(list(map(lambda x:x*x,l)))#合并为一行代码解决
>>>[4, 0, 0, 4, 0, 4, 4, 4]

（3）map中的function取自定义函数

def func(x):
    return x*2
print(list(map(func,range(3))))
>>>[0, 2, 4]

（二） python中列表和元组的联系与区别？

相同点：

列表与元组都是容器，都能存储数据
列表与元组的数据可以进行互相转化

不同点：

列表属于动态数据，不可变但可以对元素进行增、删、改来改变元素的长度。
元组属于静态数据，不可变类型。
元组被定义不允许修改。
列表定义后用户可以使用for或者while对列表中的数据进行遍历，能对列表中的元素进行增、删、改。
列表与元组保存数据的格式不同，列表使用[]括号存储数据，元组使用()存储数据。
列表和元组查询速度，元组优于列表，安全性元组比列表安全性高。
一般用于存储同一类型同语义的数据的集合。

（三）列表与字典的区别？

1.二者区别

列表是有序的集合，可以通过索引进行取值。字典是无序的集合，如果向字典添加内容，显示的顺序可能会跟添加的顺序不同
列表和字典都是异构性（可变数据类型），可以包含不同种类和任意对象，举例:[“year”,{“key”:“value”},[“chengzi”],(37)]
列表中的元素是使用索引访问的，而字典是使用键来访问的。

2.优点和缺点都有哪些？

列表和字典的优缺点是相辅相成的，列表节省内存，字典浪费内存，列表查询速度慢，字典查询速度快
列表的优点是占用内存空间小，节省内存（插入，修改，删除都是本地修改，用的是同一块内存空间，pop除外，因为pop有返回值）
列表的缺点是查询和插入的速度慢，会随着元素的增加而增加字典的缺点是占用大量内存空间，浪费内存
字典的优点是查找和插入的速度快，不会随着key的增加而变慢

（四） Python多线程的使用？

1.线程模块

Python3 通过两个标准库_thread和threading提供对线程的支持。
_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。threading 模块除了包含 _thread模块中的所有方法外，还提供的其他方法：

threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法：

run(): 用以表示线程活动的方法。
start():启动线程活动。
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。

2.使用 threading 模块创建线程
可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用start()方法启动新线程，它调用了线程的run()方法：

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.counter, 5)
        print ("退出线程：" + self.name)

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")

3.线程同步
如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：

#!/usr/bin/python3

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("开启线程： " + self.name)
        # 获取锁，用于线程同步
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # 释放锁，开启下一个线程
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")