作者簡介：大家好我是編程ID
個人主頁：編程ID的csdn博客
系列專欄：Python
推薦一款編程題刷題神器點擊跳轉進入網站
1. 一行代碼實現1-100之和
res=sum(range(1,101))
print(res) #5050
2. 如何在一個函數內部修改全局變量
a=5
def func():
global a
a=10
return a
func()
print(a) #10
3. 列出 5 個常用 Python 標准庫？
常用的有
os 提供了與操作系統關聯的函數
import os
os.getcwd()
os.path.join('/usr/temp','test.log')
datatime 提供了日期和時間處理的常用方法
from datetime import datetime
# 將時間戳轉換為日期類型
datetime.fromtimestamp(1638175727)
datetime.strptime('2021-12-01 13:13:13','%Y-%m-%d %H:%M:%S')
datetime.now()
random 隨機數生成庫
import random
# 生成1-100的隨機數
print(random.randint(1,100))
# 在abcdef中隨機選擇一個
print(random.choice('abcdef'))
math 數學運算庫
import math
print(math.pow(2,4))
print(math.sin(1))
print(math.floor(2.5))
re 正則匹配模塊
import re
# 將正則表達式編譯成Pattern對象
pattern = re.compile(r'hello')
# 使用Pattern匹配文本，獲得匹配結果，無法匹配時將返回None
match = pattern.match('hello world!')
if match:
# 使用Match獲得分組信息
print(match.group())
# 搜索整個字符串
m = re.search('[a-z]+','abcdef123ghh')
print(m.group(0))
m2 = re.search('[0-9]+','abcdef123ghh')
print(m2.group(0))
4. 如何合並兩個字典
#4、如何合並兩個字典
dic1={
'name':'psy'}
dic2={
'age':18}
dic1.update(dic2)
print(dic1) #{'age': 18, 'name': 'psy'}
5. 談一下Python的GIL
#5、談一下Python的GIL
"""
GIL是Python的全局解釋器鎖，同一個進程如果有多個線程，一個線程在運行Python程序的時候會占用Python解釋器（加一把鎖即GIL），使
該進程內的其他線程無法運行，等該線程運行完後其他縣城才能運行。如果線程運行過程中遇到好事操作，則解釋其鎖解開，使其他線程運行。
所以在多線程中，線程的運行仍時有先後順序的，並不是同時進行的。
補充：多進程中因為每個進程都能被系統分配資源，相當於每個進程有一個Python解釋器，所以多進程可以實現多個進程的同時運行，
缺點就是進行系統資源開銷大。
“”"
6、Python實現列表去重 【並保證原來的順序】
#6、Python實現列表去重 【並保證原來的順序】
num_list = [1, 3, 1, 5, 3, 6, 1]
new_num=[]
jh=set()
for item in num_list:
if item not in jh:
new_num.append(item)
jh.add(item)
print(new_num) #[1, 3, 5, 6]
res=[num for num in set(num_list)] #方法2
print(res) #[1, 3, 5, 6]
7、fun(args,kwargs)中的args, kwargs 什麼意思？
#7、fun(args,kwargs)中的args, kwargs 什麼意思？
"""
*arg 表示傳入的是非鍵值對的數據，即元祖類型
**kwargs 表示傳入的是鍵值對數據，即字典類型
如果你有其他語言基礎的話，你應該聽說過重載的概念，對Python 為了避免這種繁瑣的情況發生，引入了 args 和 kwargs；
args 用來接受非鍵值對的數據，即元組類型，而 kwargs 則用來接受鍵值對數據，即字典類型。
“”"
8. Python2 和 Python3 的 range（100）的區別？
#8、Python2 和 Python3 的 range（100）的區別？
python2返回的是列表
python3返回的是迭代器，節約資源
9. 生成一個16位的隨機字符串
#9、生成一個16位的隨機字符串
import random
import string # string.printable 隨機生成字符串，長度是100
res=''
for i in range(16):
res=res+random.choice(string.printable)
print(res) #G)_$U/#[email protected];6#
print(''.join((random.choice(string.printable)) for i in range(16))) #[email protected]}Z+Z(CS~5 AZ!+ 【方法2】
10、一句話解釋什麼樣的語言能夠用裝飾器?
#10、一句話解釋什麼樣的語言能夠用裝飾器?
函數可以作為參數傳遞
11、python內建的數據類型
#11、python內建的數據類型
#整型 int 布爾型 bool 字符串 str 列表 list 元祖 tuple 字典 dict
12、簡述面向對象中new和init區別？
#12、簡述面向對象中new和init區別？
（1）__new__至少要一個參數cls，代表當前類，此參數在實例化由python解釋器自動識別
（2）__new__必須要有一個返回值，返回實例化出來的實例，這點在自己實現__new__時要特別注意！
可以return 父類（通過super(當前類名,cls)）.__new__出來的實例，或者直接是object的__new__出來的實例。
（3）__new__有一個參數self，就是這個__new__返回的實例，__init__在__new__的基礎上可以完成一些其它初始化的動作，
__init__不需要返回值
（4）如果__new__創建的是當前類的實例，會自動調用__init__函數，通過return語句裡面調用的__new__函數的第一個參數是cls來保證是當前類實例，
如果是其他類的類名，那麼實際創建返回的就是其他類的實例，其實就不會調用當前類的__init__函數，也不會調用其他類的__init__函數
"""#【下面舉例說明】 #__init__和__new__的區別 class Person(object): def __new__(cls,name,age): print('__new__ called') return super(Person,cls).__new__(cls) def __init__(self,name,age): print('__init__ called') self.name=name self.age=age def __str__(self): return 'Person:{}-{}'.format(self.name,self.age) child=Person('psy',18) print(child) """結果顯示：
__new__ called
__init__ called
Person:psy-18
表明：
__new__的調用優於__init__方法；
__new__方法負責創建一個實例對象，__init__方法負責將該實例對象進行初始化；
__new__方法正式創建這個類實例的方法，返回額的對象正式__init__的self參數；
__init__用於實例化對象，__new__用於繼承，是類別級的方法
#__new__的應用場景
#__new__方法主要是當你繼承一些不可變的class時(比如int, str, tuple)， 提供給你一個自定義這些類的實例化過程的途徑
class PositiveInt(int):
def __new__(cls,value):
return super(PositiveInt,cls).__new__(cls,abs(value))
print(PositiveInt(-55)) #55
class RoundFloat(float):
def __new__(cls,value):
return super(RoundFloat,cls).__new__(cls,round(value,2))
print(RoundFloat(3.1415926))
13、簡述 with 方法打開處理文件幫我我們做了什麼？
""" 打開文件在進行讀寫操作時，可能會出現一些異常狀況，如果按照常規的f.open寫法，我們需要try,except，finally，做異常判斷， 並且文件最終不管遇到什麼情況，都要執行finally f.close()關閉文件。 其中利用with方法幫我們實現了finally中的f.close()。 """
14、列表[1,2,3,4,5]，請使用 map() 函數輸出[1,4,9,16,25]，並使用列表推導式提取出大於 10 的數，最終輸出 [16,25]？
#14、列表[1,2,3,4,5]，請使用 map() 函數輸出[1,4,9,16,25]，並使用列表推導式提取出大於 10 的數，最終輸出 [16,25]？
l1=[1,2,3,4,5]
print(list(map(lambda x:x*x,l1))) #[1, 4, 9, 16, 25]
print([x for x in list(map(lambda x:x*x,l1)) if x>10]) #[16, 25]
15、python 中生成隨機整數、隨機小數、2-6 之間小數方法？
#15、python 中生成隨機整數、隨機小數、2-6 之間小數方法？
print(random.randint(1,10)) #隨機整數
print(random.random()) #隨機小數
print(random.uniform(2,6)) #2-6之間的小數
16、避免轉義給字符串加哪個字母表示原始字符串？
#16、避免轉義給字符串加哪個字母表示原始字符串？
res=b'input\n' #bytes字節符，打印以b開頭
print(res) #b'input\n'
res=r'input\n' # 非轉義原生字符，經處理'\n'變成了'\'和'n'。也就是\n表示的是兩個字符，而不是換行。
print(res) #input\n
res=u'input\n' # unicode編碼字符，python3默認字符串編碼方式。
print(res) #input + 換行
17、 < di v class=“nam”> Python，用正則匹配出標簽裡面的內容（“Python”），其中 class 的類名是不確定的。
#17、<div class="nam">Python</div>，用正則匹配出標簽裡面的內容（“Python”），其中 class 的類名是不確定的。
import re
s='<div class="nam">Python</div>'
res=re.findall(r'<div class=".*">(.*?)<.*>',s)[0]
print(res) #Python
18、Python 中斷言方法舉例？
#18、Python 中斷言方法舉例？
age = 10
#assert 0 < age < 10
""" 結果顯示： Traceback (most recent call last): File "E:/000文章的代碼/27/python面試題.py", line 157, in <module> assert 0 < age < 10 AssertionError """
19、dict 中 fromkeys 的用法
#19、dict 中 fromkeys 的用法
keys=('info1','info2')
res=dict.fromkeys(keys,['psy',18,'girl'])
print(res) #{'info1': ['psy', 18, 'girl'], 'info2': ['psy', 18, 'girl']}
20、請用正則表達式輸出漢字
import re
s="not 404 found 中國 2018 我愛你"
r1='[a-zA-Z0-9’!"#$%&\'()*+,-./:;<=>[email protected]，。?*、…【】《》？“”‘’！[\\]^_`{|}~]+\s?'
res=re.sub(r1,'',s)
print(res) #中國 我愛你
21、Python2 和 Python3 區別？列舉 5 個
#21、Python2 和 Python3 區別？列舉 5 個
""" （1）去除<>，全部使用!= （2）print都要加() （3）xrange()改為range() （4）內存操作cStringIO改為StringIO （5）加入nonlocal 作用：可以引用外部非全局變量 （6）zip() map() 和filter()都返回迭代器，而不是生成器，更加節約內存 """
22、列出 Python 中可變數據類型和不可變數據類型，為什麼？
""" 不可變類型：int str tuple 可變類型：list dict set 原理：可變數據類型即公用一個內存空間地址，不可變數據類型即每場一個對象就會產生一個內存地址 """
23、dict的內部實現？
""" 在 Python 中，字典是通過哈希表實現的。也就是說，字典是一個數組，而數組的索引是鍵經過哈希函數處理後得到的。 哈希函數的目的是使鍵均勻地分布在數組中。由於不同的鍵可能具有相同的哈希值，即可能出現沖突，高級的哈希函數能夠使沖突數目最小化。 """
24、s = “ajldjlajfdljfddd”，去重並從小到大排序輸出"adfjl"？
s='ajldjlajfdljfddd'
res1=sorted(list(set(s))) #['a', 'd', 'f', 'j', 'l']
res=''.join(res1)
print(res) #adfjl
25、用 lambda 函數實現兩個數相乘？
mul=lambda x,y:x*y
print(mul(2,5)) #10
26、字典根據鍵從小到大排序？
info = {
'name': 'Gage', 'location':'nj', 'sex': 'man'}
res_key=sorted(info.items(),key=lambda x:x[0]) #根據鍵排序
print(res_key) #[('location', 'nj'), ('name', 'Gage'), ('sex', 'man')]
res_value=sorted(info.items(),key=lambda x:x[1]) #根據值排序
print(res_value) #[('name', 'Gage'), ('sex', 'man'), ('location', 'nj')]
#若對列表中的字典進行排序
l=[{
'name':'psy','age':18},{
'name':'xk','age':24},{
'name':'pyg','age':55}]
#按年齡進行排序
l.sort(key=lambda item:item['age'])
print(l) #[{'name': 'psy', 'age': 18}, {'name': 'xk', 'age': 24}, {'name': 'pyg', 'age': 55}]
salaries={
'psy':200,'xk':180,'gyp':300,'pyg':250}
#將salaries按照薪資的高低進行排序
res=sorted(salaries,key=lambda item:salaries[item],reverse=True)
print(res) #['gyp', 'pyg', 'psy', 'xk']
27、Python 獲取當前日期？
import time
import datetime
print(datetime.datetime.now()) #2019-04-03 17:06:16.347417
print(time.strftime('%Y-%m-%d %H:%M:%S')) #2019-04-03 17:06:51
28、簡述5條：Python的pep8-代碼規范
不要在行尾加分號, 也不要用分號將兩條命令放在同一行
不要使用反斜槓連接行
不要在返回語句或條件語句中使用括號
頂級定義之間空2行, 方法定義之間空1行，頂級定義之間空兩行
如果一個類不繼承自其它類, 就顯式的從object繼承
29、Fibonacci 數列
def func(n):
a,b=0,1
while n:
yield b
a,b=b,a+b
n-=1
print(list(func(10))) #[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
30、Python 三目運算
#res=a-b if a>b else b-a
#解釋：如果a>b成立，返回a-b，否則返回b-a
31、單例模式 【後面會有文章重點介紹單例模式】
class Single():
__isstance=None
__first_init=False
def __new__(cls, *args, **kwargs):
if not cls.__isstance:
cls.__isstance=object.__new__(cls)
def __init__(self,name):
if not self.__first_init:
self.name=name
Single.__first_init=True
32、遞歸
def digui(n):
if n==1:
return 1
else:
return (n*digui(n-1))
print(digui(4)) #24
33、統計字符串每個單詞出現的次數
from collections import Counter
s3='kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h'
print(Counter(s3)) #Counter({'l': 9, ';': 6, 'h': 6, 'f': 5, 'a': 4, 'j': 3, 'd': 3, 's': 2, 'k': 1, 'b': 1, 'g': 1})
34、正則 re.complie 作用
#re.complie是將正則表達式編程成一個對象，加快速度，並且可以重復使用
content = 'Hello, I am Jerry, from Chongqing, a montain city, nice to meet you……'
regex=re.compile('\w*o\w*')
res=regex.findall(content)
print(res) #['Hello', 'from', 'Chongqing', 'montain', 'to', 'you']
35、filter 方法求出列表所有奇數並構造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a=[1,2,3,4,5,6,7,8,9,10]
res=list(filter(lambda x:x%2,a))
print(res) #[1, 3, 5, 7, 9]
36、列表推導式求列表所有奇數並構造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a=[1,2,3,4,5,6,7,8,9,10]
res=[x for x in a if x%2==1]
print(res) #[1, 3, 5, 7, 9]
37、a=（1，）b=(1)，c=(“1”) 分別是什麼類型的數據？
a=(1,)
print(type(a)) #<class 'tuple'>
b=(1)
print(type(b)) #<class 'int'>
c=("1")
print(type(c)) #<class 'str'>
37、兩個列表[1,5,7,9]和[2,2,6,8]合並為[1,2,2,3,6,7,8,9] 【歸並排序】
l1=[1,5,7,9]
l2=[2,2,6,8]
def merge_sort(l1,l2):
left_p,right_p=0,0
result=[]
while left_p<len(l1) and right_p<len(l2):
if l1[left_p]<l2[right_p]:
result.append(l1[left_p])
left_p+=1
else:
result.append(l2[right_p])
right_p+=1
result+=l1[left_p:]
result+=l2[right_p:]
return result
print(merge_sort(l1,l2))
38、用 python 刪除文件和用 linux 命令刪除文件方法
""" python刪除文件： os.remove(文件名) linux命令刪除文件： rm 文件名 """
39、logging 模塊的使用？
#logging是日志模塊，爬蟲時可能用到
import logging
logging.basicConfig(level=logging.INFO,format='%(asctime)s-%(name)s-%(levelname)s-%(message)s')
logger=logging.getLogger('psy') #psy我設置的文件名
logger.info('Start log')
logger.debug('Do something')
logger.warning('Something maybe fail')
logger.error('Somthing exists error')
logger.critical('Break down')
40、寫一段自定義異常代碼
def func():
try:
for i in range(5):
if i>2:
raise Exception('數字大於2')
except Exception as e:
print(e)
func() #數字大於2
41、正則表達式匹配中，（.）和（.?）匹配區別？
#（.*）是貪婪匹配，會把滿足正則的盡可能多的往後匹配
#（.*?）是非貪婪匹配，會把滿足正則的盡可能少匹配
s = "<a>哈哈</a><a>呵呵</a>"
import re
res1 = re.findall("<a>(.*)</a>", s)
print("貪婪匹配", res1) #貪婪匹配 ['哈哈</a><a>呵呵']
res2 = re.findall("<a>(.*?)</a>", s)
print("非貪婪匹配", res2) #非貪婪匹配 ['哈哈', '呵呵']
42、[[1,2],[3,4],[5,6]]一行代碼展開該列表，得出[1,2,3,4,5,6]
a=[[1,2],[3,4],[5,6]]
new_a=[]
for item in a:
new_a.extend(item)
print(new_a) #[1, 2, 3, 4, 5, 6]
res=[j for i in a for j in i]
print(res) #[1, 2, 3, 4, 5, 6]
43、x=“abc”,y=“def”,z=[“d”,“e”,“f”]，分別求出 x.join(y) 和 x.join(z) 返回的結果
#join()括號裡面的是可迭代對象，x插入可迭代對象中間，形成字符串，結果一致
x="abc"
y="def"
z=["d","e","f"]
print(x.join(y)) #dabceabcf
print(x.join(z)) #dabceabcf
44、舉例說明異常模塊中 try except else finally 的相關意義
""" try..except..else沒有捕獲到異常，執行else語句 try..except..finally不管是否捕獲到異常，都執行finally語句 """
#45、python中兩個值交換
a,b=1,2
a,b=b,a
print(a,b) #2 1
46、舉例說明 zip() 函數用法 zip()函數實質就是整合
l1=[1,2,3,4]
l2=[4,5,6]
res=list(zip(l1,l2))
print(res) #[(1, 4), (2, 5), (3, 6)]
47、a=“張明 98分”，用 re.sub，將 98 替換為 100
import re
a="張明 98分"
res=re.sub(r'\d+','100',a)
print(res) #張明 100分
48、a="hello"和b="你好"編碼成 bytes 類型
a=b"hello"
b="你好".encode()
print(type(a)) #<class 'bytes'>
print(type(b)) #<class 'bytes'>
49、[1,2,3]+[4,5,6]的結果是多少
print([1,2,3]+[4,5,6]) #[1, 2, 3, 4, 5, 6]
50、提高 python 運行效率的方法
（1）使用生成器，因為可以節約大量內存
（2）循環代碼優化，避免過多重復代碼的執行
（3）核心模塊用Cython PyPy等，提高效率
（4）多線程、多進程、協程
（5）多個if elif條件判斷，可以把最有可能先發生的條件放到前面寫，這樣可以減少程序的判斷次數，提高效率
51、遇到 bug 如何處理
（1）細節上的錯誤，通過print()打印，能執行到print()說明一般上面的代碼沒有問題，分段檢測程序是否有問題，如果是js的話可以alter活console.log
（2）如果涉及一些第三方的框架，會去查找光放文檔或者一些技術博客
（3）對於bug的管理與歸類總結，一般測試將測試出的bug用teambin等bug管理工具進行記錄，然後我們會一條一條進行修改，修改的過程也是理解業務邏輯和提高自己編程邏輯缜密性的方法，然後自己再做一些筆記記錄。
（4）導包問題、城市定位多音字造成的顯示錯誤問題
52、list=[2,3,5,4,9,6]，從小到大排序，不許用 sort，輸出[2,3,4,5,6,9]
#若使用sort
l=[2,3,5,4,9,6]
print(sorted(l)) #[2, 3, 4, 5, 6, 9]
#不使用sorted，自己定義函數
def quicksort(old_list):
if len(old_list)<2:
return old_list
else:
temp=old_list[0]
lowbeforetemp=[i for i in old_list[1:] if i<=temp]
bigbeforetemp=[i for i in old_list[1:] if i>temp]
final_list=quicksort(lowbeforetemp)+[temp]+quicksort(bigbeforetemp)
return final_list
print(quicksort([2,3,5,4,9,6])) #[2, 3, 4, 5, 6, 9]
53、兩個數相除，保留兩位小數
print(round(10/3,2)) #3.33
54、正則匹配，匹配日期 2018-03-20
s='Date：2018/03/20'
import re
res1=re.findall('(\d+)',s) #['2018', '03', '20']
res='-'.join(res1)
print(res) #2018-03-20
55、使用 pop 和 del 分別刪除字典中的"name"和"age"字段，dic={“name”:“zs”,“age”:18,“sex”:“girl”}
dic={
"name":"zs","age":18,"sex":"girl"}
dic.pop("name")
print(dic) #{'sex': 'girl', 'age': 18}
del dic["age"]
print(dic) #{'sex': 'girl'}
56、簡述多線程、多進程
進程是資源（CPU、內存等）分配的基本單位，它是程序執行時的一個實例。
線程是程序執行時的最小單位，它是進程的一個執行流。
進程有自己的獨立地址空間，每啟動一個進程，系統就會為它分配地址空間，建立數據表來維護代碼段、堆棧段和數據段，這種操作非誠昂貴。
【所以各個進程有自己的地址空間，彼此互相不打擾】
線程是共享進程中的數據的，使用相同的地址空間，因此CPU切換一個線程的花費比進程要小很多，同時創建一個線程的開銷也比進程要小很多。
57、簡述 any() 和 all() 方法
#連個返回的都是bool值 all如果存在0 None False返回False,否則返回
True;any與之相反
print(all([0,1,2,3])) #False
print(all([1,2,3])) #True
print(any([0,1,2,3])) #True
print(any([0,False,None])) #False
58、異常分類
""" IOError 輸入輸出異常 AttributeError 試圖訪問一個對象沒有的屬性 ImportError 無法引入模塊或包，基本都是路徑的問題 IndentationError 語法錯誤，代碼沒有正確的對齊 KeyError 試圖訪問你字典裡不存在的鍵 SyntaxError Python代碼邏輯語法出錯，不能執行 NameError 使用一個還未賦予對象的變量 """
59、Python 中 copy 和 deepcopy 區別 【深拷貝和淺拷貝】
import copy
#copy的使用
l1=[1,2,[3,4]]
l2=copy.copy(l1)
print(id(l1)==id(l2)) #False 兩者id不相同
l1.append(5)
l1[2].append(5)
print(l1) #[1, 2, [3, 4, 5], 5]
print(l2) #[1, 2, [3, 4, 5]]
#deepcopy的使用
l1=[1,2,[3,4]]
l2=copy.deepcopy(l1)
print(id(l1)==id(l2)) #False 兩者id不相同
l1.append(5)
l1[2].append(5)
print(l1) #[1, 2, [3, 4, 5], 5]
print(l2) #[1, 2, [3, 4]]
""" copy()和deepcopy()是Python語言copy模塊中的兩個method，copy()其實是與deep copy相對的shallow copy。 對於簡單的object,用shallow copy和deep copy沒區別。 復雜的Object,如list中套著list的情況,shallow copy中的子list並未從原object真的獨立出來，因此如果你改變原object的子list中的一個元素，你的copy就會跟著一起改變。 deep copy則更加符合我們對復制的直覺定義：一旦復制出來了，就應該是獨立的了。 """
60、在python數據處理中的復制方法（下面介紹3種，需要導入numpy庫）
import numpy as np
方法一：b=a 【此時：b和a實際指向同一個東西，改變a或b，兩者一起發生變化】
a=np.arange(12)
b=a
b.shape=(3,4)
print(a.shape) #(3, 4)
print(id(a)==id(b)) #True
方法二：c=a.view() 【此時：c和a不是指向同一個東西，但是共用一堆值】
a=np.arange(12)
c=a.view()
c.shape=(3,4)
print(a.shape) #(12,)
print(id(a)==id(c)) #False
方法三：d=a.copy() 【此時：d和a各自為各自的值，沒有一點關系】
a=np.arange(12)
d=a.copy()
d[0]=5
print(a) #[ 0 1 2 3 4 5 6 7 8 9 10 11]
print(d) #[ 5 1 2 3 4 5 6 7 8 9 10 11]
print(id(a)==id(d)) #False
61、列出幾種魔法方法並簡要介紹用途
""" __init__ 對象初始化方法 __new__ 創建對象時執行的方法，單例模式會用到 __str__ 當時用print輸出對象時，只要自己定義了__str__(self)方法，則就打印在這個方法中return的數據 【必須要有return】 __del__ 刪除對象執行的方法 """
62、上下文管理器 with…as 的實現
上下文管理器(context manager)用於規定某個對象的使用范圍。一旦進入或者離開該使用范圍，會有特殊操作被調用 比如為對象分配或者釋放內存)。
它的語法形式是with…as…
常用的上下文管理器： with open(‘test.txt’,‘w’)as f:f.write(‘Hello World!’)
open函數既能夠當做一個簡單的函數使用，又能夠作為上下文管理器。這是因為open函數返回了一個文件類型變量。
要實現上下文管理器，必須實現兩個方法：一個負責進入語句塊的准備操作（enter 方法），另一個負責離開語句塊的善後操作（exit 方法）。
當一個對象被用作上下文管理器時：
enter 方法將在進入代碼塊前被調用。
exit 方法則在離開代碼塊之後被調用(即使在代碼塊中遇到了異常)。
自己實現的上下文管理方法，
class PypixOpen:
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
def __enter__(self):
self.openedFile = open(self.filename, self.mode)
return self.openedFile
def __exit__(self, *unused):
self.openedFile.close()
with PypixOpen(filename, mode) as writer:
writer.write("Hello World from our new Context Manager!")
注意：
（1）我們完全忽視了語句塊內部可能出現的問題。
（2）如果語句塊內部發生了異常，__exit__方法將被調用，而異常將會被重新拋出(re-raised)。
當處理文件寫入操作時，大部分時間你肯定不希望隱藏這些異常，所以這是可以的。
而對於不希望重新拋出的異常，我們可以讓__exit__方法簡單的返回True來忽略語句塊中發生的所有異常(大部分情況下這都不是明智之舉)。
（3）上面代碼*unused 指向exc_type, exc_value, traceback三個參數，當程序塊中出現異常(exception)，這三個參數用於描述異常。
我們可以根據這三個參數進行相應的處理。如果正常運行結束，這三個參數都是None。
給出的答案
class Close():
def __init__(self,obj):
self.obj=obj
def __enter__(self):
return self.obj #返回作為as目標
def __exit__(self, exc_type, exc_val, exc_tb):
try:
self.obj.close()
except AttributeError:
print(exc_type)
63、python arg.py 1 2 命令行啟動程序並傳參，print(sys.argv) 會輸出什麼數據？
#[arg.py 1 2]
64、請將[i for i in range(3)]改成生成器
class iter():
def __init__(self,data):
self.data=data
self.loop=-1
def __iter__(self):
return self
def __next__(self):
if self.loop>=self.data:
raise StopIteration
self.loop+=1
return self.loop
Iter=iter(range(3))
print(Iter) #<__main__.iter object at 0x000001BA9D92F898>
print(Iter.__iter__()) #<__main__.iter object at 0x0000016888BDF898>
print(Iter.data) #range(0, 3)
print(Iter.__next__) #<bound method iter.__next__ of <__main__.iter object at 0x0000016888BDF898>>
""" #列表解析生成列表 [x*x for x in range(3)] 結果：[0,1,4] #生成器表達式 (x*x for x in range(3)) 結果：(0,1,4) #兩者之間的轉換 list(x*x for x in range(3)) 結果[0,1,4] """
65、字符串轉化大小寫？
s='MyDay'
print(s.upper()) #MYDAY
print(s.lower()) #myday
66、請說明 sort 和 sorted 對列表排序的區別
l=[2,4,1,3,8,6,5]
l.sort()
print(l) #[1, 2, 3, 4, 5, 6, 8]
l=[2,4,1,3,8,6,5]
print(sorted(l)) #[1, 2, 3, 4, 5, 6, 8]
"""
（1）sort()與sorted()的不同在於：sort()是在原位重新排列列表，而sorted()是產生一個新的列表
sorted(L)返回一個排序後的L，不改變原始的L；L.sort()是對原始的L進行操作，調用後原始的L會改變，沒有返回值
所以a=a.sort()是錯的，a=sorted(a)才對！
（2）sorted()適用於任何可迭代容器，list.sort()僅支持list
（3）基於以上兩點，sorted的使用頻率比list.sort()更高些
67、對 foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4] 進行排序，使用 lambda 函數從小到大排序
#方法一：直接使用list.sort()
foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
foo.sort()
print(foo) #[-20, -5, -4, -4, -2, 0, 2, 4, 8, 8, 9]
#方法二：使用lambda函數
foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
res=sorted(foo,key=lambda x:x)
print(res) #[-20, -5, -4, -4, -2, 0, 2, 4, 8, 8, 9]
68、對 foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4] 進行排序，將正數從小到大，負數從大到小
foo = [-5, 8, 0, 4, 9, -4, -20, -2, 8, 2, -4]
res=sorted(foo,key=lambda x:(x<0,abs(x)))
print(res) #[0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20]
#69、Python 傳參數是傳值還是傳址？
""" Python 中函數參數是引用傳遞（注意不是值傳遞）。 對於不可變類型（數值型、字符串、元組），因變量不能修改，所以運算不會影響到變量自身； 而對於可變類型（列表字典）來說，函數體運算可能會更改傳入的參數變量。 """
70、w、w+、r、r+、rb、rb+ 文件打開模式區別
r 以只讀方式打開文件。文件的指針會被放在文件的開頭。這是默認模式。
w 打開一個文件只用於寫入。如果該文件已存在則將其覆蓋，如果該文件不存在，創建新文件。
a 打開一個文件用於追加。如果該文件存在，文件指針將會放在文件的結尾。也就是說：新的內容會被寫入到已有內容之後。
如果該文件不存在，創建新文件進行寫入。
rb 以二進制格式打開一個文件用於只讀。文件指針會放在文件的開頭。這是默認模式。
wb 以二進制格式打開一個文件只用於寫入。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。
ab 以二進制格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是：新的內容會被寫入到已有內容之後。
如果該文件不存在，創建新文件進行寫入。
r+ 打開一個文件用於讀寫。文件指針將會放在文件的開頭。
w+ 打開一個文件用於讀寫。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。
a+ 打開一個文件用於讀寫。如果該文件已存在，文件指針將會放在文件的結尾。文件打開時會時追加模式。
如果該文件不存在，創建新文件進行寫入。
rb+ 以二進制格式打開一個文件用於讀寫。文件指針會放在文件的開頭。
wb+ 以二進制格式打開一個文件用於讀寫。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。
ab+ 以二進制格式打開一個文件用於讀寫。如果該文件已存在，文件指針將會放在文件的結尾。
如果該文件不存在，創建新文件進行寫入。
71、int(“1.4”)、int(1.4)的輸出結果？
print(int("1.4")) #報錯ValueError: invalid literal for int() with base 10: '1.4'
print(int(1.4)) #1
72、Python 垃圾回收機制？
“”"
（1）引用計數
import sys
str1='hello world'
print(sys.getrefcount(str1)) #在python解釋器下運行，為2 創建一次，調用一次
（2）分代計數
Python默認定義了三代對象集合，索引數越大，對象存活時間越長
Python中使用了某些啟發式算法（heuristics）來加速垃圾回收。
【例如，越晚創建的對象更有可能被回收。對象被創建之後，垃圾回收器會分配它們所屬的代（generation）。每個對象都會被分配一個代，而被分配更年輕代的對象是優先被處理的。】
（3）引用循環
垃圾回收器會定時尋找這個循環，並將其回收。
舉個例子，假設有兩個對象o1和o2，而且符合o1.x == o2和o2.x == o1這兩個條件。如果o1和o2沒有其他代碼引用，那麼它們就不應該繼續存在。但它們的引用計數都是1。
“”"
73、Python 字典和 json 字符串相互轉化方法 【序列化和反序列化】
import json
dic={
"name":"psy","age":18}
#序列化 把python的對象編碼轉換為json格式的字符串
res1=json.dumps(dic)
print(res1,type(res1)) #{"age": 18, "name": "psy"} <class 'str'> 【json中一般使用""】
#反序列化 把json格式字符串解碼為python數據對象。
res2=json.loads(res1)
print(res2,type(res2)) #{'name': 'psy', 'age': 18} <class 'dict'>
74、Python 正則中 search 和 match 的區別
""" match() 從第一個字符開始找, 如果第一個字符就不匹配就返回 None, 不繼續匹配. 用於判斷字符串開頭或整個字符串是否匹配,速度快。 search() 會整個字符串查找,直到找到一個匹配。 """
import re
str1='superman'
str2='hello superman'
print(re.match('super',str1)) #<_sre.SRE_Match object; span=(0, 5), match='super'>
print(re.match('super',str1).span()) #(0, 5)
print(re.match('super',str2)) #None
print(re.search('super',str1)) #<_sre.SRE_Match object; span=(0, 5), match='super'>
print(re.search('super',str1).span()) #(0, 5)
print(re.search('super',str2)) #<_sre.SRE_Match object; span=(6, 11), match='super'>
print(re.search('super',str2).span()) #(6, 11)
75、Python 中讀取 Csv、Excel 文件的方法？
import pandas as pd
#read_csv=pd.read_csv('test1.csv')
#read_excel=pd.read_excel('test2.xlsx')
76、輸入日期， 判斷這一天是這一年的第幾天？
import datetime
def DayOfYear():
year=input('請輸入年份：').strip()
mon=input('請輸入月份：').strip()
day=input('請輸入日：').strip()
data1=datetime.date(year=int(year),month=int(mon),day=int(day))
data2=datetime.date(year=int(year),month=1,day=1)
return (data1-data2).days+1
print(DayOfYear())
"""運行結果： 請輸入年份：2019 請輸入月份：4 請輸入日：18 108 """
77、什麼是 lambda 函數？有什麼好處？
lambda 函數是一個可以接收任意多個參數（包括可選參數）並且返回單個表達式值的匿名函數
好處：
（1）lambda 函數比較輕便，即用即刪除，很適合需要完成一項功能，但是此功能只在此一處使用，連名字都很隨意；
（2）匿名函數，一般用來給filter，map這樣的函數式編程服務；
（3）作為回調函數，傳遞給某些應用，比如消息處理
78、求兩個列表的交集、差集、並集
set()集合中有關於交集、差集、並集的方法 交集intersection() 差集difference 並集union
a=[1,2,3,4]
b=[4,3,5,6]
jj1=[i for i in a if i in b]
jj2=list(set(a).intersection(set(b)))
print('交集：',jj1,jj2) #交集： [3, 4] [3, 4]
cj1=list(set(a).difference(set(b)))
cj2=list(set(b).difference(set(a)))
print('差集：',cj1,cj2) #差集： [1, 2] [5, 6]
bj=list(set(a).union(set(b)))
print('並集',bj) #並集 [1, 2, 3, 4, 5, 6]
**79、什麼是負索引？**
#與正索引不同，負索引是從右邊開始檢索
80、正則匹配不是以4和7結尾的手機號？
import re
tels=["13100001234","18912344321","10086","18800007777"]
#方法1：
for item in tels:
if len(item)!=11 or item.endswith('4') or item.endswith('7'):
print('{}不是想要的手機號'.format(item))
else:
print('{}是想要的手機號'.format(item))
#方法二：
for item in tels:
res=re.match("1\d{9}[0-3,5-6,8-9]",item)
if res:
print('{}是想要的手機號'.format(res.group()))
else:
print('{}不是想要的手機號'.format(item))
81、用兩種方法去空格？
str="hello world ha ha"
res1=str.replace(' ','')
print(res1) #helloworldhaha
res2_l=str.split(' ')
res2=''.join(res2_l)
print(res2) #helloworldhaha
82、統計字符串中某字符出現次數？
str="張三 哈哈 張三 呵呵 張三"
from collections import Counter
l=str.split(' ')
res=Counter(l)
print(res) #Counter({'張三': 3, '哈哈': 1, '呵呵': 1})
print(Counter(l)['張三']) #3
print(str.count('張三')) #3
83、正則表達式匹配 URL
str = 'Its after 12 noon, do you know where your rooftops are?
import re
pattern=re.compile(r'http[s]?://(?:[a-zA-Z]|[0-9]|[[email protected]&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+')
url=re.findall(pattern,str)
print(url)
84、正則匹配以 163.com 結尾的郵箱？
email_list= ["[email protected]","[email protected]", "[email protected]" ]
import re
for item in email_list:
res=re.match('[\w]{4,20}@163\.com$',item)
if res:
print('{}符合規定的郵件地址，匹配的結果是：{}'.format(item,res.group()))
else:
print('{}不符合規定的郵件地址'.format(item))
85、s=“info:xiaoZhang 33 shandong”,用正則切分字符串輸出[‘info’, ‘xiaoZhang’, ‘33’, ‘shandong’]
s="info:xiaoZhang 33 shandong"
import re
res=re.split(r":| ",s) #|表示或，根據:或 切分
print(res) #['info', 'xiaoZhang', '33', 'shandong']
86、兩個有序列表，l1,l2，對這兩個列表進行合並不可使用 extend 【很前面的一題很像…】
l1=[1,4,7]
l2=[2,5,6]
l1.extend(l2)
print(l1) #[1, 4, 7, 2, 5, 6] 【無序】
l1=[1,4,7]
l2=[2,5,6]
def merge_sort(l1,l2):
left_p,right_p=0,0
result=[]
while left_p<len(l1) and right_p<len(l2):
if l1[left_p]<l2[right_p]:
result.append(l1[left_p])
left_p+=1
else:
result.append(l2[right_p])
right_p+=1
result+=l1[left_p:]
result+=l2[right_p:]
return result
print(merge_sort(l1,l2)) #[1, 2, 4, 5, 6, 7]
87、代碼描述列表推導式、字典推導式、生成器？
import random
tds_list=[i for i in range(10)]
print('列表推導式',tds_list,type(tds_list)) #列表推導式 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
tds_dict={
k:random.randint(4,9) for k in ["a","b","c","d"]}
print('字典推導式',tds_dict,type(tds_dict)) #字典推導式 {'d': 9, 'c': 6, 'a': 9, 'b': 7} <class 'dict'>
generate=(i for i in range(10))
print('生成器',generate,type(generate)) #生成器 <generator object <genexpr> at 0x0000021C8A507410> <class 'generator'>
88、根據鍵對字典排序，不可使用zip？
dic = {
"name":"zs","sex":"man" ,"city":"bj"}
#對字典按鍵key進行排序
res1=sorted(dic.items(),key=lambda x:x[0])
print(res1) #[('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
#對字典的值value進行排序
res2=sorted(dic.items(),key=lambda x:x[1])
print(res2) #[('city', 'bj'), ('sex', 'man'), ('name', 'zs')]
89、閱讀一下代碼他們的輸出結果是什麼？
def multi():
return [lambda x : i*x for i in range(4)]
print([m(2) for m in multi()]) #[6, 6, 6, 6]
""" **分析：這是一個閉包,下面是閉包定義： 1、閉包是一個嵌套函數 2、閉包必須返回嵌套函數 3、嵌套函數必須引用一個外部的非全局的局部自由變量** def multi(): func_list=[] for i in range(4): def lam(x): return i*x func_list.append(lam) return func_list 在python裡，相對而言的局部變量綁定的是值，非局部變量綁定的是空間， 而不是值本身。 所以，for循環生成的i，相對於函數lam來說，是全局變量，所以綁定的是i所在的內存地址，但i最後變成了3，lam綁定的是3。 所以導致了,生成的四個函數所得值時相同的. 那實現結果為[0,2,4,6]呢? 按照剛才的思路,我們只需將lam函數中的i變成局部變量,則函數lam綁定的就是值,而不是內存地址： def mul(): func_list=[] for i in range(4): def lam(x,n=i): #這時候因為n是局部變量，所以綁定的是n的值 return x*n func_list.append(lam) return func_list print([m(2) for m in mul()]) #[0, 2, 4, 6] """
90、代碼實現 Python 的線程同步，在屏幕上依次打印10次“ABC”
from threading import Thread,Lock
mutex=Lock()
def print1(lock):
lock.acquire()
print('A')
lock.release()
def print2(lock):
lock.acquire()
print('B')
lock.release()
def print3(lock):
lock.acquire()
print('C')
lock.release()
for i in range(10):
t1=Thread(target=print1,args=(mutex,))
t1.start()
t1.join()
t2 = Thread(target=print2, args=(mutex,))
t2.start()
t2.join()
t3 = Thread(target=print3, args=(mutex,))
t3.start()
t3.join()
91、簡述 read、readline、readlines 的區別？
read 讀取整個文件
readline 讀取下一行，使用生成器方法
readlines 讀取整個文件到一個迭代器以供我們遍歷
92、a=" hehheh "去除首尾空格
a=" hehheh "
print(a.strip()) #hehheh
93、yield方法
yield就是保存當前程序執行狀態。
你用for循環的時候，每次取一個元素的時候就會計算一次。用yield的函數叫generator,和iterator一樣。
它的好處是不用一次計算所有元素，而是用一次算一次，可以節省很多空間，generator 每次計算需要上一次計算結果，所以用yield,否則一旦return，上次計算結果就沒了。
94、字符串 “123” 轉換成 123，不使用內置 API，例如 int()
def change(s):
num=0
for item in s:
n=eval(item) #此時n為int類型
num=num*10+n
return num
res=change('123')
print(res,type(res)) #123 <class 'int'>
95、is 和 == 的區別
**is 比較的是內存地址 == 比較內容和數據類型**
a=[1,2,3]
b=a
print(id(a),id(b)) #1753026079880 1753026079880
print(a is b) #True
print(a == b) #True
import copy
c=copy.deepcopy(a)
print(id(a),id(c)) #1753026079880 1753026098120
print(a is c) #False
print(a==c) #True
96、有沒有一個工具可以幫助查找 python 的 bug 和進行靜態的代碼分析？
PyChecker是一個python代碼的靜態分析工具，它可以幫助查找python代碼的bug，會對代碼的復雜度和格式提出警告Pylint是另外一個工具可以進行codingstandard檢查
97、文件遞歸
import os
def print_directory_contents(s_path):
""" 這個函數接收文件夾的名稱作為輸入參數 返回該文件夾中文件的路徑 以及其包含文件夾中文件的路徑 """
for s_child in os.listdir(s_path):
s_child_path = os.path.join(s_path, s_child)
if os.path.isdir(s_child_path):
print_directory_contents(s_child_path)
else:
print(s_child_path)
print_directory_contents('D:\QQ') #D:\QQ\QQ_Setup.exe
98、Python 如何copy一個文件？
#shutil 模塊有一個 copyfile 函數可以實現文件拷貝 copyfile(source_file, destination_file)**
from shutil import copyfile
copyfile('test.py','test_new.py') #把該目錄下的test.py復制到相同目錄下的test_new.py
99、打亂一個排好序的 list 對象 alist？
import random
alist = [1, 2, 3, 4, 5]
random.shuffle(alist)
print(alist) #[4, 1, 2, 3, 5]
**100、對 s="hello"進行反轉**
s="hello"
print(s[::-1]) #olleh
101、Python 中單下劃線和雙下劃線使用
foo:一種約定,Python內部的名字,用來區別其他用戶自定義的命名,以防沖突，就是例如__init__(),del(),call()這些特殊方法
_foo:一種約定,用來指定變量私有.程序員用來指定私有變量的一種方式.不能用from module import * 導入，其他方面和公有一樣訪問；
__foo:這個有真正的意義:解析器用_classname__foo來代替這個名字,以區別和其他類相同的命名,它無法直接像公有成員一樣隨便訪問,通過對象名._類名__xxx這樣的方式可以訪問.
102、反轉一個整數
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 < 2147483647 else 0
s=Solution()
res=s.reverse(-120)
print(res) #-21
103、代碼描述靜態方法 (staticmethod)，類方法(classmethod) 和實例方法
class Method():
def foo(self,x):
print('running foo {}-{}'.format(self,x))
@classmethod
def class_foo(cls,x):
print('running class_foo {}-{}'.format(cls,x))
@staticmethod
def static_foo(x):
print('running static_foo {}'.format(x))
m=Method()
m.foo('psy') #running foo <__main__.Method object at 0x000002498DF18B00>-psy
m.class_foo('psy') #running class_foo <class '__main__.Method'>-psy
m.static_foo('psy') #running static_foo psy
104、新式類和舊式類的區別？
a. 在python裡凡是繼承了object的類，都是新式類
b. Python3裡只有新式類
c. Python2裡面繼承object的是新式類，沒有寫父類的是經典類
d. 經典類目前在Python裡基本沒有應用
105、請寫出一個在函數執行後輸出日志的裝飾器以及計時器
""" 簡單的裝飾器模板： def outter(func): def wrapper(*args,**kwargs): f=func() return wrapper def timmer(func): #計時器 def wrapper(*args,**kwargs): start=time.time() func(*args,**kwargs) end=time.time() spend=round(end-start,2) print('該程序執行花費時間為{}'.format(spend)) return wrapper """
def do_log(func): #日志裝飾器
def wrapper(*args,**kwargs):
if func.__name__=='debug':
msg="debug {}".format(args[0])
elif func.__name__=='info':
msg="info {}".format(args[0])
else:
msg="{} {}".format(func.__name__,args[0])
return func(msg,**kwargs)
return wrapper
@do_log
def debug(msg):
print(msg)
@do_log
def info(msg):
print(msg)
debug('123') #debug 123
info('456') #info 456
106、請解釋一下協程的優點
子程序切換不是線程切換，而是由程序自身控制
沒有線程切換的開銷，和多線程比，線程數量越多，協程的性能優勢就越明顯
不需要多線程的鎖機制，因為只有一個線程，也不存在同時寫變量沖突，在協程中控制共享資源不加鎖
107、閉包必須滿足那幾點
1.必須有一個內嵌函數
2.內嵌函數必須引用外部函數中的變量
3.外部函數的返回值必須是內嵌函數
108、面試技巧
你的缺點是什麼？
缺點真的是一個非常不好答的問題，但是只要掌握了以下這個原則，這道問題也只是小菜一碟，那就是：避重就輕。
什麼是重？性格方面的問題，人際方面的問題，工作能力方面的原因。如果你說：“我的缺點就是耐心太差”，“我的缺點就是溝通能力有待提高”，那你真的是一個大傻帽。
什麼是輕？舉點例子：我方向感不太好，不善於理財（金融崗位除外）之類的。有人會問了，我說了這些缺點，面試官會不會覺得我很虛偽？那我告訴你，只要你的虛偽不至於讓他想吐（比如“我最大的缺點就是太追求完美”），那虛偽絕對要比傻乎乎的坦誠好。
你有什麼想問我的嗎？
一般問到這個問題，整個面試就要結束了，但是不要掉以輕心，因為最後這個問題決定了面試官對你的最終印象。
所以這個問題背後的潛台詞是什麼呢？那就是：你還想了解一些什麼，幫助你更好地留在這個公司？換言之，就是你有多想留在這個公司？ 如果你說“沒有”，那麼面試官說不定心裡咯噔一下：原來你對這個職位興趣也就這點啊……這個問題其實給了你表忠心的機會，你可以很認真地問她：“那如果我來到了這個公司，那每天的日常大概會是什麼樣的？”或者“這個公司的氛圍是什麼樣的？”（暗示你來這裡工作的強烈欲望）。
109、對列表去重並保持原來的順序
#方法一
l1=[11,2,3,22,2,4,11,3]
res=[]
for item in l1:
if item not in res:
res.append(item)
print(res) #[11, 2, 3, 22, 4]
#方法二：利用sort方法
l1=[11,2,3,22,2,4,11,3]
l2=list(set(l1)) #將列表用set去重，再轉換回列表（沒有按照之前的順序）
l2.sort(key=l1.index) #將上一步得到的列表排序，按照l1中的順序排序
print(l2) #[11, 2, 3, 22, 4]
110、#將列表中的數據按照age排序
l=[{
"name":"psy","age":18},{
"name":"mama","age":54},{
"name":"baba","age":55},{
"name":"xk","age":24},{
"name":"gyp","age":25}]
l.sort(key=lambda x:x["age"])
print(l) #[{'name': 'psy', 'age': 18}, {'name': 'xk', 'age': 24}, {'name': 'gyp', 'age': 25}, {'name': 'mama', 'age': 54}, {'name': 'baba', 'age': 55}]
111、下面的輸出是什麼
def extend_list(v,li=[]):
li.append(v)
return li
list1=extend_list(10)
list2=extend_list(123,[])
list3=extend_list('a')
print(list1) #[10,'a']
print(list2) #[123]
print(list3) #[10,'a']
print(list1 is list3) #True
112、下列代碼的輸出結果是什麼？
l=['a','b','c','d','e']
print(l[10:]) #[]
113、下面代碼執行完的輸出
def func(m):
for k,v in m.items():
m[k+2]=v+2
m={
1:2,3:4}
l=m #淺拷貝
l[9]=10
func(l)
m[7]=8
print("l:",l)
print("m:",m)
""" 結果=====》報錯如下： Traceback (most recent call last): File "E:/000文章的代碼/0000_2018老男孩教育上海python脫產班vip/python面試題/題目3.py", line 11, in <module> func(l) File "E:/000博客文章的代碼/0000_2018老男孩教育上海python脫產班vip/python面試題/題目3.py", line 5, in func for k,v in m.items(): RuntimeError: dictionary changed size during iteration #【原理！】 在迭代一個列表或者字典的時候，不能修改列表或字典的大小！！！！！！ """
114、#4種操作的比較：= 切片 copy deepcopy
import copy
l1=[11,22,[33,44]]
l2=l1
l3=l1[:]
l4=copy.copy(l1)
l5=copy.deepcopy(l1)
l1[2].append(55)
print(l1) #[11, 22, [33, 44, 55]]
print(l2) #[11, 22, [33, 44, 55]]
print(l3) #[11, 22, [33, 44, 55]]
print(l4) #[11, 22, [33, 44, 55]]
print(l5) #[11, 22, [33, 44]]
115、Python中字符串的格式化（%和format），你一般用哪種，為什麼？
答：1、簡單的用%，超過兩個值的一般都用format
2、如果一個字符串格式化的時候變量是一個元祖的話，利用%容易犯錯；並且在python3裡面都推薦使用format進行格式化！
"""
#控制精度
print('{:.2f}'.format(3.141592653)) #3.14
#千位分隔符【金錢顯示】
res='{:,}'.format(1234567890)
print(res) #1,234,567,890
116、生成如下列表：[[0,0,0,0,0],[0,1,2,3,4],[0,2,4,6,8],[0,3,6,9,12]]
#方式一
list1=[]
for i in range(4):
tmp=[]
for j in range(5):
tmp.append(i*j)
list1.append(tmp)
print(list1) #[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [0, 3, 6, 9, 12]]
#方式二
res=[[i*j for j in range(5)] for i in range(4)]
print(res) #[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [0, 3, 6, 9, 12]]
117、裝飾器知識點
1.裝飾器的原理及為什麼要用裝飾器
2. 裝飾器的基本用法
3. 帶參數的裝飾器
4. 被裝飾的函數有返回值怎麼處理
5. 多個裝飾器的執行順序
6. 裝飾類的裝飾器
118、os和sys都是干什麼的
#os是和系統相關的，sys是與系統交互有關的
import os
BASE_DIR=os.path.abspath(__file__) #取當前文件的絕對路徑
base_dir=os.path.dirname(os.path.abspath(__file__)) #取當前文件的父目錄的路徑 #E:\000文章的代碼\27
path=os.path.join(base_dir,"abc") #在當前父目錄下拼接一個abc的文件夾目錄
path1=base_dir+"\\abc" #不建議使用這種硬編碼的形式拼接路徑
import sys
sys.path.append() #向當前運行的環境變量中添加一個指定的路徑
sys.argv #返回一個列表，用戶在cmd中輸入的參數
119、面向對象的三大特性：
封裝、繼承、多態
120、談談你對面向對象的理解？
面向對象的理解
在我理解,面向對象是向現實世界模型的自然延伸，這是一種“萬物皆對象”的編程思想。在現實生活中的任何物體都可以歸為一類事物，而每一個個體都是一類事物的實例。
面向對象有三大特性，封裝、繼承和多態。
封裝就是將一類事物的屬性和行為抽象成一個類，使其屬性私有化，行為公開化，提高了數據的隱秘性的同時，使代碼模塊化。這樣做使得代碼的復用性更高。
繼承則是進一步將一類事物共有的屬性和行為抽象成一個父類，而每一個子類是一個特殊的父類–有父類的行為和屬性，也有自己特有的行為和屬性。這樣做擴展了已存在的代碼塊，進一步提高了代碼的復用性。
如果說封裝和繼承是為了使代碼重用，那麼多態則是為了實現接口重用。多態的一大作用就是為了解耦–為了解除父子類繼承的耦合度。如果說繼承中父子類的關系式IS-A的關系，那麼接口和實現類之之間的關系式HAS-A。簡單來說，多態就是允許父類引用(或接口)指向子類(或實現類)對象。很多的設計模式都是基於面向對象的多態性設計的。
總結一下，如果說封裝和繼承是面向對象的基礎，那麼多態則是面向對象最精髓的理論。掌握多態必先了解接口，只有充分理解接口才能更好的應用多態。
121、python面向對象中的繼承有什麼特點？
繼承的優點：
1、建造系統中的類，避免重復操作。
2、新類經常是基於已經存在的類，這樣就可以提升代碼的復用程度。
繼承的特點：
1、在繼承中基類的構造（init()方法）不會被自動調用，它需要在其派生類的構造中親自專門調用。有別於C#
2、在調用基類的方法時，需要加上基類的類名前綴，且需要帶上self參數變量。區別於在類中調用普通函數時並不需要帶上self參數
3、Python總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查找。（先在本類中查找調用的方法，找不到才去基類中找）。
122、面向對象深度優先和廣度優先是什麼？
"深度優先遍歷"考察遞歸, 將子節點為空作為終止遞歸的條件
"廣度優先遍歷"考察隊列的結構, 消除父節點(出隊列,順便打印), 添加子節點(進隊列),當隊列內元素個數為零, 完成遍歷
python3中不區分深度優先和廣度優先 python2中才區分
123、面向對象中super的作用？
super() 函數是用於調用父類(超類)的一個方法。
super 是用來解決多重繼承問題的，直接用類名調用父類方法在使用單繼承的時候沒問題，但是如果使用多繼承，會涉及到查找順序（MRO）、重復調用（鑽石繼承）等種種問題。
MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表。
"""
class Person():
def __init__(self,name,age):
self.name=name
self.age=age
class Male(Person):
def __init__(self,name,age,location):
super().__init__(name,age)
self.location=location
man=Male('psy',18,'nuist')
124、編寫Python腳本，分析xx.log文件，按域名統計訪問次數
import re
#1讀取文本
with open('xx.log','r',encoding='utf-8')as f:
data=f.read()
#2取域名
res=re.findall("https://(.*?)/",data) #返回列表
#3統計
res_dic={
}
for item in res:
if item not in res_dic:
res_dic[item]=1
else:
res_dic[item] +=1
#4排序
res2=sorted(res_dic,key=lambda x:res_dic[x],reverse=True)
for key in res2:
print(res_dic[key],key)
125、數據庫【設計表結構（外鍵約束怎麼建？！）】
設計 圖書管理系統 表結構：
- 書（pk 書名）
- 作者（pk 姓名）
- 出版社（pk 出版社名稱 地址）
分析：
一本書只能由一家出版社出版 【多對一，多個出版社對應一本書】》設置外鍵，外鍵放置在“一”的表裡面，大家都可以用
一本書可以有多個作者，一個作者也可以寫多本書 【多對多】》通過第三張表，分別與書和作者建立聯系
""" """MySQL中建表的語句
CREATE TABLE book(
id INT PRIMARY KEY AUTO_INCREMENT,title VARCHAR(64),publisher_id INT,
FOREIGN KEY (publisher_id) REFERENCES publisher(id));
CREATE TABLE author(
id INT PRIMARY KEY AUTO_INCREMENT,name VARCHAR(32));
CREATE TABLE book2author(
id INT PRIMARY KEY AUTO_INCREMENT,book_id INT,author_id INT,
FOREIGN KEY (book_id) REFERENCES book(id),
FOREIGN KEY (author_id) REFERENCES author(id));
CREATE TABLE publisher(
id INT PRIMARY KEY AUTO_INCREMENT,name VARCHAR(64),address VARCHAR(255));
"""
阿裡模擬筆試題：
題目：
國內最大的web站點統計服務商CNZZ,監測某客戶站點正在進行首頁廣告位更新，該首頁有n個廣告位，有3種廣告（A,B,C），A廣告占用1個廣告位，B廣告占用2個廣告位；C廣告占用3個；廣告連在一起，可任意組合，為了保證首頁的美觀，A廣告的左右相鄰不能出現A廣告，B和C則無限制。
問該站點首頁有多少種廣告位布局方案。
輸入：n個廣告位
輸出：z種布局方案
編譯器版本: Python 2.7.6
請使用標准輸出(sys.stdout)；已禁用圖形、文件、網絡、系統相關的操作，如Process , httplib , os；縮進可以使用tab、4個空格或2個空格，但是只能任選其中一種，不能多種混用；如果使用sys.stdin.readline，因為默認會帶換行符，所以要strip(’ ')進行截取；建議使用raw_input()
時間限制: 3S (C/C++以外的語言為: 5 S) 內存限制: 128M (C/C++以外的語言為: 640 M)
輸入:
輸入：n個廣告位，n為大於0的正整數
輸出:
輸出：z種布局方案，z為大於0的正整數
輸入范例:
輸入范例：3
輸出范例:
輸出范例：3
"""
#代碼
def cut(n,isA):
if n<=0:
return 0 #當廣告位為0時，返回0
if n==1:
return 1 #廣告位為1時，返回1 A
if n==2:
return 1 #廣告位為2時，返回2 B
if n==3:
if isA:
return 2
else:
return 3 #廣告位為3時，返回2 AB BA C
if isA:
return cut(n-2,False)+cut(n-3,False)
else:
return cut(n-1,True)+cut(n-2,False)+cut(n-3,False)
print(cut(6,False))
結束語
發現非常好用的一個刷題網站!大家一起努力！加油！！！
題目難度可以自行選擇
在線編程出答案，（也可自行查看答案）非常方便
程序員刷題神器網站點擊鏈接注冊即可刷題
祝大家早日找到滿意的工作
