碼上歡樂
相關內容    簡體    繁體

第三章 函數練習題

本文轉載自   查看原文   2018-09-21 13:25   1379 

文件處理相關

1，編碼問題

（1）請問python2與python3中的默認編碼是什么？

1
2
python  2.x 默認的字符編碼是ASCII，默認的文件編碼也是ASCII
python  3.x 默認的字符編碼是 unicode ，默認的文件編碼也是utf - 8

　　

（2）為什么會出現中文亂碼，你能舉例說明亂碼的情況有哪幾種？

1
2
3
4
5
6
7
8
9
無論以什么編碼在內存里顯示字符，存到硬盤上都是 2 進制，所以編碼不對，程序就會出錯了。
（ascii編碼（美國），GBK編碼（中國），shift_JIS編碼（日本），，，，）
要注意的是，存到硬盤上時是以何種編碼存的，再從硬盤上讀出來時，就必須以何種編碼讀，要不然就亂了。。
 
常見的編碼錯誤的原因有:
　　python解釋器的默認編碼
　　Terminal使用的編碼
　　python源文件文件編碼
　　操作系統的語言設置,掌握了編碼之前的關系后,挨個排錯就ok

　　

（3）如何進行編碼轉換？

1
2
3
4
5
6
7
8
9
10
11
12
如果想要中國的軟件可以正常的在美國人的電腦上實現，有下面兩種方法：
     1 ，讓美國人的電腦都裝上gbk編碼
     2 ，讓你的軟件編碼以utf - 8 編碼
 
     第一種方法不可現實，第二種方法比較簡單，但是也只能針對新開發的軟件，
如果你之前開發的軟件就是以gbk的編碼寫的，上百萬行代碼已經寫出去了，
重新編碼成utf - 8 格式也會費很大力氣。
     所以，針對已經用gbk開發的軟件項目如何讓項目在美國人的電腦上正常顯示
     還記得 unicode 的一個功能就是其包含了跟全球所有國家編碼的映射關系，
所以無論你以什么編碼存儲的數據，只要我們的軟件把數據從硬盤上讀到內存，
轉成 unicode 來顯示即可，由於所有的系統，編程語言都默認支持 unicode ，
所有我們的gbk軟件放在美國電腦上，加載到內存里面，變成了 unicode ，中文就可正常展示

　　

（4）#_*_coding:utf-8_*_  的作用是什么？

1
#_*_coding:utf-8 _*_ 的作用是.py文件是什么編碼，就需要告訴python用什么編碼去讀取這個.py文件

　　

（5）解釋python2.x  bytes與python3.x  bytes的區別

1
2
3
簡單點說：
Python  2  將 strings 處理為原生的 bytes 類型，而不是  unicode ，
Python  3  所有的 strings 均是  unicode  類型。

　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
在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的區別是什么？

1
2
3
4
5
文件操作時候，以“r "或者”rb" 模式打開，只能讀取，無法寫入；
硬盤上保存的文件都是某種編碼的 0101010 ，打開時需要注意：
     rb，直接讀取文件保存時原生的 0101010 ，在Python中用字節類型表示
     r和encoding，讀取硬盤的 0101010 ，並按照encoding指定的編碼格式進行斷句，
再將“斷句”后的每一段 0101010 轉換成 unicode 的  010101010101 ，在Python中用字符串類型表示

　　

　

（2）解釋一下下面三個參數的作用分別是什么？

　　

1
open (f_name, 'r' ,encoding = "utf-8" )

 

1
2
3
4
5
6
f_name 是文件的路徑，mode是打開的方式，encoding是編碼格式
  encoding  #文件編碼 
  mode  #打開模式 
  name  #文件名 
  newlines  #文件中用到的換行模式，是一個tuple 
  softspace  #boolean型，一般為0，據說用於print

　　

（3） w和wb的區別是什么？

1
2
3
4
5
文件操作時候，以 “w”或“wb” 模式打開，則只能寫，並且在打開的同時會先將內容清空。
寫入到硬盤上時，必須是某種編碼的 0101010 ，打開時需要注意：
     wb，寫入時需要直接傳入以某種編碼的 0100101 ，即：字節類型
     w 和 encoding，寫入時需要傳入 unicode 字符串，內部會根據encoding制定的編碼
