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

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
# 10
# 12
# 14
# 16
# 18
# 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，生成器 迭代器

# 生成器:
s = (i for i in range(10))
print(next(s))
# 结果:0

# 迭代器:
def fun(n):
    x=0
    while(x<n):
        yield x
        x+=1
s = fun(3)
print(next(s))
print(s.__next__())
# 结果:0
# 1

from collections import Iterable,Iterator
print(isinstance({1,2,3},Iterable))
# 结果:True

s = iter([1,2,3,4,3,2,1])
print(s.__next__())
# 结果：
# 1
# 2
# 3
# 4
print(next(s))
# 结果：
# 1
# 2
# 3
# 4
for i in s:
    print(i)
# 结果：
# 1
# 2
# 3
# 4
# 3
# 2
# 1

10，斐波那契数列

def fun(x):
    n, a, b = 0, 0, 1
    while n < x:
        yield b
        a, b = b, a + b
        n += 1

　　结果：

res = fun(4)
# for i in res:
#     print(i)
# 结果：1
# 1
# 2
# 3

print(next(res))
print(next(res))
print(next(res))
print(next(res))
print(next(res))
# 结果：1
# 1
# 2
# 3
# StopIteration

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模块有几个日志级别？

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

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

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

# 20，请配置logging模块，使其在屏幕和文件里同时打印以下格式的日志
# 2017-10-18 15:56:26,613 - access - ERROR - account [1234] too many login attempts
import logging

logger = logging.getLogger('mylog')
logger.level = logging.INFO

# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('exer.log')
# 再创建一个handler，用于写入输出控制台
ch = logging.StreamHandler()
fh.level = logging.WARNING
ch.level = logging.ERROR

logger.addHandler(fh)
logger.addHandler(ch)

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(lineno)s %(message)s')

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.debug('too many login attempts')
logger.info('too many login attempts')
logger.warning('too many login attempts')
logger.error('too many login attempts')
logger.critical('too many login attempts')

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的作用是什么？

将内存的数据类型转化为字符串，使其能存储到硬盘上或者通过网络传输到远程，因为硬盘或者网络传输只接受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

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

[DEFAULT]

[client]
port = 3306
socket = /data/mysql_3306/mysql.sock

[mysqld]
explicit_defaults_for_timestamp
port = 3306
socket = /data/mysql_3306/mysql.sock
back_log = 80
basedir = /usr/local/mysql
tmpdir = /tmp
datadir = /data/mysql_3306
default-time-zone = '+8:00'

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

# _*_ coding: utf-8 _*_

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

import configparser

# 创建ConfigParser实例
config = configparser.ConfigParser()

# 读取配置文件
res = config.read('my.ini')
print(res)
config.set('mysqld','default-time-zone ','+00.00')
config.write(open('my.ini','w'))
# 设置sections节点中，键名为options的值
config.remove_option('mysqld','explicit_defaults_for_timestamp')
config.write(open('my.ini','w'))
config.set('DEFAULT','character-set-server ','utf8')
config.write(open('my.ini','w'))

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

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

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

# 12，写一个用户登录验证程序，文件如下：1234.json
# {"expire_date": "2021-01-01", "id": 1234, "status": 0, "pay_day": 22, "password": "abc"}
# 　　
# 用户名为json文件名，密码为 password。
# 判断是否过期，与expire_date进行对比。
# 登陆成功后，打印“登陆成功”，三次登陆失败，status值改为1，并且锁定账号。
import os
import json
import time

def user_login():
    retry_count = 0
    while retry_count<3:
        account = input('\033[32;1mplease input Acount:\033[0m').strip()
        password = input('\033[32;1mplease input Password:\033[0m').strip()
        load_file(account)
        access_auth(account,password)
        retry_count += 1
    else:
        update_file(account)
def access_auth(account,password):
    account_data = load_file(account)
    if account_data['status'] == 0:
        if account_data['password']  == password:
            expire_time = time.mktime(time.strptime(account_data['expire_date'],'%Y-%m-%d'))
            if time.time() > expire_time:        #如果信用卡已经过期，当前时间戳大于国企的时间戳
                print("\033[31;1mAccount %s had expired,Please contract the bank"%account)
                exit()
            else:       #信用卡未过期，返回用户数据的字典
                return account_data
        else:
            print("\033[31;1mAccount or Passwordoes not correct!\033[0m")
    else:
        print("\033[31;1mAccount already be lock\033[0m")
        exit()
