Python 闯关之路二（模块的应用）

最新推荐文章于 2023-04-24 15:55:11 发布

yaoyao4959

最新推荐文章于 2023-04-24 15:55:11 发布

阅读量510

点赞数

分类专栏： Python

Python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

原文： https://www.cnblogs.com/wj-1314/p/8534245.html

1.有如下字符串：n = "路飞学城"（编程题）

- 将字符串转换成utf-8的字符编码的字节，再将转换的字节重新转换为utf-8的字符编码的字符串
- 将字符串转换成gbk的字符编码的字节，再将转换的字节重新转换为utf-8的字符编码的字符串

n = '路飞学诚'

print(n.encode('utf-8'))

# b'\xe8\xb7\xaf\xe9\xa3\x9e\xe5\xad\xa6\xe8\xaf\x9a'

print(n.encode('utf-8').decode('utf-8'))

# 路飞学诚

print(n.encode('gbk'))

# b'\xc2\xb7\xb7\xc9\xd1\xa7\xb3\xcf'

print(n.encode('gbk').decode('gbk'))

# 路飞学诚

print(n.encode('gbk').decode('gbk').encode('utf-8'))

# b'\xe8\xb7\xaf\xe9\xa3\x9e\xe5\xad\xa6\xe8\xaf\x9a'

print(n.encode('gbk').decode('gbk').encode('utf-8').decode('utf-8'))

# 路飞学诚

2，读文件找到第9个字符，华，找到第二行的实，删除最后一行写入文件

桃之夭夭，灼灼其华。之子于归，宜其室家。

桃之夭夭，有蕡其实。之子于归，宜其家室。

桃之夭夭，其叶蓁蓁。之子于归，宜其家人。

f = open('poem.txt', 'r+', encoding='utf-8')

f.seek(3*8)

print(f.read(1))

f.seek(3*28+2)

print(f.read(1))

data_list = f.readlines()

print(data_list)

data_list.pop()

print(data_list)

f.seek(0)

f.truncate()

f.write(''.join(data_list))

3，求出函数的执行时间，利用装饰器

import time

def time_func(func):

def wrapper(*args,**kwargs):

time_start = time.time()

func(*args,**kwargs)

time_end = time.time()

print(time_end-time_start)

return wrapper

@time_func

def x(a,b):

time.sleep(1)

return a+b

x(1,8)

# 结果：1.0001220703125

带参数的装饰器

# 带参数的装饰器

import time

def show_timw(func):

def wrapper(a,b):

start_time = time.time()

ret = func(a,b)

end_time = time.time()

print("消耗时间为：%s" %(end_time-start_time))

return ret

return wrapper

@show_timw

def add(a,b):

time.sleep(1)

return a+b

print(add(48,45))

# 结果：

# 消耗时间为：1.0008337497711182

# 93

4.作用域

def test():

print(luffy)

luffy = "the king of sea."

test()

# 结果：the king of sea.

def test():

print(luffy)

luffy = 'e'

test()

luffy = "the king of sea."

test()

　　两个test都会报错，因为在定义变量之前已经调用变量了，所以错误

5，li = [1,2,3,5,5,6,7,8,9,9,8,3] 利用生成器功能，写一个所有数值乘以2的功能

li = [1,2,3,5,5,6,7,8,9,9,8,3]

res = (i*2 for i in li)

# print(list(res))

# 结果：[2, 4, 6, 10, 10, 12, 14, 16, 18, 18, 16, 6]

# print(next(res))

# 结果：2（一次取一个值）

for i in res:

print(i)

# 结果：2

# 4

# 6

# 10

# 12

# 14

# 16

# 18

# 16

# 6

print(res.__next__())

# 结果：2

6.打印日志11/26/2017 10:44:21 PM bug 24 并写入文件example.log中

import logging

logging.basicConfig(filename='example.log', format='%(asctime)s - %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p', level=logging.DEBUG)

logging.warning('bug 24')

# 文件内容：

# 03/24/2018 08:52:36 PM - bug 24

7，json和pickle

import json,pickle # json 可序列化的有 int str list tuple dict 没有集合

# pickle 可序列化python所有数据类型包括函数 pickle 可序列化一些类但类需要引用

li = [1,2,3]

dict = {1,2,3}

def fun():

return 3

str_data = json.dumps(li)

print(type(str_data),str_data)

# 结果：<class 'str'> [1, 2, 3]

list_data = json.loads(str_data)

print(list_data,type(list_data))

# 结果：[1, 2, 3] <class 'list'>

s = pickle.dumps(li)

print(s,type(s))

