3.7練習題

時間  2019-12-01
標籤 3.7 練習題 简体版
原文   原文鏈接 
#!/usr/bin/env python 
# -*- coding:utf-8 -*-
# date: 2019/6/30 9:55
# Author： 炳暢


# 請說明python2 與python3中的默認編碼是什麼？
'''
PYTHON2是A1SC碼，python是utf-8
'''

# 爲何會出現中文亂碼？你能列舉出現亂碼的狀況有哪幾種？
'''
解碼和編碼的格式不同,一共有四種狀況，中國windows是GBK的，linux和蘋果都是utf-8
標準答案
.py文件是什麼編碼就須要告訴python用什麼編碼去讀取這個.py文件。
sys.stdout（標準輸出）.encoding（編碼），默認就是locale的編碼，print會用sys.stdout.encoding去encode(編碼)成字節流，
交給terminal（終端）顯示。因此locale(開始)須要與terminal（結束）一致，才能正確print打印出中文。
sys.setdefault encoding(‘utf8’)，用於指定str.encode(編碼) str.decode(解碼)的默認編碼，默認是ascii。
如下幾種(local 爲軟件運行時的語言環境):
終端爲UTF-8，locale爲zh_CN.GBK
終端爲UTF-8，locale爲zh_CN.UTF-8
終端爲GBK，locale爲zh_CN.GBK
終端爲GBK，locale爲zh_CN.UTF-8
'''

# 如何進行編碼轉換？
'''
字符串在python3內部中是採用unicode的編碼方式，
因此其餘語言先decode（解碼）轉換成unicode編碼，
再encode（編碼）轉換成utf8編碼。
'''

# -*-coding:utf-8-*- 的做用是什麼？
'''
開頭指明白這個是用utf-8編碼的
'''

# 解釋py2 bytes vs py3 bytes的區別
'''
pythn2是先把字符串轉換成bytes（二進制類型）類型
Python3中全部的字符類型都是unicode（萬國碼）
string（字符串） -> encode（解碼）  -> bytes（二進制）
bytes(二進制） -> decode（編碼）  -> string（字符串）

'''

# r和rb的區別是什麼
'''
r 只讀
rb 二進制的方式讀文件
'''

# 解釋一下如下三個參數的分別做用
open(f_name,'r',encoding="utf-8")
'''
open打開或者建立
f_name 文件名，自定義
r 只讀
encoding = 自定編碼方式

'''

# 函數基礎：
# 寫函數，計算傳入數字參數的和。（動態傳參）

def ji(a,x):
    return a + x
print(ji(2,1))

# 寫函數，用戶傳入修改的文件名，與要修改的內容，執行函數，完成整個文件的批量修改操做
def han(s):  # 傳入要修改的數值
    a = []
    for i in s:
        b = i.capitalize()  # 把大寫的轉換成小寫
        a.append(b)
    print(a)


s = ["2019-06-20 09:51:36,787 - meanwhile - ERROR - account[1234] too 中文"]

han(s)

 


# 寫函數，檢查用戶傳入的對象（字符串、列表、元組）的每個元素是否含有空內容。
def file(x):
    a = 0
    for i in x:
        if i == " ":
            a += 1
    print(a)

s = "2019-06-20 09:51:36,787 - meanwhile - ERROR - account[1234] too 中文"
file(s)
# 寫函數，檢查傳入字典的每個value(值)的長度,若是大於2，
# 那麼僅保留前兩個長度的內容，並將新內容返回給調用者。
dic = {"k1": "v1v1", "k2": [11, 22, 33, 44]}
# PS:字典中的value只能是字符串或列表
def file(x):
    for i, o in x.items():
        if len(o) > 2 :
            dic[i] = o[:2]
        else:
            continue
    return x
print(file(dic))

 


# 解釋閉包的概念
'''
因爲上一層的做用域沒有釋放，返回的函數對象包含了一個做用域，致使該函數，無論在哪裏調用，都優先使用包含的做用域
官方答案
閉包(closure)是函數式編程的重要的語法結構。
函數式編程是一種編程範式 (而面向過程編程和麪向對象編程也都是編程範式)。
  在面向過程編程中，咱們見到過函數(function)；
  在面向對象編程中，咱們見過對象(object)。
  函數和對象的根本目的是以某種邏輯方式組織代碼，
  並提升代碼的可重複使用性(reusability)。
  閉包也是一種組織代碼的結構，它一樣提升了代碼的可重複使用性。
'''

# 函數進階：
# 寫函數，返回一個撲克牌列表，裏面有52項，每一項是一個元組
# 例如：[(‘紅心’，2),(‘草花’，2), …(‘黑桃A’)]
def file():
    num = []
    for i in range(2, 12):
        num.append(i)
    num.extend(['J', 'Q', 'K', 'A'])
    type = ['紅心', '草花', '方塊', '黑桃']
    t = []
    for i in num:
        for e in type:
            t.append((e,i))
    return t
print(file())

 


# 寫函數，傳入n個數，返回字典{‘max’:最大值,’min’:最小值}
# 例如:min_max(2,5,7,8,4)
# 返回:{‘max’:8,’min’:2}
def han(*ages):
    max_1 = ages[0]
    min_1 = ages[0]
    for i in ages :
        if i > max_1:
            max_1 = i
        elif i < min_1:
            min_1 = i
    return {"max":max_1,"min":min_1}
print(han(2,5,7,8,4))

 


# 寫函數，專門計算圖形的面積
#
# 其中嵌套函數，計算圓的面積，正方形的面積和長方形的面積
#
# 調用函數area(‘圓形’,圓半徑) 返回圓的面積
# 調用函數area(‘正方形’,邊長) 返回正方形的面積
# 調用函數area(‘長方形’,長，寬) 返回長方形的面積
# def area():
# def 計算長方形面積():
#     pass
#
# def 計算正方形面積():
#     pass
#
# def 計算圓形面積():
#     pass
import math
print(
    '
    請按照以下格式輸出：
      調用函數area(‘圓形’,圓半徑) 返回圓的面積
      調用函數area(‘正方形’,邊長) 返回正方形的面積
      調用函數area(‘長方形’,長，寬) 返回長方形的面積
    '
)
def area(name,*ages):
    def areas(x,y):
        return ("該長方形的面積爲",x*y)
    def aread(z):
        return ("該正方形的面積爲:",z**2)
    def areaf(r):
        return ("該圓的面積:",math.pi*r*r)
    if name == '長方形':
        return areas(*ages)
    elif name == '正方形':
        return aread(*ages)
    elif name == '圓形':
        return areaf(*ages)
    else:
        return ("格式不正確，請從新輸入")
print(area('長方形', 34, 34))
print(area('圓形', 3423))
print(area('正方形', 1243))
print(area('正z形', 12313))

 


# 寫函數，傳入一個參數n，返回n的階乘
# 例如:cal(7)
# 計算7*6*5*4*3*2*1
def cal(n):
    a = []
    c = 1
    while int(n)>0:
        a.append(n)
        n -= 1
    if int(n) == 0:
        for i in a:
            c = c *i
            print(c)
cal(45)

# 答案2
def cal(n):
   res= 1
   for i in range(n,0,-1):
       # print(i)
       res = res*i
       print(res)
   return res

print(cal(7))

# 編寫裝飾器，爲多個函數加上認證的功能（用戶的帳號密碼來源於文件），
# 要求登陸成功一次，後續的函數都無需再輸入用戶名和密碼
# 答案
import json
def login(func):
    def file():
        name = input("name>>>:").strip()
        password = input("password>>>:").strip()
        a = True
        if a:
            with open('userinfo.txt', 'r', encoding='utf-8')as f:
                userinfo = json.load(f)
                if name == userinfo['name'] and password == userinfo['password']:
                    print("success")
                    a = False
                    func()
                else:
                    print("輸入錯誤！！")
        else:
            func()

    return file


@login
def name():
    print("hello")

name()

 



# 生成器和迭代器的區別？

'''
迭代器裏面包含生成器
官方答案：
對於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便可
'''

# 生成器有幾種方式獲取value（值）？
'''
有next和for循環的方式
'''

# 經過生成器寫一個日誌調用方法， 支持如下功能
'''
根據指令向屏幕輸出日誌
根據指令向文件輸出日誌
根據指令同時向文件&屏幕輸出日誌
以上日誌格式以下
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')
import logging

#
# def logger(filenamea, channel='file'):
#     # logger = logging.getLogger()
#     # logger.setLevel(logging.DEBUG)
#     # fh = logging.FileHandler(filename)
#     # logger.addHandler(fh)
#     # file_formatter = logging.Formatter("%(asctime)s  - %(message)s")
#     # fh.setFormatter(file_formatter)
#     qw = 1
#     a2w = yield
#     if channel == 'terminal':
#         logging.error(qw, a2w)
#     elif channel == 'file':
#         logging.basicConfig(filename=filenamea, level=logging.DEBUG)
#         logging.error(qw, a2w)
#     elif channel == 'both':
#         # logger.error(a,a2)
#         logging.error(qw, a2w)
#     else:
#         print("格式不正確")
#     qw += 1
#
#
# log_obj = logger(filenamea="web.log", channel='terminal')
# log_obj.__next__()
# log_obj.send('user alex login success')
def logger(filenamea, channel='file'):
    qw = 1
    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)

    if channel == 'terminal':
        while True:
            a2w = yield
            a3 = str([qw]) + a2w
            logging.log(logging.DEBUG, a3)
            qw += 1
    elif channel == 'file':
        # logging.basicConfig(filename=filenamea, level=logging.DEBUG)
        fh = logging.FileHandler(filenamea)
        file_formatter = logging.Formatter("%(asctime)s - %(message)s")
        fh.setFormatter(file_formatter)
        logger.addHandler(fh)
        while True:
            a2w = yield
            a3 = str([qw]) + a2w
            logging.error(a3)
            qw += 1
    elif channel == 'both':
        fh = logging.FileHandler(filenamea)
        ch = logging.StreamHandler()
        logger.addHandler(fh)
        logger.addHandler(ch)
        file_formatter = logging.Formatter("%(asctime)s  - %(message)s")
        com = logging.Formatter("%(asctime)s  - %(message)s")
        ch.setFormatter(com)
        fh.setFormatter(file_formatter)
        while True:
            a2w = yield
            a3 = str([qw]) + a2w
            logging.error(a3)
            qw += 1

    else:
        print("格式不正確")




log_obj = logger(filenamea="web.log", channel='both')
#log_obj = logger(filenamea="web.log", channel='file')
log_obj.__next__()
log_obj.send('user alex login success')
log_obj.send('user alex login success')
log_obj.send('user alex login success')
log_obj.send('user alex login success')
log_obj.send('user alex login success')

 



# 用map來處理字符串列表,把列表中全部人都變成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao','nezha']
a = map(lambda x :x+'_sb' , name )
for i in a:
    print(i)

# 官方答案
# map()函數
# map()是 Python 內置的高階函數，它接收一個函數 f 和一個 list，並經過把
# 函數 f 依次做用在 list 的每一個元素上，獲得一個新的 list 並返回。
# 
# 　　注意：map()函數在不改變原有的lisy，而是返回一個新的list
# 代碼:
name=['alex','wupeiqi','yuanhao','nezha']
a = map(lambda x :x+'_sb' , name )
for i in a:
    print(i)

# 用filter函數處理數字列表，將列表中全部的偶數篩選出來
num = [1,3,5,6,7,8]
a = filter(lambda x : x%2 == 0,num)
for i in a:
    print(i)


# 標準答案
num = [1,3,5,6,7,8]
def func(x):
   if x%2 == 0:
       return True

ret = filter(func,num)
print(list(ret))
 

 


# 以下，每一個小字典的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}
]
# 計算購買每支股票的總價

 

 
 
for i in portfolio:
    a = int(i["shares"]) * int(i["price"])
    print(i['name'], "的總價爲", a)
 

 


# 用filter過濾出，單價大於100的股票有哪些
 

 
 
f = filter(lambda d: d['price'] >= 100, portfolio)
print(list(f))
 

 

 


# 請分別介紹文件操做中不一樣的打開方式之間的區別：
'''
模式 含義
r  文本只讀模式
rb 二進制模式 這種方法是用來傳輸或存儲，不給人看的
r+ 讀寫模式，只要有r，那麼文件必須存在
rb+    二進制讀寫模式
w  只寫模式，不能讀，用w模式打開一個已經存在的文件，若是有內容會清空，從新寫
wb 以二進制方式打開，只能寫文件，若是不存在，則建立
w+ 讀寫模式，先讀後寫，只要有w，會清空原來的文件內容
wb+    二進制寫讀模式
a  追加模式，也能寫，在文件的末尾添加內容
ab 二進制追加模式
a+ 追加模式，若是文件不存在，則建立文件，若是存在，則在末尾追加
ab+    追讀寫二進制模式，從文件頂部讀取文件，從文件底部添加內容，不存在則建立

 

 


# 二、有列表 li = ['alex', 'egon', 'smith', 'pizza', 'alen'], 請將以字母「a」開頭的元素的首字母改成大寫字母；
 

 
 
li = ['alex', 'egon', 'smith', 'pizza', 'alen']
li_w = []
for i in li:
    if i.startswith("a"):
        li_w.append(i.capitalize())
    else:
        li_w.append(i)
print(li_w)

for i in range(len(li)):
    if li[i][0] == "a":
        li[i] = li[i].capitalize()
    else:
        continue
print(li)
 

 

 



# 有以下程序, 請給出兩次調用show_num函數的執行結果，並說明爲何：
 

 
 
num = 20
def show_num(x=num):
    print(x)
show_num()
num = 30
 

 


# 答
'''
是20，由於在函數的X是默認參數
若是函數收到的是一個不可變對象（好比數字、字符或者元組）的引用，
就不能直接修改原始對象，
至關於經過「傳值’來傳遞對象，
此時若是想改變這些變量的值，
能夠將這些變量申明爲全局變量。
 

 


# 有列表 li = ['alex', 'egon', 'smith', 'pizza', 'alen'], 請以列表中每一個元素的第二個字母倒序排序；

# 答案
 

 
 
li = ['alex', 'egon', 'smith', 'pizza', 'alen']
print(sorted(li, key=lambda x: x[1], reverse=True))
 

 

sorted(iterable[, cmp[, key[, reverse]]]),排序語法
參數說明：

iterable -- 可迭代對象。
cmp -- 比較的函數，這個具備兩個參數，參數的值都是從可迭代對象中取出，此函數必須遵照的規則爲，大於則返回1，小於則返回-1，等於則返回0。
key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。
reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（默認）。
'''
 

 


# 有名爲poetry.txt的文件，其內容以下，請刪除第三行；
#
#   昔人已乘黃鶴去，此地空餘黃鶴樓。
#   黃鶴一去不復返，白雲千載空悠悠。
#   晴川歷歷漢陽樹，芳草萋萋鸚鵡洲。
#   日暮鄉關何處是？煙波江上令人愁。
 

 
 
import os

p = 'poetry.txt'
file = open(p,'r',encoding='utf-8')
pnew = '%s.new'%p
filenew = open(pnew,'w',encoding='utf-8')
x = '晴川歷歷漢陽樹，芳草萋萋鸚鵡洲。'
for i in file:
    if x in i:
        i = ''
        filenew.write(i)
    else:
        filenew.write(i)
file.close()
filenew.close()
os.replace(pnew,p)

# 逐行讀取文件

f1 = open('poetry.txt', 'r',encoding='utf-8')
str='晴川歷歷漢陽樹，芳草萋萋鸚鵡洲。'
with open('poetry1.txt', 'w',encoding='utf-8')as f2:
    f3 = 'poetry.txt'
    f4 = 'poetry1.txt'
    for l in f1:
        if str in l:
            l = ''
            f2.write(l)
        else:
            f2.write(l)

f1.close()
f2.close()
os.replace(f4,f3)
 

 

 


# 六、有名爲username.txt的文件，其內容格式以下，寫一個程序，判斷該文件中是否存在"alex",
# 若是沒有，則將字符串"alex"添加到該文件末尾，不然提示用戶該用戶已存在；
#   pizza
#   alex
#   egon
 

 
 
with open('username.txt','r+',encoding='utf-8') as f:
    str = 'alex'
    i = f.read()
    if str in i:
        print("該用戶已存在")
    else:
        f.write('\nalex')
 

 

 



# 七、有名爲user_info.txt的文件，其內容格式以下，寫一個程序，刪除id爲100003的行；
'''
# pizza, 100001
# alex, 100002
# egon, 100003
 

 
 
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)
 

 

 
 

 



# 有名爲user_info.txt的文件，其內容格式以下，寫一個程序，
# 將id爲100002的用戶名修改成alex li
 

 
 
file = 'user_info.txt'
old_str = '100002'
new_str = 'alex li, 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)
 

 

 


 九、寫一個計算每一個程序執行時間的裝飾器；
 

 
 
import time
def timer(func):
    def x(*ages):
        s_time = time.time()
        func(*ages)
        t_time = time.time
        print(s_time,t_time)
    return x

@timer
def a():
    print("執行結算！")

a()
 

 

 

 
 


# lambda是什麼？請說說你曾在什麼場景下使用lambda？
'''
# 答案
lambda函數就是能夠接受任意多個參數(包括可選參數)而且返回單個表達式值得函數
    好處：
        1.lambda函數比較輕便，即用即扔，適合完成只在一處使用的簡單功能
        2.匿名函數，通常用來給filter，map這樣的函數式編程服務
        3.做爲回調函數，傳遞給某些應用，好比消息處理
'''
 

 


# 十一、題目：寫一個搖骰子游戲，要求用戶壓大小，賠率一賠一。
#
# 要求：三個骰子，搖大小，每次打印搖骰子數。
 

 
 
import random

def roll_a(numbers=3, points=None):
    print("遊戲開始")
    if points is None:
        points = []
    while numbers > 0:
        point = random.randrange(1, 7)
        points.append(point)
        numbers -= 1
    return points
def roll_r(total):
    is_b = 11 <= total <= 18
    is_s = 3 <= total <= 10

    if is_b:
        return "b"
    elif is_s:
        return "s"
def start_game():
    your_money = 1000
    while your_money > 0:
        print('----- 遊戲開始 -----')
        choices = ["大", "小"]
        your_choice = input("請下注， 大 or 小")
        your_bet = input("下注金額：")
        if your_choice in choices:
            points = roll_a()
            total = sum(points)
            you_win = your_choice == roll_r(total)
            if you_win:
                your_money = your_money + int(your_bet)
                print("骰子點數", points)
                print("恭喜， 你贏了%s元， 你如今的本金%s 元" % (your_bet, your_money + int(your_bet)))
            else:
                your_money = your_money - int(your_bet)
                print("骰子點數", points)
                print("很遺憾， 你輸了%s元， 你如今的本金%s 元" % (your_bet, your_money - int(your_bet)))
        else:
            print('格式有誤，請從新輸入')
    else:
        print("game over")

start_game()
 

 

 

 
 





'''
# 請使用列表生成式將列表li = [1, 2, 3, 4, 5, 6, 7, 8, 9]中的每個元素乘以2
# li = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# def lb():
#     while True:
#         m = yield
#         print(m + 2)
# a = lb()
# a.__next__()
# for i in li :
#   a.send(i)

# 
# li = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 
# 
# def lb():
#     c = 0
#     while True:
#         m = yield c
#         c = m + 2
# 
# 
# a = lb()
# a.__next__()
# for i in li:
#     r = a.send(i)
#     print(r)
'''

 

謝謝欣賞,有問題或者建議請聯繫我郵箱861257034@qq.com，有道雲有代碼註釋，
 

有道雲連接：http://note.youdao.com/noteshare?id=f05692f283b0e25557a3a9116c64b154&sub=54E2674777384F39AF941BDB91F800E4python


        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程