[已解决]局部/全局变量问题——20讲内嵌函数闭包课后习题1

sjyabd

建议回到小甲鱼原帖参考标准答案：https://fishc.com.cn/thread-42685-1-1.html
小甲鱼留的该课后习题内容为：
1. 请用已学过的知识编写程序，找出小甲鱼藏在下边这个长字符串中的密码，密码的埋藏点符合以下规律：
    a) 每位密码为单个小写字母
    b) 每位密码的左右两边均有且只有三个大写字母

小甲鱼给出的答案思路是通过islower() isupper()语句
多次判定每个字符前后大写字母的数量来确定是否满足条件


我自己想的思路也是通过islower/upper语句，但是是将所有的字母通过他们的位置参数转化为数字的数学问题。假设小甲鱼给的超长字符串为小写字母l。我想将满足条件的位置参数值留下，不满足的剔除。最终保留下来的参数放在另一列表l_filtered中。再通过For each in l_filtered, l[each]的方法挨个读取到符合条件的字符，并打印出来。

可是我感觉我的代码好像没法正确显示最终的结果，有些字符没有被正常删去。我猜想是关于局部/全局变量的原因。我在程序的最外层添加了各个列表，例如l_filtered1, l_filtered2, ll来存放不同的数据，但是我在for循环中修改是不是没法对身为全局变量的这些列表内容进行正常修改呢？所以导致最终的结果有出入？这是我自己的理解，但是不知道是否正确，从开始做这道题，到现在一共想了两天加起来四五个小时了。。还是没能想到解决办法。。不得不来求助大家。。

我在下面自己的代码尽可能的多加注释，希望能帮助大家理解我的思路，并指正我的错误。。谢谢

