Python筆試面試題目及答案

1.is 和==的區別？

is：比較的是兩個對象的id值是否相等，也就是比較倆對象是否爲同一個實例對象。是否指向同一個內存地址

== ： 比較的兩個對象的內容/值是否相等，默認會調用對象的eq()方法

2.python中內置的數據結構有幾種？

4種
列表 字典 字符串 集合 元祖

3.Python中變量的做用域？（變量查找順序)

函數做用域的LEGB順序

1.什麼是LEGB?

L： local 函數內部做用域

E: enclosing 函數內部與內嵌函數之間

G: global 全局做用域

B： build-in 內置做用

python在函數裏面的查找分爲4種，稱之爲LEGB，也正是按照這是順序來查找的

4.python新式類和經典類的區別

在Python 2及之前的版本中，由任意內置類型派生出的類，都屬於「新式類」，都會得到全部「新式類」的特性；
反之，不禁任意內置類型派生出的類，則稱之爲「經典類」。
「新式類」和「經典類」的區分在Python 3以後就已經不存在，在Python 3.x以後的版本，由於全部的類都派生自內置類型object(即便沒有顯示的繼承object類型)，即全部的類都是「新式類」。

5.super函數的具體用法和場景

https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p07_calling_method_on_parent_class.html

6.一行代碼實現1-100之和

print(sum(range(1,101)))

7.用一行python代碼寫出實現四個數之和

rom functools import reduce
#使用sum內置函數求和
print(sum([1,2,3,10248]))
#使用reduce函數
print(reduce(lambda x,y : x + y, [1,2,3,10248]))

'''
reduce() 函數會對參數序列中元素進行累積。

函數將一個數據集合（鏈表，元組等）中的全部數據進行下列操做：
用傳給 reduce 中的函數 function（有兩個參數）先對集合中的第 一、2 個元素進行操做，
獲得的結果再與第三個數據用 function 函數運算，最後獲得一個結果。
'''

8.一行代碼生成指定列表

'''
用一行代碼生成[1,4,9,16,25,36,49,64,81,100]
'''
print([i * i for i in range(1,11)])
#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

9.全字母短語判斷

'''
全字母短句 PANGRAM 是包含全部英文字母的句子，
好比：A QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
定義並實現一個方法 get_missing_letter, 傳入一個字符串採納數，
返回參數字符串變成一個 PANGRAM 中所缺失的字符。應該忽略傳入字符串參數中的大小寫，
返回應該都是小寫字符並按字母順序排序（請忽略全部非 ACSII 字符）
'''

def get_missing_letter(a):
    s1 = set('abcdefghijklmnopqrstuvwxyz')
    s2 = set(a)
    ret = ''.join(sorted(s1-s2))
    return ret

print(get_missing_letter('Lions, and tigers, and bears, oh my'))

 10.列表切片下標超限

list = ['a','b','c','d','e']
print(list[10:]) #[]
print(list[10]) #IndexError: list index out of range

'''
代碼將輸出[],不會產生IndexError錯誤，
就像所指望的那樣，嘗試用超出成員的個數的index來獲取某個列表的成員。
例如，嘗試獲取list[10]和以後的成員，會致使IndexError。
然而，嘗試獲取列表的切片，開始的index超過了成員個數不會產生IndexError，而是僅僅返回一個空列表。
這成爲特別讓人噁心的疑難雜症，由於運行的時候沒有錯誤產生，致使Bug很難被追蹤到。
'''

11.列表合併

'''
兩個有序列表，l1,l2，對這兩個列表進行合併不可以使用extend
'''

def loop_merge_sort(l1, l2):
    tem = []
    while len(l1) > 0 and len(l2) > 0:
        if l1[0] < l2[0]:
            tem.append(l1[0])
            del l1[0]
        else:
            tem.append(l2[0])
            del l2[0]
    return tem

l1 = [1,3,5,9,8,2,68,12,35]
l2 = [5,6,8,7,2,65,12,45,36]
listed = loop_merge_sort(l1, l2)
print(listed)

