1. 字典根據鍵從小到大排序？

In[38]: dic = {"name": "Tom", "age": 30, "country": "USA"}In[39]: sorted(dic.iteritems(), key=lambda x : x[0])
Out[39]: [('age', 30), ('country', 'USA'), ('name', 'Tom')]In[40]: dict(sorted(dic.iteritems(), key=lambda x : x[0]))
Out[40]: {'age': 30, 'country': 'USA', 'name': 'Tom'}

sorted 語法：

sorted(iterable[, cmp[, key[, reverse]]])

參數說明：

• iterable：可迭代對象。
• cmp：比較的函數，這個具有兩個參數，參數的值都是從可迭代對象中取出，此函數必須遵守的規則為，大于則返回1，小于則返回-1，等于則返回0。
• key：主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自于可迭代對象中，指定可迭代對象中的一個元素來進行排序。
• reverse：排序規則，reverse = True 降序 ， reverse = False 升序（默認）。

2. 單例模式

class Single(object):__isstance = None__first_init = Falsedef __new__(cls, *args, **kwargs):if not cls.__isstance:cls.__isstance = object.__new__(cls)return cls.__isstancedef __init__(self, name):if not self.__first_init:self.name = nameSingleton.__first_init = True

3. 統計字符串每個單詞出現的次數

In[41]: from collections import Counter
In[42]: s3 = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"In[43]: Counter(s3)
Out[43]: 
Counter({';': 6,'a': 4,'b': 1,'d': 3,'f': 5,'g': 1,'h': 6,'j': 3,'k': 1,'l': 9,'s': 2})

4. a=（1，）b=(1)，c=(“1”) 分別是什么類型的數據？

In[46]: a = (1,)
In[47]: type(a)
Out[47]: tupleIn[48]: b = (1)
In[49]: type(b)
Out[49]: intIn[50]: c = ("1")
In[51]: type(c)
Out[51]: str

5. x=“abc”,y=“def”,z=[“d”,“e”,“f”]，分別求出 x.join(y) 和 x.join(z) 返回的結果

join() 括號里面的是可迭代對象，x 插入可迭代對象中間，形成字符串，結果一致

In [1]: x = "abc"In [2]: y = "def"In [3]: z = ["d", "e", "f"]In [4]: x.join(y)
Out[4]: 'dabceabcf'In [5]: x.join(z)
Out[5]: 'dabceabcf'

6. 請說明 sort 和 sorted 對列表排序的區別

• sort() 與 sorted() 的不同在于，sort 是在原位重新排列列表，而 sorted() 是產生一個新的列表。sorted(L) 返回一個排序后的 L，不改變原始的L；
• L.sort() 是對原始的 L 進行操作，調用后原始的 L 會改變，沒有返回值；所以a = a.sort()是錯的啦！a = sorted(a)才對。
• sorted() 適用于任何可迭代容器，list.sort() 僅支持 list
• 基于以上兩點，sorted 使用頻率比 list.sort() 更高些，所以 Python 中更高級的排序技巧便通過 sorted() 來演示

7. 對 foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4] 進行排序，使用 lambda 函數從小到大排序

In [6]: foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]In [7]: sorted(foo, key=lambda x: x)
Out[7]: [-20, -5, -4, -4, -2, 0, 2, 4, 8, 8, 9]In [9]: sorted(foo, key=lambda x: x, reverse=True)
Out[9]: [9, 8, 8, 4, 2, 0, -2, -4, -4, -5, -20]

8. int(“1.4”)、int(1.4)的輸出結果？

In [10]: int("1.5")
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-10-8d7b10d14577> in <module>()
----> 1 int("1.5")ValueError: invalid literal for int() with base 10: '1.5'In [11]: eval("1.5")
Out[11]: 1.5In [12]: int(1.5)
Out[12]: 1

9. Python 垃圾回收機制？

1.引用計數

In [13]: import sys...: s = "hello world"...: sys.getrefcount(s)...: 
Out[13]: 3In [14]: s = "china"In [15]: sys.getrefcount(s)
Out[15]: 2In [16]: s = "beijing"In [17]: sys.getrefcount(s)
Out[17]: 2

2.分代技術

Python默認定義了三代對象集合，索引數越大，對象存活時間越長
Python中使用了某些啟發式算法（heuristics）來加速垃圾回收。例如，越晚創建的對象更有可能被回收。對象被創建之后，垃圾回收器會分配它們所屬的代（generation）。每個對象都會被分配一個代，而被分配更年輕代的對象是優先被處理的。

3.引用循環

垃圾回收器會定時尋找這個循環，并將其回收。舉個例子，假設有兩個對象o1和o2，而且符合o1.x == o2和o2.x == o1這兩個條件。如果o1和o2沒有其他代碼引

10. 什么是 lambda 函數？有什么好處？

lambda 函數是一個可以接收任意多個參數(包括可選參數)并且返回單個表達式值的匿名函數

1、lambda 函數比較輕便，即用即刪除，很適合需要完成一項功能，但是此功能只在此一處使用，
連名字都很隨意的情況下；

2、匿名函數，一般用來給 filter， map 這樣的函數式編程服務;

3、作為回調函數，傳遞給某些應用，比如消息處理

11. 簡述 read、readline、readlines 的區別？

read 讀取整個文件
readline 讀取下一行，使用生成器方法
readlines 讀取整個文件到一個迭代器以供我們遍歷

12. Python 中單下劃線和雙下劃線使用

__foo__ 一種約定，Python 內部的名字，用來區別其他用戶自定義的命名，以防沖突，就是例如 __init__(), __del__() , __call__() 這些特殊方法

_foo :一種約定，用來指定變量私有。程序員用來指定私有變量的一種方式。不能用 from module import * 導入，其他方面和公有一樣訪問；

__foo:這個有真正的意義：解析器用_classname__foo來代替這個名字，以區別和其他類相同的命名，它無法直接像公有成員一樣隨便訪問，通過對象名._類名__xxx這樣的方式可以訪問.

12. 代碼描述靜態方法 (staticmethod)，類方法(classmethod) 和實例方法

@staticmethod 和@classmethod 都可以直接類名.方法名()來調用，不用在實例化一個類。

class A(object):def foo(self,x):print "executing foo(%s,%s)"%(self,x)@classmethoddef class_foo(cls,x):print "executing class_foo(%s,%s)"%(cls,x)@staticmethoddef static_foo(x):print "executing static_foo(%s)"%xa=A()

@staticmethod 經常有一些跟類有關系的功能但在運行時又不需要實例和類參與的情況下需要用到靜態方法

IND = 'ON'class Kls(object)：def __init__(self, data)：self.data = data@staticmethoddef check_ind()：return (IND == 'ON')def do_reset(self)：if self.check_ind()：print('Reset done for：', self.data)def set_db(self)：if self.check_ind()：self.db = 'New db connection'print('DB connection made for： ', self.data)ik1 = Kls(12)
ik1.do_reset()
ik1.set_db()

13. 新式類和舊式類的區別？

• Python 2.x 中默認都是經典類，只有顯式繼承了 object 才是新式類，Python 3.x 中默認都是新式類，經典類被移除，不必顯式的繼承 object。
• 新式類都從 object 繼承，經典類不需要。
• 新式類的 MRO(method resolution order 基類搜索順序)算法采用 C3 算法廣度優先搜索，而舊式類的 MRO 算法是采用深度優先搜索。
• 新式類相同父類只執行一次構造函數，經典類重復執行多次。

14. 請寫出一個在函數執行后輸出日志的裝飾器

裝飾器就是一個函數，它可以在不需要做任何代碼變動的前提下給一個函數增加額外功能，啟動裝飾的效果。 它經常用于有切面需求的場景，比如：插入日志、性能測試、事務處理、緩存、權限校驗等場景。 下面是一個日志功能的裝飾器

from functools import wrapsdef do_log(func):@wraps(func)def wrapper(*args, **kw):if func.__name__ == "debug":msg = "debug {}".format(args[0])elif func.__name__ == "info":msg = "info {}".format(args[0])else:msg =  "unknown {}".format(args[0])return func(msg, **kw)return wrapper@do_log
def debug(msg):print(msg)@do_log
def info(msg):print(msg)if __name__ == "__main__":debug("123")info("abc")

15. 請解釋一下協程的優點