l = '''ACFlCTLIQlAIVMTqHFkswqbDDHtpgcWaXSSglUYKE
lqNsYCyaQXBzrFUbkAUAWAKrDgDtAlGMBqWQhpEwquZqWZJpslUfMllCwWptqINjrOBTLuPzwvXNbLCx
oFRritKRpJgBOaGPZdkUzvYnvYmAlEsVmKRXqyQUOdCBqLYyboOYeAQNLnkuiDXCiNiksSSRpDMVQQgs
TmYThnppfKSmkpjjceGLaMOvYgsvNkGENKgGtUSzVPlLMeephDKrWGNpAxBqRiCnQIuKwDZurIRsznUp
xhstMWpHdZzqeEnttlAHiWbhbIJpwKBAGsFWthBiwBDKTFzIUamELZJFLbmqOmwBIYBJIofAUyxTLUEm
LcOXzjIHFcfUfEWccbWzhVuIZMdTVsOaNsLTpHjrvFaYTnJUrqaYnUmbobfOXXtkjKjFUEhVNlPWeaIY
uABNuEDKFWiUaqQiBHGsgEmDSKiJKLkkzFWlobXIyUlDzGcwDnEOwwWxgFpebsslmKItazIYctPROSJp
ImDHusQIkoFQSmuqwdcPNERvflfHtkGTrtbQXqZUsazoxmbVTPIuuxKvfALAaGnIuIZwczCcoIRMncBs
timFGHPJPaHMPTLjsBjIwbbzKyghaDTUStzJceaYAneywwpvdiUJifPHtXmAwZPChWsDmwonzeeQCEiB
xWsJLAtrdVEOBxEaYiSabHdUwlXlDOAKzZUwozJoBGvnFttDkXdYdjQSzzhTIPfYpWVFdiFIqSbyPZIi
VoXunBPbAJVMWluPcIfHmjPeHaTyClCvTOucEYEZXbVDiZMsfeuruDGMmQEsHutzvzVmWvCoPRguBiHh
taTeaguPmNuAxzYJLEcdoApfIFBaLUqettjTJNlHZYlJZRRoKXEvFnoUHdPjDuXuTAubGODkHAokpItw
SlEwhjrUSlfMawWlTMciWAzVcgPcqCHIaogokYAWGsvWZzBfJqzxIkCNvHDvBkOMCyeYXzVVuRJLQIOy
BMoVPgFLOagDxyPfWxTtZQNCLOrVVclPzMNYruNUyMOBKxBvinxuGMAAfndhPsROtkOJAAJQSxpmTzXm
CmEwZOhlItvETUneqvdKLghLyREjuJWRFjVVuNMiPuvvmRaEUmjCXDVuMRAvBuHUYGKPXthWISIbueRp
uvxpmqclmrXpAGFrxhJGxQwlrbkHEmcEUooCoPqGzbrCfIWmtUKmzzXvcqbhxKcAwXCNjbJDWDndKiLK
HwaFKyhXJQgHjIaTfIJrkhUpTHJZebRertDigQtDKxGerMRgHWFTrqqZlcBjAUfTZdFlZCAEZnhzgTIy
gJSsWJjFcCVoFonAfKPTOhTxjxTRtzSKLoIOScEwBCDvWFDVGpBOpijqdwvugoYsyuIOZJTcySDrzy
wBxediHOIYgasrUIDsNZcParqTGfTaBZHoSssXGtiCVvLReyoiitzMpsouqUeMHGWwDMgBaQTRkxPwNP
XsvyFVXfjgKuamMTsEsbeKDgAdVndyDleenPBcXWKGPcDsALDajkCEGufvbtyXUZnelqISbQnHphDoTH
RMIxMKclpWSvQHkzRhdAehBVaKYaXRPMpGaeRxvTRVFfewirvIDoGvYTAvKSoMFCLUNVFVKrYMeYtBrS
KgiBOjvliNOHLrmztypGhQjtpEQwzVfpVqsTUPvOCPzgqOuvLXJBQZHLmSwGTxEMgCAbogXombCiBDNX
BvGtXjrGWbWHtNCoRuqIZPhBQXZiNUhbmzOiyByAoMSBvusppiPVibIqmLXwXEVfcEAyNeUxaEZThULu
mkGmoLrpOEktwRluXvOmmfEWxZkxUNIqZKuzbaUmLKBYrXMmdOYLEzljzbSJnqRbSiAFyUNyyieKITkh
mvkKyosXKCaTsXQIKczJmxuqIEKeGGGwZyWTolQynlWngjDzFMlwhJFEmODeycbEfxgSRbIXySfwlhZZ
BUBhKyGBHRzWGRXAzarcmSDORvaOMOqYlcVIMwlHGtrLMhFWioqeKfvsJdTXmfQzavzSzCRrVzLFMaBT
DMOPFJcjzXcPvBkzacRmVKTQAvVobGRBypFHvoUdjvBhwWXVdDjvfJOocyIHbMqZGMaRaaFFnmtvTSkY
nIHbmPAtuEszMDFURBYxcOJXKMvJbfSbhiaacxhxiZBnoHTcFeqXQfjTqpcMKFpvvzkpSxlDxSlhikFZ
XSplcknpxiZfwUwGsrfpBUkevEiwndkKrVpWKufWpLTWXcyyXehOcDfnzgTAkhwOAcaiHqJWzsuAvMyD
pDJgeCdAJMwatRfcpKQGTkwxHracsYOlZeXoGthHIRfDBYzhuGEQRKFRnqSEbWDCJObWSAoSwFzVZEnI
rVBwXibUaTwnSTwRmIwkIgoGPRiOMLOTvnzEBBCfcugYZwGSsHRKCJoRsxxzRkKwnTRcRNfbMGssqmXV
IKYzyWHIsCjdzxiHEtvHaufVgcoqVkqIQertevTUTIVMYlNXCGEUzQowqsFpciURKoUwqCRogxeghOWs
cMnuAathgFvNIVqqXpmdJDJPhXQpZCyNbTYktMyTUtQEBeQBhEZzqHotmYREADhFodlcPmTMutBZyefW
sBmsnUbVnHUGAyaDirMoowBwXnzrmfHJgfpAquFoHTuvQvIJcjqiqVdntXbgwpVywbsKxqUMNxYVxBmQ
OAcxOAVPuJeOgABYEHhevhnUOgCUuTBAhJcUGsasbMInGCbHnHXWDdXijDRkUYFuOytTcMPtWklmTHTR
XFTfcFfSSqFUFbQVCKEjUOLveXtsHrIfkphXyDkRELnaTfuaZUClLqbdpWAREJHJpycYRDjElqlVeNya
kTCjDpvFrdnlXogrDZdQzAYaePDdfvHWdcaQGgrrHKBdMnMYbsikbkffVsITSUhEapmLGQYbHoiKGRcg
GPLeEvmCOAkGIuDBdnYPlzuUmLOfetGXpbTbPjjWCZiOJxlDazSbEPVpnNLDsLiwlgleiCdPezQwnNWT
ECLuRGpfJZlnZtcghLucmvlOZNwXaikbKGmoGZJIcsfNnmaHIcPXiEYDHjLKpVtNsqemAmaiTIzvLqlU
mlcvraikZozZwBoExUkELoiaAbTAkqDhrARHQyAvWvYUjthfWjZqbQNTnkgmySsORxGcxouYcyCSkjmC
fpTGOlFoXWLINurMZdQURRnZCiZqsEKeVVZdFMnaoUepdAdARtUuXTvkGzmpEVNZiYSWJAwkcSKgAWTD
mUNVxVebIiavuOAxWUBkuUkXCYtRoZhVNwCZGlaANNpBvXgSDeLURUdQnQteKAXbGlOLGYYYCzCGjzua
UmrdPYuRrUBvLFfwBGTiABTmpANdPCptqKwWXARMKrtmbggOBDgNkeHzNUCIXUIuOAavRbLTnzNNRgzL
boTJooLJIdVFbbjWNngnzPznJglCLEWqulqzSuAyvqYdivDqxEtYPKTwVheFmDidEOnLqjPHBcjoOVvt
MCDmQfwNxkOPuxiJqLQOPRAGJappmpikgmrvRAlKjFjTlaznQldBJmzSMDvCWghWOgfhfkHFZBNdbmMf
MsaQHrtJQvZuGFCrPVBNSNZBFZRdpmQNZYZXpkGjXRAXhELlxDfGhiXwgAUujQbqUCiKaRIYruNDRDlL
zInUkJBpySRZoqwQlqmoxADBjjtGjFPLTkcexYGwGYlANZQaXNgKkPXUUqlViVzxPxxtMQPqOxTcChCg
dvKNliVwzRfMmSsBFeuePnbmVqvyfdOXnZpUopEqfCMnnXpfZnNYwNKiZFPUWWmNCMibsyQEhiodVjTz
UxsicVsZNMXyvBLrdJxGGeCPEutNCzYBRamXwRlmVdqUTPnUoAWaVDshgTHZhvhVlLZsoqbyqOjJMPac
hHqiCKhgFkDUhUDSwsrEwaBrKhXINTjYmHvsTyFdRHliydbfQtRFZcsSTfcSfqyIgQuXLZnrdAwylBmW
BRbmVwdoNFcnoxMKHaYOhgihIsKitcrgEkfjIOKsDPOadFhMwVSKWeCfxxxfWjgNiGDaiYDtMhCgedOR
nTYoeVrpGsyDIsuKhffqaEqoqfWukaQlcUShYicuZAdoYVGvRchUgcmNwxQGogDvKhyAkIuqHCIXQfXp
CtkSSTXTugolUKfqSzugIOpyHhIlcTjDBTKPqcyaRhmgFdSBkYurnvnukNGVoxpZBFmwIEmehuaUcoeu
btkjJqKcAAqxgrKcoRGuqHVUHqKgEaqRCIXlaTqaUewJBEWnTnTJIDYdLeGUMDfndHPYTAGQbhxreADo
WZtdvbJVnNGRNvlAsqIPlpXSXEZGBdqVyNCCwylcXprVoGqnPXZioKnqbdrYlDhbsTVDJqRQKoPtQXzu
RnrGgCfYfeRRxiihjItxHurPwtYJoObDzlEABeIRxQocvWrJtyWchmZXJdYvTgicUircdiMKYAkNbdKu
gPpzXnTQIZxtIhvfBfjIHRaDXbYExxYBvrejpEaVHlinHlYRrhsbChnAwTKlQtHntqcqiXZwTUEdlsVy
WFdZNRfqzkhWzeKMGmkuKoSkuSZRkddsuBNFVMFLPeUkLwCCDKagNjMZwtHcVcEEKyjAYubHipuqNjaV
JukystpMZrhBgLqRVMpaIPsyAvYIsBDVqKNCMLqLwyhJhuWDdCPBgSzJTLkJvaGPirOFwfuMtkyXeKoZ
rGPRJqXyhdYNOXVSqGvbSPozAbjhpyfgGVuNUYaRQomzrTtzAMJnYnyvDnuBkbVvmYzhlhqmwgCZaGJG
GGRbaFdfnDlUfCfhpDWTkWfpUDuUksJvRFNxVYBKGoxBCdhmYZwyDPzWihcQXgByRbYxWZslVsbuTHTf
vaulICCTRkkiYuYoqFdzuxsqOBkzEJHbNXhSnHYxyeGoEklCeaUVEtjxmXyOEzcpsAhfKCTejxOxwGYh
eLtoPpPINviTCHUsgzSkycIxtvekMaoZkBIyLboyvMxxaqfviBxkSALNjiNYqGTypcZDvHonaVBZCSLp
SjRTsJmDuPwKnYwCdTprFvbXnrhARNToXpryIfEoIwSWIdfSKeOHDYwgyUvwXXpKUKQEiyZxCsTkAjME
hdxShAAUYJTkprXuFITxxJuKMiphRAyAeUFZgknMMLvUaSjiMlGmLARvTMpllxEQyfvEqkcONHVFcaTW
tqcbVrgeTLTGuJsrjZdYrrjtoLKcEfjkIhjzXgEkYhZggujFJuQlVtSqvuejtxAEqjgXrYjmwLkSRmXp
pkTfONxRyAxRYqJccLxuhabwMTWfwLTlzuVGJtVJOXxwKjFIZENpGHwRvTRitDBQBesRYATKhmWmmmbP
EXOzdBHNeghlqpjJFmzXyADNHQNEThWDyMsGsTmyFnywIPvDSIcxHbKQHgmJEcfsPzYvSYIbQjnTAgzF
UfZAbwfgCMRxtmZQQyayJFFhCSVeeUcQzSLWqhENNUpyLZaJsQsFQsPyFIjGtcmoJaFQGKTFtKUBdBBo
xECKHgYSMcBWnzRvPyihfjwyjhTTavfYqOrbrgZDSrwVYFjNsdxLJIigfMgythUoUIVSydOnfhAaesXZ
kfyDztQiBCMHjfEGLFllxfejLJjanZVRENsXhIxSWDgbvHHOAFtHzqdfquGbdQvOFlhDiWpxwEolxbep
fVfpKYGMNIQuOlmtTkNRDFTVMtVkEXYUDZKfEihbxXsSLGDcKSHSMXZxAturZVEQgismVAgMVVatqjBM
rXeHaGdccPJMlqhVAePDyEoIRTLCwJpkNTuOjEKEvXaAGhWmhWPHCBMVPkcPklbGIvzMzOFplRUsvZbE
vScmmoKktOUVOeKBcqVvoSsplqqssDvLiPqucbrxoNkodsbrZnvoDfyNGyUAURseEuJPUWsEiVCNcUNd
sxzoRVpEFuFloqWLumNVJITKXnWnOlGpCaQgTLJYizixXoxAHHbodRtPHBbnSzZRZOmlWKOQqvHWAhDh
cYBGRQsFwyesMILhiwjnvjeMIZnHYHYNrmOahjrVPuRgsxdfgUbKCZAVfcOizDeQLKiFQmQQUlDHnCQe
lMnlLSrtXhmGDqISCgElUrZXbXjGGkdWadBbxzVojGQwyhAbWMhSKFFwoIqJfIDdZjUdfCYFkpDdIuWe
aFIUFhnlsREthBRoaquSzBVVOPABfuAYZpoalZwNfZMPOptcoQYVUdRYlXuYChPAdRJgFgwPyTszSXIe
qHRtMxyNlPGoBfpjxHnNvwIADmJmquLgMQGtpJAyvflZjFwAgIymerCTnVkjvqPKFVRscOqAhqvCqCjw
BBojzXKIdphOVTFKhBpnIWYRfuqvQZgVMaqNBkYKzqGaEnBFKZukSLdPbXNmcZtMeykLwlLbZqaHayOb
IWZvbxEXXnaozCHeyiYMnWqIAwJxhMIPDsgySMKhdBYmdrGdbJOfJralshwvhWlmatTsylewdimJEzph
tuTzSGOkGDPPvltRVJPdHRPBTAsKWncfjjuHdlEVOeZIvVnUFHmyGTFDlMGVyAIdzLocbTXIHYTopIok
UHFAVjEXPlsMoKTriyGnfeTlVzvGhVZzUAWWPdZNdIxKioQylFMJZmSToyRGsDJKJXQxPkINvmoHCVUc
RIjImkWWxTnDLQiXdmHqQrWBuvguUUubGByTRnJfkNWxsSupcfIVgboDWzqYHEfAnIKCfdYUOslfXPax
YnaJfNLqJgcxRjBmRpOYgNpZOpzMOCVIRiiXdIqqFxPJhQqJadKiCesOsZoWGWbbQSVRZUlbNZdzeUTE
nhdMSCKCPbpWZguZHGkLiWCisjqnaLbJpbRFAHPjGbHOXKZQXoQQZohmVqjTcdWNhXEjPlLKnjpwbMPQ
ybzDvGgkybXtbDmjQuyOrMrcYGRGGfuuPXzieaetSBidnSRPsLaXKGcxDkXmHbqMWZJXsQkwtojlxOeU
KSIFdVvNEnOUmIZDdlnwtJcPBlcpRWNTazpzgItwJotSLWZruzrMlSGASMWDwOqTpeYYHaTHCCurPdwB
AWzUtwblZXNrBYdjUoDacvmRVURqOzUPlnFISsZMFPtthnDHSsFgkYfsMtXFuNPhLTleWVrmelyFaemo
bVIhEAxNwOUDQCOCDIBHsQlFxCbHErKiBsvQNjuIGnIzZiwoVTdUZnucSaKdHrxJeGQfTawFJefGJFFa
GHzELfnGBmkZyorbbDDwhvEVeIYIGLPMEuZduqFjbeWbVfzVIRZNXwPLgcYUsevuhEQXfYcJshYnJaWz
iqvlswEBRKNYEJidlzdWnQJpBtyjHYVpkQGzdYkeREqjhmmnUIbGZVnwwaMKqgXfURSICNxdteUSGhGZ
UEEFhWRoTKGRwFmPpZPOsalsrNOlkTdXqGKoWlWkqJvYYrtLiTfhdItMbbhdumSYgCcQVUARnYFWkCsC
jElZxrQHIlbTHFLOnrutlvyxzaSIdkJgeyMUnUmtXfnaIedbAInAuQssOQqBTLbvFRiqKqUSdUEmcRmN
LvAxlgliymfbjTwDSqNTLcAEIerzpUShNKkuehciEAYeGJOFFcOvurJFUyfZhQqzfaneiBcrPhaphSCB
StQiJvtoPhHcLUbriDUIfifVFnNtJfGlmcbQJSXsZfVjpbqnkMllUmHzLvEuSarSlNlNHsWvYlfhjMEA
epYTjoRGZeAAtURFeDfDxTYmOmONuQQBdcdncFGjhHmKlwqmUWoXuIXIxaaXnNThgPGtIlynrUIPLQTG
xXhattDrfBGbZRveKbgjzxJLdYREQlMeLtcIEUoyJocdAfUbymxuFLVjGkOQniiPParqoyQYfDYAQTkM
WLicLxpEFkBbwlKrTyYilKTtYkpVGxtOjYmcBDOrwFhFiGutmpTyTarUbVUeSevBTdaPDpjRkaEmLJMg
WsMhSGfIcBChcqrRKgKpjvGnFipjswgjetRtniMagakbCXAjpzWTtMlgZGCJwGyglpcLebrKWhgwJfWV
qGifWNEpCtjuejHoyVCdIxzMYGnfoslgTNAJdtVBWDVoGLzHSAVBTnhNIvAOExQNiJOIPPiHkdaRbfaP
ixDDoCDOOeAqvQJFxLWDICfGmufyxmaMshbvcrtjqqVtffZTnbtCOQfzRMGwOQEKaAmSWjnYdNgvdkmd
dQmaKZSdqKNrnvJlcyVMKuNWmuoOeyKecgjXbmSqnpjwJEaDYoehEklEgJyiksGxdEKgfYRXQecRZgfe
qKWGc'''
ll = []#这三个空列表是下面将要用来存放各种数据的，我会在后面用到每个列表时有具体的详细解释
lll = []
l_filtered1 = []
index = 0#这三个参数可以理解为某种计数器，我在下面用到的时候会详细解释。
start = 0
n = -1
for each in l:#找到原字符串中所有的小写字母的位置,这里的each是字符串中的每个英文字母
    if each.islower() == 1:#如果是小写的话，n是该字母的位置参数，从-1开始，第一个字母的话就是0
        n += 1
        ll.append(n)#我通过append语句把小写字母的位置参数n假如到空ll列表中

    else:
        n += 1#如果是大写字母，n同样也要+1，这样确保每个字母的n和它在字符串中的实际位置参数是匹配的，只不过大写字母的位置参数n我就不保留在ll列表了。