12.請寫出一段python代碼實現刪除list裏面的重複元素？

l1 = ['b','c','d','c','a','a']

'''
方法一使用集合去重 set
'''
l2 = list(set(l1)) #set集合元素不重複 能夠去重 而後再轉化爲list
print(l2) #集合set是無序的  會打亂原來list列表順序

'''
方法二 用list的sort方法 避免打亂list順序
'''
l1 = ['b','c','d','c','a','a']
l2 = list(set(l1))
l2.sort(key=l1.index) # 保存順序和原list一致 今天才發現python的sort有個key參數,我好圡...
#key=l1.index表示按照l1列表中的數值對應的下標進行排序，也就是按照原先的順序排序
print(l2)

'''
方法三 方法二 能夠視做一個
'''
l1 = ['b','c','d','c','a','a']
l2 = sorted(set(l1), key=l1.index)
print(l2)

'''
sort 和 sorted 主要的區別在於:
list.sort()是對已經存在的列表進行操做，進而能夠改變進行操做的列表。
而內建函數sorted返回的是一個新的list，而不是在原來的基礎上進行的操做.
'''

'''
方法四 將一個列表的數據取出來放到另一個列表中，之間作判斷
'''
l1 = ['b','c','d','c','a','a']
l2 = []
for i in l1:
    if not i in l2:
        l2.append(i)
print(l2)

'''
方法五  使用字典
'''
b = {}
b = b.fromkeys(l1)
# print(b)
c = list(b.keys())
print(c)

#Python 字典 fromkeys() 函數用於建立一個新字典，
# 以序列 seq 中元素作字典的鍵，value 爲字典全部鍵對應的初始值。
#seq -- 字典鍵值列表。
#value -- 可選參數, 設置鍵序列（seq）的值。不指定默認值none

13.閱讀一下代碼他們的輸出結果是什麼？

def multi():
    return[lambda x:i*x for i in range(4)]
print([m(3) for m in multi()])

'''
正確答案是[9,9,9,9]，而不是[0,3,6,9]
產生的緣由是Python的閉包的後期綁定致使的，這意味着在閉包中的變量是在內部函數被調用的時候被查找的，
由於，最後函數被調用的時候，for循環已經完成, i 的值最後是3,
所以每個返回值的i都是3,因此最後的結果是[9,9,9,9]
'''

14.列表生成式生成新的列表

'''
該列表只包含知足如下條件的值，元素爲原始列表中偶數切片（下標爲偶數而且值也爲偶數）
'''

alist = [1,2,5,8,10,3,18,6,20]
# num = [0,1,2,3,4,5,6,7,8,9,10]
res = [i for i in alist[::2] if i % 2 == 0]
print(res)

'''
這兩道題相同
該函數的輸入是一個僅包含數字的list,輸出一個新的list，其中每個元素要知足如下條件：

一、該元素是偶數

二、該元素在原list中是在偶數的位置(index是偶數)
'''

15.單例模式的實現方式

'''
單例模式（Singleton Pattern）是一種經常使用的軟件設計模式，
該模式的主要目的是確保某一個類只有一個實例存在。
當你但願在整個系統中，某個類只能出現一個實例時，單例對象就能派上用場。
'''
#python如何實現單例模式?請寫出兩種實現方式?

#方式一 使用裝飾器
def singleton(cls):
    instances = {}
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return wrapper
@singleton

class foo(object):
    pass
foo1 = foo()
foo2 = foo()
print(foo1 is foo2)

#方法二 使用基類 New 是真正建立實例對象的方法，因此重寫基類的new 方法，以此保證建立對象的時候只生成一個實例
class Singleton2(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton2, cls).__new__(cls, *args, **kwargs)
        return cls._instance

class foo(Singleton2):
    pass

foo1 = foo()
foo2 = foo()

print (foo1 is foo2)