# 结果：b'\x80\x03]q\x00(K\x01K\x02K\x03e.' <class 'bytes'>

data = pickle.loads(s)

print(data,type(data))

# 结果：[1, 2, 3] <class 'list'>

with open('test.txt','w',encoding='utf-8') as f:

json.dump(li,f)

data = json.load(open('test.txt','r',encoding='utf-8'))

print(data,type(data))

# 结果：[1, 2, 3] <class 'list'>

pickle.dump(li,open('test1.txt','wb'))

data = pickle.load(open('test1.txt','rb'))

print(data,type(data))

# 结果：[1, 2, 3] <class 'list'>

pickle.dump(fun,open('test2.txt','wb'))

data = pickle.load(open('test2.txt','rb'))

print(data())

# 结果：3

8，闭包

def fun1():

n = 10

def fun2():

return n

return fun2

f=fun1()

print(f())

# 结果：10

9，生成器迭代器

+ View Code

10，斐波那契数列

def fun(x):

n, a, b = 0, 0, 1

while n < x:

yield b

a, b = b, a + b

n += 1

　　结果：

+ View Code

11，map filter globals() locals() hash()

print(globals())

# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':

# <_frozen_importlib_external.SourceFileLoader object at 0x0000017306D6B080>, '__spec__':

# None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,

# '__file__':

# 'D:/exer.py', '__cached__': None}

print(locals())

# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':

# <_frozen_importlib_external.SourceFileLoader object at 0x0000017306D6B080>, '__spec__':

# None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,

# '__file__': 'D:/exer.py', '__cached__': None}

n1=[1,2,3]

def fun():

n1[1] ='123'

return n1

print(fun())

# 结果：[1, '123', 3]

print('n1是什么: ',n1)

# 结果：n1是什么: [1, '123', 3]

res = map(lambda x:x*2,[1,2,3])

for i in res:

print(i)

# 结果：

# 2

# 4

# 6

print(list(res))

# 结果：[2, 4, 6]

res = filter(lambda x:x%2==0,list(range(10)))

# for i in res:

# print(i)

# 结果：

# 0

# 2

# 4

# 6

# 8

print(res.__next__())

# 结果： 0

print(next(res))

# 结果： 0

print(hash((1,2,3))) # 只有不可变的才可哈希 int str tuple 如：list dict set 不能被哈希

# 结果：2528502973977326415

12，三目匿名 lambda

a = 2

b = 5

print(a if a>b else b)

# 结果：5

res =lambda a,b: a if a>b else b

print(res(2,3))

# 结果：3

fun = lambda x,y:x+y

print(fun(2,3))

# 结果：5

fun = lambda x,y:x if x>y else y

print(fun(2,3))

# 结果：3

res = map(lambda x:x*x,list(range(5)))

for i in res:

print(i)

# 结果：

# 0

# 1

# 4

# 9

# 16

fun = lambda x,y:x/y if x>y else x*y

print(fun(4,3))

# 结果：1.3333333333333333

13，time datetime

import time

import datetime

print(time.time())

# 结果：1521903163.3908226

print(time.asctime())

# 结果：Sat Mar 24 22:52:43 2018

print(time.gmtime())

# 结果：time.struct_time(tm_year=2018, tm_mon=3, tm_mday=24, tm_hour=14, tm_min=52, tm_sec=43, tm_wday=5, tm_yday=83, tm_isdst=0)

print(time.strftime('%Y-%m-%d %I:%M:%S %p',time.localtime()))

# 结果： 2018-03-24 10:52:43 PM

str_time =time.strftime('%Y-%m-%d %I:%M:%S %p',time.localtime())

# print(str_time)

# 结果：2018-03-24 10:52:43 PM

res = time.strptime(str_time,'%Y-%m-%d %I:%M:%S %p')

print(res)

# 结果：time.struct_time(tm_year=2018, tm_mon=3, tm_mday=24, tm_hour=22, tm_min=55, tm_sec=10, tm_wday=5, tm_yday=83, tm_isdst=-1)

print(time.mktime(res))

# 结果：1521903326.0

res =datetime.datetime.now() + datetime.timedelta(days=2,hours=3)

print(res)

# 结果：2018-03-27 01:55:43.520904

res1 = datetime.datetime.now().replace(year=2015,month=2,day=2)

print(res1)

# 结果：2015-02-02 22:55:58.174786

print(datetime.date.fromtimestamp(time.time()))

# 结果：2018-03-24

print(random.randint(1,3)) # 会包含3

print(random.randrange(1,3)) # 不会包含3

print(random.random())

print(random.choice('123123'))

14，random模块

import random