print(ll)#我自己想看一下所有筛选出来的小写字母都有哪些
l_filtered1 = ll[:]#这里把所有放着小写字母的ll列表拷贝一份出来，用于下一步的筛选和修改。
print('==============我是分割线 下一轮筛选要开始啦================')
#开始第一次数据清洗：清洗掉所有左右3位内包含有小写字母的字符
for each in ll:#ll中的each是超长字符串l中每个小写字符的位置参数，是int单位
    if each >= 3 and each <= (len(l) - 3):#前三后三个字符自动忽视，因为他们前后字符位数不够三，自然不满足条件‘前后三位有且只有大写字母’
        if l[each+1].islower()==1 or l[each+2].islower()==1 or l[each+3].islower()==1 or l[each-1].islower()==1 or l[each-2].islower()==1 or l[each-3].islower()==1:
            #通过6个or逻辑连接分别判定前三后三这六个字符中有没有小写。如果有小写，说明他们不符合条件，需要剔除。
            lll.append(each)#lll的目的挑出这些不符合条件的，暂时放在lll里面，等着下一步用来剔除。
            #lll是第一次筛选的结果
        else:
            continue
    else:#原字符串l开头和结尾的三个字符自动忽视，因为他们前后字符位数不够三，自然不满足条件‘前后三位有且只有大写字母’
        lll.append(each)