#方法三 類
'''
元類，元類是用於建立類對象的類，類對象建立實例對象時必定要調用call方法，
所以在調用call時候保證始終只建立一個實例便可，type是python的元類
'''
class singleton3(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(singleton3, cls).__call__(*args, **kwargs)
        return cls._instance

class foo(object):
    __metaclass__ = singleton3

foo1 = foo()
foo2 = foo()
print(foo1 is foo2)

16.將一個整數反轉

'''
反轉一個整數，例如-123 --> -321
'''

class solution(object):
    def reverse(self, x):
        if -10 < x < 10:
            return x
        str_x = str(x)
        if str_x[0] != "-":
            str_x = str_x[::-1]
            x = int(str_x)
        else:
            str_x = str_x[1:][::-1]
            x = int(str_x)
            x = -x
        return x if -2147483648 < x < 2147483648 else 0

if __name__ == '__main__':
    s = solution()
    reverse_int = s.reverse(-125)
    print(reverse_int)

17.將一個字符串反轉

print('String'[::-1])

18.python中的可變類型與不可變類型

'''
1,可變類型有list,dict.不可變類型有string，number,tuple.

2,當進行修改操做時，可變類型傳遞的是內存中的地址，也就是說，直接修改內存中的值，並無開闢新的內存。

3,不可變類型被改變時，並無改變原內存地址中的值，而是開闢一塊新的內存，將原地址中的值複製過去，對這塊新開闢的內存中的值進行操做。
'''

19.字典推導式

d = {'a':24,'g':52,'i':12,'k':33}

dd = {key: value for key, value in d.items()}

print(dd)

'''
快速更換key和value
'''

dv = {v:k for k,v in d.items()}
print(dv)

20.統計一段字符串中字符出現的次數

'''
統計一段字符串中字符出現的次數
'''
#方法一
def count_str(str2):
    '''
    定義一個字符出現次數的函數
    :param str2:
    :return:
    '''
    dict_str = {}
    for i in str2:
        dict_str[i] = dict_str.get(i, 0) + 1
    return dict_str

dict_str = count_str("AAABBCCAC")
# print(dict_str)
# {'C': 3, 'B': 2, 'A': 4}

# str_count_data = ''
for k, v in dict_str.items():
    # str_count_data += k + str(v)
    print('%s出現的次數是%d' %(k,v))

21.字符串轉化爲字典

'''
將字符串 "k:1 |k1:2|k2:3|k3:4"，處理成字典 {k:1,k1:2,...}
'''
#方法一 ：函數
str1 = 'k:1|k1:2|k2:3|k3:4'
def str2dict(str1):
    dict1 = {}
    for i in str1.split('|'):
        key,value = i.split(':')
        dict1[key] = int(value)
    return dict1

d = str2dict(str1)
print(d.items())

#方法二：字典推導式
d = {k:int(v) for t in str1.split('|') for k,v in (t.split(':'), )}
print(d)

22.字符串轉化爲整數

'''
字符串 "123" 轉換成 123，不使用內置api，例如 int()
'''

#方法一 利用str函數
def strtoint(s):
    num = 0
    for i in s:
        for j in range(10):
            if i == str(j):
                num = num*10 + j
    return num

# s = "123"
# print(strtoint(s))

#方法二 利用ord函數
'''
它以一個字符（長度爲1的字符串）做爲參數，返回對應的 ASCII 數值，或者 Unicode 數值
如：
>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
ord('2')
50
'''
def strtoint2(s):
    num = 0
    for i in s:
        num = num * 10 + ord(i) - ord('0')
    return num

# s = "123"
# print(strtoint2(s))

#方法三 利用eval方法
'''
eval() 函數用來執行一個字符串表達式，並返回表達式的值。
'''
'''
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
'''
def strtoint3(s):
    num = 0
    for i in s:
        t = "%s * 1" % i
        n = eval(t)
        num = num * 10 + n
    return num
# s = "123"
# print(strtoint3(s))

#方法四: 結合方法二，使用 reduce，一行解決
from functools import reduce
def strtoint4(s):
    return reduce(lambda num,i:num * 10 + ord(i)-ord('0'), s, 0 )
s = "123"
print(strtoint4(s))

23.對字典按value值進行排序

'''
現有字典 d= {'a':24,'g':52,'i':12,'k':33}請按value值進行排序?
'''
d = {'a':24, 'h':43, 'c':54, 'k':66}
print(d.items()) # items() 函數以列表返回可遍歷的(鍵, 值) 元組數組。
#[('h', 43), ('k', 66), ('a', 24), ('c', 54)]

dd = sorted(d.items(), key=lambda x:x[1])
print(dd)

'''
先將字典轉換爲list，這裏的匿名函數裏面的 x 表示一個元組，x[1]表示元組裏面的第二個元素，
按照第二個元素排序
'''

24.給定一個整數數組和一個目標值，找出數組中和爲目標值的兩個數

'''
給定一個整數數組和一個目標值，找出數組中和爲目標值的兩個數。
你能夠假設每一個輸入只對應一種答案，且一樣的元素不能被重複利用。
示例:給定nums = [2,7,11,15],target=9 由於 nums[0]+nums[1] = 2+7 =9,因此返回[0,1]
'''

#enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合爲一個索引序列，
# 同時列出數據和數據下標，通常用在 for 循環當中。
class Solution:
    def twoSum(self, list1, target):
        '''
        :param list: List[int]
        :param target: int
        :return: List[int]
        '''
        for i, j in enumerate(list1):#返回元素j及下標i(下標從0開始)
            k = i + 1 #i的後一個元素開始計算累計出現的次數
            if list1[k:].count(target - j) > 0: #count() 方法用於統計某個元素在列表中出現的次數
                for n in range(list1[k:].count(target - j)):
                    b = list1.index(target - j, k)#k的存在能夠去重 每次從k開始
                    print(i ,b)
                    k = b + 1


solution = Solution()
# list1 = [2,7,11,15]
list1 = [1, 3, 4, 6, -3, 4, 1, 3, 8, 9, 3, 0, -3, 6, 0, 2, 9]
target = 9
nums = solution.twoSum(list1, target)
# print(nums)
# print(list(enumerate(list1)))
# print(list1[0:])
# print(list1.index(3,1))

'''
List.index(obj[,start=0[,stop=len(L)]])
obj -- 查找的對象。
start -- 可選參數，開始索引，默認爲0。（可單獨指定）
stop -- 可選參數，結束索引，默認爲列表的長度。（不能單獨指定）
'''

25.給定兩個列表，怎麼找出他們相同的元素和不一樣的元素？

'''
給定兩個列表，怎麼找出他們相同的元素和不一樣的元素？
'''

list1 = [1,2,3]
list2 = [3,4,5]

set1 = set(list1)
set2 = set(list2)

print(set1 & set2) #相同的
print(set1 ^ set2) #不一樣的

26.求出列表全部奇數並構造新列表

a = [1,2,3,4,5,6,7,8,9,10]
list1 = [i for i in a if i%2 == 1]
print(list1)

27.找出整數數組中的第二大

def find_second_large_num(num_list):
    '''
    找出數組中第二大數字
    :param num_list:
    :return:
    '''
    #方法一：直接排序 輸出倒數第二個
    temp_list = sorted(num_list)
    print('方法一\nSecond_large_num is :',temp_list[-2])

    #方法二：
    #設置兩個標誌位,一個存儲最大數,一個存儲次大數
    #one 存儲最大值，two 存儲次大值.遍歷一次數組便可
    # 先判斷是否大於 one，若大於將 one 的值給 two 將 num_list[i] 的值給 one，
    # 不然比較是否大於two，若大於直接將 num_list[i] 的值給two，不然pass
    one = num_list[0]
    two = num_list[0]
    for i in range(1, len(num_list)):
        if num_list[i] > one:
            two = one
            one = num_list[i]
        elif num_list[i] > two:
             two = num_list[i]
    print('方法二\nSecond_large_num is :', two)
    # 方法三
    # 用 reduce 與邏輯符號 (and, or)
    # 基本思路與方法二同樣，可是不須要用 if 進行判斷。
    from functools import reduce
    num = reduce(lambda ot, x: ot[1] < x and (ot[1], x) or ot[0] < x and (x, ot[1]) or ot, num_list, (0,0))[0]
    print("方法三\nSecond_large_num is :", num)

if __name__== '__main__':
    num_list =  [34, 11, 23, 56, 78, 0, 9, 12, 3, 7, 5]
    find_second_large_num(num_list)

28.按照list中指定的元素排序

'''
請按alist中元素的age由大到小排序
'''

alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]