print(random.randint(1,3)) # 会包含3

print(random.randrange(1,3)) # 不会包含3

print(random.random())

print(random.choice('123123'))

# 结果：

# 3

# 1

# 0.8458542042848031

# 1

import string

# digits：获取所有的10进制数字字符

# punctuation：获取所有的标点符号

# ascii_letters：获取所有ascii码中字母字符的字符串（包含大写和小写）

print(''.join(random.sample(string.digits+string.punctuation+string.ascii_letters,6)))

# 结果：.uim4D

li = list(range(10))

random.shuffle(li)

print(li)

# 结果： [5, 2, 1, 7, 6, 3, 4, 8, 0, 9]

15，os模块

得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()

返回指定目录下的所有文件和目录名:os.listdir()

函数用来删除一个文件:os.remove()

删除多个目录：os.removedirs（r“c：\python”）

检验给出的路径是否是一个文件：os.path.isfile()

检验给出的路径是否是一个目录：os.path.isdir()

判断是否是绝对路径：os.path.isabs()

检验给出的路径是否真地存:os.path.exists()

返回一个路径的目录名和文件名:os.path.split() e.g os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt')

分离扩展名：os.path.splitext() e.g os.path.splitext('/usr/local/test.py') 结果：('/usr/local/test', '.py')

获取路径名：os.path.dirname()

获得绝对路径: os.path.abspath()

获取文件名：os.path.basename()

运行shell命令: os.system()

读取操作系统环境变量HOME的值:os.getenv("HOME")

返回操作系统所有的环境变量： os.environ

设置系统环境变量，仅程序运行时有效：os.environ.setdefault('HOME','/home/alex')

给出当前平台使用的行终止符:os.linesep Windows使用'\r\n'，Linux and MAC使用'\n'

指示你正在使用的平台：os.name 对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'

重命名：os.rename（old， new）

创建多级目录：os.makedirs（r“c：\python\test”）

创建单个目录：os.mkdir（“test”）

获取文件属性：os.stat（file）

修改文件权限与时间戳：os.chmod（file）

获取文件大小：os.path.getsize（filename）

结合目录名与文件名：os.path.join(dir,filename)

改变工作目录到dirname: os.chdir(dirname)

获取当前终端的大小: os.get_terminal_size()

杀死进程: os.kill(10884,signal.SIGKILL)

16，sys模块

sys.argv 命令行参数List，第一个元素是程序本身路径

sys.exit(n) 退出程序，正常退出时exit(0)

sys.version 获取Python解释程序的版本信息

sys.maxint 最大的Int值

sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform 返回操作系统平台名称

sys.stdout.write('please:') #标准输出 , 引出进度条的例子，注，在py3上不行，可以用print代替

val = sys.stdin.readline()[:-1] #标准输入

sys.getrecursionlimit() #获取最大递归层数

sys.setrecursionlimit(1200) #设置最大递归层数

sys.getdefaultencoding() #获取解释器默认编码

sys.getfilesystemencoding #获取内存数据存到文件里的默认编码

17，作用域，范围

x = 10

def add(a, b=x):

return a + b

ret = add(10)

print(ret) # 输出 20

x = 20

ret = add(10)

print(ret) # 输出 20 不是30 注意模块执行的流程从上到下

18，lambda的应用

# 2.lambda 的应用

# ---CASE 1

fs = map(lambda i:(lambda j: i*j), range(6))

print([f(2) for f in fs])

#---CASE 2

fs = [lambda j:i*j for i in range(6)]

print([f(2) for f in fs])

#---CASE 3

fs = []

for i in range(6):

fs.append(lambda j:i*j)

if i==3:

break

print([f(2) for f in fs])

#---CASE 4

fs = [(lambda i:lambda j:i*j)(i) for i in range(6)]

print([f(2) for f in fs])

# 结果：

# [0, 2, 4, 6, 8, 10]

# [10, 10, 10, 10, 10, 10]

# [6, 6, 6, 6]

# [0, 2, 4, 6, 8, 10]

19，logging模块有几个日志级别？

1 2	`总共有5个级别，默认级别是WARNING，` `按照级别高低分别为CRITICAL ERROR WARNING INFO DEBUG`

20，请配置logging模块，使其在屏幕和文件里同时打印以下格式的日志

1	`2017-10-18` `15:56:26,613` `-` `access` `-` `ERROR` `-` `account [1234] too many login attempts`

+ View Code

21，json，pickle，shelve三个区别是什么？

json：转化的数据类型，int str list tuple dict 不支持set

json只可以用于字符串或者字典等与python数据类型之间的序列化与反序列化之间的操作

