原文: 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()
|
Python 闯关之路二(模块的应用)相关推荐
- Python 闯关之路一(语法基础)
原文:https://www.cnblogs.com/wj-1314/p/8403977.html python 闯关之路一(语法基础) 1,什么是编程?为什么要编程? 答:编程是个动词,编程就等于写 ...
- python使用什么注释语句和运算-python 闯关之路一(语法基础)
1,什么是编程?为什么要编程? 答:编程是个动词,编程就等于写代码,那么写代码是为了什么呢?也就是为什么要编程呢,肯定是为了让计算机帮我们搞事情,代码就是计算机能理解的语言. 2,编程语言进化史是什么 ...
- python闯关游戏,Python挑战游戏( PythonChallenge)闯关之路Level 0
Python挑战游戏( PythonChallenge)闯关之路Level 0 Python挑战游戏( PythonChallenge)闯关之路Level 0 关卡入口地址:http://www.py ...
- python闯关训练营怎么样3.0_泡着枸杞写bug的三流程序员凭什么逆袭到一线大厂?...
大多数互联网的从业者都有一个梦想:进大厂. 因为不仅可以享受较好的福利待遇,也能与更优秀的人一起共事,获得更专业.更快速的成长. 最近经常有朋友提及想要入门编程学习,该如何学习? 关于编程学习,各种语 ...
- 小学生蓝桥杯Python闯关 | 汇总
学习Python从娃娃抓起!记录下蓝桥杯Python学习和备考过程中的题目,记录每一个瞬间. 1.小学生蓝桥杯Python闯关 | 获取字符串的最后一个字符_COCOgsta的博客-CSDN博客 2. ...
- 思维导图 XMind 闯关之路(第03关)插入图片
本系列文章 主要是XMind软件的 一个基础教程,文章总纲链接:专题分纲目录 思维导图 XMind 闯关之路 这里依然以我们以上一关 关卡测试为基础,能够做到: 1 子分支插入图片 接下来我们开始 在 ...
- 专题分纲目录 思维导图 XMind 闯关之路
专题分纲目录 均为索引,本纲为:思维导图 XMind 闯关之路 系列文章目录 思维导图 XMind 闯关之路(启动)下载和安装 思维导图 XMind 闯关之路(第01关)新建文件 & 建立分支 ...
- 思维导图 XMind 闯关之路(第05关)插入外框概要
本系列文章 主要是XMind软件的 一个基础教程,文章总纲链接:专题分纲目录 思维导图 XMind 闯关之路 这里依然以我们以上一关 关卡测试为基础,能够做到: 1 插入外框 接下来我们开始 在一个子 ...
- 思维导图 XMind 闯关之路(第01关)新建文件 建立分支
本系列文章 主要是XMind软件的 一个基础教程,文章总纲链接:专题分纲目录 思维导图 XMind 闯关之路 特殊说明:我们是使用mac版的 XMind8 进行演示.windows版本也是类似,只是稍 ...
最新文章
- AI一分钟 | 小鹏汽车回应前苹果员工窃取商业机密:积极配合相关调查
- 微型计算机的发展通常以为技术指标,计算机组成原理期末复习题.doc
- 内存分配的几个函数的简单对比分析
- Python基础教程(三):运算符、条件语句
- 如何查看header object和category 03的IBASE的relationship关系
- JS关键字和保留字汇总
- angularjs跨页面传参遇到的一些问题
- 【Android】Intent传递对象(序列化)
- Linux系统下多版本gcc使用问题记录
- 使用.tar文件 升级cisco 3550 IOS
- lema刻字机_Chris Lema访谈– WordPress业务
- win10系统怎么改奇摩输入法_windows10如何更改输入法
- centos 6.8 安装mysql
- 移动前端开发与web前端开发的区别
- 龙芯3A3000和龙芯3B3000芯片处理器参数介绍
- 如何去除win 10右键菜单的“使用skype共享”
- w ndows读音,汉字读音及音标 - 51windows.Net
- origin画图工具使用,去除注释的方框和图例的红色线框,x轴标注旋转
- 传统行业如何在互联网时代转型
- 数分笔记整理25 - 数据处理项目 - 中国城市资本流动问题探索
热门文章
- fl studio中文官网20.8中文版本新增中文语言更新内容详情
- 支付宝APP用户提现,商家转账给支付宝功能
- 工业网关+云平台赋能分布式风电能源物联网:降本升效
- mysql性能优化——生产实际问题场景举证分析
- FreeMarker知识点(初学用)
- 直播平台搭建|实现完整直播流程,考验直播平台性能
- 区块链政策法律研究组成立会在京召开
- 将数据批量导入PL SQL的方法
- 三星旗舰优惠千八,苹果优惠过千,国产旗舰只降五百打发叫花子
- 运维、监控、AIOps的几个重要观点