def sort_by_age(list1):
    return sorted(alist, key=lambda x:x['age'], reverse=True)

print(sort_by_age(alist))

29.產生一個公差爲11的等差數列

'''
寫一個列表生成式，產生一個公差爲11的等差數列
'''

print([x*11 for x in range(10)])

30.輸入某年某月某日，判斷這一天是這一年的第幾天？

'''
輸入某年某月某日，判斷這一天是這一年的第幾天？
'''
import datetime

y = int(input('請輸入4位數字的年份：'))
m = int(input('請輸入月份：'))
d = int(input('請輸入那一天：'))

targetDay = datetime.date(y, m, d)
dayCount = targetDay - datetime.date(targetDay.year - 1,12,31)#減的是上一年最後一天
# print(dayCount) #98 days, 0:00:00
print('%s是%s年的第%s天。'%(targetDay, y, dayCount.days))

31.對列表中的字典排序

'''
給列表中的字典排序：假設有以下list對象，alist=[{"name":"a","age":20},{"name":"b","age":30},{"name":"c","age":25}],
將alist中的元素按照age從大到小排序
'''
alist=[{"name":"a","age":20},{"name":"b","age":30},{"name":"c","age":25}]
alist_sort = sorted(alist, key=lambda x:x.__getitem__('age'),reverse=True)
print(alist_sort)