pickle：支持python里面所有的数据类型，只能在python里使用，函数也可以序列化

pickle可以用于python类有类型与python数据类型之间的序列化与反序列化的操作

shelve：pickle封装了shelve，只能在python里使用，也就是说shelve对pickle进行了包装，是一个键值对的形式，shelve模块很简单，只有一个open函数

22，json的作用是什么？

1 2	`将内存的数据类型转化为字符串，使其能存储到硬盘上或者通过网络传输到远程，因为硬盘或者网络传输只接受bytes类型。` `JSON不仅是标准格式，而且比XML更快，而且可以在web页面直接读取，非常方便。`

23，subprocess执行命令方式有几种？

三种执行命令的方法：

subprocess.run(*popenargs, input=None, timeout=None, check=False, **kwargs) #官方推荐

subprocess.call(*popenargs, timeout=None, **kwargs) #跟上面实现的内容差不多，另一种写法

subprocess.Popen() #上面各种方法的底层封装

24，为什么要设计好目录结构？

可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个

，测试目录在哪儿，配置文件在哪儿等等。从而非常快速的了解这个项目。

可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪个文件和代码应该放

在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，

仍然能够组织良好。

25，打印出命令行的第一个参数，例如：打印出 luffy

1	`python argument.py luffy`

26，代码如下：

'''

Linux当前目录/usr/local/nginx/html/

文件名：index.html

'''

import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(index.html)))

print(BASE_DIR)

打印的内容是什么？ nginx
os.path.dirname和os.path.abspath含义是什么？
目录名，绝对路径

27，通过configparser模块完成以下功能

文件名my.ini

+ View Code

修改时区 default-time-zone = '+8:00' 为校准的全球时间 +00:00
删除 explicit_defaults_for_timestamp
为DEFAULT增加一条 character-set-server = utf8

+ View Code

28，写一个6位随机验证码程序（使用random模块),要求验证码中至少包含一个数字、一个小写字母、一个大写字母.

# 10，写一个6位随机验证码程序（使用random模块),

# 要求验证码中至少包含一个数字、一个小写字母、一个大写字母.

import random

import string

# ascii_letters:获取所有ascii码中字母字符的字符串（包含大写和小写）

# digits:获取所有的10进制数字字符

res = ''.join(random.sample(string.digits+string.ascii_letters,6))

# res = ''.join(random.sample(string.ascii_lowercase + string.digits, 6))

print(res)

29，利用正则表达式提取到 luffycity.com ，内容如下

<!DOCTYPE html>

<html lang="en">

<head>

<meta charset="UTF-8">

<title>luffycity.com</title>

</head>

<body>

</body>

</html>

# 11，利用正则表达式提取到 luffycity.com ，内容如下

import re

with open('str.txt','r',encoding='utf-8') as f:

data = f.read()

print(data)

res = re.search('\w+\.com',data).group()

print("结果 ",res)

30，写一个用户登录验证程序，文件如下：1234.json

1	`{"expire_date":` `"2021-01-01",` `"id":` `1234,` `"status":` `0,` `"pay_day":` `22,` `"password":` `"abc"}`

用户名为json文件名，密码为 password。
判断是否过期，与expire_date进行对比。
登陆成功后，打印“登陆成功”，三次登陆失败，status值改为1，并且锁定账号。

+ View Code

31，把第30题三次验证的密码进行hashlib加密处理。即：json文件保存为md5的值，然后用md5的值进行验证

+ View Code

32，最近luffy买了个tesla，通过转账的形式，并且支付了5%的手续费，tesla价格为75万。文件为json，请用程序实现该转账行为。
需求如下：

（1）目录结构为：

.

├── account

│ ├── luffy.json

│ └── tesla.json

└── bin

└── start.py

　　当执行start.py时，出现交互窗口

------- Luffy Bank ---------

1. 账户信息

2. 转账

选择1 账户信息显示luffy的当前账户余额。
选择2 转账直接扣掉75万和利息费用并且tesla账户增加75万

33，对上题增加一个需求：提现。，目录结构如下：

.

├── account

│ └── luffy.json

├── bin

│ └── start.py

└── core

└── withdraw.py

当执行start.py时，出现交互窗口

------- Luffy Bank ---------

1. 账户信息

2. 提现

选择1 账户信息显示luffy的当前账户余额和信用额度。
选择2 提现提现金额应小于等于信用额度，利息为5%，提现金额为用户自定义。

34，尝试把上一章的验证用户登陆的装饰器添加到提现和转账的功能上。

35，对第34题的用户转账、登录、提现操作均通过logging模块记录日志,日志文件位置如下

