一，基础题
1.计算100-300之间，所有能被3和7整除的，所有数之和
#!/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.定义函数统计一个字符串中大写字母，小写字母，数字的个数，并返回结果
#!/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'xe8x80x81xe7x94xb7xe4xbaxba'
5.如何计算数字绝对值
#!/usr/bin/env python # -*- coding:utf8 -*- a = 123456 #创建数字类型 b = abs(a) #取数字的绝对值,也就是无论是正数还是负数取它的绝对值 print(b) #打印出绝对值 # 输出 # 123456
6.简述深浅拷贝原理
浅拷贝值拷贝外层
深拷贝除最底层外都拷贝
7.举例布尔值为False的值
布尔值False 为空，一切返回为空的为False，如：空字符串，空列表，空字典，空元祖，数字类型0，None等空值的为False
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/sevenlibin
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("ad+", "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," ")) #每循环一次将循环到的数据前加上8个空格写入文件 continue #退出本次循环，继续下次循环 else: pass if cha == "查找中": #判断没找到backend www.oldboy.org时，将循环到的行写入新文件 w2.write(i) #将循环到的行写入新文件 else: #如果判断标记不等于，查找中 if i.strip().startswith("backend"): #判断循环到的行是否有backend开头的 cha = "查找中" #如果有backend开头的，将判断表示改为查找中 shuju2 = "{}{}".format(" ",i) #将当前行前面加一个换行符 w2.write(shuju2) #将当前行写入文件 chli(ym,shju)