print(lll)#我自己想看看挑出来需要剔除的字母都有哪些。。
print('看看这个lll中，也就是需要剔除的,都有哪些元素？')
print('===============我是分割线 下一轮筛选要开始啦=================')

for each in lll:
    l_filtered1.remove(each)#如上注释所说，lll中的都是需要剔除的，所以用for循环把每一个都从l_filtered1（这个列表是所有的小写字母）中删除，这样留下的是符合第一层条件的小写字母，准备第二层条件'仅有3个大写字母'筛选。
print('看看第一次筛选过后剩下的l_filtered1还有什么？准备进行第二次筛选')
print(l_filtered1)#我自己想看看剔除后还剩多少。。
print('============我是分割线 下一轮筛选要开始啦====================')

#第二次筛选就是要看什么叫 '有且只有三个大写字母'
#也就是说该小写字母在前后三位均是大写的情况下，前后第四位一定是小写
l_filtered2 = l_filtered1[:]#我再拷贝一个l_filtered2出来用于第二次剔除
for each in l_filtered1:#所有满足第一轮筛选条件的小写字母
    if each >= 4 and each <= (len(l) - 4):#如果它们是在开头结尾的四位以内就自动忽视 因为没有第四位的存在 而且不加这个语句的话each+4 each-4会报错out of range
        if l[each+4].islower() == 1 and l[each-4].islower() == 1:#通过and逻辑连接，超长字符串中符合第一轮筛选的小写字母的前后第四位如果均为小写则满足条件，则进行保留。否则剔除。
            continue
        else:
            l_filtered2.remove(each)#从拷贝过来的l_filtered2中剔除
    else:
        l_filtered2.remove(each)#开头结尾四位以内的也直接剔除