子程序切換不是線程切換，而是由程序自身控制
沒有線程切換的開銷，和多線程比，線程數量越多，協程的性能優勢就越明顯
不需要多線程的鎖機制，因為只有一個線程，也不存在同時寫變量沖突，在協程中控制共享資源不加鎖

16. a=“hello” 和 b=“你好” 編碼成 bytes 類型

In [1]: a = b"hello"In [2]: b = bytes("hello", "utf-8")In [3]: c = "北京".encode("utf-8")In [4]: a, b, c
Out[4]: (b'hello', b'hello', b'\xe5\x8c\x97\xe4\xba\xac')

17. 寫一個函數，接收整數參數 n，返回一個函數，函數的功能是把函數的參數和 n 相乘并把結果返回

主要考察閉包知識點：

1.必須有一個內嵌函數

2.內嵌函數必須引用外部函數中的變量

3.外部函數的返回值必須是內嵌函數

In [5]: def f(n):...:     def g(m):...:         return n*m...:     return g...: In [6]: f(3)(4)
Out[6]: 12In [7]: m = f(4)In [8]: m(5)
Out[8]: 20

18. Python 字典和 json 字符串相互轉化方法

在 Python 中使用 dumps 方法 將 dict 對象轉為 Json 對象，使用 loads 方法可以將 Json 對象轉為 dict 對象。

In [9]: dic = {'a': 10, 'b': "123", 'c': "hello world"}In [10]: import jsonIn [11]: json_str = json.dumps(dic)In [12]: json_str
Out[12]: '{"a": 10, "b": "123", "c": "hello world"}'In [13]: dic_loads = json.loads(json_str)In [14]: dic_loads
Out[14]: {'a': 10, 'b': '123', 'c': 'hello world'}In [15]: json.loads(str(dic))
---------------------------------------------------------------------------
JSONDecodeError                           Traceback (most recent JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)In [16]: json.loads(str(dic).replace("'", "\""))
Out[16]: {'a': 10, 'b': '123', 'c': 'hello world'}

如果直接使用 json.loads(str(dic))會報錯原因就是，單引號的字符串不符合 Json 的標準格式所以再次使用了 replace("’", “”")。

Json 的標準格式是不支持單引號型字符串的。

19. 分布式鎖

分布式鎖是控制分布式系統之間的同步訪問共享資源的一種方式。 對于分布式鎖的目標，我們必須首先明確三點：

• 任何一個時間點必須只能夠有一個客戶端擁有鎖。
• 不能夠有死鎖，也就是最終客戶端都能夠獲得鎖，盡管可能會經歷失敗。
• 錯誤容忍性要好，只要有大部分的Redis實例存活，客戶端就應該能夠獲得鎖。 分布式鎖的條件 互斥性：分布式鎖需要保證在不同節點的不同線程的互斥 可重入性：同一個節點上的同一個線程如果獲取了鎖之后，能夠再次獲取這個鎖。 鎖超時：支持超時釋放鎖，防止死鎖 高效，高可用：加鎖和解鎖需要高效，同時也需要保證高可用防止分布式鎖失效，可以增加降級。 支持阻塞和非阻塞：可以實現超時獲取失敗，tryLock(long timeOut) 支持公平鎖和非公平鎖

分布式鎖的實現方案 1、數據庫實現（樂觀鎖） 2、基于zookeeper的實現 3、基于Redis的實現（推薦）

20. Python 實現分布式鎖

REDIS分布式鎖實現的方式：SETNX + GETSET,NX是Not eXists的縮寫，如SETNX命令就應該理解為：SET if Not eXists。 多個進程執行以下Redis命令：

SETNX lock.foo <current Unix time + lock timeout + 1>

如果 SETNX 返回1，說明該進程獲得鎖，SETNX將鍵 lock.foo 的值設置為鎖的超時時間（當前時間 + 鎖的有效時間）。 如果 SETNX 返回0，說明其他進程已經獲得了鎖，進程不能進入臨界區。進程可以在一個循環中不斷地嘗試 SETNX 操作，以獲得鎖。

import time
import redis
from conf.config import REDIS_HOST, REDIS_PORT, REDIS_PASSWORDclass RedisLock:def __init__(self):self.conn = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, db=1)self._lock = 0self.lock_key = ""@staticmethoddef my_float(timestamp):"""Args:timestamp:Returns:float或者0如果取出的是None，說明原本鎖并沒人用，getset已經寫入，返回0，可以繼續操作。"""if timestamp:return float(timestamp)else:#防止取出的值為None，轉換float報錯return 0@staticmethoddef get_lock(cls, key, timeout=10):cls.lock_key = f"{key}_dynamic_lock"while cls._lock != 1:timestamp = time.time() + timeout + 1cls._lock = cls.conn.setnx(cls.lock_key, timestamp)# if 條件中，可能在運行到or之后被釋放，也可能在and之后被釋放# 將導致 get到一個None，float失敗。if cls._lock == 1 or (time.time() > cls.my_float(cls.conn.get(cls.lock_key)) andtime.time() > cls.my_float(cls.conn.getset(cls.lock_key, timestamp))):breakelse:time.sleep(0.3)@staticmethoddef release(cls):if cls.conn.get(cls.lock_key) and time.time() < cls.conn.get(cls.lock_key):cls.conn.delete(cls.lock_key)def redis_lock_deco(cls):def _deco(func):def __deco(*args, **kwargs):cls.get_lock(cls, args[1])try:return func(*args, **kwargs)finally:cls.release(cls)return __decoreturn _deco@redis_lock_deco(RedisLock())
def my_func():print("myfunc() called.")time.sleep(20)if __name__ == "__main__":my_func()

21. 魔法函數 _call_怎么使用?

_call_ 可以把類實例當做函數調用。 使用示例如下

class Bar：def __call__(self, *args, **kwargs)：print('in call')if __name__ == '__main__'：b = Bar()b()

22. Python 中的反射了解么?

Python 的反射機制設定較為簡單，一共有四個關鍵函數分別是 getattr、hasattr、setattr、delattr

hasattr()、getattr()、setattr() 的用法:

這三個方法屬于 Python 的反射機制里面的，

• hasattr 可以判斷一個對象是否含有某個屬性，
• getattr 可以充當 get 獲取對象屬性的作用。
• setattr 可以充當 person.name = "liming"的賦值操作。

代碼示例如下：

class Person()：def __init__(self)：self.name = "liming"self.age = 12def show(self)：print(self.name)print(self.age)def set_name(self)：setattr(Person, "sex", "男")def get_name(self)：print(getattr(self, "name"))print(getattr(self, "age"))print(getattr(self, "sex"))def run()：if hasattr(Person, "show")：print("判斷 Person 類是否含有 show 方法")Person().set_name()Person().get_name()if __name__ == '__main__'：run()

23. Python 的魔法方法及用途

1 _init_()：

類的初始化方法。它獲取任何傳給構造器的參數（比如我們調用 x = SomeClass(10, ‘foo’) ， __init__就會接到參數 10 和 ‘foo’ 。 __init__在 Python 的類定義中用的最多。

2 _new_：
__new__是對象實例化時第一個調用的方法，它只取下 cls 參數，并把其他參數傳給 init 。 __new__很少使用，但是也有它適合的場景，尤其是當類繼承自一個像元組或者字符串這樣不經常改變的類型的時候.

3 _del_：
__new__和 __init__是對象的構造器， __del__是對象的銷毀器。它并非實現了語句 del x (因此該語句不等同于 x.del())。而是定義了當對象被垃圾回收時的行為。 當對象需要在銷毀時做一些處理的時候這個方法很有用，比如 socket 對象、文件對象。但是需要注意的是，當 Python 解釋器退出但對象仍然存活的時候，__del__并不會 執行。 所以養成一個手工清理的好習慣是很重要的，比如及時關閉連接。

24. metaclass 作用？以及應用場景？

metaclass 即元類，metaclass 是類似創建類的模板，所有的類都是通過他來 create 的(調用new)，這使得你可以自由的控制創建類的那個過程，實現你所需要的功能。 我們可以使用元類創建單例模式和實現 ORM 模式。

可以使用元類實現一個單例模式，代碼如下