def load_file(account):
    file_name = '%s.json'%account
    if os.path.isfile(file_name):
        with open(file_name,'r',encoding='utf-8') as f:
            acc_data = json.load(f)
            return acc_data
    else:
        print("file [%s] does not exist"%account)
        exit()

def update_file(account):
    account_data = load_file(account)
    print(account_data)
    account_data['status'] =1
    print(account_data)
    file_name = '%s.json' % account
    with open(file_name, 'w', encoding='utf-8') as f:
        acc_data = json.dump(account_data, f)

user_login()

import json,time

count = 0
data = json.load(open('1234.json','r',encoding='utf-8'))
_username = '1234.json'
_password = data['password']
time_json = time.mktime(time.strptime(data['expire_date'],'%Y-%m-%d'))
time_now = time.time()
while count < 3:
    if data['status'] == 1:
        print('账号已锁定！')
        break
    elif time_now > time_json:
        print('账号已过期！')
        break
    else:
        name = input('name:').strip()
        password = input('password:').strip()
        if name == _username and password == _password:
            print('登录成功！')
            break
        else:
            print('请重新输入')
        count += 1
else:
    data['status'] = 1
    json.dump(data,open('1234.json','w',encoding='utf-8'))

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

{"expire_date": "2019-03-01", "id": 1234, "status": 0, "pay_day": 22, "password": "900150983cd24fb0d6963f7d28e17f72"}
import json,time,hashlib

count = 0
data = json.load(open('1234.json','r',encoding='utf-8'))
_username = '1234.json'
_password = data['password'] #abc
time_json = time.mktime(time.strptime(data['expire_date'],'%Y-%m-%d'))
time_now = time.time()
while count < 3:
    if data['status'] == 1:
        print('账号已锁定！')
        break
    elif time_now > time_json:
        print('账号已过期！')
        break
    else:
        name = input('name:').strip()
        password = input('password:').strip()
        if name == _username:
            m = hashlib.md5()
            m.update(password.encode())
            if m.hexdigest() == _password:
                print('登录成功！')
                break
        else:
            print('请重新输入')
        count += 1
else:
    data['status'] = 1
    json.dump(data,open('1234.json','w',encoding='utf-8'))

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)

 

执行结果：

1 alex
2 Alex

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，什么是迭代？

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

41，请用代码实现：

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

strr = "alexericrain"
pinjie = '_'.join(strr)
print(type(pinjie),pinjie)
# <class 'str'> a_l_e_x_e_r_i_c_r_a_i_n

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

li = ['alex','eric','rain']
pinjie = '_'.join(li)
print(type(pinjie),pinjie)
# <class 'str'> alex_eric_rain

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，　请分别介绍文件操作中不同的打开方式之间的区别：

模式    含义
r    文本只读模式
rb    二进制模式 这种方法是用来传输或存储，不给人看的
r+    读写模式，只要有r，那么文件必须存在
rb+    二进制读写模式
w    只写模式，不能读，用w模式打开一个已经存在的文件，如果有内容会清空，重新写
wb    以二进制方式打开，只能写文件，如果不存在，则创建
w+    读写模式，先读后写，只要有w，会清空原来的文件内容
wb+    二进制写读模式
a    追加模式，也能写，在文件的末尾添加内容
ab    二进制追加模式
a+    追加模式，如果文件不存在，则创建文件，如果存在，则在末尾追加
ab+    追读写二进制模式，从文件顶部读取文件，从文件底部添加内容，不存在则创建

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

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迭代器

s='hello'
l=[1,2,3,4]
t=(1,2,3)
d={'a':1}
set={1,2,3}
f=open('a.txt')

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"中保存。

info = 'Luffy'
res = info.swapcase()
f = open('test1.txt','w',encoding='utf-8')
f.write(res)
f.close()

51，Python中print(__doc__)的作用

　　作用：输出文件开头注释的内容

举例：

　　momodule.py

"""This is the module docstring."""

def f(x):
    """This is the function docstring."""
    return 2 * x

　　执行

>>> import mymodule
>>> mymodule.__doc__
'This is the module docstring.'
>>> mymodule.f.__doc__
'This is the function docstring.'