.

├── account

│ └── luffy.json

├── bin

│ └── start.py

└── core

| └── withdraw.py

└── logs

└── bank.log

30-35题的答案见：http://www.cnblogs.com/wj-1314/p/7501455.html

36，简述ascii，unicode，utf-8，gbk之间的关系

unicode 包含所有国家的字符编码

utf-8 可变长的字符编码，英文表示一个字节，中文表示三个字节

ascii 美国标志信息交换代码，是基于拉丁字母的一套电脑编码系统。

主要用于显示现代英语和其他西欧语言，一个字符占一个字节

gbk 全称，汉字内码扩展规范，一个字符占用两个字节

37，阅读代码，请写出执行结果

1 a = "alex"

2 b = a.capitalize()

3 print(a)

4 print(b)

+ View Code

38，写代码，有如下变量，请按照要求实现每个功能

name="aleX"

a.移除 name 变量对应的值两边的空格，并输入移除后的内容
b.判断 name 变量对应的值是否以"al"开头，并输出结果
c.判断 name 变量对应的值是否以"X"结尾，并输出结果
d.将 name 变量对应的值中的“l”替换为“p”，并输出结果
e.将 name 变量对应的值根据“l”分割，并输出结果。
f.请问，上一题e分割之后得到值是什么类型（可选）
g.将 name 变量对应的值变大写，并输出结果
h.将 name 变量对应的值变小写，并输出结果
i.请输出 name 变量对应的值的第 2 个字符？
j.请输出 name 变量对应的值的前 3 个字符？
k.请输出 name 变量对应的值的后 2 个字符？
l.请输出 name 变量对应的值中“e”所在索引位置？
m.获取子序列，仅不包含后一个字符。如：oldboy则获取oldbo;root则获取roo

a.移除 name 变量对应的值两边的空格，并输入移除后的内容

print(name.strip()) #aleX

b.判断 name 变量对应的值是否以"al"开头，并输出结果

print(name.startswith('al')) #False

c.判断 name 变量对应的值是否以"X"结尾，并输出结果

print(name.endswith('X')) #False

d.将 name 变量对应的值中的“l”替换为“p”，并输出结果

print(name.replace('l','p')) #apeX

e.将 name 变量对应的值根据“l”分割，并输出结果。

print(name.split('l')) #['a', 'eX']

f.请问，上一题e分割之后得到值是什么类型（可选）

print(type(name.split('l'))) #<class 'list'>

g.将 name 变量对应的值变大写，并输出结果

print(name.upper()) #ALEX

h.将 name 变量对应的值变小写，并输出结果

print(name.lower()) #alex

i.请输出 name 变量对应的值的第 2 个字符？

print(name[1:2]) #l

j.请输出 name 变量对应的值的前 3 个字符？

print(name[:3]) #ale

k.请输出 name 变量对应的值的后 2 个字符？

print(name[-2:]) #eX

l.请输出 name 变量对应的值中“e”所在索引位置？

print(name.index('e')) #2

m.获取子序列，仅不包含后一个字符。如：oldboy则获取oldbo;root则获取roo

n1 = "oldboy"

n2 = n1.strip('y')

print(n2) #oldbo

39，字符串是否可以迭代对象？如可以请使用for循环每一个元素？

是

name = 'study'

for i in name:

print(i)

# 结果：

# s

# t

# u

# d

# y

40，什么是迭代？

1 2	`利用for循环来遍历一个列表（list）或元祖（tuple），将值依次取出，这种方法我们称为迭代` `利用for语句迭代字符串，创建一个字符串，name` `=` `"deidai",然后用for语句进行迭代。`

41，请用代码实现：

a，利用下划线将列表的每一个元素拼接成字符串，strr＝"alexericrain"

+ View Code

b.利用下划线将列表的每一个元素拼接成字符串，li＝['alex','eric','rain']

+ View Code

42，开发敏感词语过滤程序，提示用户输入内容，如果用户输入的内容中包含特殊的字符：
如："苍老师"“东京热”，则将内容替换为***

sentence_input = input("请输入：")

sensitive_varcabulary1 = str.maketrans("苍老师",'***')

sensitive_varcabulary2 = str.maketrans("东京热",'***')

new_sentence = sentence_input.translate(sensitive_varcabulary1).translate(sensitive_varcabulary2)

print(new_sentence)

# 请输入：dads大大的苍老师

# dads大大的***

43，　请分别介绍文件操作中不同的打开方式之间的区别：

44，什么是装饰器？写一个装饰器，可以打印输出方法执行时长的信息。
　　装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
　　这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
　　我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。