print(l_filtered2)#我看看还剩多少。。
print('这时候的l_filtered2是第二次筛选过后的 所有符合条件的小写字母的index')
print('============我是分割线 下一轮筛选要开始啦==================')
#这时候把经过两次筛选留下来的index对应回最初的l中，看看剩下的都是那些字母
result = ''#这里准备输出最终满足条件的所有小写字母 准备一个空字符串result作为容器
for each in l_filtered2:#把l_filtered2中所有筛选出来的，在原始超长字符串中以l[each]的形式找回到每个字符，并放在result容器中
    result += l[each]

print(result)
print('这应该是最后的结果了吧。。。')
print('可是为什么还是不对呢。。。')
print(l_filtered2)#我也不知道我的l_filtered2为什么会有问题。。暴风哭泣。。。我太难了。。
    

鱼币不多 还请大家见谅。。以后说不定还有什么时候要来继续问问题。。。呜呜呜。。。

最佳答案

月排行榜 / 总排行榜

sunrise085

2020-3-27 09:13:39

你的程序我看出来的有两个错误。
第一，在第一遍清除的时候，，你没有考虑到每一行结尾的回车字符，'\n'也算字符串中的一个字符，这一点你没有考虑到。你应该在第一次查找小写字母之前，先将原字符串拷贝一份，清除'\n'，注意是从字符串中清除'\n'，不是清除下标；
第二、在第二次筛选的时候，有且仅有三个大写字母，你没有考虑全面，首尾的情况你考虑的不对，例如： 'ABCdEFGh……hQWEkDRT'这种情况开头的d和结尾的k是符合条件的，但是你的程序则会把开头的d去掉，而结尾的k处则会报错

说句题外话，发帖的时候请不要引付费的链接，不是所有的人都会去看付费链接的。

跳转到最佳答案楼层

sunrise085

你的程序我看出来的有两个错误。
第一，在第一遍清除的时候，，你没有考虑到每一行结尾的回车字符，'\n'也算字符串中的一个字符，这一点你没有考虑到。你应该在第一次查找小写字母之前，先将原字符串拷贝一份，清除'\n'，注意是从字符串中清除'\n'，不是清除下标；
第二、在第二次筛选的时候，有且仅有三个大写字母，你没有考虑全面，首尾的情况你考虑的不对，例如： 'ABCdEFGh……hQWEkDRT'这种情况开头的d和结尾的k是符合条件的，但是你的程序则会把开头的d去掉，而结尾的k处则会报错

说句题外话，发帖的时候请不要引付费的链接，不是所有的人都会去看付费链接的。

jackz007

        很简单的一道逻辑判断题，何须搞得如此繁复！

s , p = 'a' + '' . join(l . split('\n')) + 'a' , ''
for k in range(4 , len(s) - 4):
    if s[k - 4] . islower() and s[k - 3 : k] . isupper() and s[k] . islower() and s[k + 1 : k + 4] . isupper() and s[k + 4] . islower() : p += s[k]
print(p)

        代码中第一行中的 l 就是小甲鱼给出的长字符串

sjyabd

sunrise085 发表于 2020-3-27 12:30
你的程序我看出来的有两个错误。
第一，在第一遍清除的时候，，你没有考虑到每一行结尾的回车字符，'\n'也 ...

谢谢指点，我恍然大悟了！
经过测试之后，发现只加了 把每行结尾的回车字符\n删除
结果就正确了！
我在拷贝小甲鱼的代码时候，一行行的字符换行时也没有用\n显示出来，我就忘记了换号符号也是一个单位了。。非常感谢！

关于前三后三个字母，我完全赞同你的观点！其实我在写的时候有想到，但是我肉眼看了一下 前三后三个小写字母不符合要求。。就强行用这个规则把它们筛选掉了。。人肉筛选。。。哈哈哈。。。谢谢提醒，我应该改进一下这个筛选的逻辑。。不能靠人肉。。

sjyabd

sunrise085 发表于 2020-3-27 09:13
你的程序我看出来的有两个错误。
第一，在第一遍清除的时候，，你没有考虑到每一行结尾的回车字符，'\n'也 ...

辛苦了，再次感谢。我也是第一次发帖提问，没有想太多，也没有注意到小甲鱼的链接是需要付费的。。抱歉抱歉，以后我会多注意的！

sjyabd

jackz007 发表于 2020-3-27 14:13
很简单的一道逻辑判断题，何须搞得如此繁复！

        代码中第一行中的 l 就是小甲鱼给出的长 ...

抱歉大佬没有把你选为最佳答案。。并不是说你的代码不好，而是太厉害了。。我看了二十分钟才看懂。。我还没有学过join和split语句，也是去谷歌了一下才看明白。。短短几行就完成了这个任务。。真的厉害。。
我选上面那位兄弟是因为他看了我的代码，找出了我的错误。。我的蹩脚代码一定花费了他不少时间。。大佬你别介意。。

非常感谢分享代码，受益匪浅！其实这段代码中绝大多数东西都在小甲鱼前20讲中讲到了，但是我没能活用起来。。功力还差的远之又远。。继续虚心向各位学习！