32.統計一個文本中單詞頻次最高的10個單詞

#方法一 正則 + 字典
import re

file = '6_10.txt'
distone = {}#定義存放結果字典
with open(file) as f :
        for line in f:
            line = re.sub("\W+", " ", line)#正則
            lineone = line.split( )#空格分割
            for keyone in lineone:
                if not distone.get(keyone):
                    distone[keyone] = 1
                else:
                    distone[keyone] += 1

num_ten = sorted(distone.items(), key = lambda x:x[1], reverse=True)[:10]
num_ten = [x[0] for x in num_ten]
print(num_ten)

#方法二 使用 built-in 的 Counter 裏面的 most_common
import re
from collections import Counter

with open(file) as f:
    alist = list(map(lambda c:c[0], Counter(re.sub('\W+', ' ', f.read()).split( )).most_common(10)))
    print(alist)

33.編寫函數 實現如下功能：

該函數的輸入是一個僅包含數字的list,輸出一個新的list，其中每個元素同時要知足如下條件：
一、該元素是偶數
二、該元素在原list中是在偶數的位置(index是偶數)

def num_list(num):
    return [i for i in num if i % 2 == 0 and num.index(i) % 2 == 0]

num = [0,1,2,3,4,5,6,7,8,9,10]
result = num_list(num)
print(result)

34.自定義函數，讓全部奇數都在偶數前面，並且奇數升序排列，偶數降序排序

'''
給定一個任意長度數組，實現一個函數
讓全部奇數都在偶數前面，並且奇數升序排列，偶數降序排序，
如字符串'1982376455',變成'1355798642'
'''

'''
isinstance() 函數來判斷一個對象是不是一個已知的類型，相似 type()。

isinstance() 與 type() 區別：

type() 不會認爲子類是一種父類類型，不考慮繼承關係。

isinstance() 會認爲子類是一種父類類型，考慮繼承關係。

若是要判斷兩個類型是否相同推薦使用 isinstance()。
'''
'''
isinstance(object, classinfo)
object -- 實例對象。
classinfo -- 能夠是直接或間接類名、基本類型或者由它們組成的元組。
'''

