檔案處理相關
1，編碼問題
（1）請問python2與python3中的預設編碼是什麼？
python 2.x預設的字元編碼是ASCII，預設的檔案編碼也是ASCII
python 3.x預設的字元編碼是unicode，預設的檔案編碼也是utf-8
（2）為什麼會出現中文亂碼，你能舉例說明亂碼的情況有哪幾種？
無論以什麼編碼在記憶體裡顯示字元，存到硬碟上都是2進制，是以編碼不對，程式就會出錯了。
（ascii編碼（美國），GBK編碼（中國），shift_JIS編碼（日本），，，，）
要注意的是，存到硬碟上時是以何種編碼存的，再從硬碟上讀出來時，就必須以何種編碼讀，要不然就亂了。。
常見的編碼錯誤的原因有:
python解釋器的預設編碼
Terminal使用的編碼
python源檔案檔案編碼
作業系統的語言設定,掌握了編碼之前的關系後,挨個排錯就ok
（3）如何進行編碼轉換？
如果想要中國的軟體可以正常的在美國人的電腦上實作，有下面兩種方法：
1，讓美國人的電腦都裝上gbk編碼
2，讓你的軟體編碼以utf-8編碼
第一種方法不可現實，第二種方法比較簡單，但是也隻能針對新開發的軟體，
如果你之前開發的軟體就是以gbk的編碼寫的，上百萬行代碼已經寫出去了，
重新編碼成utf-8格式也會費很大力氣。
是以，針對已經用gbk開發的軟體項目如何讓項目在美國人的電腦上正常顯示
還記得unicode的一個功能就是其包含了跟全球所有國家編碼的映射關系，
是以無論你以什麼編碼存儲的資料，隻要我們的軟體把資料從硬碟上讀到記憶體，
轉成unicode來顯示即可，由于所有的系統，程式設計語言都預設支援unicode，
所有我們的gbk軟體放在美國電腦上，加載到記憶體裡面，變成了unicode，中文就可正常展示
（4）#_*_coding:utf-8_*_ 的作用是什麼？
#_*_coding:utf-8 _*_ 的作用是.py檔案是什麼編碼，就需要告訴python用什麼編碼去讀取這個.py檔案
（5）解釋python2.x bytes與python3.x bytes的差別
簡單點說：
Python 2 将 strings 處理為原生的 bytes 類型，而不是 unicode，
Python 3 所有的 strings 均是 unicode 類型。
在python2.x中，寫字元串，比如
>>>s = ”學習“
>>>print s
學習
>>>s
'\xd1\xa7\xcf\xb0'
雖然說列印的是學習，但是直接調用的變量s，确實一個個16進制表示的二進制位元組，
我們稱這個為byte類型，即位元組類型，它把8個二進制一組稱為一個byte，用16進制表示
是以說python2.x的字元串其實更應該稱為字元串，通過存儲的方式就能看出來，
但是在python2.x中還有一個bytes類型，兩個是否相同呢，回答是肯定的，在python2.x中，bytes==str
python3.x中
把字元串變成了unicode，檔案預設編碼程式設計了utf-8，這意味着，隻要用python3.x，
無論我們的程式以那種語言開發，都可以在全球各國電腦上正常顯示。
python3.x除了把字元串的編碼改成了unicode，還把str和bytes做了明确區分，
str就是unicode格式的字元串bytes就是單純的二進制
（補充一個問題，為什麼在python3.x中，把unicode編碼後，字元串就變成了bytes格式
，為什麼不直接列印成gbk的字元，我覺得就是想通過這樣的方式明确的告訴你，想在python3.x中看字元，
必須是unicode，其他編碼一律是bytes格式）
2，檔案處理
（1） r和rb的差別是什麼？
檔案操作時候，以“r"或者”rb"模式打開，隻能讀取，無法寫入；
硬碟上儲存的檔案都是某種編碼的0101010，打開時需要注意：
rb，直接讀取檔案儲存時原生的0101010，在Python中用位元組類型表示
r和encoding，讀取硬碟的0101010，并按照encoding指定的編碼格式進行斷句，
再将“斷句”後的每一段0101010轉換成unicode的 010101010101，在Python中用字元串類型表示
（2）解釋一下下面三個參數的作用分别是什麼？
open(f_name,'r',encoding="utf-8")
f_name 是檔案的路徑，mode是打開的方式，encoding是編碼格式
encoding #檔案編碼
mode #打開模式
name #檔案名
newlines #檔案中用到的換行模式，是一個tuple
softspace #boolean型，一般為0，據說用于print
（3） w和wb的差別是什麼？
檔案操作時候，以 “w”或“wb” 模式打開，則隻能寫，并且在打開的同時會先将内容清空。
寫入到硬碟上時，必須是某種編碼的0101010，打開時需要注意：
wb，寫入時需要直接傳入以某種編碼的0100101，即：位元組類型
w 和 encoding，寫入時需要傳入unicode字元串，内部會根據encoding制定的編碼
将unicode字元串轉換為該編碼的 010101010
（4）a和ab的差別是什麼？
檔案操作時，以 “a”或“ab” 模式打開，則隻能追加，即：在原來内容的尾部追加内容
寫入到硬碟上時，必須是某種編碼的0101010，打開時需要注意：
ab，寫入時需要直接傳入以某種編碼的0100101，即：位元組類型
a 和 encoding，寫入時需要傳入unicode字元串，内部會根據encoding制定的編碼
将unicode字元串轉換為該編碼的 010101010
（5）readline和readlines的差別
readline() #讀取一行
readlines() #讀取所有内容，并傳回清單（一行為清單的一個元素值）
（6）全局替換程式：
寫一個腳本，允許使用者按以下方式執行時，即可以對指定檔案内容進行全局替換
`python your_script.py old_str new_str filename`
替換完畢後列印替換了多少處内容
（7）模拟登陸
- 使用者輸入帳号密碼進行登陸
- 使用者資訊儲存在檔案内
- 使用者密碼輸入錯誤三次後鎖定使用者，下次再登入，檢測到是這個使用者也登入不了
函數基礎
1，寫函數，計算傳入數字參數的和。（動态傳參）
#寫函數，計算傳入數字參數的和。（動态傳參）
x = int(input("輸入要計算的值x: ")) #定義動态輸入的x值
y = int(input("輸入要計算的值y: ")) #定義動态輸入的y值
def calc(x,y):
result = x+y
return ("結果是：",result)
a = calc(x,y)
print(a)
# 輸入要計算的值x: 123
# 輸入要計算的值y: 456
# ('結果是：', 579)
2，寫函數，使用者傳入修改的檔案名，與要修改的内容，執行函數，完成整個檔案的批量修改操作
# 2、寫函數，使用者傳入修改的檔案名，與要修改的内容，執行函數，完成整個檔案的批量修改操作
import os
file_name = "print_tofile.txt"
file_new_name = '%s.new' %file_name
old_str = '最近學習不太好'
new_str = '最近學習真不好'
f_old = open(file_name,'r',encoding='utf-8')
f_new = open(file_new_name,'w',encoding='utf-8')
for line in f_old:
if old_str in line:
line = line.replace(old_str,new_str)
f_new.write(line)
print(line)
f_old.close()
f_new.close()
os.replace(file_new_name,file_name)
import os
def update_func(a: object, old_str: object, new_str: object) -> object: #定義三個接受值的形參，a是要修改的檔案名，b是要修改的内容，c是修改後的内容
#打開檔案，檔案名為接受的形參a
file_old = 'a.txt'
file_new = 'aa.txt'
f_old = open(file_old,'r',encoding='utf-8')
#打開修改後寫入的檔案
f_new = open(file_new,'w',encoding='utf-8')
# old_str = '你是我唯一的愛'
# new_str = 'you are my everything'
#循環每一行的檔案的資料
for line in f_old:
new_content = line.replace(old_str,new_str) #将要修改的内容字元串用replace替換
f_new.write(new_content) #将替換後的内容寫入修改後寫入的檔案中
f_new.close()
f_old.close()
os.replace(file_new,file_old)
update_func('a.txt','你是我唯一的愛','you are my everything')
修改前的檔案内容：
你是我唯一的愛，you are my everything
修改後的檔案内容：
you are my everything，you are my everything
3，寫函數，檢查使用者傳入的對象（字元串、清單、元組）的每一個元素是否含有空内容。
def check_str(a): #a為傳過來的參數
calc = False #空格統計預設False沒有
for line in a:
if line.isspace():
calc = True
return calc
a = '123 132 456 7489 456'
res = check_str(a)
print(res)
def func(strr,listt,tuplee):
if strr.isspace():
print("字元串有空内容")
else:
print("字元串裡面沒有空内容")
if len(listt) ==0:
print("清單有空内容")
else:
print("清單裡面沒有空内容")
if len(tuplee) == 0:
print("元祖有空内容")
else:
print("元組裡面沒有空内容")
res = func('123456',[],())
# 字元串裡面沒有空内容
# 清單有空内容
# 元祖有空内容
4，寫函數，檢查傳入字典的每一個value的長度,如果大于2，那麼僅保留前兩個長度的内容，并将新内容傳回給調用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value隻能是字元串或清單
# 4，寫函數，檢查傳入字典的每一個value的長度,如果大于2，
# 那麼僅保留前兩個長度的内容，并将新内容傳回給調用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def check_func(a): #a為傳過來的參數
li = []
for item in a.values():
length = len(item)
if length >2:
li.append(item[0:2])
else:
continue
return li
a = check_func(dic)
print(a)
# ['v1', [11, 22]]
5，解釋閉包的概念
關于閉包，即函數定義和函數表達式位于另一個函數的函數體内（嵌套函數）。
而且這些内部函數可以通路他們所在的外部函數中聲明的所有局部變量，參數。
當其中一個這樣的内部函數在包含他們的外部函數之外被調用時候，就形成了閉包。
也就是說，内部函數會在外部函數傳回後被執行。而當這個内部函數執行的時候，
它仍然必需通路其外部函數的局部變量，參數以及其他内部函數，這些局部變量，
參數聲明（最初時）的值是外部函數傳回時候的值，但也會受到内部函數的影響。
閉包的意義：傳回的函數對象，不僅僅是一個函數對象，在該函數外還包裹了一層作用域，
這使得，該函數無論在何處調用，優先使用自己外層包裹的作用域
簡單的說，閉包就是一個内部函數+外部環境
6，寫函數，計算傳入字元串中的【數字】、【字母】、【空格】和【其他】的個數
# 6，寫函數，計算傳入字元串中的【數字】、【字母】、【空格】和【其他】的個數
def func(strr):
digit_number = 0
space_number = 0
alpha_number = 0
else_number = 0
for i in strr:
if i.isdigit():
digit_number +=1
elif i.isspace():
space_number +=1
elif i.isalpha():
alpha_number +=1
else:
else_number +=1
return ("數字，空格，字母，其他内容分别有：",(digit_number,space_number,alpha_number,else_number))
res = func('sda!@#$%^&1234567dfghj da da ')
print(res)
# ('數字，空格，字母，其他内容分别有：', (7, 3, 12, 7))
函數進階
1，寫函數，傳回一個撲克牌清單，裡面有52項，每一項是一個元組
例如：[(‘紅心’，2),(‘草花’，2), …(‘黑桃A’)]
def cards():
num = []
for i in range(2,11):
num.append(i)
num.extend(['J','Q','K','A'])
type = ['紅心','草花','方塊','黑桃']
result = []
for i in num:
for j in type:
result.append((j,i))
return result
print(cards())
# [('紅心', 2), ('草花', 2), ('方塊', 2), ('黑桃', 2),
# ('紅心', 3), ('草花', 3), ('方塊', 3), ('黑桃', 3),
# ('紅心', 4), ('草花', 4), ('方塊', 4), ('黑桃', 4),
# ('紅心', 5), ('草花', 5), ('方塊', 5), ('黑桃', 5),
# ('紅心', 6), ('草花', 6), ('方塊', 6), ('黑桃', 6),
# ('紅心', 7), ('草花', 7), ('方塊', 7), ('黑桃', 7),
# ('紅心', 8), ('草花', 8), ('方塊', 8), ('黑桃', 8),
# ('紅心', 9), ('草花', 9), ('方塊', 9), ('黑桃', 9),
# ('紅心', 10), ('草花', 10), ('方塊', 10), ('黑桃', 10),
# ('紅心', 'J'), ('草花', 'J'), ('方塊', 'J'), ('黑桃', 'J'),
# ('紅心', 'Q'), ('草花', 'Q'), ('方塊', 'Q'), ('黑桃', 'Q'),
# ('紅心', 'K'), ('草花', 'K'), ('方塊', 'K'), ('黑桃', 'K'),
# ('紅心', 'A'), ('草花', 'A'), ('方塊', 'A'), ('黑桃', 'A')]
2，寫函數，傳入n個數，傳回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4)
傳回:{‘max’:8,’min’:2}
# 2，寫函數，傳入n個數，傳回字典{‘max’:最大值,’min’:最小值}
# 例如:min_max(2,5,7,8,4)
# 傳回:{‘max’:8,’min’:2}
def max_min(*args):
the_max = args[0]
the_min = args[0]
for i in args:
if i>the_max:
the_max = i
else:
the_min = i
return {'max':the_max,'min':the_min}
res = max_min(2,4,6,48,-16,486)
print(res)
# {'max': 486, 'min': -16}
3，寫函數，專門計算圖形的面積
- 其中嵌套函數，計算圓的面積，正方形的面積和長方形的面積
- 調用函數area(‘圓形’,圓半徑) 傳回圓的面積
- 調用函數area(‘正方形’,邊長) 傳回正方形的面積
- 調用函數area(‘長方形’,長，寬) 傳回長方形的面積
def area():
def 計算長方形面積():
pass
def 計算正方形面積():
pass
def 計算圓形面積():
pass
import math
print('''
請按照如下格式輸出：
調用函數area(‘圓形’,圓半徑) 傳回圓的面積
調用函數area(‘正方形’,邊長) 傳回正方形的面積
調用函數area(‘長方形’,長，寬) 傳回長方形的面積''')
def area(name,*args):
def areas_rectangle(x,y):
return ("長方形的面積為：",x*y)
def area_square(x):
return ("正方形的面積為：",x**2)
def area_round(r):
return ("圓形的面積為：",math.pi*r*r)
if name =='圓形':
return area_round(*args)
elif name =='正方形':
return area_square(*args)
elif name =='長方形':
return areas_rectangle(*args)
print(area('長方形', 3, 4))
print(area('圓形', 3))
print(area('正方形', 3))
# 請按照如下格式輸出：
# 調用函數area(‘圓形’,圓半徑) 傳回圓的面積
# 調用函數area(‘正方形’,邊長) 傳回正方形的面積
# 調用函數area(‘長方形’,長，寬) 傳回長方形的面積
# ('長方形的面積為：', 12)
# ('圓形的面積為：', 28.274333882308138)
# ('正方形的面積為：', 9)
4，寫函數，傳入一個參數n，傳回n的階乘
例如:cal(7)
計算7*6*5*4*3*2*1
# 4、寫函數，傳入一個參數n，傳回n的階乘。
# 例如: cal(7） 計算7 * 6 * 5 * 4 * 3 * 2 * 1
def cal(n):
res= 1
for i in range(n,0,-1):
# print(i)
res = res*i
print(res)
return res
print(cal(7))
5，編寫裝飾器，為多個函數加上認證的功能（使用者的賬号密碼來源于檔案），要求登入成功一次，後續的函數都無需再輸入使用者名和密碼
# 5，編寫裝飾器，為多個函數加上認證的功能（使用者的賬号密碼來源于檔案），
# 要求登入成功一次，後續的函數都無需再輸入使用者名和密碼
def login(func):
def wrapper(*args,**kwargs):
username = input("account:").strip()
password = input("password:").strip()
with open('userinfo.txt','r',encoding='utf-8') as f:
userinfo = f.read().strip(',')
userinfo = eval(userinfo)
print(userinfo)
if username in userinfo['name'] and password in userinfo['password']:
print("success")
else:
print("pass")
return wrapper
@login
def name():
print("hello")
name()
生成器和疊代器
1，生成器和疊代器的差別？
對于list、string、tuple、dict等這些容器對象,使用for循環周遊是很友善的。
在背景for語句對容器對象調用iter()函數。iter()是python内置函數。
iter()函數會傳回一個定義了 next()方法的疊代器對象，它在容器中逐個通路容器内的
元素。next()也是python内置函數。在沒有後續元素時，next()會抛出
一個StopIteration異常，通知for語句循環結束。
疊代器是用來幫助我們記錄每次疊代通路到的位置，當我們對疊代器使用next()函數的
時候，疊代器會向我們傳回它所記錄位置的下一個位置的資料。實際上，在使用next()函數
的時候，調用的就是疊代器對象的_next_方法（Python3中是對象的_next_方法，
Python2中是對象的next()方法）。是以，我們要想構造一個疊代器，
就要實作它的_next_方法。但這還不夠，python要求疊代器本身也是可疊代的，
是以我們還要為疊代器實作_iter_方法，而_iter_方法要傳回一個疊代器，
疊代器自身正是一個疊代器，是以疊代器的_iter_方法傳回自身self即可。
2，生成器有幾種方式擷取value？
兩種方式擷取：
for 循環
next 擷取
3，通過生成器寫一個日志調用方法， 支援以下功能
- 根據指令向螢幕輸出日志
- 根據指令向檔案輸出日志
- 根據指令同時向檔案&螢幕輸出日志
- 以上日志格式如下
2017-10-19 22:07:38 [1] test log db backup 3
2017-10-19 22:07:40 [2] user alex login success
#注意：其中[1],[2]是指自日志方法第幾次調用，每調用一次輸出一條日志
代碼結構如下：
def logger(filename,channel='file'):
"""
日志方法
:param filename: log filename
:param channel: 輸出的目的地，螢幕(terminal)，檔案(file)，螢幕+檔案(both)
:return:
"""
...your code...
#調用
log_obj = logger(filename="web.log",channel='both')
log_obj.__next__()
log_obj.send('user alex login success')
内置函數
1，用map來處理字元串清單,把清單中所有人都變成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao','nezha']
map()函數
map()是 Python 内置的高階函數，它接收一個函數 f 和一個 list，并通過把
函數 f 依次作用在 list 的每個元素上，得到一個新的 list 并傳回。
注意：map()函數在不改變原有的list，而是傳回一個新的list
# 1，用map來處理字元串清單,把清單中所有人都變成sb,比方alex_sb
# name=['alex','wupeiqi','yuanhao','nezha']
name=['alex','wupeiqi','yuanhao','nezha']
def sb(x):
return x+'_sb'
res = map(sb,name)
print(list(res))
# 結果：
['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'nezha_sb']
2，用filter函數處理數字清單，将清單中所有的偶數篩選出來
num = [1,3,5,6,7,8]
# 2，用filter函數處理數字清單，将清單中所有的偶數篩選出來
# num = [1,3,5,6,7,8]
num = [1,3,5,6,7,8]
def func(x):
if x%2 == 0:
return True
ret = filter(func,num)
print(list(ret))
# 結果：
[6, 8]
3，如下，每個小字典的name對應股票名字，shares對應多少股，price對應股票的價格
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
計算購買每支股票的總價
用filter過濾出，單價大于100的股票有哪些
# 3，如下，每個小字典的name對應股票名字，shares對應多少股，price對應股票的價格
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
#
# 計算購買每支股票的總價
# 用filter過濾出，單價大于100的股票有哪些
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
m = map(lambda y:y['shares']*y['price'],portfolio)
print(list(m))
# [9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
a = []
for index,i in enumerate(portfolio):
res= i['shares'] * i['price']
a.append(res)
print(a)
# [9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
# 3、用filter過濾出，單價大于100的股票有哪些
f = filter(lambda d:d['price']>=100,portfolio)
print(list(f))
# [{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]
其他練習
1，有清單 li = ['alex', 'egon', 'smith', 'pizza', 'alen'], 請将以字母“a”開頭的元素的首字母改為大寫字母；
# 1，有清單 li = ['alex', 'egon', 'smith', 'pizza', 'alen'],
# 請将以字母“a”開頭的元素的首字母改為大寫字母；
li = ['alex', 'egon', 'smith', 'pizza', 'alen']
li_new = []
for i in li:
if i.startswith('a'):
li_new.append(i.capitalize())
else:
li_new.append(i)
print(li_new)
for i in range(len(li)):
if li[i][0] == 'a':
li[i] = li[i].capitalize()
else:
continue
print(li)
2，有如下程式, 請給出兩次調用
show_num
函數的執行結果，并說明為什麼：
num = 20
def show_num(x=num):
print(x)
show_num()
num = 30
show_num()
如果函數收到的是一個不可變對象（比如數字、字元或者元組）的引用，就不能直接修改原始對象，相當于通過“傳值’來傳遞對象，此時如果想改變這些變量的值，可以将這些變量申明為全局變量。
3，有清單 li = ['alex', 'egon', 'smith', 'pizza', 'alen'], 請以清單中每個元素的第二個字母倒序排序；
4，有名為
poetry.txt
的檔案，其内容如下，請删除第三行；
昔人已乘黃鶴去，此地空餘黃鶴樓。
黃鶴一去不複返，白雲千載空悠悠。
晴川曆曆漢陽樹，芳草萋萋鹦鹉洲。
日暮鄉關何處是？煙波江上使人愁。
# 4，有名為poetry.txt的檔案，其内容如下，請删除第三行；
# 方法一：
# import os
# p = 'poetry.txt'
# file = open(p,'r',encoding='utf-8')
# print(file)
# pnew = '%s.new'%p
# filenew = open(pnew,'w',encoding='utf-8')
# str1 = '晴川曆曆漢陽樹，芳草萋萋鹦鹉洲。'
# for i in file:
# if str1 in i:
# i = ''
# filenew.write(i)
# else:
# filenew.write(i)
# file.close()
# filenew.close()
# os.replace(pnew,p)
# 方法二：逐行讀取檔案
import os
f1=open('poetry.txt', 'r',encoding='utf-8')
str='晴川曆曆漢陽樹，芳草萋萋鹦鹉洲。'
with open('poetry1.txt', 'w', encoding='utf-8') as f2:
ff1='poetry.txt'
ff2='poetry1.txt'
for line in f1:
if str in line:
line=''
f2.write(line)
else:
f2.write(line)
f1.close()
f2.close()
os.replace(ff2,ff1)
5，有名為
username.txt
的檔案，其内容格式如下，寫一個程式，判斷該檔案中是否存在"alex", 如果沒有，則将字元串"alex"添加到該檔案末尾，否則提示使用者該使用者已存在；
pizza
alex
egon
# 5，有名為username.txt的檔案，其内容格式如下，寫一個程式，
# 判斷該檔案中是否存在"alex", 如果沒有，
# 則将字元串"alex"添加到該檔案末尾，否則提示使用者該使用者已存在；
with open('username.txt','r+',encoding='utf-8') as f:
str1 = 'alexx'
i = f.read()
print(i)
if str1 in i:
print("the user already exist in")
else:
f.write('\nalexx')
6，有名為user_info.txt的檔案，其内容格式如下，寫一個程式，删除id為100003的行；
pizza,100001
alex, 100002
egon, 100003
# 6，有名為user_info.txt的檔案，其内容格式如下，
# 寫一個程式，删除id為100003的行；
import os
a = 'user_info.txt'
b = 'user_info1.txt'
with open(a,'r',encoding='utf-8') as f:
with open(b, 'w', encoding='utf-8') as f2:
for i in f:
if '100003' in i:
pass
else:
f2.write(i)
os.replace(b,a)
7，有名為user_info.txt的檔案，其内容格式如下，寫一個程式，将id為100002的使用者名修改為
alex li
；
pizza,100001
alex, 100002
egon, 100003
# 7，有名為user_info.txt的檔案，其内容格式如下，寫一個程式，
# 将id為100002的使用者名修改為alex li；
file = 'user_info.txt'
old_str = '100002'
new_str = 'alex, 100002'
file_data=''
with open(file,'r',encoding='utf-8') as f1:
for line in f1:
if old_str in line:
line =new_str
file_data +=line
with open(file,'w',encoding='utf-8') as f1:
f1.write(file_data)
8，什麼是裝飾器？，寫一個計算每個程式執行時間的裝飾器；
裝飾器模式（Decorator Pattern）允許向一個現有的對象添加新的功能，
同時又不改變其結構。這種類型的設計模式屬于結構型模式，它是作為現有的類的一個包裝。
這種模式建立了一個裝飾類，用來包裝原有的類，并在保持類方法簽名完整性的前提下，
提供了額外的功能。
8，寫一個計算每個程式執行時間的裝飾器；
import time
def timer(func):
def wrapper(*args,**kwargs):
start_time = time.time()
func(*args)
stop_time = time.time()
d_time = stop_time-start_time
print(d_time)
return wrapper
@timer
def sayhi():
print("hello word")
sayhi()
9，lambda是什麼？請說說你曾在什麼場景下使用lambda？
lambda函數就是可以接受任意多個參數(包括可選參數)并且傳回單個表達式值得函數
好處：
1.lambda函數比較輕便，即用即扔，适合完成隻在一處使用的簡單功能
2.匿名函數，一般用來給filter，map這樣的函數式程式設計服務
3.作為回調函數，傳遞給某些應用，比如消息處理
10，請分别介紹檔案操作中不同檔案之間打開方式的差別
| 模式 | 含義 |
| r | 文本隻讀模式 |
| rb | 二進制模式 這種方法是用來傳輸或存儲，不給人看的 |
| r+ | 讀寫模式，隻要有r，那麼檔案必須存在 |
| rb+ | 二進制讀寫模式 |
| w | 隻寫模式，不能讀，用w模式打開一個已經存在的檔案，如果有内容會清空，重新寫 |
| wb | 以二進制方式打開，隻能寫檔案，如果不存在，則建立 |
| w+ | 讀寫模式，先讀後寫，隻要有w，會清空原來的檔案内容 |
| wb+ | 二進制寫讀模式 |
| a | 追加模式，也能寫，在檔案的末尾添加内容 |
| ab | 二進制追加模式 |
| a+ | 追加模式，如果檔案不存在，則建立檔案，如果存在，則在末尾追加 |
| ab+ | 追讀寫二進制模式，從檔案頂部讀取檔案，從檔案底部添加内容，不存在則建立 |
11，簡述普通參數，指定參數，預設參數，動态參數的差別
普通參數：以正确的順序傳入函數，調用時數量必須和聲明的一樣
指定參數：參數和函數調用關系密切，函數調用使用關鍵字參數來确定傳入的參數值，參數
允許函數調用時參數的順序和聲明時不一緻
預設參數：函數進行調用時，如果沒有新的參數傳入則預設的情況下，就調用預設參數
動态參數：個别函數能處理比當初聲明時更多的參數，這些參數就動态參數
12，寫函數，計算傳入的字元串中數字，字母，空格，以及其他的個數
def func(s):
al_num =0
space_num = 0
digit_num = 0
others_num = 0
for i in s:
if i.isdigit():
digit_num +=1
elif i.isspace():
space_num +=1
elif i.isalpha():
al_num +=1
else:
others_num +=1
return (al_num,space_num,digit_num,others_num)
result = func("asdsadjlk1212jdjakdk2 d d d d323233223下")
print(result)
result = func(" d d d d323233223下")
print(result)
13，寫函數，判斷使用者傳入的對象（字元串，清單，元組）長度是否大于5
def func(s,lis,tup):
zifuchuan = len(s)
liebiao = len(lis)
yuanzu = len(tup)
if zifuchuan>5:
print("大于5")
else:
print("小于5")
if liebiao >5:
print("大于5")
else:
print("小于5")
if yuanzu >5:
print("大于5")
else:
print("小于5")
return (zifuchuan,liebiao,yuanzu)
func('dadadad','[1,2,3]',{1,2,3})
14，寫函數監測使用者傳入的對象（字元，清單，元組）的每一個元素是否有空内容
def func(n):
for i in a:
i = str(i)
if '' in i:
return ('空格： ',i)
else:
return ('沒空格')
a = ('dasdsd dasd','ds')
res = func(a)
print(res)
15，寫函數，檢查傳入清單的長度，如果大于2，那麼僅僅保留前兩個長度的内容，并将新内容傳回給調用者
def func(li):
len_li = len(li)
if len_li>2:
print("清單長度大于2")
new_li = li[0:2]
return (new_li)
res = func([12,12,45,78,32,12])
print(res)
16，寫函數，檢查擷取傳入清單或元組的所有奇數位索引對應的元素，并将其作為新清單傳回給調用者
def func(li,tup):
li = []
tup = []
for i in range(len(li)):
if i %2 ==1:
li.append(li[i])
print(li)
for j in range(len(tup)):
if j %2 ==1:
tup.append(tup[j])
print(tup)
return (li,tup)
res = func([1,2,3,4,5,6,7,8,9],(1,2,3,11,21,4,5,6,7))
print(res)
17，寫函數，檢查傳入字典的每一個value的長度，如果大于2，那麼僅僅儲存前兩個長度的内容，并将新内容傳回給調用者
18，寫函數，計算傳入字元串中的【數字】、【字母】、【空格】和【其他】的個數
# 18，寫函數，計算傳入字元串中的【數字】、【字母】、【空格】和【其他】的個數
def func(strr):
digit_number = 0
space_number = 0
alpha_number = 0
else_number = 0
for i in strr:
if i.isdigit():
digit_number +=1
elif i.isspace():
space_number +=1
elif i.isalpha():
alpha_number +=1
else:
else_number +=1
return ("數字，空格，字母，其他内容分别有：",(digit_number,space_number,alpha_number,else_number))
res = func('sda!@#$%^&1234567dfghj da da ')
print(res)
# ('數字，空格，字母，其他内容分别有：', (7, 3, 12, 7))
不經一番徹骨寒 怎得梅花撲鼻香
![英國準許谷歌淘汰Cookie計劃：已消除競争擔憂[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)