孰能生巧

python3练习题100道，孰能⽣巧，之前要想⼀个下午的内容，

马上就有了答案

第1章字符串练习题

1.1交换

已知a的值为“hello”，b的值为“world”，如何交换a和b的值？

得到a的值为“world”，b的值为“hello”

a="hello"

b="world"

#⽅式1

a,b=b,a

print("a的值："+a+";b的值："+b)

#⽅式2

a="hello"

b="world"

c=a

a=b

b=c

print("a的值：{};b的值{}".format(a,b))

1.2回⽂

回⽂的定义：“回⽂”就是正读倒读都是⼀样的

如奇数个“98789”，这个数字正读是“98789”倒读也是“98789”。

偶数个数字“3223”也是回⽂数。

字母“abcba”也是回⽂。

判断⼀个字符串是否是回⽂字符串，是打印True，不是打印Fal。

a=input("请输⼊⼀个字符串：")

print(a)

flag=True

foriinrange(len(a)//2):

ifa[i]!=a[-i-1]:

flag=Fal

print("{}不是⼀个回⽂字符串;".format(a))

break

ifflag:

print("{}是⼀个回⽂字符串;".format(a))

1.3字符串切割

已知⼀个字符串为“hello_world_huihui”口腔护士工作内容 ，如何得到⼀个队列["hello","world","huihui"]

a="hello_world_huihui"

print(("_"))

1.4拼接字符串

有个列表['hello','world','huihui'] 如何把列表⾥的字符串串联起来

得到字符串"hello_world_huihui

a=['hello','world','huihui']

aa=""

foriina:

aa+=i

aa+="_"

print(aa[:-1])

1.5替换字符

把字符串s中的每个空格替换成"%20"

输⼊：s="Wearehappy."

输出："We%20are%20happy."

s="Wearehappy."

ss=e("","%20")

print(ss)

1.6九九乘法表

打印99乘法表

foriinrange(1,10):

forjinrange(1,i+1):

print("{}*{}={}".format(j,i,i*j),end="")

print()

1.7字符下标

找出单词"welcome" 在字符串"Hello,welcome."中出现的位置，找不到返回-1

从下标0开始索引

a="welcome"

b="Hello,e.."

n=0

ifainb:

foriinb:

ifi!=a[0]:

n+=1

el:

end=len(a)+n

#print(end)

ifa==b[n:end]:#[6:14]

print("单词{}在{}的第{}位出现；".format(a,b,n))

break

n+=1

el:

print("单词{}未在{}中出现；".format(a,b))

1.8统计字符出现的次数

统计字符串"Hello,welcometomyworld." 中字母w出现的次数

统计单词my出现的次数

a="Hello,welcometomyworld."

b='w'

#⽅式⼀：

#ifbina:

##count=0

##foriina:

##ifi==b:

##count+=1

##print("{}在字符串{}中,出现了{}次；".format(b,a,count))

##el:

##print("{}未出现在字符串{}中；".format(b,a))

#⽅式⼆：

#直接将m替换为my即可

count=0whileTrue:ifbina:a=e(b,'',1)count+=1el:breakprint("{}在字符串{}中,出现了【{}】次；".format(b,a一丝惬意心中来 ,count))

1.9统计每个字符出现的次数

题⽬：输⼊⼀个字符串str，输出第m个只出现过n次的字符， 如在字符串gbgkkdehh中，找出第2个只出现1次的字符，输出结果：d

#a="gbgkkdehh"

a=input('请输⼊⼀个字符串：')

m=3

n=2

b={}

count=0

foriina:

():

b[i]=1

el:

b[i]+=1

prin车子多久保养一次 t(b)

():

ifb[i]==n:

count+=1

ifcount==m:

print(i)

break

1.10判断字符a含b

判断字符串a="welcometomyworld"是否包含单词b="world"，包含返回True，不包含返回Fal

a="welcometomyworld"

b="world"

ifbina:

print("True")

el:

print("Fal")

1.11查找字符⾸次出现位置

输出指定字符串A在字符串B中第⼀次出现的位置，如果B中不包含A，则输出-1

从0开始计数

A="hello"

B="hihowareyouhelloworld,helloyoyo!"

A="hello"

B="hihowareyouhelloworld,helloyoyo!"

n=0

ifAinB:

b=e(A,'=',1)

print(b)

foriinb:

ifi!='=':

n+=1

el:

print("{}在字符串{}中第⼀次出现的位置是{}".format(A,B,n))

el:

print(-1)

1.12查找字符串最后⼀次出现位置

输出指定字符串A在字符串B中最后出现的位置，如果B中不包含A，则输出-1

从0开始计数

A="hello"

B="hihowareyouhelloworld,helloyoyo!"

A="hello"

B="hihowareyouhelloworld,helloyoyo!"

n=0

count=0

print(len(B))

whileAinB:

n=(A)

B=e(A,'',1)

count+=1

#print(n)

print(n+(count-1)*len(A))

1.13判断奇数偶数

给定⼀个数a，判断⼀个数字是否为奇数或偶数

a=int(input("请输⼊任意⼀个整数："))

#print(a,type(a))

ifa%2==0:

print("偶数")

el:

print("奇数")

1.14判断⼀个姓名是否姓王

输⼊⼀个姓名，判断是否姓王

a="王五"

b="⽼王"

a="⽼王五"

ifa[0]=="王":

print("{}姓‘王’".format(a))

el:

print("{}不姓'王'".format(a))

1.15判断是不是数字

如何判断⼀个字符串是不是纯数字组成

a="123456"

b="yoyo123"

#⽅式1

importre

a="123456"

b=l('d',a)

iflen(a)==len(b):

print("{}是纯数字；".format(a))

el:

print("{}不是纯数字；".format(a))

#⽅式2

a="12345c6"

t():

print("数字字符串")

el:

print("⾮数字字符串")

1.16字符串⼤⼩写转换

将字符串a="wow!"全部转成⼤写

字符串b="WelcomeToMyWorld"全部转成⼩写

a="wow!"

print(())

print(())

1.17字符串去掉⾸尾空格

将字符串a="welcometomyworld"⾸尾空格去掉

a="welcometomyworld"

print(())

print('abcab'.strip('a'))

1.18字符串去掉左边指定空格或字符

将字符串a="welcometomyworld！"左边的空格去掉

a="welcometomyworld！"

print(())

1.19字符串去掉右边指定空格或字符

将字符串a="welcometomyworld!"右边的空格去掉

a="welcometomyworld!"

print(())

print(("!"))

1.20去除字符串⾥⾯所有的空格

将字符串a="welcometomyworld!"⾥⾯的所有空格都去掉

a="welcometomyworld!"

print(e('',''))

1.21字符串去重后排序

s="ajldjlajfdljfddd"，去重并从⼩到⼤排序输出"adfjl"

s="ajldjlajfdljfddd"

rs=[]

foriins:

ifinotinrs:

(i)

#rs=sorted(rs)#列表排序⽅式1

()

s="".join(rs)

print(rs,s)

1.22字符串去重保留顺序

s="ajldjlajfdljfddd"，去重保留原来的顺序，输出"ajldf"

s="ajldjlajfdljfddd"

rs=""

foriins:

ifinotinrs:

rs+=i

print(rs)

1.23画菱形

题⽬打印出如下图案（菱形）:

n=7

foriinrange(n//2+1):

print(''*(n//2-i)+'*'*(2*i+1))#3,1;2,3;1,5;;0,7;;

foriinrange(n//2-1,-1,-1):

print(''*(n//2-i)+'*'*(2*i+1))

1.24输⼊⼀个正整数，判断是⼏位数

题⽬给⼀个不多于5位的正整数，要求：

⼀、求它是⼏位数，

⼆、逆序打印出各位数字。

a=12345

a=input("请输⼊⼀个不超过5位的正整数：")

print("{}是⼀个【{}】位数；".format(a,len(a)))

print(a[::-1])

第2章⼩学数学题

2.1.⽔仙花数

如果⼀个3位数等于其各位数字的⽴⽅和，则称这个数为⽔仙花数。

例如：153=1^3+5^3+3^3，因此153就是⼀个⽔仙花数

那么问题来了，求1000以内的⽔仙花数（3位数）

result=[]

forjinrange(100,1000):

i=str(j)

bai=int(i[0])

shi=int(i[1])

ge=int(i[2])

ifbai**3+shi**3+ge**3==j:

(j)

print(result)

2.2完全数

如果⼀个正整数等于除它本⾝之外其他所有除数之和，就称之为完全数。

例如：6是完全数，因为6=1+2+3；

下⼀个完全数是28=14+7+4+2+1。

求1000以下的完全数

pn=[]

foriinrange(1,1000):

chushu=[1]

sum=1

forjinrange(2,i):

ifi%j==0:

(j)

sum+=j

ifsum==i:

(i)

print("{}是⼀个完全数，真因⼦有{};".format(i,chushu))

print(pn)

2.3数字1-100求和

求1+2+3…+100和

n=11

ifn%2==0:

sum=(1+n)*(n//2)

el:

sum=(1+n)*(n//2+0.5)

print("1-{}的和是{}".format(n,sum))

2.4计算求1-2+3-4+5-…-100的值

计算求1-2+3-4+5-…-100的值

n=10

ifn%2==0:

sum=-1*(n//2)

el:

sum=-1*(n//2)+n

print(sum)

2.5计算求1+100的值

计算求1+100的值

n=100

if(n-1)%2==0:

sum=(n-1)//2*(-1)+1

el:

sum=(n-1)//2*(-1)+1+n

#sum=(1-n)//2+1+n#取模的数据，千万不要随意变更+-号，-9//2=-5

print(sum)

2.6计算1-n之间的所有5的倍数之和

定义⼀个函数：计算1-n之间的所有5的倍数之和，默认计算1-100（n是⼀个整数）

n=100

sum=0

nc=n//5

foriinrange(1,nc):

sum+=i*5

print(sum)

2.7n个⾃然数的⽴⽅和

计算公式13+23+33+43+…….+n3

实现要求：

输⼊:n=5

输出:225

对应的公式:13+23+33+43+53=225

n=5

sum=0

foriinrange(1,n+1):

sum+=i**3

print(sum)

2.8阶乘10!

阶乘的意思:10!=10x9x8x7x6x5x4x3x2x1

求10!

n=10

Factorial=1

foriinrange(2,n+1):

Factorial*=i

print(Factorial)

2.9求1+2!+3!+...+10!的和

求1+2!+3!+...+10!的和

n=10

sum=1

foriinrange(2,n):

Factorial=1

foriinrange(1,i+1):

Factorial*=i

print(Factorial)

sum+=Factorial

print(sum)

2.10求s=a+aa+aaa+a的值

求s=a+aa+aaa+a的值

如：n=5a=3

33333=3x10**4+3x10**3+3x10**2+3x10**1+3x10**0

n=5

a=3

tsum=0

sum=0

nn=n-1

foriinrange(1,n+1):

sum=a*i*10**(nn)

nn-=1

print(sum,nn)

tsum+=sum

print(tsum)

2.11斐波那契数列1、1、2、3、5、8、13.....

已知⼀个数列：1、1、2、3、5、8、13、。。。。的规律为从3开始的每⼀项都等于其前两项的和，这是斐波那契数列。

求满⾜规律的100以内的所有数据

snl=[1,1]

num=2

whilenum<100:

(num)

num=snl[-1]+snl[-2]

print(snl)

第3章列表练习题

3.1反转（判断对称）

如何判断⼀个数组是对称数组：

要求：判断数组元素是否对称。例如[1，2，0，2，1]，[1，2，3，3，2，1]这样的都是对称数组

⽤Python代码判断，是对称数组打印True，不是打印Fal,如：

x=[1,"a",0,"2",0,"a",1]

x=[1,"ac",0,"2",0,"a",1]

flag=True

count=len(x)//2

foriinrange(count):

ifx[i]!=x[-i-1]:

flag=Fal

break

ifflag:

print("{}是⼀个对称数组？True".format(x))

el:

print("{}是⼀个对称数组?Fal".format(x))

3.2列表切⽚

如果有⼀个列表a=[1,3,5,7,11]

问题：1如何让它反转成[11,7,5,3,1]

2.取到奇数位值的数字，如[1,5,11]

a=[1,3,5,7,11]

print(a[::-1])

print(a[::2])

3.3列表⼤⼩排序

问题：对列表a中的数字从⼩到⼤排序

a=[1,6,8,11,9,1,8,6,8,7,8]

a=[1,6,8,11,9,1,8,6,8,7,8]

foriinrange(len(a)):

forjinrange(i+1,len(a)):

ifa[i]>a[j]:

a[i],a[j]=a[j],a[i]

print(a)

3.4取出最⼤值最⼩值

L1=[1,2,3,11,2,5,3,2,5,33,88]

找出列表中最⼤值和最⼩值

L1=[1,2,3养锦鲤 ,11,2,5,3,2,5,33,88]

max=L1[0]

min=L1[0]

count=len(L1)

foriinrange(count):

ifL1[i]>max:

max,L1[i]=L1[i],max

ifL1[i]

min,L1[i]=L1[i],min

print(max,min)

3.5找出列表中单词最长的⼀个

a=["hello","world","yoyo","congratulations"]

找出列表中单词最长的⼀个

a=["hello","world","yoyo","congratulations"]

max=a[0]

foriina:

iflen(max)

max=i加油干的图片

print(max)

3.6切⽚取出列表中最⼤的三个数

取出列表中最⼤的三个值

L1=[1,2,3,11,2,5,3,2,5,33,88]

L1=[1,2,3,11,2,5,3,2,5,33,88]

()

print(L1[-1:-4:-1])

3.7列表按绝对值排序

a=[1,-6,2,-5,9,4,20,-3]按列表中的数字绝对值从⼩到⼤排序

a=[1,-6,2,2,-5,5,9,-5,4,20,-3]

l=[]

foriinrange(len(a)):

ifa[i]<0:

(a[i])#将负数放在⼀个列表中；

a[i]=-a[i]

()

()#对负数列表进⾏排序

print(a,l)

foriinrange(len(a)):

if-a[i]inl:

a[i]=-a[i]

dell[-1]#删除负数列表中相应的数

print(a,l)

3.8按字符串长度排序

b=["hello","helloworld","he","hao","good"]

按list⾥⾯单词长度倒叙

b=["hello","helloworld","he","h3e","hao","good"]

lens=[]

foriinb:

(len(i))#将每个字符串的长度放在列表中

(rever=True)

print(lens)#长度列表，降序

foriinb:

num=(len(i))#找到索引位置

lens[num]=i#将相应索引位置替换为字符串

print(lens)

print(lens)

3.9去重与排序

L1=[1,2,3,11,2,5,3,2,5,33,88]

如何⽤⼀⾏代码得出[1,2,3,5,11,33,88]

L2=[1,2,3,4,5],L[10:]结果是多少（报错？还是None，还是[]）

L1=[1,2,3,11,2,5,3,2,5,33,88]

L1=sorted(list(t(L1)))#t集合是⼀个⽆序的不重复的元素序列

#()

print(L1)

[]

3.10去重保留顺序

将列表中的重复值取出(仅保留第⼀个)，要求保留原始列表顺序

如a=[3,2,1,4,2,6,1]输出[3,2,1,4,6]

a=[3,2,1,4,2,6,1]

result=[]

foriina:

ifinotinresult:

(i)

print(result)

3.11列表合并

a=[1,3,5,7]

b=['a','b','c','d']

如何得到[1,3,5,7,'a','b','c','d']

a=[1,3,5,7]

b=['a','b','c','d']

#(b)

#print(a)

print(a+b)

3.12⽣成列表(列表推导式)

⽤⼀⾏代码⽣成⼀个包含1-10之间所有偶数的列表

n=10

list=[2*xforxinrange(1,n//2+1)]

print(list)

3.13列表成员的平⽅

列表a=[1,2,3,4,5],计算列表成员的平⽅数，得到[1,4,9,16,25]

a=[1,2,3,4,5]

result=[i**2foriina]

print(result)

3.14找出列表⼤于0的数

使⽤列表推导式，将列表中a=[1,3,-3,4,-2,8,-7,6]

找出⼤于0的数，重新⽣成⼀个新的列表

a=[1,3,-3,4,-2,8,-7,6]

list=[iforiinaifi>0]

print(list)

3.15统计列表有多少⼤于0

统计在⼀个队列中的数字，有多少个正数，多少个负数，如[1,3,5,7,0,-1,-9,-4,-5,8]

a=[1,3,5,7,0,-1,-9,-4,-5,8]

zheng=0

fu=0

foriina:

ifi>0:

zheng+=1

elifi<0:

fu+=1

print(zheng,fu)

3.16列表排除筛选

a=["张三","张四","张五","王⼆"]如何删除姓张的

a=["张三","张四","张五","王⼆","2张2五"]

aa=()

#print(id(a),id(aa))#查看引⽤地址是否⼀个

n=0

foriinrange(len(a)):

ifa[i][0]=='张':

delaa[i-n]

n+=1

print(aa)

3.17列表过滤(filter)

题1：有个列表a=[1,3,5,7,0,-1,-9,-4,-5,8]使⽤filter函数过滤出⼤于0的数

题2：列表b=["张三","张四","张五","王⼆"]过滤掉姓张的姓名

b=[1,3,5,7,0,-1,-9,-4,-5,8]

defzhengshu(n):

returnn>0

bb=filter(zhengshu,b)

print(list(bb))

#a=["张三","张四","张五","王⼆","2张2五"]

#defname(n):

#returnn[0]!='张'

#aa=filter(name,a)

#print(list(aa))

3.18过滤列表中不及格学⽣(filter)

过滤掉列表中不及格的学⽣

a=[

{"name":"张三","score":66},

{"name":"李四","score":88},

{"name":"王五","score":90},

{"name":"陈六","score":56},

]

a=[

{"name":"张三","score":66},

{"name":"李四","score":88},

{"name":"王五","score":90},

{"name":"陈六","score":56},

]

defscore(n):

returnn["score"]>60

rs=filter(score,a)

print(rs,list(rs))

3.19找出列表中最⼤数出现的位置

有个列表a=[1,2,3,11,2,5,88,3,2,5,33]

找出列表中最⼤的数，出现的位置，下标从0开始

a=[1,2,3,11,2,5,88,3,2,5,33]

max=max(a)

num=(max)

print(num)

3.20找出列表中出现次数最多的元素

a=[

'my','skills','are','poor','I','am','poor','I',

'need','skills','more','my','ability','are',

'so','poor'

]

找出列表中出现次数最多的元素

a=[

'my','skills','are','poor','I','am','poor','I',

'need','skills','more','my','ability','are',

'so','poor'

]

mstr=a[0]

mcount=1

foriina:

(i)>=mcount:

mcount=(i)

mstr=i

print(mstr,mcount)

3.21分别统计列表中每个成员出现的次数

a=[

'my','skills','are','poor','I','am','poor','I',

'need','skills','more','my','ability','are',

'so','poor'

]

a=[

'my','skills','are','poor','I','am','poor','I',

'need','skills','more','my','ability','are',

'so','poor'

]

rs={}

foriina:

():

rs[i]=1

el:

rs[i]+=1

print(rs)

3.22列表查找元素位置

给定⼀个整数数组A及它的⼤⼩n，同时给定要查找的元素val，

请返回它在数组中的位置(从0开始)，若不存在该元素，返回-1。

若该元素出现多次请返回第⼀个找到的位置

如A1=[1,"aa",2,"bb","val",33]

或A2=[1,"aa",2,"bb"]

deffind(n,m):

ifmnotinn:

return-1

el:

(m)

A1=[1,"aa",2,"bb",2,"val",33]

print(find(A1,2))

3.23列表查找两数之和

给定⼀个整数数组nums和⼀个⽬标值target，请你在该数组中找出和为⽬标值的那两个整数，并返回他

们的数组下标。

你可以假设每种输⼊只会对应⼀个答案。但是，数组中同⼀个元素不能使⽤两遍。

⽰例:

给定nums=[2，7，11，15]，target=9

因为nums[0]+nums[1]=2+7=9

所以返回[0，1]

nums=[3,3,5,2,7,11,15]

target=9

newn=[]

defsum(nums,target):

foriinnums:

ifi

(i)

foriinrange(len(newn)):

forjinrange(i+1,len(newn)):

ifnewn[i]+newn[j]==target:

return[i,j]

print(sum(nums,target))

3.24⼆维数组取值(矩阵)

有a=[["A",1],["B",2]]，如何取出2

a=[["A",1],["B",2]]

#foriinrange(len(a)):

#forjinrange(len(a[i])):

#ifa[i][j]==2:

#print('a[{}][{}]'.format(i,j))

foriinrange(len(a)):

if2ina[i]:

print('a[{}][{}]'.format(i,a[i].index(2)))

3.25⼆维数组拼接

a=[[1,2],[3,4],[5,6]]如何⼀句代码得到[1,2,3,4,5,6]

a=[[1,2],[3,4],[5,6]]

rs=[jforiinaforjini]

print(rs)

3.26列表转字符串

L=[1,2,3,5,6]，如何得出'12356'？

L=[1,2,3,5,6]

rs=''

foriinL:

rs+=str(i)

print(rs)

3.27两个列表如何得到字典

a=["a","b","c"]

b=[1,2,3]

如何得到{'a':1,'b':2,'c':3}

a=["a","b","c"]

b=[1,2,3]

rs={}

foriinrange(len(a)):

rs[a[i]]=b[i]

print(rs)

3.28列表按age从⼩到⼤排序

如下列表

people=[

{"name":"yoyo","age":20},

{"name":"admin","age":28},

{"name":"zhangsan","age":25},

]

按年龄age从⼩到⼤排序

people=[

{"name":"yoyo","age":20},

{"name":"admin","age":28},

{"name":"zhangsan","age":25},

]

foriinrange(len(people)):

forjinrange(i+1,len(people)):

ifpeople[i]["age"]>people[j]["age"]:

people[i]["age"],people[j]["age"]=people[j]["age"],people[i]["age"]

print(people)

3.29列表插⼊元素

现有nums=[2,5,7]，如何在该数据最后插⼊⼀个数字9，如何在2后⾯插⼊数字0

nums=[2,5,7]

(9)

n=(2)

(n+1,0)

print(nums)

3.30打乱列表顺序随机输出

有个列表a=[1,2,3,4,5,6,7,8,9]

如何打乱列表a的顺序,每次得到⼀个⽆序列表

a=[1,2,3,4,5,6,7,8,9]

print(list(t(a)))

第4章元祖字典集合

4.1输出1-100除3余1的数，结果为tuple

输出1-100除3余1的数，结果为tuple

rs=[]

foriinrange(1,101):

ifi%3==1:

(i)

print(tuple(rs))

4.2把2个元祖转字典

将('a','b','c','d','e')和(1,2,3,4,5)两个tuple转成

（1，2，3，4，5）为key,('a','b','c','d','e')为value的字典

a=(1,2,3,4,5)

b=('a','b','c','d','e')

c={}

foriinrange(len(a)):

ifa[i]():

c[a[i]]=b[i]

print(c)

4.3把字典的value值转成str

将字典⾥的值是数值型的转换为字符串，如a={'aa':11,'bb':222}

得到{'aa':'11','bb':'222'}

a={'aa':11,'bb':222}

():

a[i]=str(a[i])

print(a)

4.4(1)和(1,)区别，[1]和[1,]

a=[1,2,3]和b=[(1),(2),(3)]以及c=[(1,),(2,),(3,)]的区别？

a=[1,2,3]

b=[(1),(2),(3)]

c=[(1,),(2,),(3,)]

print(a==b)

print(a==c)

print(type(1),type((1)),type((1,)))

print(type([1]),type([1,]))

4.5map函数将[1，2，3，4]处理成[1,0,1,0]

map函数,有个列表a=[1,2,3,4]计算列表中每个数除以2取出余数得到[1,0,1,0]

a=[1,2,3,4]

defxx(n):

returnn%2

rs=map(xx,a)

print(rs,list(rs))

4.6map函数将列表[1,2,3,4,5]转变成[1,4,9,16,25]

map函数将列表[1,2,3,4,5]使⽤python⽅法转变成[1,4,9,16,25]

a=[1,2,3,4,5]

defjiec(n):

returnn**2

rs=map(jiec,a)

print(list(rs))

4.7map函数a=[1,3,5],b=[2,4,6]相乘得到[2,12,30]

map函数对列表a=[1,3,5],b=[2,4,6]相乘得到[2,12,30]

a=[1,3,5]

b=[2,4,6]

defcheng(a,b):

returna*b

#print(cheng(a,b))

rs=map(cheng,a,b)

print(list(rs))

4.8reduce函数计算1-100的和

reduce函数计算1-100的和

fromfunctoolsimportreduce

defadd(x,y):

returnx+y

rs=reduce(add,[iforiinrange(1,101)])

print(rs)

4.9reduce函数计算10！

reduce函数计算1！+2！+3！+。。。+10！

fromfunctoolsimportreduce

defadd(x,y):

returnx*y

list1=[]

foriinrange(1,11):

rs=reduce(add,[iforiinrange(1,i+1)])

(rs)

print(list1)

print(sum(list1))

defsum(x,y):

returnx+y

rs1=reduce(sum,list1)

print(rs1)

4.10两个字典合并a={"A":1,"B":2},b={"C":3,"D":4}

两个字典合并a={"A":1,"B":2},b={"C":3,"D":4}

a={"A":1,"B":2}

b={"C":3,"D":4}

():

():

a[i]=b[i]

print(a)

4.11{'a':1,'b':2,'c':1}得到{1:['a','c'],2:['b']}

m1={'a':1,'b':2,'c':1}#将同样的value的key集合在list⾥，输出{1:['a','c'],2:['b']}

m1={'a':1,'b':2,'c':1}

rs={}

():

ifm1[i]():

rs[m1[i]]=[i]

el:

rs[m1[i]]+=[i]

print(rs)

4.12字典按key排序d={"name":"zs","age":18,"}

d={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}

字典根据键从⼩到⼤排序

d={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}

kl=[]

dl={}

():

(i)

()

print(kl)

foriinkl:

dl[i]=d[i]

print(dl)

4.13集合（交集、差集、并集）

a=[2,3,8,4,9,5,6]

b=[2,5,6,10,17,11]

1.找出a和b中都包含了的元素

2.a或b中包含的所有元素

3.a中包含⽽集合b中不包含的元素

a=[2,3,8,4,9,5,6]

b=[2,5,6,10,17,11]

defxx(m,n,w):

rs=[]

ifw=='all':

rs=list(t(m+n))

returnrs

el:

rs=()#复制列表和直接引⽤的区别

ifw=='only':

foriinm:

ifiinn:

(i)

returnrs

elifw=='have':

foriinm:

ifinotinn:

(i)

returnrs

el:

print("参数有误")

print(xx(a,b,'have'))#a,b中均有

print(xx(a,b,'x'))

print(xx(a,b,'only'))#a中有b中⽆

print(xx(a,b,'all'))#a,b中所有

第5章综合练习题（上机考试）

5.1有1、2、3、4组成⽆重复数的三位数（排列组合）

有1、2、3、4数字能组成多少互不相同⽆重复数的三位数?

分别打印这些三位数的组合

a=[1,2,3,4]

rs=[]

foriinrange(len(a)):

b=()

delb[i]

forjinrange(len(a)-1):

c=()

delc[j]

forkinrange(len(a)-2):

s1=str(a[i])+str(b[j])+str(c[k])

(int(s1))

print(len(rs),rs)

#rs1=list(t(rs))

#print(len(rs1),rs1)

5.2冒泡排序

a=[11,2,33,1,5,88,3]

冒泡排序：

依次⽐较两个相邻的元素，如果顺序（如从⼩到⼤、⾸字母从A到Z）

错误就把他们交换过来

a=[11,2,33,1,5,88,3]

foriinrange(len(a)):

forjinrange(i+1,len(a)):

ifa[i]>a[j]:

a[i],a[j]=a[j],a[i]

print(a)

5.3⽂本中每⾏中长度超过3的单词

在以下⽂本中找出每⾏中长度超过3的单词:

arsago-nevermindhowlongprecily-having

littleornomoneyinmypur,andnothingparticulartointerestme

onshore,IthoughtIwouldsailaboutalittleandethewaterypart

ayIhaveofdrivingoffthespleen,andregulating

thecirculation.-MobyDick

python的预期结果(尽量不超过3⾏搞定):

[['Call','Ishmael.','Some','years','never','mind','long','precily','having'],

['little','money','pur,','nothing','particular','interest'],

['shore,','thought','would','sail','about','little','watery','part'],

['world.','have','driving','spleen,','regulating'],

['circulation.','Moby','Dick']]]

a="""arsago-nevermindhowlongprecily-having

littleornomoneyinmypur,andnothingparticulartointerestme

onshore,IthoughtIwouldsailaboutalittleandethewaterypart

ayIhaveofdrivingoffthespleen,andregulating

thecirculation.-MobyDick"""

a=e(',','')

a=e('.','')

a=e('n','')

a=("")

rs=[iforiinaiflen(i)>3]

print(rs)

#foriina:

#iflen(i)<=3:

#(i)

#print(a)

5.4列表数据写⼊txt（open读写）

有⼀个数据listofdict如下

a=[

{"yoyo1":"123456"},

{"yoyo2":"123456"},

{"yoyo3":"123456"},

]

写⼊到本地⼀个txt⽂件，内容格式如下：

yoyo1,123456

yoyo2,123456

yoyo3,123456

withopen("",mode='w')asf:

a=[

{"yoyo1":"123456"},

{"yoyo2":"123456"},

{"yoyo3":"123456"},

]

foriina:

():

(j+','+i[j]+"n")

5.5判断邮箱程序（正则）

写⼀个⼩程序：控制台输⼊邮箱地址（格式为urname@），程序识别⽤户名和公司名后，将⽤户名和公司名输出到

控制台。

要求：

1.校验输⼊内容是否符合规范（xx@）,如是进⼊下⼀步，如否则抛出提⽰"incorrectemailformat"。注意必须以.com结尾

2.可以循环“输⼊--输出判断结果”这整个过程

3.按字母Q（不区分⼤⼩写）退出循环，结束程序

importre

whileTrue:

a=input("请输⼊邮箱地址：")

ifa=='Q':

break

elifa=='q':

break

el:

rs=l('.*@.*.com',a)

print(rs)

5.6判断⼀个字符串的括号⾃否闭合（栈）#思考了⼀下午

判断⼀个字符串的括号⾃否闭合（包括⼤⼩中括号）

左括号和右括号必须是⼀⼀对应

⽐如：{[{()}]()}就是⼀个闭合的字符串

{[{()}]([)]}这个⾥⾯([)]这种就是不闭合

importre

defneedc(s,name,all_name):

a=[]

nn=[]

ifname[0]ins:

foriinrange(len(s)):

ifname[0]==s[i]:

(i)

elifname[1]==s[i]:

([a[-1],i])#同⼀类型括号，第⼀个右括号的左边，⼀定是它的当前字符串左边最后⼀个左括号；

dela[-1]

#print(nn)

foriinnn:

news=s[i[0]+1:i[1]]

#print("{}符号中的列表:{};".format(name,news))

forjinall_name:

(j[0])!=(j[1]):

return"{}符号中，在脚标：{},即在列表：{}；符号{}异常！".format(name,i,news,j)

return"符号{}中所有符号均正常；".format(name)

#s="{[{()}]([)]}"

s="{[{()}]()}"

s=l('[^A-Za-z0-9]',s)

all_name=['{}','[]','()']

foriinall_name:

rs=needc(s,i,all_name)

print(rs)

参考⽹上⼤佬的，这⾥⽤到的思想：正常的最⼩区域的括号，⼀定是先左，再右；也就是⼀个字符串中，第⼀个右括号的左边，⼀定是它的

左括号（{},[],()）；

defis_clod(m):

left=[]

foriinm:

ifi=='{'ori=='['ori=='(':#遇到左边的括号，则追加到列表中；

(i)

elifi=='}':#遇到有括号，

iflen(left蚬子的功效与作用 )==()!='{':#左括号为空，则说明有括号多了；弹出的不是左⼤括号

returnFal

elifi==']':

iflen(left)==()!='[':

returnFal

elifi==')':

iflen(left)==()!='(':

returnFal

iflen(left)!=0:#列表不为0，则说明左括号多了

returnFal

returnTrue#以上没有遇到fal，则说明括号正确

a='{[{()}]([)]}'

#a='{[{()}]()}'

print(is_clod(a))

5.7计算纯数字白鼻子 ⼦串组成的单⼀数字（⼦串）

有⼀个纯数字组成的字符串,返回连续单⼀数字⼦串的个数

输⼊字符串：“22252”

只含单⼀数字的⼦串是

1个字符：2出现4次，5出现1次

2个字符22出现2次

3个字符222出现1次

4个⼦串0次

5个字符0次

总共4+1+2+1=8

输出结果：8

⽰例:

输⼊：22252

输出：8

defnums(n):

onlyn=list(t(n))

count=0

foriinonlyn:

forjinrange(1,len(n)+1):#字符个数

forkinrange(len(n)):

ifn[k:k+j]==i*j:

count+=1

returncount

a="22252"

print(nums(a))

defnums(s):

count=0

foriinrange(len(s)):

count+=1

forjinrange(i+1,len(s)):

ifs[j]==s[i]:#与i相当，则说明数字在重复

count+=1

el:

break

returncount

print(nums('22252'))

5.8移除字符串⾥⾯的'ab'

有⼀个字符串列表['aababbc','badabcab']将字符串中的'ab'移除

⽐如'aababbc'移除⾥⾯的ab后得到abc需继续移除ab，得到c，直到字符串中不会出现连续的ab

defremove(n,str):

foriinrange(len(n)):

#print(n[i])

whilestrinn[i]:

n[i]=n[i].replace(str,'')

returnn

a=['aababbc','badabcab']

print(remove(a,'ab'))

5.9看代码得结果（join⽤法）

x="abc",y="def",z=["d","e","f"],

分别求出(y)和(z)返回的结果

x="abc"

y="def"

z=["di","e","f"]

print((y))#dabcdabcfab错误，末尾不⽤分割

print(','.join(y))

print(',,'.join(y))

print((z))#diabceabcf

5.10看代码得结果（类和继承）

阅读以下代码，打印结果是什么？

classA(object):

def__init__(lf):

lf.__Gender()

()

def__Gender(lf):

print("A.__Gender()")

defName(lf):

print("()")

classB(A):

def__Gender(lf):

print("B.__Gender()")

defName(lf):

print("()")

b=B()

b=B()#默认先调B的构造⽅法，B没有，所以调⽤⽗类的构造⽅法；私有⽅法只有在⾃⼰的类中才可以访问

#A.__Gender()()

#_Gender⼀个下划线，是保护变量；

#__Gender两个下划线，是私有变量；

5.11看代码得结果（闭包）

阅读以下代码，得到的结果是什么

deffun():

temp=[lambdax:i*xforiinrange(4)]

returntemp

foreveryLambdainfun():

print(everyLambda(2))

参考：/qdPython/article/details/107938206

5.12看代码得结果(列表推导式)

A0=dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))

A1=range(10)

A2=[iforiinA1ifiinA0]

A3=[A0[s]forsinA0]

A4=[iforiinA1ifiinA3]

A5={i:i*iforiinA1}

A6=[[i,i*i]foriinA1]

A0=dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))

A1=range(10)

A2=[iforiinA1ifiinA0]

A3=[A0[s]forsinA0]

A4=[iforiinA1ifiinA3]

A5={i:i*iforiinA1}

A6=[[i,i*i]foriinA1]

print("A0:{}".format(A0))#{a:1,}

print("A1:{}".format(A1))#range(0,10)

print("A2:{}".format(A2))#[]

print("A3:{}".format(A3))#[1,2,3,4,5]

print("A4:{}".format(A4))#[1,2,3,4,5]

print("A5:{}".format(A5))#{0:0,1:1,2:4,9:81}

print("A6:{}".format(A6))#[[0,1][1,2]..[9,81]]

5.13看代码得结果(函数)

阅读以下代码，得到什么结果

deff(x,l=[]):

foriinrange(x):

(i*i)

printl

f(2)

f(3,[3,2,1])

f(3)

deff(x,l=[]):

foriinrange(x):

(i*i)

print(l)

f(3)#[0,1,4]

f(2)#[0,1]答案错的；#正确的[0,1,4,0,1]#所以此处是追加

f(3,[3,2,1])#[3,2,1,0,1,4]

print(id(f(3)),id(f(2)))#这⾥函数调⽤，引⽤的是⼀个地址

5.14看代码得结果(深拷贝和浅拷贝)

写出以下程序的输出结果

fromcopyimportdeepcopy,copy

li=[1,2,[3,4]]

li_sliced=li[:]

li_copied=copy(li)

li_deep_copied=deepcopy(li)

li[0]=888

li[2][0]=666

print(li_sliced,li_copied,li_deep_copied)

fromcopyimportdeepcopy,copy

li=[1,2,[3,4]]

li_sliced=li[:]#[1,2,[666,4]]#浅拷贝，藕断丝连

li_copied=copy(li)#[1,2,[666,4]]

li_deep_copied=deepcopy(li)#[1,2,[3,4]]#深拷贝，彻底⽆关

print(id(li),id(li_sliced),id(li_deep_copied))

print(id(li[2]),id(li_sliced[2]),id(li_deep_copied[2]))

li[0]=888

li[2][0]=666

print(li_sliced,li_copied,li_deep_copied)

5.15mapreducefilter的使⽤

分别使⽤mapreducefilter函数完成下⾯的任务

1.计算1-100的和

2.1-10,对每个数字的平⽅

3.["a","ab","abc","bc","cd"]输出含有c字符的元素，返回值是list

fromfunctoolsimportreduce

#1.计算1-100的和

defsum(x,y):

returnx+y

sums=reduce(sum,[xforxinrange(1,101)])

print(sums)

#2.1-10,对每个数字的平⽅

defs(x):

returnx**2

s=map(s,[xforxinrange(1,11)])

print(list(s))

#3.["a","ab","abc","bc","cd"]输出含有c字符的元素，返回值是list

defhaves(strs):

return'c'instrs

ss=filter(haves,["a","ab","abc","bc","cd"])

print(list(ss))

5.16通过切⽚操作完成以下任务(切⽚)

有个字符串为""通过切⽚完成下⾯的任务

1.输出前3个字符

2.输出后2个字符

3.倒叙输出

4.间隔1个字符串输出

x=""

print(x[:3])

print(x[-2:])

print(x[::-1])

print(x[::2])

5.17根据列表数字出现次数排序去重(排序)

a=[1,2,1,2,2,2,3,4,5,6,56,7,1,3,4]

按列表中数字出现的次数，从⾼到低排序，并去除重复的

⽐如2出现了4次，排第⼀个位置。1出现了3次，于是可以得到：[2,1,3,4,5,6,7,56]

a=[1,2爆炒甘蓝 ,1,2,2,2,3,4,5,6,56,7,1,3,4]

countl=[]

num=list(t(a))#a的⽆重复列表

result=[]

foriinnum:

c=(i)

(c)#求出num中每个数字在a中出现的次数

news=sorted(t(countl),rever=True)#⽆重复次数列表的降序

print(num,countl,news)

foriinnews:

whileiincountl:#次数⼀直在列表，则循环

indexs=(i)#求出⾸次出现的索引

(num[indexs])#结果列表追加该次数的字符

countl[indexs]='x'

print(result)

a=[1,2,1,2,2,2,3,4,5,6,56,7,1,3,4]

dictc={}

onlya=t(a)

result=[]

foriinonlya:

cn=(i)

():

dictc[cn]=[i]

el:

dictc[cn]=dictc[cn]+[i]

print(dictc)

newd=dict(sorted((),key=lambdad:d[0],rever=True))

print(newd)

():

result+=i

print(result)

参考：/python3/

#字典根据“键”或“键值”进⾏不同顺序的排序

#函数原型：sorted(dic,value,rever)

#解释：dic为⽐较函数，value为排序的对象（这⾥指键或键值），

#rever：注明升序还是降序，True--降序，Fal--升序（默认）

5.18补缺失的代码-给个路径查找⽂件（递归）

defprint_directory_contents(sPath):

"""

这个函数接受⽂件夹的名称作为输⼊参数，

返回该⽂件夹中⽂件的路径，

以及其包含⽂件夹中⽂件的路径。

"""

importos

deffile_name(file_dir):

forroot,dirs,(file_dir):

print(root)#当前⽬录路径

print(dirs)#当前路径下所有⼦⽬录

print(files)#当前路径下的所有⽂件

5.19如何判断⼀个字符串有没有重复字符

判断⼀个字符串是否包含重复字符。例如：“hello”就包含重复字符‘l’，⽽“world”就不包含重复字符,有重复打印True,没重复打印Fal

a="helo"

b=t(a)

iflen(a)!=len(b):

print(True)

el:

print(Fal)

5.20找出⼀个字符串中⼦串不含有重复字符的最长⼦串（⼦串）

给定⼀个字符串，请你找出其中不含有重复字符的最长⼦串的长度。

⽰例1:

输⼊:"abcabcbb"输出:3

解释:因为⽆重复字符的最长⼦串是"abc"，所以其长度为3。

⽰例2:

输⼊:"bbbbb""输出:1

解释:因为⽆重复字符的最长⼦串是"b"，所以其长度为1。

⽰例3:

输⼊:"pwwkew"输出:3

解释:因为⽆重复字符的最长⼦串是"wke"'，所以其长度为3。

请注意，你的答案必须是⼦串的长度，"pwke"是⼀个⼦序列，不是⼦串。

a='pwwkew'

n=len(t(a))

result=''

flag=True

print(n)#4

whileflag:

foriinrange(len(a)-n+1):#6-4+1=3;#6-3+1=4

iflen(t(a[i:n+i]))==n:

result=a[i:n+i]

#print("当前n：{}，字符串:{}".format(n,result))

flag=Fal

break

n-=1#3,

print(result)

5.21⼀个字符串中所有⼦串是回⽂的次数（⼦串）

回⽂是指正序（从左向右）和倒序（从右向左）读都是⼀样的。

例如：121，abcdedcba，123321等都是回⽂

这种的字符串“ABCABADCSABBAUYIIYU”找出回⽂出现的次数

⼦串回⽂是：'BB','II','ABA','ABBA','YIIY','UYIIYU'总共有6个

defhuiwen(str):

l=len(str)#3#字符串长度

result=[]

foriinrange(2,l+1):#[2,4]#取的新的字符串长度

forjinrange(l-i+1):#2,1#不同长度字符串，循环原字符串的次数

sstr=str[j:j+i]#[0,2],[1,3];,[0:3]

sl=len(sstr)//2

ifsstr[:sl]==sstr[-1:-sl-1:-1]:

(sstr)

returnresult

a="ABCABADCSABBAUYIIYU"

print(huiwen(a))

5.22找出列表中连续的数字，只取⾸尾（栈）

找出列表中连续的数字，然后只取⾸尾

有⼀个列表[1,2,3,4,8,6,7,11,15]

输出[(1,4),(6,8)]

a=[1,2,3,4,8,6,7,11,15]

b=sorted(t(a))

print(b)

start=""

result=[]

foriinrange(len(b)-1):

ifb[i+1]-b[i]==1:

ifnotstart:

start=b[i]

el:

ifstart:

end=b[i]

((start,end))

start=""

print(result)