第四十八節，考試題

時間  2019-11-12
標籤 第四十 八節 考試 简体版
原文   原文鏈接

一，基礎題
1.計算100-300之間，全部能被3和7整除的，全部數之和python

#!/usr/bin/env python
# -*- coding:utf8 -*-
shu = 0
for i in range(100,301):
    if i % 3 == 0 and i % 7 == 0:
        shu += i
print(shu)

2.定義函數統計一個字符串中大寫字母，小寫字母，數字的個數，並返回結果git

#!/usr/bin/env python
# -*- coding:utf8 -*-
zfch = "DGGDHJHJURTUTGhrhyktktreh6544636" #建立字符串

def fjk(s): #定義函數接收字符串
    a = 0 #循環時統計大寫字母
    b = 0 #循環時統計小寫字母
    c = 0 #循環時統計數字
    for i in s:
        if i.isupper(): #判斷循環到的字符若是是大寫字母
            a += 1 #將統計大寫字母加1
        if i.islower(): #判斷循環到的字符若是是小寫字母
            b += 1 #將統計小寫字母加1
        if i.isdigit(): #判斷循環到的字符若是是數字
            c += 1 #將統計數字加1
    print(a,b,c) #最後打印出統計到的大寫字母，小寫字母，數字的個數


fjk(zfch) #執行函數，將字符串傳入函數
# 輸出
# 14 11 7

3.獲取兩個列表 i1=[11,22,33],i2=[22,33,44]中相同的元素集合正則表達式

#!/usr/bin/env python
# -*- coding:utf8 -*-
a = [11,22,33] #建立列表
a1 = set(a) #將列表轉換成集合

b = [22,33,44]#建立列表
b1 = set(b)#將列表轉換成集合

a1.intersection_update(b1) #查找出a集合和b集合都存在的元素,並從新更新到a集合
print(a1) #打印出更新後的a集合
# 輸出
# {33, 22}

4.將字符串 "老男人" 轉換成utf-8編碼的字節類型算法

#!/usr/bin/env python
# -*- coding:utf8 -*-
a = "老男人" #建立字符串
b = bytes(a,encoding="utf-8") #將字符串轉換成utf-8的字節類型
print(b) #打印出字節
# 輸出
# b'\xe8\x80\x81\xe7\x94\xb7\xe4\xba\xba'

5.如何計算數字絕對值json

#!/usr/bin/env python
# -*- coding:utf8 -*-
a = 123456 #建立數字類型
b = abs(a) #取數字的絕對值,也就是不管是正數仍是負數取它的絕對值
print(b) #打印出絕對值
# 輸出
# 123456

 6.簡述深淺拷貝原理數組

淺拷貝值拷貝外層app

深拷貝除最底層外都拷貝frontend

 

7.舉例布爾值爲False的值dom

布爾值False 爲空，一切返回爲空的爲False，如：空字符串，空列表，空字典，空元祖，數字類型0，None等空值的爲Falsepython2.7

 

8.內置函數all和any的區別

all() 接收可迭代類型，循環參數，若是每一個元素都爲真，那麼all的返回值爲真，有一個元素爲假返回的都是假

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#all() 接收可迭代類型，循環參數，若是每一個元素都爲真，那麼all的返回值爲真，有一個元素爲假返回的都是假
#假數據有，0（數字），None（返回值），"" (空字符串)，[] (空列表)，（） （空元組），{} （空字典）

#列1
a = [1,"123",[123,456],(123,456),{"k1":123,"k2":456}]
f1 = all(a)
print(f1)
#輸出 True （真）

#列2
b = [0,"你好",[123,456],(123,456),{"k1":123,"k2":456}]
f2 = all(b)
print(f2)
#輸出 False （假）說明：裏面的類型中有一個或者多個爲假

any() 接收可迭代類型，循環參數，若是有一個元素爲真，那麼any的返回值爲真，所有爲假才返回假

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#any() 接收可迭代類型，循環參數，若是有一個元素都爲真，那麼all的返回值爲真，所有爲假才返回假
#假數據有，0（數字），None（返回值），"" (空字符串)，[] (空列表)，（） （空元組），{} （空字典）

#列1
a = [0,"1",[],(),{}]    #其中有1個爲真
f1 = any(a)
print(f1)
#輸出 True （真）

#列2
b = [0,"",[],(),{}]     #所有爲假
f2 = all(b)
print(f2)
#輸出 False （假）說明：裏面的類型所有爲假

 

9.利用內置函數將十進制數字12，分別轉換成二進制，八進制，十六進制表示的字符串

二進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = 12
b = bin(a)
print(b)
# 輸出
# 0b1100

八進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = 12
b = oct(a)
print(b)
# 輸出
# 0o14

十六進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = 12
b = hex(a)
print(b)
# 輸出
# 0xc

10.簡述內置函數dir,help,type做用

dir()查看一個對象類的內置方法有哪些

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = 12
b = dir(a)
print(b)
# 輸出
# ['__abs__', '__add__', '__and__', '__bool__', '__ceil__']

help()查看一個類的類庫功能詳情

type()查看一個對象的類型

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = 12
b = type(a)
print(b)
# 輸出
# <class 'int'>

11.簡述內置函數globals(),locals()做用

globals()獲取當前代碼裏的全部全局變量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = 12
b = 456
c = 789
d = globals()
print(d)

locals()獲取當前代碼裏的全部局部變量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
def f1():
    a = 123
    b = 456
    c = 789
    print(locals()) 
f1()
# 輸出
# {'c': 789, 'a': 123, 'b': 456}

12.簡述三元運算書寫格式

三元運算,就是if條件判斷，先後各有一個值,指向一個變量
條件成立，就將第一個值賦給變量，條件不成立就將第二個值賦給變量
就是一個條件判斷，和兩個不一樣的值組合成的判斷運算，就是三元運算
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = 11
b = "小屁孩"
c = "小青年"
#判斷若是a變量小於或者等於10就將b變量賦值給nian變量，不然就將c變量賦值給nian變量
nian = b if a <= 10 else c
print(nian)

13.簡述lambda表達式書寫格式

表達式建立簡單的函數
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""列1"""
f1 = lambda a,b:a + b   #lambda 表達式定義函數
f2 = f1 (1,2)   #調用函數
print(f2)
"""列2"""
av = lambda a:a     #lambda 表達式定義函數
av1 = av("你好")      #調用函數
print(av1)
# 輸出
# 3
# 你好

14.利用內置函數zip()，實現功能
l1 = ["alex",22,33,44,55]
l2 = ["is",22,33,44,55]
l3 = ["good",22,33,44,55]
l4 = ["guy",22,33,44,55]
請獲取字符串 s = "alex_is_good_guy"

#!/usr/bin/env python
# -*- coding:utf-8 -*-
l1 = ["alex",22,33,44,55]
l2 = ["is",22,33,44,55]
l3 = ["good",22,33,44,55]
l4 = ["guy",22,33,44,55]
b = zip(l1,l2,l3,l4) #將4個列表的元素，組合成元祖，列表元素個數是多少，就組合成多少個元祖，以每一個列表第一個元素組合成一個元祖，以此類推，須要for循環後返回
for k, v in enumerate(b,1): #給b循環對象設置一個鍵
    if k == 1:  #判斷若是鍵等於1
        print("_".join(v)) #判斷若是鍵等於1，將鍵等於1的元祖元素連接成一個字符串，打印出來
# 輸出
# alex_is_good_guy

 15.簡述文件打開模式，r和rb的區別

r 爲只讀模式 ，爲字符串只讀模式

rb 爲字節方式只讀模式

 

16.文件操做時with的做用

with 自動打開文件，對文件操做後，自動關閉文件,不用寫關閉文件函數，並且支持同時打開兩個文件（推薦）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# with 自動打開文件，對文件操做後，自動關閉文件（推薦）
# 格式：with open("文件路徑","打開模式") as 句柄變量:
# 返回：句柄變量
with open("h.log", "r+", encoding="utf-8") as f:    #自動打開文件，對文件操做後，自動關閉文件
    a = f.read()    #讀出文件內容
    print(a)    #打印出文件內容

17.利用with實現同時打開兩個文件（一讀一寫）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 列2 同時打開兩個文件，將一個文件的內容寫入另一個文件
# 假如原始文件很大，因此經過循環文件句柄，讀一行寫一行到新文件，減小內存使用率
with open("1.log", "r", encoding="utf-8") as  a, open("2.log", "w", encoding="utf-8") as b:    #自動打開文件，對文件操做後，自動關閉文件
    for i in a:     #循環出原始文件的數據
        b.write(i)  #每循環出一行原始文件數據，寫入新文件裏

18.函數默認返回值是什麼

默認返回值是None

19.簡述函數的普通參數，指定參數，默認參數，動態參數的特色以及注意事項

普通參數

print("普通參數：數量一致，一一對應")
def f1(a,b):
    c = a + b
    print(c)
f1(5,5)

指定參數

print("指定參數:調用函數時指定參數")
def g1(a,b):
    c = a + b
    print(c)
g1(b = 4, a = 3)

默認參數

print("默認參數:在定義函數時形式參數指定默認實參")
def h1(a=5, b=3):
    c = a + b
    print(c)
h1()

動態參數

print("動態參數:*args (接收實際參數組合成元組)")
def i1(*args):
    print(args)
i1(123, 456, 789)

 

20.經過字符串格式化將7.88123輸出時僅保留小數點後兩位，列如：bala7.88bala

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""用字符串格式化來保留小數點後多少位數"""
a = "bala"
b = 7.88123 #建立一個浮點數
c = "{:s} {:.2f}{:s}".format(a,b,a)
print(c)

21.判斷如下字符串格式化是否正確，若是不正確請改正

a = "iam{name},age{age},really{name}".format(name="seven",age=18)
b = "iam{0[0]},age{0[1]}".format(["seven",18])  這個錯誤

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = "iam{name},age{age},really{name}".format(name="seven",age=18)
print(a)
b = "iam{0[0]},age{0[1]}".format(["seven",18])
print(b)
# 輸出
# iamseven,age18,reallyseven
# iamseven,age18

22.python有幾種導入模塊的方式

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from xxx import xxx
import xxx

23.分頁，若是有192個商品，每頁顯示10個商品，問共須要幾頁

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = divmod(192,10)
print(a)
# 輸出
# (19, 2)  19頁零兩條

24.函數傳遞參數時，是引用仍是複製值？

是複製值

 

25.python3中的range函數和python2.7中的range函數有什麼區別？

python3是生成器須要循環才能實現，Python2.7是直接生成

 

26.python中導入模塊時，如何其搜索路徑？

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys
a = sys.path #獲取python的各類路徑
for i in a:
    print(i)

27.sys.argv的做用

獲取向腳本文件傳入的參數，返回的列表，列表裏的第一個元素是腳本文件路徑和名稱，後面的元素是傳入的向腳本傳入的參數

 

28.如何獲取一個路徑的上級目錄的路徑

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
a = os.path.dirname("py/lib")
print(a)

29.請將下三個路徑按照a,b,c的順序拼接起來
a = "/Users/seven"
b = "lib"
c = "bin"

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
a = "/Users/seven"
b = "lib"
c = "bin"
d = os.path.join(a,b,c)
print(d)
# 輸出
# /Users/seven\lib\bin

 30.簡述獲取一個隨機字母的思路

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import random
"""實現4位字母隨機數130"""
suij2 = ""      #統計隨機數
for i in range(4):      #循環4次
    rad = random.randrange(65,91)       #每一次循環隨機一個65至91之間的一個數賦值rad變量
    c = chr(rad)        #將每次獲得的隨機數以十進制的ascii碼轉換成對應字母（ascii碼字母範圍是65-91）
    suij2 += c      #將轉換的字母賦值給，統計隨機數
print(suij2)        #打印出統計隨機數

 

31.簡述re模塊中match,search以及findall方法的特色

匹配開頭，match，從頭匹配一個符合規則的字符串，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None

匹配全局第一個符合規則的字符串，search,瀏覽所有字符串，匹配第一符合規則的字符串，瀏覽整個字符串去匹配第一個，未匹配成功返回None

匹配全部，findall瀏覽所有字符串，匹配全部合規則的字符串，匹配到的字符串放到一個列表中，未匹配成功返回空列表

 

32.簡述正則表達式中分組的做用

注意：分組的意義，就是在匹配成功的字符串中，在提取()裏，組裏面的字符串

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
#也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體
a = re.findall("a(\d+)", "a466666664a4a4a4dg4g654gb")    #匹配 (a) (\d0-9的數字) (+能夠是1個到多個0-9的數字)
print(a)

c = re.findall("a\d+", "a466666664a4a4a4dg4g654gb")    #匹配 (a) (\d0-9的數字) (+能夠是1個到多個0-9的數字)
print(c)
#打印出
# ['466666664', '4', '4', '4']
# ['a466666664', 'a4', 'a4', 'a4']

33.請書寫輸出結果
import re
a = "hello/bin/uuu/haa/d"
b = re.findall(r"(\w+)/",a)
print(b)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = "hello/bin/uuu/haa/d"
c = re.findall(r"\w+/",a) #匹配任何字幕一位或多位加後面有/斜槓的
b = re.findall(r"(\w+)/",a) #匹配任何字幕一位或多位加後面有/斜槓的，分組只獲取字母部分，斜槓不要
print(b)
print(c)
# 輸出
# ['hello', 'bin', 'uuu', 'haa']
# ['hello/', 'bin/', 'uuu/', 'haa/']

 34.簡述計算1*2+3*4+5*6+7*8+99*100

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = 1*2+3*4+5*6+7*8+99*100
print(a)
# 輸出
# 10000

