基礎部分

1.列出 5 個常用 Python 標準庫？

os：提供了不少與操作系統相關聯的函數

sys: 通常用于命令行參數

re: 正則匹配

math: 數學運算

datetime: 處理日期時間

2.Python 內建數據類型有哪些？

int、bool、 str、 list、 tuple、 dict

3.簡述 with 方法打開處理文件幫我我們做了什么？

打開文件在進行讀寫的時候可能會出現一些異常狀況，如果按照常規的f.open

寫法，我們需要try,except,finally，做異常判斷，并且文件最終不管遇到什么情況，都要執行finally f.close()關閉文件，with方法幫我們實現了finally中f.close

（當然還有其他自定義功能，有興趣可以研究with方法源碼）

4.列出 Python 中可變數據類型和不可變數據類型，為什么？

（1）可變類型（mutable）：變量進行append、+=等這種操作后 == 改變了變量的值，而不會新建一個對象，變量引用的對象的地址也不會變化，不過對于相同的值的不同對象，在內存中則會存在不同的對象，即每個對象都有自己的地址，相當于內存中對于同值的對象保存了多份，這里不存在引用計數，是實實在在的對象。

• list
• dict
• set
• bytearray
• user-defined classes (除非是特別定義的不可變)

（2）不可變類型（immutable）：改變了變量的值 == 新建了一個對象，而對于相同的值的對象，在內存中則只有一個對象（一個地址）, python的id() 方法讓你明白

• int
• float
• decimal
• complex
• bool
• string
• tuple
• range
• frozenset
• bytes

例子:

``` # -- coding: utf-8 --

# 不可變類型 a = 3 b = 3 print(id(a)) print(id(b))

# 可變類型 c = [1,2,3] d = [1,2,3] print(id(c)) print(id(d)) ```

5.Python 獲取當前日期？

print(datetime.datetime.now())

6.統計字符串每個字符出現的次數

# -*- coding: utf-8 -*-

 

str = 'taodejintaodejinjjdsinad'

result = {}

for i in str:

    result[i] = str.count(i)

print(result)

7.用 python 刪除文件和用 linux 命令刪除文件方法

python：os.remove(文件名)

linux: rm 文件名

8.寫一段自定義異常代碼

# -*- coding: utf-8 -*-

 

# 自定義異常 需要繼承Exception

class MyException(Exception):

    def __init__(self,*args):

        self.args = args

 

# 先定義異常基類，然后派生不同類型的異常

class loginError(MyException):

    def __init__(self,code =100, message = '登錄異常',args = ('登錄異常',)):

        self.args = args

        self.message = message

        self.code = code

 

 

class loginountError(MyException):

    def __init__(self):

        self.args = ('退出異常',)

        self.message = '退出異常'

        self.code = 200

 

 

try:

    raise loginountError()

except loginountError as e:

    print(e)

    print(e.code)

    print(e.message)

9.舉例說明異常模塊中 try except else finally 的相關意義

try..except..else沒有捕獲到異常，執行else語句

try..except..finally不管是否捕獲到異常，都執行finally語句

 

10.遇到 bug 如何處理

百度，問人

語言特性

1.談談對 Python 和其他語言的區別

三個方面：

語言特點： 簡潔優雅，省略了各種大括號和分號，還有一些關鍵字，類型說明

語言類型： 解釋型語言，運行的時候是一行一行的解釋并運行，所以調試代碼很方便，開發效率高

第三方庫： python是開源的,并且python的定位時任由其發展,應用領域很多比如Web,運維,自動化測試,爬蟲,數據分析,人工智能.Python具有非常完備的第三方庫

一句話概括：Python是一門語法簡潔優美,功能強大無比,應用領域非常廣泛,具有強大完備的第三方庫的一門弱類型的可移植,可擴展,可嵌入的解釋型編程語言

2.簡述解釋型和編譯型編程語言

解釋型:就是邊解釋邊執行 編譯性:編譯后再執行

3.Python 的解釋器種類以及相關特點？

CPython

由C語言開發的 使用最廣的解釋器,在命名行下運行python，就是啟動CPython解釋器.

IPython

基于cpython之上的一個交互式計時器 交互方式增強 功能和cpython一樣

PyPy

目標是執行效率 采用JIT技術 對python代碼進行動態編譯，提高執行效率

JPython

運行在Java上的解釋器 直接把python代碼編譯成Java字節碼執行

IronPython

在微軟 .NET 平臺上的解釋器，把python編譯成. NET 的字節碼

4.說說你知道的Python3 和 Python2 之間的區別？

• print

py2：print語句，語句就意味著可以直接跟要打印的東西，如果后面接的是一個元組對象，直接打印

py3：print函數，函數就以為這必須要加上括號才能調用，如果接元組對象，可以接收多個位置參數，并可以打印

如果希望在 Python2 中 把 print 當函數使用，那么可以導入 future 模塊 中的 print_function

下面有個示例：

# py2

>>> print("hello", "world")

('hello', 'world')

# py3

>>> print("hello", "world")

hello world

# py2

>>> print("hello", "world")

('hello', 'world')

>>> from __future__ import print_function

>>> print("hello", "world")

hello world

• 輸入函數

py2：input_raw()

py3：input()

• 在使用super()的不同

py2：必須顯示的在參數中寫上基類

py：直接無參數調用即可

• 1/2的結果

py2：返回0

py3：返回0.5，沒有了int和long的區別

• 編碼

py2：默認編碼ascii

py3：默認編碼utf-8

而且為了在py2中使用中文，在頭部引入coding聲明，不推薦使用

• 字符串

py2：unicode類型表示字符串序列，str類型表示字節序列

py3:：str類型表示字符串序列，byte類型表示字節序列

• True和False

py2：True 和 False 在 Python2 中是兩個全局變量，可以為其賦值或者進行別的操作，初始數值分別為1和0，雖然修改是違背了python設計的原則，但是確實可以更改

py3：修正了這個變量，讓True或False不可變

• 迭代器

py2：當中許多返回列表的方法，如range,字典對象的 dict.keys()、dict.values() 方法, map、filter、zip；并且迭代器必須實現next方法

py3：將返回列表的方法改為了返回迭代器對象，內置了next，不用特意去實現next

• nonlocal

py2：沒有辦法在嵌套函數中將變量聲明為一個非局部變量，只能在函數中聲明全局變量

py3：nonlocal方法實現了，示例如下：

def func():

 c = 1

    def foo():

        c = 12

    foo()

    print(c)

func()    #1

def func():

    c = 1

    def foo():

        nonlocal c

        c = 12

    foo()

    print(c)

func()   # 12

 

5.Python3 和 Python2 中 int 和 long 區別？

python2中有long類型 python3中沒有long類型，只有int類型

 

6.xrange 和 range 的區別？

兩種用法介紹如下： 1.range([start], stop[, step]) 返回等差數列。構建等差數列，起點是start，終點是stop，但不包含stop，公差是step。 start和step是可選項，沒給出start時，從0開始；沒給出step時，默認公差為1。 例如：

>>> range(10)                             #起點是0，終點是10，但是不包括10

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> range(1,10)                           #起點是1，終點是10，但是不包括10

[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> range(1,10,2)                         #起點是1，終點是10，步長為2

[1, 3, 5, 7, 9]

>>> range(0,-10,-1)                       #起點是1，終點是10，步長為-1

[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

>>> range(0,-10,1)                        #起點是0，終點是-10，終點為負數時，步長只能為負數，否則返回空

[]

>>> range(0)                              #起點是0，返回空列表

[]

>>> range(1,0)                            #起點大于終點，返回空列表

[]

2.xrange([start], stop[, step]) xrange與range類似，只是返回的是一個"xrange object"對象，而非數組list。 要生成很大的數字序列的時候，用xrange會比range性能優很多，因為不需要一上來就開辟一塊很大的內存空間。 例如：

 

>>> lst = xrange(1,10)

>>> lst

xrange(1, 10)

>>> type(lst)

<type 'xrange'>

>>> list(lst)

[1, 2, 3, 4, 5, 6, 7, 8, 9]

 

區別如下： 1.range和xrange都是在循環中使用，輸出結果一樣。 2.range返回的是一個list對象，而xrange返回的是一個生成器對象(xrange object)。 3.xrange則不會直接生成一個list，而是每次調用返回其中的一個值，內存空間使用極少，因而性能非常好。

 

編碼規范

7.什么是 PEP8?

《Python Enhancement Proposal #8》又稱之為Python 代碼格式而編訂的風格指南

8.了解 Python 之禪么？

Beautiful is better than ugly.

# 優美勝于丑陋（Python以編寫優美的代碼為目標）

 

Explicit is better than implicit.

# 明了勝于晦澀（優美的代碼應當是明了的，命名規范，風格相似）

 

Simple is better than complex.

# 簡潔勝于復雜（優美的代碼應當是簡潔的，不要有復雜的內部實現）

 

Complex is better than complicated.

# 復雜勝于凌亂（如果復雜不可避免，那代碼間也不能有難懂的關系，要保持接口簡潔）

 

Flat is better than nested.

# 扁平勝于嵌套（優美的代碼應當是扁平的，不能有太多的嵌套）

 

Sparse is better than dense.

# 間隔勝于緊湊（優美的代碼有適當的間隔，不要奢望一行代碼解決問題）

 

Readability counts.

# 可讀性很重要（優美的代碼是可讀的）

 

Special cases aren't special enough to ``break` `the rules.

Although practicality beats purity.

# 即便假借特例的實用性之名，也不可違背這些規則（這些規則至高無上）

 

Errors should never pass silently.

Unless explicitly silenced.

# 不要包容所有錯誤，除非你確定需要這樣做（精準地捕獲異常，不寫except:pass風格的代碼）

 

In the face of ambiguity, refuse the temptation to guess.

# 當存在多種可能，不要嘗試去猜測

 

There should be one-- ``and` `preferably only one --obvious way to ``do` `it.

# 而是盡量找一種，最好是唯一一種明顯的解決方案（如果不確定，就用窮舉法）

 

Although that way may not be obvious at first unless you're Dutch.

# 雖然這并不容易，因為你不是 Python 之父（這里的Dutch是指Guido）

 

Now is better than never.

Although never is often better than *right* now.

# 做也許好過不做，但不假思索就動手還不如不做（動手之前要細思量）

 

If the implementation is hard to explain, it's a bad idea.

If the implementation is easy to explain, it may be a good idea.

# 如果你無法向人描述你的方案，那肯定不是一個好方案；反之亦然（方案測評標準）

 

Namespaces are one honking great idea -- let's ``do` `more of those!

# 命名空間是一種絕妙的理念，我們應當多加利用（倡導與號召）

開交互界面 輸入import this 回車就OK了。

9.了解 docstring 么？

DocStrings 文檔字符串是一個重要工具，用于解釋文檔程序，其實就是對程序方法的一些說明信息。我們可以在函數體的第一行使用一對三個單引號"或者一對三個雙引號""" 來定義文檔字符串。

你可以使用函數名.__doc__

"(注意雙下劃線)調用函數中的文檔字符串屬性。DocStrings 文檔字符串使用慣例:它的首行簡述函數功能。

 

簡單來說，就是出現在模塊、函數、類、方法里第一個語句的，就是docstring。會自動變成屬性doc。

def foo():    

""" This is function foo"""

可通過foo.__doc__訪問得到’ This is function foo’.

 

10.了解類型注解么？

類型注解介紹 我們知道 Python 是一種動態語言，變量以及函數的參數是不區分類型。 Python解釋器會在運行的時候動態判斷變量和參數的類型，這樣的好處是編寫代碼速度很快，很靈活，但是壞處也很明顯，不好維護，可能代碼寫過一段時間重新看就很難理解了，因為那些變量、參數、函數返回值的類型，全都給忘記了。 而且當你在讀別人的代碼的時候，也無法一眼看出變量或者參數的類型，經常要自己推敲，這樣給學習帶來了很大的障礙。 所以Python3里有了這個新特性，可以給參數、函數返回值和變量的類型加上注解，不過這個僅僅是注釋而已，對代碼的運行來說沒有任何影響，變量的真正類型還是會有Python解釋器來確定，你所做的只是在提高代碼的可讀性，僅此而已。

def add(x: int, y: int) -> int:

    return x + y

 

沒用過類型注解(Type Annotations)的同學可能咋一看有點迷糊，其實上面這段代碼和下面這個代碼是一樣的。

def add(x, y):

    return x + y

11.例舉你知道 Python 對象的命名規范，例如方法或者類等

module_name, 模塊

package_name, 包

ClassName, 類

method_name, 方法

ExceptionName, 異常

function_name, 函數

GLOBAL_VAR_NAME, 全局變量

instance_var_name, 實例

function_parameter_name, 參數

local_var_name. 本變量

12.Python 中的注釋有幾種？

1.python單行注釋符號(#)

2.批量、多行注釋符號。多行注釋是用三引號''' '''包含的

3.對于函數還有文檔注釋

為函數添加文檔注釋，需要在函數頭（包含def關鍵字的那一行）的下一行用一對單引號或雙引號將注釋括起來。

13.如何優雅的給一個函數加注釋？

見12文檔注釋

def add (x,y):

    "計算兩個數的和"

    return x + y

 

print(add.__doc__)

#輸出結果：計算兩個數的和

14.如何給變量加注釋？

變量的聲明同一行加上#的注釋

15.Python 代碼縮進中是否支持 Tab 鍵和空格混用。

在Python中，官方推薦使用4個空格作為縮進，而不是使用Tab鍵。不過，實際上你可以在你的代碼中混用Tab和空格，但這可能會導致一些混亂，尤其是在跨不同編輯器或者查看代碼時。

如果你想確保你的代碼中只使用空格作為縮進，你可以在你的編輯器中設置將Tab自動轉換為相應數量的空格。大多數現代編輯器和IDE都支持這種設置。

以下是一個Python代碼示例，它混用了Tab和空格作為縮進：

def hello_world():

print("Hello")  # 使用了Tab作為縮進

print("World")  # 使用了4個空格作為縮進

盡管這樣的代碼是可以運行的，但最好還是遵循一種縮進風格，并在你的編輯器或IDE中設置對應的規則。

16.是否可以在一句 import 中導入多個庫?

支持，但是不推薦。

因為一次導入多個模塊可讀性不是很好，所以一行導入一個模塊會比較好。同樣的盡量少用 from modulename import *，因為判斷某個函數或者屬性的來源有些困難，不方便調試，可讀性也降低了。

17.在給 Py 文件命名的時候需要注意什么?

1.模塊名和包名采用小寫字母并且以下劃線分隔單詞的形式； 如:regex_syntax,py_compile,_winreg

2.類名或異常名采用每個單詞首字母大寫的方式； 如：BaseServer,ForkingMixIn,KeyboardInterrupt

3.全局或者類常量，全部使用大寫字母，并且以下劃線分隔單詞； 如：MAX_LOAD

4.其余變量命名包括方法名，函數名，普通變量名則是采用全部小寫字母，并且以下劃線分隔單詞的形式命名。 如：my_thread

5.以上的內容如果是內部的，則使用下劃線開頭命名。 如：init,new

18.例舉幾個規范 Python 代碼風格的工具

PyCharm，vscode

數據類型

19.列舉 Python 中的基本數據類型？

Python 語言中包含以下幾種基本數據類型：

1. int (整數)：可以是正數、零或負數。例如，1, -1, 0。
2. float (浮點數)：浮點數是一個數字，包含一個小數點。例如，1.23, -0.12。
3. bool (布爾)：布爾數據類型通常用于比較和邏輯運算，只有兩個值：True 或 False。
4. str (字符串)：字符串是字符的序列，可以是引號內的任何文本。例如，'Hello', "World"。
5. list (列表)：列表是一個順序存儲多個值的集合，可以修改。例如，[1, 2, 3]。
6. tuple (元組)：元組與列表類似，但是不可變。例如，(1, 2, 3)。
7. dict (字典)：字典是一個無序的鍵-值對集合。例如，{'name': 'Alice', 'age': 25}。

20.如何區別可變數據類型和不可變數據類型

可變數據類型：在id不變的情況下，value可改變（列表和字典是可變類型，但是字典中的key值必須是不可變類型）

不可變數據類型：value改變，id也跟著改變。（數字，字符串，布爾類型，都是不可類型）

21.將"hello world"轉換為首字母大寫"Hello World"

str = 'hello,world'

a = str.title()

print(a)

22.如何檢測字符串中只含有數字?

a = '12121212'.isdigit()

print(a)

b = 'dsa1212121'.isdigit()

print(b)

23.將字符串"ilovechina"進行反轉

s1 ='ilovechina'[: :-1]

print(s1)

24.Python 中的字符串格式化方式你知道哪些？

1、最傳統的用%格式化字符串

“Hello, %s. You are %s.” % (name, age)

2、string.format ()

“Hello,{}. You are {}”.format(name,age)

3、f-string python3.6誕生的新方法

該方法叫做“F字符串方法”，又稱為“格式化字符串文字”。F字符串是開頭有一個f的字符串文字，以及包含表達式的大括號將被其值替換。表達式在運行時進行渲染，然后使用format協議進行格式化。

f’his name is {name}’

25.有一個字符串開頭和末尾都有空格，比如“ adabdw ”,要求寫一個函數把這個字符串的前后空格都去掉。

a = ' asdf '

b = a.replace(' ','')

print(a)

print(b)

26.獲取字符串”123456“最后的兩個字符。

#獲取字符串最后兩個字符

def getLastTwo(s):

    return s[-2:]

27.一個編碼為 GBK 的字符串 ，要將其轉成 UTF-8 編碼的字符串，應如何操作？

str.encode("GBK") str.encode("UTF-8")

 

 

(1)、s="info：xiaoZhang 33 shandong"，用正則切分字符串輸出['info', 'xiaoZhang', '33', 'shandong']
```
-- coding: utf-8 --
import re

s="info：xiaoZhang 33 shandong"
def reStr1(s): return re.split(r'[\s\:\：]+', s)
print(reStr1(s)) ```

(2)、a = "你好 中國 "，去除多余空格只留一個空格。

(3)、怎樣將字符串轉換為小寫

s2.upper()

29.單引號、雙引號、三引號的區別？

（1）單引號和雙引號平時使用時候，是沒有太多區別的。但是在定義字符串時候，可以單雙引號混用來避免轉義問題。

（2）三引號作用：

-可以作為格式化輸出

-可以作為多行注釋

列表

30.已知 AList = [1,2,3,1,2],對 AList 列表元素去重，寫出具體過程。

list(set(list)) --先將列表轉化為set，再轉化為list就可以實現去重操作

31.如何實現 "1,2,3" 變成 ["1","2","3"]

str = "1,2,3"

print(str.split(","))

32.給定兩個 list，A 和 B，找出相同元素和不同元素

利用集合：

A=[1,2,3,4,5,6,7,8,9]

B=[1,3,5,7,9]

print('A、B中相同元素：')

print(set(A)&set(B))

print('A、B中不同元素：')

print(set(A)^set(B))

33.[[1,2],[3,4],[5,6]]一行代碼展開該列表，得出[1,2,3,4,5,6]

l1 = [[1,2],[3,4],[5,6]] l = [j for t in l1 for j in t]

34.合并列表[1,5,7,9]和[2,2,6,8]

a1 = [1,5,7,9]

a2 = [2,2,6,8]

print(a1+a2)

35.如何打亂一個列表的元素？

import random

l = [1,2,3,4,5,6]

random.shuffle(l)

print(l)

字典

36.字典操作中 del 和 pop 有什么區別？

del 可以刪除指定key的鍵值對，并且沒有返回。用法：del dict[key]； 也可以使用del來清空整個字典 pop是從字典中取走指定key的鍵值對，并且返回鍵值。是字典的一個方法。用法：dict.pop(key)

37.按照字典的內的數值排序

dict1={'a':2,'e':3,'f':8,'d':4}

# 正向排序

dict2 = sorted(dict1)

# 反向排序

dict3 = sorted(dict1,reverse=True)

print(dict2)

print(dict3)

38.請合并下面兩個字典 a = {"A":1,"B":2},b = {"C":3,"D":4}

def dictMerge1():

    a = {"A":1,"B":2}

    b = {"C":3,"D":4}

    a.update(b)

    print(a)

dictMerge1()

39.如何使用生成式的方式生成一個字典，寫一段功能代碼。

list4 = [('name','zhangsan'),('age',22),('phone',110)]

# for 循環遍歷列表，將列表中小元組的key和value取出，作為字典中的key：value

dict_1 = {key:value for key,value in list4}

print (dict_1)

40.如何把元組("a","b")和元組(1,2)，變為字典{"a":1,"b":2}

a = ("a","b")

b = (1,2)

z = zip(a,b)

print(dict(z))

41.Python 常用的數據結構的類型及其特性？

一、基礎數據類型

　　標準數據類型：

　　　　·不可變數據類型

　　　　　　Number（數字）：int、float、bool、complex（復數）

　　　　　　String（字符串）

　　　　　　Tuple（元祖）：不可變，無法通過下標來修改值

　　　　·可變數據類型

　　　　　　List（列表）:[ ]

　　　　　　Set（集合）：{ }

　　　　　　Dictionary（字典）:{ key:value}

　　可變數據類型：當值改變時，id編號不變化【可以使用id()函數來查看】

　　不可變數據類型：當值改變時，會產生新的id編號

二、基本數據結構(列表、集合、字典、元祖)：

　　· 列表（list）：

　　　　特點：是一個可變集合，不僅結構可變，里面還可以放不同類型的對象：num = [1,2,3，‘123’，True，321]

　　　　 常規操作：

　　　　　　·獲取元素：可以通過下標獲取：num[0]，輸出：1

　　　　　　　　　　　 可以通過切片獲取：num[3:5]，輸出：'123',321

　　　　　　·添加元素：

　　　　　　　　num.append(3)：在列表后方添加元素

　　　　　　　　num.insert(index,value)：插入到列表的指定位置
　　　　　　　　num + [1,2,3] 或 num.extend([1,2,3])：連接兩個列表

　　·元祖（tuple）

　　　　特點：不可變

　　　　常規操作：

　　　　　　·可以通過下標取值，但無法修改

　　　　　　·可以通過 index(value1，value2) 來獲取制定元素在元祖中出現的位置

　　　　　　·可以通過count(value) 來統計指定元素在元祖中出現的個數

　　·集合（{ }）

　　　　特點：集合是一個無序不重復元素的集

　　　　常規操作：

　　　　　　推導式：

 

42.如何交換字典 {"A"：1,"B"：2}的鍵和值？

mydict={"a":1,"b":2,"c":3}

mydict_new={}

for key,val in mydict.items():

    mydict_new[val]=key

print(mydict_new)

43.Python 里面如何實現 tuple 和 list 的轉換？

list(tup) tuple(list)

44.我們知道對于列表可以使用切片操作進行部分元素的選擇，那么如何對生成器類型的對象實現相同的功能呢？

這個題目考察了 Python 標準庫的itertools模快的掌握情況，該模塊提供了操作生成器的一些方法。 對于生成器類型我們使用islice方法來實現切片的功能。例子如下

from itertools import islice

gen = iter(range(10)) #iter()函數用來生成迭代器

#第一個參數是迭代器，第二個參數起始索引，第三個參數結束索引，不支持負數索引

for i in islice(gen,0,4)：

    print(i)

45.請將[i for i in range(3)]改成生成器

直接將中括號改成小括號就行了

(i for i in range(3))

46.a="hello"和 b="你好"編碼成 bytes 類型

a="hello"

c=a.encode(encoding='utf-8')

a = b'hello'

 

b="世界"

b = b.encode(encoding='utf-8')

 

print(a,b,c)

47.下面的代碼輸出結果是什么？

 

 

48.下面的代碼輸出的結果是什么?

a = (1,2,3,[4,5,6,7],8)

# a[2] = 2

a[3][0] = 2

print(a)

(1, 2, 3, [2, 5, 6, 7], 8)

49.Python 交換兩個變量的值

a,b =b,a

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

1）read([size])方法從文件當前位置起讀取size個字節，若無參數size，則表示讀取至文件結束為止，輸出的結果是字符串對象

2）readline()：每次讀出一行內容，所以，讀取時占用內存小，比較適合大文件，輸出的結果也是一個字符串對象。

3）readlines()：讀取整個文件所有行，保存在一個列表(list)變量中，每行作為一個元素，但讀取大文件會比較占內存。

總結：read和readline返回的是字符串，而readlines返回的是列表，其中每行是作為列表的一個元素。

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

1、可以處理的數據類型是 string、int、list、tuple、dict、bool、null

2、自定義時間序列化轉換器

import json

from json import JSONEncoder

from datetime import datetime

class ComplexEncoder(JSONEncoder):

    def default(self, obj):

        if isinstance(obj, datetime):

            return obj.strftime('%Y-%m-%d %H:%M:%S')

        else:

            return super(ComplexEncoder,self).default(obj)

d = { 'name':'alex','data':datetime.now()}

print(json.dumps(d,cls=ComplexEncoder))

# {"name": "alex", "data": "2018-05-18 19:52:05"}

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

import json

a = json.dumps({"ddf":"你好"},ensure_ascii=False)

b = json.dumps({"ddf":"你好"})

print(a) #{"ddf": "你好"}

print(b)

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

# -*- coding: utf-8 -*-

 

with open("F:/Scrapy_test/test/A") as A:

    content_a = A.read() #用read結果可以對A、B中的字母都排序好，如果用readlines()就只會把A、B整個文件的字母排序

 

with open("F://Scrapy_test//test//B") as B:

    content_b = B.read()

 

s = ''.join(sorted(content_a+content_b))

C = open("F://Scrapy_test//test//C",'w+')

result = C.write(s)

A.close()

B.close()

C.close()

 

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

def toDate(n):

    if type(n) is not int:

        return;

    from datetime import date

    from datetime import timedelta

    date2 = date.today() + timedelta(days=n)

    print(date2.strftime("%Y%m%d"))

 

toDate(2)

toDate(29)

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

def lazy_mul(n):

    def mul(m):

        return m*n

    return mul

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

 

無法編譯通過。 將函數內的str變量換為其他名稱即可

 

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

print(list(even for even in range(100) if (even%2 == 0 )))

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

with open(r'c:\test.txt', 'r') as f:

     data = f.read()

59.python 字典和 json 字符串相互轉化方法

在Python中自帶json庫。通過import json導入。 在json模塊有2個方法， loads()：將json數據轉化成dict數據 dumps()：將dict數據轉化成json數據 load()：讀取json文件數據，轉成dict數據 dump()：將dict數據轉化成json數據后寫入json文件

60.請寫一個 Python 邏輯，計算一個文件中的大寫字母數量

import os

os.chdir(r'F://Scrapy_test//test') #os.chdir切換到指定目錄

with open('B') as today:

    count=0

    for i in today.read():

        if i.isupper():

            count+=1

print(count)