class Singleton(type)：def __init__(self, *args, **kwargs)：print("in __init__")self.__instance = Nonesuper(Singleton, self).__init__(*args, **kwargs)def __call__(self, *args, **kwargs)：print("in __call__")if self.__instance is None：self.__instance = super(Singleton, self).__call__(*args, **kwargs)return self.__instanceclass Foo(metaclass=Singleton)：pass  # 在代碼執行到這里的時候，元類中的__new__方法和__init__方法其實已經被執行了，而不是在 Foo 實例化的時候執行。且僅會執行一次。foo1 = Foo()
foo2 = Foo()
print(foo1 is foo2)

25. 在 Python 中是如何管理內存的？

1. 垃圾回收：

Python 不像 C++，Java 等語言一樣，他們可以不用事先聲明變量類型而直接對變量進行賦值。對 Python 語言來講，對象的類型和內存都是在運行時確定的。這也是為什么我們稱 Python 語言為動態類型的原因（這里我們把動態類型可以簡單的歸結為對變量內存地址的分配是在運行時自動判斷變量類型并對變量進行賦值）。

2. 引用計數：

Python 采用了類似 Windows 內核對象一樣的方式來對內存進行管理。每一個對象，都維護這一個對指向該對對象的引用的計數。當變量被綁定在一個對象上的時候，該變量的引用計數就是 1，(還有另外一些情況也會導致變量引用計數的增加)，系統會自動維護這些標簽，并定時掃描，當某標簽的引用計數變為 0 的時候，該對就會被回收。

26. 當退出 Python 時是否釋放所有內存分配？

不是的，循環引用其他對象或引用自全局命名空間的對象的模塊，在 Python 退出時并非完全釋放。

另外，也不會釋放 c 庫保留的內存部分。

27. Python 中遞歸的最大次數，那如何突破呢？

Python 有遞歸次數限制，默認最大次數為 2000。

In [17]: import sysIn [18]: sys.getrecursionlimit()
Out[18]: 2000

通過下面的代碼可以突破這個限制

In [19]: sys.setrecursionlimit(2500)In [20]: sys.getrecursionlimit()
Out[20]: 2500

另外需要注意的是 sys.setrecursionlimit() 只是修改解釋器在解釋時允許的最大遞歸次數，此外，限制最大遞歸次數的還和操作系統有關。

28. 一個包里有三個模塊，demo1.py、demo2.py、demo3.py，但使用 from tools import * 導入模塊時，如何保證只有 demo1、demo3 被導入了.

增加_init_.py 文件，并在文件中增加：

__all__ = ['demo1','demo3']

29. 代碼中經常遇到的 *args, **kwargs 含義及用法

在函數定義中使用 *args 和 **kwargs 傳遞可變長參數。

*args 用來將參數打包成 tuple 給函數體調用。

**kwargs 打包關鍵字參數成 dict 給函數體調用。

29. Python 中會有函數或成員變量包含單下劃線前綴和結尾，和雙下劃線前綴結尾，區別是什么?

“單下劃線” 開始的成員變量叫做保護變量，意思是只有類對象和子類對象自己能訪問到這些變量； “雙下劃線” 開始的是私有成員，意思是只有類對象自己能訪問，連子類對象也不能訪問到這個數據。

以單下劃線開頭（_foo）的代表不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用“from xxx import *”而導入；以雙下劃線開頭的（__foo）代表類的私有成員；

以雙下劃線開頭和結尾的（_foo）代表 Python 里特殊方法專用的標識，如 _init（）代表類的構造函數。

代碼示例:

class Person："""docstring for ClassName"""def __init__(self)：self.__age = 12self._sex = 12def _sex(self)：return "男"def set_age(self,age)：self.__age = agedef get_age(self)：return self.__age   if __name__ == '__main__'：p=Person()print(p._sex)#print(p.__age)#Python 自動將__age 解釋成 _Person__age,于是我們用 _Person__age 訪問，這次成功。print(p._Person__age)

30. IO 多路復用的作用？

阻塞 I/O 只能阻塞一個 I/O 操作，而 I/O 復用模型能夠阻塞多個 I/O 操作，所以才叫做多路復用。

I/O 多路復用是用于提升效率，單個進程可以同時監聽多個網絡連接 IO。 在 IO 密集型的系統中， 相對于線程切換的開銷問題，IO 多路復用可以極大的提升系統效率。

1. 說一說多線程，多進程和協程的區別?

進程：

進程是具有一定獨立功能的程序關于某個數據集合上的一次運行活動,
進程是系統進行資源分配和調度的一個獨立單位。每個進程都有自己的獨立內存空間，
不同進程通過進程間通信來通信。由于進程比較重量，占據獨立的內存，
所以上下文進程間的切換開銷（棧、寄存器、虛擬內存、文件句柄等）比較大，但相對比較穩定安全。

線程：

線程是進程的一個實體,是 CPU 調度和分派的基本單位,
它是比進程更小的能獨立運行的基本單位.
線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),
但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。
線程間通信主要通過共享內存，上下文切換很快，資源開銷較少，但相比進程不夠穩定容易丟失數據。

協程：

協程是一種用戶態的輕量級線程，協程的調度完全由用戶控制。
協程擁有自己的寄存器上下文和棧。
協程調度切換時，將寄存器上下文和棧保存到其他地方，在切回來的時候，恢復先前保存的寄存器上下文和棧，
直接操作棧則基本沒有內核切換的開銷，可以不加鎖的訪問全局變量，所以上下文的切換非常快。

區別： 進程與線程比較： 線程是指進程內的一個執行單元,也是進程內的可調度實體。線程與進程的區別：

1. 地址空間：線程是進程內的一個執行單元，進程內至少有一個線程，它們共享進程的地址空間，
   而進程有自己獨立的地址空間
2. 資源擁有：進程是資源分配和擁有的單位,同一個進程內的線程共享進程的資源
3. 線程是處理器調度的基本單位,但進程不是
4. 二者均可并發執行
5. 每個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口，
   但是線程不能夠獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制

協程與線程進行比較：

1. 一個線程可以多個協程，一個進程也可以單獨擁有多個協程，這樣 Python 中則能使用多核 CPU。
2. 線程進程都是同步機制，而協程則是異步
3. 協程能保留上一次調用時的狀態，每次過程重入時，就相當于進入上一次調用的狀態

2. 什么是并發和并行？

"并行是指同一時刻同時做多件事情，而并發是指同一時間間隔內做多件事情”。

并發與并行是兩個既相似而又不相同的概念：并發性，又稱共行性，是指能處理多個同時性活動的能力；并行是指同時發生的兩個并發事件，具有并發的含義，而并發則不一定并行，也亦是說并發事件之間不一定要同一時刻發生。

并發的實質是一個物理 CPU(也可以多個物理 CPU) 在若干道程序之間多路復用，并發性是對有限物理資源強制行使多用戶共享以提高效率。 并行性指兩個或兩個以上事件或活動在同一時刻發生。在多道程序環境下，并行性使多個程序同一時刻可在不同 CPU 上同時執行。

并行，是每個 CPU 運行一個程序。

3. 解釋什么是異步非阻塞？

異步 異步與同步相對，當一個異步過程調用發出后，調用者在沒有得到結果之前，就可以繼續執行后續操作。當這個調用完成后，一般通過狀態、通知和回調來通知調用者。對于異步調用，調用的返回并不受調用者控制。

非阻塞 非阻塞是這樣定義的，當線程遇到 I/O 操作時，不會以阻塞的方式等待 I/O 操作的完成或數據的返回，而只是將 I/O 請求發送給操作系統，繼續執行下一條語句。當操作系統完成 I/O 操作時，以事件的形式通知執行 I/O 操作的線程，線程會在特定時候處理這個事件。簡答理解就是如果程序不會卡住，可以繼續執行，就是說非阻塞的。

4. threading.local 的作用？

threading.local()這個方法是用來保存一個全局變量，但是這個全局變量只有在當前線程才能訪問，如果你在開發多線程應用的時候，需要每個線程保存一個單獨的數據供當前線程操作，可以考慮使用這個方法，簡單有效。代碼示例

import threading
import timea = threading.local()#全局對象def worker()：a.x = 0for i in range(200)：time.sleep(0.01)a.x += 1print(threading.current_thread(),a.x)for i in range(20)：threading.Thread(target=worker).start()

總結

以上是生活随笔為你收集整理的Python 精选笔试面试习题—sorted 与 sort 单例模式、统计字符个数Count、垃圾回收、lambda函数、静态方法、类方法、实例方法、分布式锁、的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。