將 unicode 字符串轉換為該編碼的  010101010

　　

（4）a和ab的區別是什么？

1
2
3
4
5
文件操作時，以 “a”或“ab” 模式打開，則只能追加，即：在原來內容的尾部追加內容
寫入到硬盤上時，必須是某種編碼的 0101010 ，打開時需要注意：
     ab，寫入時需要直接傳入以某種編碼的 0100101 ，即：字節類型
     a 和 encoding，寫入時需要傳入 unicode 字符串，內部會根據encoding制定的編碼
將 unicode 字符串轉換為該編碼的  010101010

　　

（5）readline和readlines的區別

1
2
3
readline()  #讀取一行
 
readlines()  #讀取所有內容，並返回列表（一行為列表的一個元素值）

（6）全局替換程序：

寫一個腳本，允許用戶按以下方式執行時，即可以對指定文件內容進行全局替換

1
`python your_script.py old_str new_str filename`

　　替換完畢后打印替換了多少處內容

 

 

（7）模擬登陸

  • 用戶輸入帳號密碼進行登陸
  • 用戶信息保存在文件內
  • 用戶密碼輸入錯誤三次后鎖定用戶，下次再登錄，檢測到是這個用戶也登錄不了

 

　　　函數基礎

1，寫函數，計算傳入數字參數的和。（動態傳參）

 

1
2
3
4
5
6
7
8
9
10
11
12
#寫函數，計算傳入數字參數的和。（動態傳參）
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)
View Code 
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')
View Code

 

修改前的文件內容：

1
你是我唯一的愛，you are my everything

修改后的文件內容：

1
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)
View Code 
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',[],())
# 字符串里面沒有空內容
# 列表有空內容
# 元祖有空內容
View Code

 

4，寫函數，檢查傳入字典的每一個value的長度,如果大於2，那么僅保留前兩個長度的內容，並將新內容返回給調用者。

dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表
View Code 
# 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]]
View Code

 

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))
View Code

 

　　函數進階

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')]
View Code

 

2，寫函數，傳入n個數，返回字典{‘max’:最大值,’min’:最小值}

1
2
例如: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}
View Code

 

3，寫函數，專門計算圖形的面積

  • 其中嵌套函數，計算圓的面積，正方形的面積和長方形的面積
  • 調用函數area(‘圓形’,圓半徑) 返回圓的面積
  • 調用函數area(‘正方形’,邊長) 返回正方形的面積
  • 調用函數area(‘長方形’,長，寬) 返回長方形的面積
  • def area():
    def 計算長方形面積():
        pass
 
    def 計算正方形面積():
        pass
 
    def 計算圓形面積():
        pass
    View Code 
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)
View Code

 

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))
View Code

 

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()
View Code

 

 

　　生成器和迭代器

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？

1
2
3
兩種方式獲取：
     for  循環
     next  獲取

　　

3，通過生成器寫一個日志調用方法， 支持以下功能

  • 根據指令向屏幕輸出日志
  • 根據指令向文件輸出日志
  • 根據指令同時向文件&屏幕輸出日志
  • 以上日志格式如下
1
2
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]是指自日志方法第幾次調用，每調用一次輸出一條日志

　　代碼結構如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
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

1
name = [ 'alex' , 'wupeiqi' , 'yuanhao' , 'nezha' ]

 

1
2
3
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']
View Code

 

2，用filter函數處理數字列表，將列表中所有的偶數篩選出來

1
num  =  [ 1 , 3 , 5 , 6 , 7 , 8 ]

 

1
2
3
4
5
6
7
8
9
10
11
12
# 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對應股票的價格

1
2
3
4
5
6
7
8
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]
View Code

 

1
2
3
4
# 　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)
View Code

 

2，有如下程序, 請給出兩次調用show_num函數的執行結果，並說明為什么：

1
2
3
4
5
6
7
8
9
10
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的文件，其內容如下，請刪除第三行；

