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'
- 修改时区 default-time-zone = '+8:00' 为 校准的全球时间 +00:00
- 删除 explicit_defaults_for_timestamp
- 为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"}
- 用户名为json文件名,密码为 password。
- 判断是否过期,与expire_date进行对比。
- 登陆成功后,打印“登陆成功”,三次登陆失败,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, 请分别介绍文件操作中不同的打开方式之间的区别:
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.'