35.python中兩種序列化json和pickle的區別

json是將python數據類型轉換成字符串，將字符串的python數據類型還原成它原本的數據類型

pickle是將python數據類型轉換成二進制字節碼，將二進制字節碼的python數據類型還原成它原本的數據類型

 

36.簡述json模塊中提供的方法：dumps,dump,loads,load的做用以及注意事項

dumps：將Python數據類型轉換成字符串【有參】

dump：將Python數據類型轉換成字符串，直接寫入文件【有參】

loads：將字符串還原它原本的數據類型【有參】

load：讀出文件裏的字符串，還原它原本的數據類型【有參】

37.有以下變量，請檢查哪些錯誤
l1 = ["alcx",123,"eric"]
l2 = ["alcx",123,"eric"]

s1 = """["alcx",123,"eric"]"""
s2 = """["alcx",123,'eric']""

a = json.loads(l1)
b = json.loads(l2)
c = json.loads(s1)
d = json.loads(s2)
e = json.dumps(l1)
f = json.dumps(l2)
g = json.dumps(s1)
h = json.dumps(s2)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import json
l1 = ["alcx",123,"eric"] #
l2 = ["alcx",123,"eric"]
s1 = """["alcx",123,"eric"]"""
s2 = """["alcx",123,'eric']"""

#a = json.loads(l1)#錯誤，將字符串還原它原本的數據類型【有參】,接收的須要字符串而不是列表
#b = json.loads(l2)#錯誤，將字符串還原它原本的數據類型【有參】,接收的須要字符串而不是列表
c = json.loads(s1) #正確，接收的是字符串
#d = json.loads(s2) #錯誤，接收的是字符串，可是列表元素有一個元素是單引號
e = json.dumps(l1)#正確，將Python數據類型轉換成字符串【有參】
f = json.dumps(l2)#正確
g = json.dumps(s1)#正確
h = json.dumps(s2)#正確

38.http請求時，其本質返回的是什麼類型？

返回的字符串

 

39.書寫郵箱的正則表達式

[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

 

40.使用冒泡算法將li = [13,22,6,99,11] 進行排序

#!/usr/bin/env python
# -*- coding:utf-8 -*-
li = [13,22,6,99,11]
for i in range(1,len(li)):#檢查列表元素個數，建立一個對應的循環次數
    for v in range(len(li) - i):#len檢查li列表有多少個元素，將返回數-1當作參數傳入range建立成循環次數
        if li[v] > li[v + 1]:# 每次循環的次數和次數加1當作列表的索引取出列表的兩個元素，判斷第一個元素是否大於第二個元素
            hun = li[v]# 若是第一個元素大於第二個元素，將第一個元素賦值給一個變量
            li[v] = li[v + 1]# 將第一個元素等於第二個元素
            li[v + 1] = hun   # 將第二個元素等於賦值的huh變量，這樣第一元素和第二元素就進行互換位置
print(li)

 

41.簡述對象和類的關係

對象是由類建立的，處理對象的方法函數，在它所屬的類庫裏

 

二，conf後綴，haproxy配置文件處理

haproxy配置文件

global
        log 127.0.0.1 local2
        daemon
        maxconn 256
        log 127.0.0.1 local2 info
defaults
        log global
        mode http
        timeout connect 5000ms
        timeout client 50000ms
        timeout server 50000ms
        option  dontlognull

listen stats :8888
        stats enable
        stats uri       /admin
        stats auth      admin:1234

frontend oldboy.org
        bind 0.0.0.0:80
        option httplog
        option httpclose
        option  forwardfor
        log global
        acl www hdr_reg(host) -i www.oldboy.org
        use_backend www.oldboy.org if www

backend www.oldboy.org
        server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000
        
backend buy.oldboy.org
        server 100.1.7.90 100.1.7.90 weight 20 maxconn 3000

查找haproxy配置文件裏指定域名的數據信息

打開文件for循環出文件裏的每行，
判斷循環到的行是否等於要查找的域名，
若是循環到的行等於要查找的域名，說明已經找到要獲取域名的數據
將該域名的數據，追加到一個新列表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
def jsh(yum): #定義函數，接收傳入的域名
    a = "查找中" #定義判斷標記
    zfch = [] #建立一個空列表來接收查找到的數據
    with open("lof.conf", "r", encoding="utf-8") as f: #打開配置文件
        for i in f: #一行一行的循環出配置文件
            if  i.strip() == "backend %s" %(yum): #將循環到的每一行字符串移除首尾空白，判斷循環到的一行字符串若是等於backend www.oldboy.org
                a = "找到" #找到backend www.oldboy.org
                continue #跳出本次循環  繼續下次環
            if a == "找到": #判斷標記若是等於找到
                if i.strip().startswith("backend"): #判斷循環到的行數據是不是backend開頭
                    a = "查找中" #若是是backend開頭，就把判斷標記改成查找中
                    break #若是是backend開頭,說明是重複的數據，就break退出整個循環
                else: #若是不是backend開頭
                    if i.strip(): #判斷是不是空行
                        zfch.append(i.strip()) #若是不是空行，就把數據移除兩邊空格後，追加到接收列表
    return zfch #最後將接收列表返回給執行函數

zx = jsh("www.oldboy.org") #運行函數，傳入要查找的域名
print(zx) #打印出函數返回值
# 輸出
# ['server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000']

 添加haproxy配置文件裏指定域名的數據信息

先用上面的函數將原始數據拿到，放在一個列表裏

而後將要添加的數據，追加到原始數據列表，此時這個列表就是該域名下所有的新數據

而後同時打開兩個文件，以一讀一寫的方式打開，

循環原始文件，判斷循環到指定域名時，將域名的新數據從新寫入，

若是沒找到指定域名時，就將原始文件讀一行，往新文件裏寫一行

#!/usr/bin/env python
# -*- coding:utf-8 -*-
def jsh(yum): #定義函數，接收傳入的域名
    a = "查找中" #定義判斷標記
    zfch = [] #建立一個空列表來接收查找到的數據
    with open("lof.conf", "r", encoding="utf-8") as f: #打開配置文件
        for i in f: #一行一行的循環出配置文件
            if  i.strip() == "backend %s" %(yum): #將循環到的每一行字符串移除首尾空白，判斷循環到的一行字符串若是等於backend www.oldboy.org
                a = "找到" #找到backend www.oldboy.org
                continue #跳出本次循環  繼續下次環
            if a == "找到": #判斷標記若是等於找到
                if i.strip().startswith("backend"): #判斷循環到的行數據是不是backend開頭
                    a = "查找中" #若是是backend開頭，就把判斷標記改成查找中
                    break #若是是backend開頭,說明是重複的數據，就break退出整個循環
                else: #若是不是backend開頭
                    if i.strip(): #判斷是不是空行
                        zfch.append(i.strip()) #若是不是空行，就把數據移除兩邊空格後，追加到接收列表
    return zfch #最後將接收列表返回給執行函數

ym = "www.oldboy.org" #接收要修改的域名
shju = "server 100.1.7.11 100.1.7.11 weight 20 maxconn 3000" #接收要添加的數據

def chli(y,sh):
    shju2 = jsh(ym) #運行自定義函數獲取到該域名下的原有數據
    shju2.append(shju) #將要添加的數據，追加到原有數據列表
    cha = "查找中" #定義判斷標記
    with open("lof.conf", "r", encoding="utf-8") as w1, open("lof2.conf", "w", encoding="utf-8") as w2: #同時打開兩個文件，一個只讀打開，一個只寫打開
        for i in w1: #一行一行的循環出只讀文件
            if i.strip() == "backend {}".format(y): #判斷循環到的行去除先後空格後若是等於backend www.oldboy.org
                cha = "找到" #說明找到要查找的域名了，將判斷標記改成找到
                w2.write(i) #將當前行寫入新文件
                f4 = " "*8 #定義8個空格
                for i2 in shju2: #循環shju2數據列表
                    w2.write("{}{}{}".format(f4,i2,"\n")) #每循環一次將循環到的數據前加上8個空格寫入文件
                continue #退出本次循環，繼續下次循環
            else:
                pass
            if cha == "查找中": #判斷沒找到backend www.oldboy.org時，將循環到的行寫入新文件   
                w2.write(i) #將循環到的行寫入新文件
            else: #若是判斷標記不等於，查找中
                if i.strip().startswith("backend"): #判斷循環到的行是否有backend開頭的
                    cha = "查找中" #若是有backend開頭的，將判斷表示改成查找中
                    shuju2 = "{}{}".format("\n",i)  #將當前行前面加一個換行符
                    w2.write(shuju2) #將當前行寫入文件

chli(ym,shju)
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程