#方法一
def func1(b):
    if isinstance(b, str):
        b = [int(i) for i in b]
    b.sort(reverse=True)#倒序排列
    for i in range(len(b)):
        if b[i] % 2 > 0:
            b.insert(0, b.pop((i)))#insert() 函數用於將指定對象插入列表的指定位置。
                    #pop() 函數用於移除列表中的一個元素（默認最後一個元素），而且返回該元素的值。
    print(''.join(str(e) for e in b))
'''
將序列中的元素以指定的字符鏈接生成一個新的字符串。

語法
語法： ‘sep’.join(seq)

參數說明： 
sep：分隔符。能夠爲空 
seq：要鏈接的元素序列、字符串、元組、字典
'''

str2 = '1982376455'
func1(str2)

#方法二
def func2(b):
    print(''.join(sorted(b, key=lambda x:int(x) % 2 == 0 and 20 - int(x) or int(x))))
func2(str2)

35.遍歷列表時刪除元素的正確作法

'''
Python-遍歷列表時刪除元素的正確作法
'''
#方法一：遍歷在新在列表操做，刪除時在原來的列表操做
a = [1,2,3,4,5,6,7,8]
# b = id(a)
# c = id(a[:])
'''
b=a與b=a[:]的區別
b=a將二者指向同一個對象
而b=a[:]會建立一個新的與a徹底相同的對象，可是與a並不指向同一對象。
在計算機中，不一樣的對象即不一樣的內存地址。
可理解爲：b=a將建立a與b兩個快捷方式並指向同一文件；
而b=a[:]先將a指向的文件複製一份做爲副本，而後建立一個指向該副本的快捷方式b。
兩者不一樣表現爲當二者指向同一對象時，改變其中任意一個，都會改變對象的值，也就是同時改變a，b的值。

'''
print(id(a))
print(id(a[:]))
#兩個不一樣的地址 19126472  19126920

for i in a[:]:
    # print(i)#
    if i > 5:
        pass
    else:
        a.remove(i)
    print(a)
print('------------')
print(id(a))

#方法二 列表推導式
a = [1,2,3,4,5,6,7,8]
b = [i for i in a if i > 5]
print(b)

#方法三 filter
a = [1,2,3,4,5,6,7,8]
b = filter(lambda x: x > 5, a)
print(list(b))

#方法四
'''
倒序刪除 由於列表老是‘向前移’，因此能夠倒序遍歷，即便後面的元素被修改了，尚未被遍歷的元素和其座標仍是保持不變的
'''
a = [1,2,3,4,5,6,7,8]
print(id(a))
for i in range(len(a) - 1, -1, -1):
    if a[i] > 5:
        pass
    else:
        a.remove(a[i])

print(id(a))
print('-------')
print(a)

36.設計實現遍歷目錄與子目錄，抓取.pyc文件

'''
設計實現遍歷目錄與子目錄，抓取.pyc文件
'''

#方法一
import os

def get_files(dir, suffix):
    res = []
    for root, dirs, files in os.walk(dir): #是一個簡單易用的文件、目錄遍歷器 取得該文件夾下的全部文件
        for filename in files:
            name, suf = os.path.splitext(filename) #splitext 分離文件名與擴展名
            if suf == suffix:
                res.append(os.path.join(root, filename))

    print(res)

get_files('D:\Software\Anaconda3\envs','.pyc')

#方法二
def pick(obj):
    if obj.endswith('.pyc'):
       print(obj)

def scan_path(ph):
    file_list = os.listdir(ph) #os.listdir() 方法用於返回指定的文件夾包含的文件或文件夾的名字的列表
    for obj in file_list:
        if os.path.isfile(obj):
            pick(obj)
        elif os.path.isdir(obj):
            scan_path(obj)

if __name__ == '__main__':
    # path = input('請輸入目錄')
    scan_path("D:\Software\Anaconda3\envs")

#方法三
from glob import iglob
def func(fp, postfix):
    for i in iglob("f{fp}/**/*{postfix}", recursive=True):
        print(i)

if __name__ == '__main__':
    postfix = '.pyc'
    func('D:\Software\Anaconda3\envs','.pyc')