原文： https://www.cnblogs.com/wj-1314/p/8534245.html
1.有如下字符串：n = "路飞学城"（编程题）
- - 将字符串转换成utf-8的字符编码的字节，再将转换的字节重新转换为utf-8的字符编码的字符串
- - 将字符串转换成gbk的字符编码的字节，再将转换的字节重新转换为utf-8的字符编码的字符串
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | 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个字符，华 ，找到第二行的 实，删除最后一行 写入文件
| 1 2 3 | 桃之夭夭，灼灼其华。之子于归，宜其室家。
桃之夭夭，有蕡其实。之子于归，宜其家室。
桃之夭夭，其叶蓁蓁。之子于归，宜其家人。
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | 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，求出函数的执行时间，利用装饰器
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | 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
|
带参数的装饰器
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | # 带参数的装饰器
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.作用域
| 1 2 3 4 5 6 7 | def test():
print(luffy)
luffy = "the king of sea."
test()
# 结果：the king of sea.
|
| 1 2 3 4 5 6 7 8 | 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的功能
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | 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
# 10
# 12
# 14
# 16
# 18
# 18
# 16
# 6
print(res.__next__())
# 结果：2
|
6.打印日志11/26/2017 10:44:21 PM bug 24 并写入文件example.log中
| 1 2 3 4 5 6 | 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
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | 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，闭包
| 1 2 3 4 5 6 7 8 | def fun1():
n = 10
def fun2():
return n
return fun2
f=fun1()
print(f())
# 结果：10
|
9，生成器 迭代器
+ View Code
10，斐波那契数列
| 1 2 3 4 5 6 | 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()
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 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]
|
| 1 2 3 4 5 6 7 8 9 | res = map(lambda x:x*2,[1,2,3])
for i in res:
print(i)
# 结果：
# 2
# 4
# 6
print(list(res))
# 结果：[2, 4, 6]
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | 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
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | 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
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | 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模块
| 1 2 3 4 5 6 7 8 9 10 | 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
|
| 1 2 3 4 5 6 7 8 9 10 11 | 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模块
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | 得到当前工作目录，即当前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模块
| 1 2 3 4 5 6 7 8 9 10 11 12 | 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，作用域，范围
| 1 2 3 4 5 6 7 8 9 10 | 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的应用
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | # 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三个区别是什么？
| 1 2 3 4 5 6 7 | 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执行命令方式有几种？
| 1 2 3 4 5 6 7 | 三种执行命令的方法：
subprocess.run(*popenargs, input=None, timeout=None, check=False, **kwargs) #官方推荐
subprocess.call(*popenargs, timeout=None, **kwargs) #跟上面实现的内容差不多，另一种写法
subprocess.Popen() #上面各种方法的底层封装
|
24，为什么要设计好目录结构？
| 1 2 3 4 5 6 | 可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个
，测试目录在哪儿，配置文件在哪儿等等。从而非常快速的了解这个项目。
可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪个文件和代码应该放
在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，
仍然能够组织良好。
|
25，打印出命令行的第一个参数，例如：打印出 luffy
| 1 | python argument.py luffy
|
26，代码如下：
| 1 2 3 4 5 6 7 | '''
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模块),要求验证码中至少包含一个数字、一个小写字母、一个大写字母.
| 1 2 3 4 5 6 7 8 9 10 11 | # 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 ，内容如下
| 1 2 3 4 5 6 7 8 9 | <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>luffycity.com</title>
</head>
<body>
</body>
</html>
|
| 1 2 3 4 5 6 7 8 | # 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
+ View Code
31，把第30题三次验证的密码进行hashlib加密处理。即：json文件保存为md5的值，然后用md5的值进行验证
+ View Code
32，最近luffy买了个tesla，通过转账的形式，并且支付了5%的手续费，tesla价格为75万。文件为json，请用程序实现该转账行为。
需求如下：
（1） 目录结构为：
| 1 2 3 4 5 6 | .
├── account
│ ├── luffy.json
│ └── tesla.json
└── bin
└── start.py
|
当执行start.py时，出现交互窗口
| 1 2 3 | ------- Luffy Bank ---------
1. 账户信息
2. 转账
|
- 选择1 账户信息 显示luffy的当前账户余额。
- 选择2 转账 直接扣掉75万和利息费用并且tesla账户增加75万
33，对上题增加一个需求：提现。，目录结构如下：
| 1 2 3 4 5 6 7 | .
├── account
│ └── luffy.json
├── bin
│ └── start.py
└── core
└── withdraw.py
|
当执行start.py时，出现交互窗口
| 1 2 3 | ------- Luffy Bank ---------
1. 账户信息
2. 提现
|
- 选择1 账户信息 显示luffy的当前账户余额和信用额度。
- 选择2 提现 提现金额应小于等于信用额度，利息为5%，提现金额为用户自定义。
34，尝试把上一章的验证用户登陆的装饰器添加到提现和转账的功能上。
35，对第34题的用户转账、登录、提现操作均通过logging模块记录日志,日志文件位置如下
| 1 2 3 4 5 6 7 8 9 | .
├── 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之间的关系
| 1 2 3 4 5 | unicode 包含所有国家的字符编码
utf-8 可变长的字符编码，英文表示一个字节，中文表示三个字节
ascii 美国标志信息交换代码，是基于拉丁字母的一套电脑编码系统。
主要用于显示现代英语和其他西欧语言，一个字符占一个字节
gbk 全称，汉字内码扩展规范，一个字符占用两个字节
|
37，阅读代码，请写出执行结果
| 1 2 3 4 | 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
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | 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循环每一个元素？
| 1 2 3 4 5 6 7 8 9 10 11 | 是
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，开发敏感词语过滤程序，提示用户输入内容，如果用户输入的内容中包含特殊的字符：
如："苍老师"“东京热”，则将内容替换为***
| 1 2 3 4 5 6 7 | 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）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import time
def timer(func):
def decor(*args):
start_time = time.time()
func(*args)
end_time = time.time()
d_time = end_time - start_time
print("run the func use : ", d_time)
return decor
@timer #printSth = timer(printSth) -> printSth = decor
def printSth(str, count):
for i in range(count):
print("%d hello,%s!"%(i,str))
printSth("world", 1000000)#run the func use : 4.414000034332275
|
45：编写3个函数，每个函数执行的时间是不一样的，
提示：可以使用time.sleep(2)，让程序sleep 2s或更多，
46：编写装饰器，为每个函数加上统计运行时间的功能
提示：在函数开始执行时加上start=time.time()就可纪录当前执行的时间戳，函数执行结束后在time.time() - start就可以拿到执行所用时间
47：编写装饰器，为函数加上认证的功能，即要求认证成功后才能执行函数
48：编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
提示：从文件中读出字符串形式的字典，可以用eval('{"name":"egon","password":"123"}')转成字典格式
49,判断下列数据类型是可迭代对象or迭代器
| 1 2 3 4 5 6 | s='hello'
l=[1,2,3,4]
t=(1,2,3)
d={'a':1}
set={1,2,3}
f=open('a.txt')
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | s='hello' #字符串是可迭代对象，但不是迭代器
l=[1,2,3,4] #列表是可迭代对象，但不是迭代器
t=(1,2,3) #元组是可迭代对象，但不是迭代器
d={'a':1} #字典是可迭代对象，但不是迭代器
set={1,2,3} #集合是可迭代对象，但不是迭代器
f=open('test.txt') #文件是可迭代对象，但不是迭代器
#如何判断是可迭代对象，只有__iter__方法，执行该方法得到的迭代器对象。
# 及可迭代对象通过__iter__转成迭代器对象
from collections import Iterator #迭代器
from collections import Iterable #可迭代对象
print(isinstance(s,Iterator)) #判断是不是迭代器
print(isinstance(s,Iterable)) #判断是不是可迭代对象
#把可迭代对象转换为迭代器
print(isinstance(iter(s),Iterator))
|
50，字符串“Luffy”，将小写字母全部转换成大写字母，将大写字幕转换成小写字幕，然后输出到一个磁盘文件"test"中保存。
| 1 2 3 4 5 | info = 'Luffy'
res = info.swapcase()
f = open('test1.txt','w',encoding='utf-8')
f.write(res)
f.close()
|
3796
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