1
2
3
4
5
6
7
昔人已乘黃鶴去，此地空余黃鶴樓。
 
黃鶴一去不復返，白雲千載空悠悠。
 
晴川歷歷漢陽樹，芳草萋萋鸚鵡洲。
 
日暮鄉關何處是？煙波江上使人愁。 
# 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)
View Code

 

　

5，有名為username.txt的文件，其內容格式如下，寫一個程序，判斷該文件中是否存在"alex", 如果沒有，則將字符串"alex"添加到該文件末尾，否則提示用戶該用戶已存在；

1
2
3
pizza
alex
egon

　　

1
2
3
4
5
6
7
8
9
10
11
# 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的行；

1
2
3
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)
View Code

 

7，有名為user_info.txt的文件，其內容格式如下，寫一個程序，將id為100002的用戶名修改為alex li；

1
2
3
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)
View Code

 

8，什么是裝飾器？，寫一個計算每個程序執行時間的裝飾器；

　　

1
2
3
4
     裝飾器模式（Decorator Pattern）允許向一個現有的對象添加新的功能，
同時又不改變其結構。這種類型的設計模式屬於結構型模式，它是作為現有的類的一個包裝。
     這種模式創建了一個裝飾類，用來包裝原有的類，並在保持類方法簽名完整性的前提下，
提供了額外的功能。

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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？

 

1
2
3
4
5
lambda 函數就是可以接受任意多個參數(包括可選參數)並且返回單個表達式值得函數
     好處：
         1.lambda 函數比較輕便，即用即扔，適合完成只在一處使用的簡單功能
         2. 匿名函數，一般用來給 filter ， map 這樣的函數式編程服務
         3. 作為回調函數，傳遞給某些應用，比如消息處理

　　

10，請分別介紹文件操作中不同文件之間打開方式的區別

模式 含義
r 文本只讀模式
rb 二進制模式 這種方法是用來傳輸或存儲，不給人看的
r+ 讀寫模式，只要有r，那么文件必須存在
rb+ 二進制讀寫模式
w 只寫模式，不能讀，用w模式打開一個已經存在的文件，如果有內容會清空，重新寫
wb 以二進制方式打開，只能寫文件，如果不存在，則創建
w+ 讀寫模式，先讀后寫，只要有w，會清空原來的文件內容
wb+ 二進制寫讀模式
a 追加模式，也能寫，在文件的末尾添加內容
ab 二進制追加模式
a+ 追加模式，如果文件不存在，則創建文件，如果存在，則在末尾追加
ab+ 追讀寫二進制模式，從文件頂部讀取文件，從文件底部添加內容，不存在則創建

11，簡述普通參數，指定參數，默認參數，動態參數的區別

1
2
3
4
5
普通參數：以正確的順序傳入函數，調用時數量必須和聲明的一樣
指定參數：參數和函數調用關系密切，函數調用使用關鍵字參數來確定傳入的參數值，參數
                 允許函數調用時參數的順序和聲明時不一致
默認參數：函數進行調用時，如果沒有新的參數傳入則默認的情況下，就調用默認參數
動態參數：個別函數能處理比當初聲明時更多的參數，這些參數就動態參數

 

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)
View Code

 

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})
View Code

 

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)
View Code

 

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)
View Code

 

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)
View Code

 

17，寫函數，檢查傳入字典的每一個value的長度，如果大於2，那么僅僅保存前兩個長度的內容，並將新內容返回給調用者

 18，寫函數，計算傳入字符串中的【數字】、【字母】、【空格】和【其他】的個數

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 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))

　　


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 第三章 習題三 Java語言程序設計-基礎篇-第八版-編程練習題-第三章 夏宇聞-第三章-verilogHDL基本語法習題 python語言程序設計基礎（嵩天）第三章課后習題部分個人練習 Vue---第三章函數的定義和使用methods 第三十二章 Linux常規練習題（一） 統計學習導論：基於R應用——第三章習題 C++面向對象程序設計第三章習題答案解析 數據庫系統概論習題集 第三章 SQL語言 第三章 Jenkins的詳細介紹
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM