操作類題目

Python 交換兩個變量的值

答：在 Python 中交換兩個對象的值通過下面的方式即可

a , b = b ,a
但是需要強調的是這并不是元組解包，通過 dis 模塊可以發現，這是交換操作的字節碼是 ROT_TWO，意思是在棧的頂端做兩個值的互換操作。

在讀文件操作的時候會使用 read、readline 或者 readlines，簡述它們各自的作用

答：read() 每次讀取整個文件，它通常用于將文件內容放到一個字符串變量中。如果希望一行一行的輸出那么就可以使用 readline()，該方法會把文件的內容加載到內存，所以對于對于大文件的讀取操作來說非常的消耗內存資源，此時就可以通過 readlines 方法，將文件的句柄生成一個生產器，然后去讀就可以了。

json 序列化時，可以處理的數據類型有哪些？如何定制支持 datetime 類型？

答：可以處理的數據類型是 str、int、list、tuple、dict、bool、None, 因為 datetime 類不支持 json 序列化，所以我們對它進行拓展。

            
              #自定義時間序列化
import json
from datetime import datetime, date

#JSONEncoder 不知道怎么去把這個數據轉換成 json 字符串的時候，它就會去調 default()函數,所以都是重寫這個函數來處理它本身不支持的數據類型，
# default()函數默#認是直接拋異常的。
class DateToJson(json.JSONEncoder)：
    def default(self, obj)：
        if isinstance(obj, datetime)：
            return obj.strftime('%Y-%m-%d %H：%M：%S')
        elif isinstance(obj, date)：
            return obj.strftime('%Y-%m-%d')
        else：
            return json.JSONEncoder.default(self, obj)


d = {'name'： 'cxa', 'data'： datetime.now()}
print(json.dumps(d, cls=DateToJson))

json 序列化時，默認遇到中文會轉換成 unicode，如果想要保留中文怎么辦？

答：可以通過 json.dumps 的 ensure_ascii 參數解決，代碼示例如下：

            
              import json
a=json.dumps({"name"："張三"},ensure_ascii=False)
print(a)

有兩個磁盤文件 A 和 B，各存放一行字母，要求把這兩個文件中的信息合并(按字母順序排列)，輸出到一個新文件 C 中。

答：

            
              #文件 A.txt 內容為 ASDCF
#文件 B.txt 內容為 EFGGTG
with open("A.txt") as f1：
    f1_txt = f1.readline()
with open("B.txt") as f2：
    f2_txt = f2.readline()
f3_txt = f1_txt + f2_txt

f3_list = sorted(f3_txt)

with open("C.txt", "a+") as f：
     f.write("".join(f3_list))
輸出的文件 C 的內容為 ACDEFFGGGST

如果當前的日期為 20190530，要求寫一個函數輸出 N 天后的日期，(比如 N 為 2，則輸出 20190601)。

答：這個題目考察的是 datetime 里的 timedelta 方法的使用，參數可選、默認值都為 0：datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0) 通過這個參數可以指定不同的日期類型進行加減操作，這里我們需要改的是 days，代碼如下

            
              import datetime


def datetime_operate(n： int)：
    now = datetime.datetime.now()  # 獲取當前時間
    _new_date = now + datetime.timedelta(days=n)  # 獲取指定天數后的新日期
    new_date = _new_date.strftime("%Y%m%d")  # 轉換為指定的輸出格式
    return new_date


if __name__ == '__main__'：
    print(datetime_operate(4))

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

答：這個題目考查了閉包的使用代碼示例如下，返回函數之類型是函數對象。

            
              def mul_operate(num):
    def g(val):
        return num * val

    return g


m = mul_operate(8)
print(m(5))

下面代碼會存在什么問題，如何改進？

def strappend(num)：
str=‘first’
for i in range(num)：
str+=str(i)
return str

答：首先不應該使用 Python 的內置類似 str 作為變量名這里我把它改為了 s,另外在Python,str 是個不可變對象，每次迭代都會生成新的存儲空間，num 越大，創建的 str 對象就會越多，內存消耗越大。使用 yield 改成生成器即可, 還有一點就是命名規范的位置，函數名改為_分割比較好，完整的代碼如下:

            
              def str_append(num):
    s = 'first'
    for i in range(num):
        s += str(i)
        yield s

if __name__ == '__main__':
    for i in str_append(3):
        print(i)

一行代碼輸出 1-100 之間的所有偶數。

答：可以通過列表生成式，然后使用與操作如果如 1 與之后結果為 0 則表明為偶數，等于 1 則為奇數。

            
              # 方法1
print([i for i in range(1, 101) if i & 0x1 == 0])
# 方法2：測試發現方法二效率更高
print(list(range(2, 101, 2)))

with 語句的作用，寫一段代碼？

with 語句適用于對資源進行訪問的場合，確保不管使用過程中是否發生異常都會執行必要的“清理”操作，釋放資源，比如文件使用后自動關閉、線程中鎖的自動獲取和釋放等。

其他的內容看下面我之前寫的代碼。

            
              #一般訪問文件資源時我們會這樣處理：

f = open(
    'c：\test.txt', 'r')
data = f.read()
f.close()
# 這樣寫沒有錯，但是容易犯兩個毛?。?# 1. 如果在讀寫時出現異常而忘了異常處理。
# 2. 忘了關閉文件句柄

#以下的加強版本的寫法：

f = open('c：\test.txt', 'r')
try：
    data = f.read()
finally：
    f.close()

#以上的寫法就可以避免因讀取文件時異常的發生而沒有關閉問題的處理了。代碼長了一些。
#但使用 with 有更優雅的寫法：

with open(r'c：\test.txt', 'r') as f：
    data = f.read()
#with 的實現

class Test：
    def __enter__(self)：
        print('__enter__() is call!')
        return self

    def dosomething(self)：
        print('dosomethong!')

    def __exit__(self, exc_type, exc_value, traceback)：
        print('__exit__() is call!')
        print(f'type：{exc_type}')
        print(f'value：{exc_value}')
        print(f'trace：{traceback}')
        print('__exit()__ is call!')

with Test() as sample：
      pass

#當對象被實例化時，就會主動調用__enter__()方法，任務執行完成后就會調用__exit__()方法，
#另外，注意到，__exit__()方法是帶有三個參數的(exc_type, exc_value, traceback),
#依據上面的官方說明：如果上下文運行時沒有異常發生，那么三個參數都將置為 None, 
#這里三個參數由于沒有發生異常，的確是置為了 None, 與預期一致.

# 修改后不出異常了
class Test：
    def __enter__(self)：
        print('__enter__() is call!')
        return self

    def dosomething(self)：
        x = 1/0
        print('dosomethong!')

    def __exit__(self, exc_type, exc_value, traceback)：
        print('__exit__() is call!')
        print(f'type：{exc_type}')
        print(f'value：{exc_value}')
        print(f'trace：{traceback}')
        print('__exit()__ is call!')
        return True


with Test() as sample：

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

答:

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

            
              dic = {'a': 123, 'b': "456", 'c': "liming"}
json_str = json.dumps(dic)
dic2 = json.loads(json_str)
print(dic2)
打?。?'{"a": 123, "b": "456", "c": "liming"}'
{'a': 123, 'b': '456', 'c': 'liming'}
我們再來看一個特殊的例子

import json
dic = {'a'： 123, 'b'： "456", 'c'： "liming"}
dic_str = json.loads(str(dic).replace("'", "\""))
print(dic_str)

下面我解釋下上面代碼是測試什么:

首先 json.loads(jsonstr) 這里面的參數只能是 jsonstr 格式的字符串.
當我們使用 str 將字典 dic 轉化為字符串以后，得到的結果為:"{‘a’: 123, ‘b’: ‘456’, ‘c’: ‘liming’}"。
如果直接使用 json.loads(str(dic)) 你會發現出現錯誤，原因就是，單引號的字符串不符合Json的標準格式所以再次使用了 replace("’", “”")。得到字典
其實這個例子主要目的是告訴大家 Json 的標準格式是不支持單引號型字符串的，否則會出現以下錯誤。
json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
60. 請寫一個 Python 邏輯，計算一個文件中的大寫字母數量

答：

            
              with open('A.txt') as fs：
    count = 0
    for i in fs.read()：
        if i.isupper()：
            count += 1
print(count)
61. 請寫一段 Python連接Mongo數據庫，然后的查詢代碼。

答:

# -*- coding: utf-8 -*-
# @Author : 陳祥安
import pymongo
db_configs = {
    'type': 'mongo',
    'host': '地址',
    'port': '端口',
    'user': 'spider_data',
    'passwd': '密碼',
    'db_name': 'spider_data'
}


class Mongo():
    def __init__(self, db=db_configs["db_name"], username=db_configs["user"],
                 password=db_configs["passwd"]):
        self.client = pymongo.MongoClient(f'mongodb://{db_configs["host"]}:db_configs["port"]')
        self.username = username
        self.password = password
        if self.username and self.password:
            self.db1 = self.client[db].authenticate(self.username, self.password)
        self.db1 = self.client[db]

    def find_data(self):
        # 獲取狀態為0的數據
        data = self.db1.test.find({"status": 0})
        gen = (item for item in data)
        return gen

if __name__ == '__main__':
    m = Mongo()
    print(m.find_data())

說一說Redis的基本類型

答: Redis 支持五種數據類型： string（字符串）、 hash（哈希）、list（列表）、 set（集合）及 zset(sorted set：有序集合)。

請寫一段 Python連接Redis數據庫的代碼。

答:

            
              from redis import StrictRedis, ConnectionPool
redis_url="redis:/[敲打]xx@112.27.10.168:6379/15"
pool = ConnectionPool.from_url(redis_url, decode_responses=True)
r= StrictRedis(connection_pool=pool)

請寫一段 Python連接Mysql數據庫的代碼。

答:

            
              conn = pymysql.connect(host='localhost', 
port=3306, user='root', 
passwd='1234', db='user', charset='utf8mb4')#聲明mysql連接對象
cursor=conn.cursor(cursor=pymysql.cursors.DictCursor)#查詢結果以字典的形式
cursor.execute(sql語句字符串)#執行sql語句
conn.close()#關閉鏈接

65.了解Redis的事務么

答: 簡單理解，可以認為 redis 事務是一些列 redis 命令的集合，并且有如下兩個特點： 1.事務是一個單獨的隔離操作：事務中的所有命令都會序列化、按順序地執行。事務在執行的過程中，不會被其他客戶端發送來的命令請求所打斷。 2.事務是一個原子操作：事務中的命令要么全部被執行，要么全部都不執行。一般來說，事務有四個性質稱為ACID，分別是原子性，一致性，隔離性和持久性。一個事務從開始到執行會經歷以下三個階段：

開始事務
命令入隊
執行事務代碼示例:

            
              import redis
import sys
def run():   
    try:
        conn=redis.StrictRedis('192.168.80.41')
       # Python中redis事務是通過pipeline的封裝實現的
        pipe=conn.pipeline()
        pipe.sadd('s001','a')
        sys.exit()
        #在事務還沒有提交前退出，所以事務不會被執行。
        pipe.sadd('s001','b')
        pipe.execute()
        pass
    except Exception as err:
        print(err)
        pass
if __name__=="__main__":
      run()

66.了解數據庫的三范式么？

答: 經過研究和對使用中問題的總結，對于設計數據庫提出了一些規范，這些規范被稱為范式一般需要遵守下面3范式即可: 第一范式（1NF）：強調的是列的原子性，即列不能夠再分成其他幾列。第二范式（2NF）：首先是 1NF，另外包含兩部分內容，一是表必須有一個主鍵；二是沒有包含在主鍵中的列必須完全依賴于主鍵，而不能只依賴于主鍵的一部分。第三范式（3NF）：首先是 2NF，另外非主鍵列必須直接依賴于主鍵，不能存在傳遞依賴。即不能存在：非主鍵列 A 依賴于非主鍵列 B，非主鍵列 B 依賴于主鍵的情況。

67.了解分布式鎖么

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

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

68.用 Python 實現一個 Reids 的分布式鎖的功能

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

            
              SETNX lock.foo

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

            
              import time
import redis
from conf.config import REDIS_HOST, REDIS_PORT, REDIS_PASSWORD

class RedisLock:
    def __init__(self):
        self.conn = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, db=1)
        self._lock = 0
        self.lock_key = ""
    @staticmethod
    def my_float(timestamp):
        """
        Args:
            timestamp:
        Returns:
            float或者0
            如果取出的是None，說明原本鎖并沒人用，getset已經寫入，返回0，可以繼續操作。
        """
        if timestamp:
            return float(timestamp)
        else:
            #防止取出的值為None，轉換float報錯
            return 0

    @staticmethod
    def get_lock(cls, key, timeout=10):
        cls.lock_key = f"{key}_dynamic_lock"
        while cls._lock != 1:
            timestamp = time.time() + timeout + 1
            cls._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)) and
                            time.time() > cls.my_float(cls.conn.getset(cls.lock_key, timestamp))):
                break
            else:
                time.sleep(0.3)

    @staticmethod
    def 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 __deco
    return _deco


@redis_lock_deco(RedisLock())
def my_func():
    print("myfunc() called.")
    time.sleep(20)

if __name__ == "__main__":
    my_func()

69.寫一段 Python 使用 mongo 數據庫創建索引的代碼:

答:

            
              # -*- coding: utf-8 -*-
# @Time : 2018/12/28 10:01 AM
# @Author : cxa
import pymongo
db_configs = {
    'type': 'mongo',
    'host': '地址',
    'port': '端口',
    'user': 'spider_data',
    'passwd': '密碼',
    'db_name': 'spider_data'
}


class Mongo():
    def __init__(self, db=db_configs["db_name"], username=db_configs["user"],
                 password=db_configs["passwd"]):
        self.client = pymongo.MongoClient(f'mongodb://{db_configs["host"]}:{db_configs["port"]}')
        self.username = username
        self.password = password
        if self.username and self.password:
            self.db1 = self.client[db].authenticate(self.username, self.password)
        self.db1 = self.client[db]

    def add_index(self):
        """
          通過create_index添加索引
        """
        self.db1.test.create_index([('name', pymongo.ASCENDING)], unique=True)

    def get_index(self,):
        """
          查看索引列表
        """
        indexlist=self.db1.test.list_indexes()
        for index in indexlist:
            print(index)

if __name__ == '__main__':
    m = Mongo()
    m.add_index()
    print(m.get_index())

更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索：z360901061

微信掃一掃加我為好友

QQ號聯系： 360901061

您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。

【本文對您有幫助就好】元

2元

5元

10元

20元

自定義