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，不是打印False。

a=input("请输入一个字符串：")
print(a)
flag=True
for i in range(len(a)//2):
    if a[i]!=a[-i-1]:
        flag=False
        print("{}不是一个回文字符串;".format(a))
        break
if flag:
    print("{}是一个回文字符串;".format(a))

1.3字符串切割

已知一个字符串为“hello_world_huihui”，如何得到一个队列["hello","world","huihui"]

1 2	`a="hello_world_huihui"` `print(a.split("_"))`

1.4拼接字符串

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

得到字符串"hello_world_huihui

a=['hello', 'world', 'huihui']
aa=""
for i in a:
    aa+=i
    aa += "_"
print(aa[:-1])

　1.5 替换字符

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

输入：s="We are happy."

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

s="We are happy."
ss=s.replace(" ","%20")
print(ss)

1.6 九九乘法表

打印99乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print("{}*{}={}".format(j,i,i*j),end="   ")
    print()

1.7字符下标

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

从下标0开始索引

a="welcome"
b="Hello,welcme.welcome.."
n=0
if a in b:
    for i in b:
        if i!=a[0]:
            n+=1
        else:
            end=len(a)+n
            # print(end)
            if a==b[n:end]: #[6:14]
                print("单词{} 在{}的第{}位出现；".format(a,b,n))
                break
            n+=1
else:
    print("单词{} 未在{}中出现；".format(a,b))

　1.8 统计字符出现的次数

统计字符串"Hello,welcome to my world."　中字母w出现的次数

统计单词my出现的次数

a="Hello, welcome to my world."
b='w'
# 方式一：
# if b in a:
# #     count=0
# #     for i in a:
# #         if i==b:
# #             count+=1
# #     print("{}在字符串{}中,出现了{}次；".format(b, a,count))
# # else:
# #     print("{}未出现在字符串{}中；".format(b,a))
 
# 方式二： #直接将m替换为my即可count=0 while True: if b in a: a=a.replace(b,'',1) count+=1 else: break print("{}在字符串{}中,出现了【{}】次；".format(b, a,count))

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

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

# a="gbgkkdehh"
a=input('请输入一个字符串：')
m=3
n=2
b={}
count=0
for i in a:
    if i not in b.keys():
        b[i]=1
    else:
        b[i]+=1
print(b)
for i in b.keys():
    if b[i]==n:
        count+=1
        if count==m:
            print(i)
            break

1.10 判断字符a含b

判断字符串a="welcome to my world" 是否包含单词b="world"，包含返回True，不包含返回False

a="welcome to my world"
b="world"
if b in a:
    print("True")
else:
    print("False")

1.11 查找字符首次出现位置

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

从0开始计数

A="hello"

B="hi how are you hello world,hello yoyo !"

A = "hello"
B = "hi how are you hello world, hello yoyo !"
n=0
if A in B:
    b=B.replace(A,'=',1)
    print(b)
    for i in b:
        if i!='=':
            n+=1
        else:
            print("{}在字符串{}中第一次出现的位置是 {}".format(A,B,n))
else:
    print(-1)

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

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

从0开始计数

A="hello"

B = "hi how are you hello world, hello yoyo !"　　

A = "hello"
B = "hi how are you hello world,hello yoyo !"
n=0
count=0
print(len(B))
while A in B:
    n=B.index(A)
    B=B.replace(A,'',1)
    count+=1
# print(n)
print(n+(count-1)*len(A))

1.13判断奇数偶数

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

a=int(input("请输入任意一个整数："))
# print(a,type(a))
if a%2==0:
    print("偶数")
else:
    print("奇数")

1.14判断一个姓名是否姓王

　输入一个姓名，判断是否姓王

a="王五"

b="老王"

a="老王五"
if a[0]=="王":
    print("{} 姓‘王’".format(a))
else:
    print("{} 不姓'王'".format(a))

1.15 判断是不是数字

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

a="123456"

b="yoyo123"

#方式1<br>import re
a="123456"
b=re.findall('\d',a)
if len(a)==len(b):
    print("{} 是纯数字；".format(a))
else:
    print("{} 不是纯数字；".format(a))<br><br>#方式2a="12345c6"<br>if a.isdigit():<br>    print("数字字符串")<br>else:<br>    print("非数字字符串")

1.16 字符串大小写转换

将字符串 a="This is string example....wow!" 全部转成大写

字符串 b="Welcome To My World"全部转成小写

a="This is string example....wow!"
print(a.upper())
print(a.lower())

1.17 字符串去掉首尾空格

将字符串a=" welcome to my world "首尾空格去掉　

a=" welcome to my world "
print(a.strip())
print('abcab'.strip('a'))

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

将字符串a = " welcome to my world ！"左边的空格去掉

1 2	`a` `=` `" welcome to my world ！ "` `print(a.lstrip())`

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

将字符串a = " welcome to my world ! "右边的空格去掉

a = " welcome to my world!"
print(a.rstrip())
print(a.rstrip("!"))

1.20 去除字符串里面所有的空格

将字符串a = " welcome to my world ! "里面的所有空格都去掉

1 2	`a` `=` `" welcome to my world ! "` `print(a.replace(' ',''))`

1.21字符串去重后排序

s = "ajldjlajfdljfddd"，去重并从小到大排序输出"adfjl"

s = "ajldjlajfdljfddd"
rs=[]
for i in s:
    if i not in rs:
        rs.append(i)
# rs=sorted(rs) #列表排序方式1
rs.sort()
s="".join(rs)
print(rs,s)

1.22字符串去重保留顺序

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

s = "ajldjlajfdljfddd"
rs=""
for i in s:
    if i not in rs:
        rs+=i
print(rs)

1.23画菱形

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

n=7
for i in range(n//2+1):
    print(' '*(n//2-i)+'*'*(2*i+1))#3,1; 2,3; 1,5;;0,7;;
for i in range(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=[]
for j in range(100,1000):
    i=str(j)
    bai=int(i[0])
    shi=int(i[1])
    ge=int(i[2])
    if bai**3+shi**3+ge**3==j:
        result.append(j)
print(result)

2.2完全数

如果一个正整数等于除它本身之外其他所有除数之和，就称之为完全数。
例如：6是完全数，因为6 = 1+2+3；
下一个完全数是28 = 14+7+4+2+1。
求1000以下的完全数

pn=[]
for i in range(1,1000):
    chushu=[1]
    sum=1
    for j in range(2,i):
        if i%j==0:
            chushu.append(j)
            sum+=j
    if sum==i:
        pn.append(i)
        print("{}是一个完全数，真因子有{};".format(i,chushu))
print(pn)

2.3 数字1-100求和

求1+2+3…+100和

n=11
if n%2==0:
    sum=(1+n)*(n//2)
else:
    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
if n%2==0:
    sum=-1*(n//2)
else:
    sum=-1*(n//2)+n
print(sum)

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

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

n=100
if (n-1)%2==0:
    sum=(n-1)//2*(-1)+1
else:
    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
for i in range(1,nc):
    sum+=i*5
print(sum)

2.7 n个自然数的立方和

计算公式 13 + 23 + 33 + 43 + …….+ n3
实现要求：
输入 : n = 5
输出 : 225
对应的公式 : 13 + 23 + 33 + 43 + 53 = 225

n=5
sum=0
for i in range(1,n+1):
    sum+=i**3
print(sum)

2.8 阶乘10!

阶乘的意思: 10!=10x9x8x7x6x5x4x3x2x1
求10!

n=10
Factorial=1
for i in range(2,n+1):
    Factorial*=i
print(Factorial)

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

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

n=10
sum=1
for i in range(2,n):
    Factorial = 1
    for i in range(1,i+1):
        Factorial*=i
    print(Factorial)
    sum+=Factorial
print(sum)

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

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

如：n = 5  a = 3
33333 = 3x10**4+ 3x10**3+ 3x10**2 + 3x10**1 +3x10**0

n=5
a=3
tsum=0
sum=0
nn=n-1
for i in range(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
while num<100:
    snl.append(num)
    num=snl[-1]+snl[-2]
print(snl)

第3章列表练习题

3.1 反转（判断对称）

如何判断一个数组是对称数组：
要求：判断数组元素是否对称。例如[1，2，0，2，1]，[1，2，3，3，2，1]这样的都是对称数组
用Python代码判断，是对称数组打印True，不是打印False,如：
x = [1, "a", 0, "2", 0, "a", 1]

x = [1, "ac", 0, "2", 0, "a", 1]
flag=True
count=len(x)//2
for i in range(count):
    if x[i]!=x[-i-1]:
        flag=False
        break
if flag:
    print("{}是一个对称数组？ True".format(x))
else:
    print("{}是一个对称数组? False".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]
for i in range(len(a)):
    for j in range(i+1,len(a)):
        if a[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)
for i in range(count):
    if L1[i]>max:
        max,L1[i]=L1[i],max
    if L1[i]<min:
        min,L1[i]=L1[i],min
print(max,min)

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

a = ["hello", "world", "yoyo", "congratulations"]
找出列表中单词最长的一个

a = ["hello", "world", "yoyo", "congratulations"]
max=a[0]
for i in a:
    if len(max)<len(i):
        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]
L1.sort()
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=[]
for i in range(len(a)):
    if a[i]<0:
        l.append(a[i]) #将负数放在一个列表中；
        a[i]=-a[i]
a.sort()
l.sort() #对负数列表进行排序
print(a,l)
 
for i in range(len(a)):
    if -a[i] in l:
        a[i]=-a[i]
        del l[-1] #删除负数列表中相应的数
print(a,l)

3.8按字符串长度排序

b = ["hello", "helloworld", "he", "hao", "good"]
按list里面单词长度倒叙

b = ["hello", "helloworld", "he","h3e","hao", "good"]
lens=[]
for i in b:
    lens.append(len(i)) #将每个字符串的长度放在列表中
lens.sort(reverse=True)
print(lens) #长度列表，降序
for i in b:
    num=lens.index(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(set(L1))) #set集合是一个无序的不重复的元素序列
# L1.sort()
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=[]
for i in a:
    if i not in result:
        result.append(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']
# a.append(b)
# print(a)
print(a+b)

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

用一行代码生成一个包含 1-10 之间所有偶数的列表

n=10
list=[2*x for x in range(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**2 for i in a]
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=[i for i in a if i>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
for i in a:
    if i>0:
        zheng+=1
    elif i<0:
        fu+=1
print(zheng,fu)

3.16列表排除筛选

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

a = ["张三","张四","张五","王二","2张2五"]
aa=a.copy()
# print(id(a),id(aa)) #查看引用地址是否一个
n=0
for i in range(len(a)):
    if a[i][0]=='张':
        del aa[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]
def zhengshu(n):
    return n>0
bb=filter(zhengshu,b)
print(list(bb))
 
# a = ["张三","张四","张五","王二","2张2五"]
# def name(n):
#     return n[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},
]
def score(n):
        return n["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=a.index(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
for i in a:
    if a.count(i) >= mcount:
        mcount=a.count(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={}
for i in a:
    if i not in rs.keys():
        rs[i]=1
    else:
        rs[i]+=1
print(rs)

3.22 列表查找元素位置

给定一个整数数组A及它的大小n，同时给定要查找的元素val，
请返回它在数组中的位置(从0开始)，若不存在该元素，返回-1。
若该元素出现多次请返回第一个找到的位置
如 A1=[1, "aa", 2, "bb", "val", 33]
或 A2 = [1, "aa", 2, "bb"]

def find(n,m):
    if m not in n:
        return -1
    else:
        return n.index(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=[]
def sum(nums,target):
    for i in nums:
        if i<target:
            newn.append(i)
    for i in range(len(newn)):
        for j in range(i+1,len(newn)):
            if newn[i]+newn[j]==target:
                return [i,j]
print(sum(nums,target))

3.24二维数组取值(矩阵)

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

a = [["A", 1], ["B", 2]]
# for i in range(len(a)):
#     for j in range(len(a[i])):
#         if a[i][j]==2:
#             print('a[{}][{}]'.format(i,j))
 
for i in range(len(a)):
    if 2 in a[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=[j for i in a for j in i]
print(rs)

3.26 列表转字符串

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

L = [1, 2, 3, 5, 6]
rs=''
for i in L:
    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={}
for i in range(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},
]
for i in range(len(people)):
    for j in range(i+1,len(people)):
        if people[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]
nums.append(9)
n=nums.index(2)
nums.insert(n+1,0)
print(nums)

3.30打乱列表顺序随机输出

有个列表a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
如何打乱列表a的顺序,每次得到一个无序列表

1 2	`a` `=` `[1,` `2,` `3,` `4,` `5,` `6,` `7,` `8,` `9]` `print(list(set(a)))`

第4 章元祖字典集合

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

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

rs=[]
for i in range(1,101):
    if i%3==1:
      rs.append(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={}
for i in range(len(a)):
    if a[i] not in c.keys():
        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}
for i in a.keys():
    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.5 map函数将[1，2，3，4]处理成[1,0,1,0]

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

a = [1, 2, 3, 4]
def xx(n):
    return n%2
rs=map(xx,a)
print(rs,list(rs))

4.6 map函数将列表[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]
def jiec(n):
    return n**2
rs=map(jiec,a)
print(list(rs))

4.7 map函数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]
def cheng(a,b):
    return a*b
# print(cheng(a,b))
rs=map(cheng,a,b)
print(list(rs))

4.8 reduce函数计算1-100的和

reduce函数计算1-100的和

from functools import reduce
def add(x,y):
    return x+y
rs=reduce(add,[i for i in range(1,101)])
print(rs)

4.9 reduce函数计算10！

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

from functools import reduce
def add(x,y):
    return x*y
list1=[]
for i in range(1,11):
    rs=reduce(add,[i for i in range(1,i+1)])
    list1.append(rs)
print(list1)
print(sum(list1))
def sum(x,y):
    return x+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}
for i in b.keys():
    if i not in a.keys():
        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={}
for i in m1.keys():
    if m1[i] not in rs.keys():
        rs[m1[i]]=[i]
    else:
        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={}
for i in d.keys():
    kl.append(i)
kl.sort()
print(kl)
for i in kl:
    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]
def xx(m,n,w):
    rs=[]
    if w=='all':
        rs=list(set(m+n))
        return rs
    else:
        rs=m.copy()  #复制列表和直接引用的区别
        if w=='only':
            for i in m:
                if i in n:
                   rs.remove(i)
            return rs
        elif w=='have':
            for i in m:
                if i not in n:
                    rs.remove(i)
            return rs
        else:
            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=[]
for i in range(len(a)):
    b=a.copy()
    del b[i]
    for j in range(len(a)-1):
        c=b.copy()
        del c[j]
        for k in range(len(a)-2):
            s1=str(a[i])+str(b[j])+str(c[k])
            rs.append(int(s1))
print(len(rs),rs)
# rs1=list(set(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]
for i in range(len(a)):
    for j in range(i+1,len(a)):
        if a[i]>a[j]:
            a[i],a[j]=a[j],a[i]
print(a)

5.3文本中每行中长度超过3的单词

在以下文本中找出每行中长度超过3的单词:
Call me Ishmael. Some years ago - never mind how long precisely - having
little or no money in my purse, and nothing particular to interest me
on shore, I thought I would sail about a little and see the watery part
of the world. It is a way I have of driving off the spleen, and regulating
the circulation. - Moby Dick

python的预期结果(尽量不超过3行搞定):
[['Call', 'Ishmael.', 'Some', 'years', 'never', 'mind', 'long', 'precisely', 'having'],
['little', 'money', 'purse,', 'nothing', 'particular', 'interest'],
['shore,', 'thought', 'would', 'sail', 'about', 'little', 'watery', 'part'],
['world.', 'have', 'driving', 'spleen,', 'regulating'],
['circulation.', 'Moby', 'Dick']]]

a="""Call me Ishmael. Some years ago - never mind how long precisely - having
little or no money in my purse, and nothing particular to interest me
on shore, I thought I would sail about a little and see the watery part
of the world. It is a way I have of driving off the spleen, and regulating
the circulation. - Moby Dick"""
a=a.replace(',',' ')
a=a.replace('.',' ')
a=a.replace('\n',' ')
a=a.split(" ")
rs=[i for i in a if len(i)>3]
print(rs)
# for i in a:
#     if len(i)<=3:
#         a.remove(i)
# print(a)

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

有一个数据list of dict如下
a = [
{"yoyo1": "123456"},
{"yoyo2": "123456"},
{"yoyo3": "123456"},
]
写入到本地一个txt文件，内容格式如下：
yoyo1,123456
yoyo2,123456
yoyo3,123456

with open("a.txt",mode='w') as f:
    a = [
        {"yoyo1": "123456"},
        {"yoyo2": "123456"},
        {"yoyo3": "123456"},
    ]
    for i in a:
        for j in i.keys():
            f.write(j+','+i[j]+"\n")

5.5 判断邮箱程序（正则）

写一个小程序：控制台输入邮箱地址（格式为 username@companyname.com），程序识别用户名和公司名后，将用户名和公司名输出到控制台。
要求：

校验输入内容是否符合规范（xx@yy.com）, 如是进入下一步，如否则抛出提示"incorrect email format"。注意必须以.com 结尾
可以循环“输入--输出判断结果”这整个过程
按字母 Q（不区分大小写）退出循环，结束程序

import re
while True:
    a=input("请输入邮箱地址：")
    if a=='Q':
        break
    elif a=='q':
        break
    else:
        rs=re.findall('.*@.*.com',a)
        print(rs)

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

判断一个字符串的括号自否闭合（包括大小中括号）
左括号和右括号必须是一一对应

比如：{[{()}]()}  就是一个闭合的字符串
{[{()}]([)]} 这个里面 ([)] 这种就是不闭合

import re
def needc(s,name,all_name):
    a=[]
    nn=[]
    if name[0] in s:
        for i in range(len(s)):
            if name[0]==s[i]:
                a.append(i)
            elif name[1] == s[i]:
                nn.append([a[-1],i]) #同一类型括号，<strong>第一个右括号的左边，一定是它的当前字符串左边最后一个左括号；</strong>
                del a[-1]
        # print(nn)
        for i in nn:
            news=s[i[0]+1:i[1]]
            # print("{}符号中的列表:{};".format(name,news))
            for j in all_name:
                if news.count(j[0])!=news.count(j[1]):
                    return "{}符号中，在脚标：{},即在列表：{}；符号{}异常！".format(name,i,news,j)
 
 
    return "符号{}中所有符号均正常；".format(name)
 
# s="{[{()}]([)]}"
s="{[{()}]()}"
s=re.findall('[^A-Za-z0-9]',s)
all_name=['{}','[]','()']
for i in all_name:
    rs=needc(s,i,all_name)
    print(rs)

参考网上大佬的，这里用到的思想：正常的最小区域的括号，一定是先左，再右；也就是一个字符串中，第一个右括号的左边，一定是它的左括号（{},[],()）；

def is_closed(m):
    left=[]
    for i in m:
        if i=='{' or i=='[' or i=='(': #遇到左边的括号，则追加到列表中；
            left.append(i)
        elif i=='}': #遇到有括号，
            if len(left)==0 or left.pop()!='{': #左括号为空，则说明有括号多了；弹出的不是左大括号
                return False
        elif i==']':
            if len(left)==0 or left.pop()!='[':
                return False
        elif i==')':
            if len(left)==0 or left.pop()!='(':
                return False
    if len(left)!=0: #列表不为0，则说明左括号多了
        return False
    return True #以上没有遇到false，则说明括号正确
a='{[{()}]([)]}'
# a='{[{()}]()}'
print(is_closed(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

def nums(n):
    onlyn=list(set(n))
    count=0
    for i in onlyn:
        for j in range(1,len(n)+1): #字符个数
            for k in range(len(n)):
                if n[k:k+j]==i*j:
                    count+=1
    return count
a="22252"
print(nums(a))

def nums(s):
    count=0
    for i in range(len(s)):
        count+=1
        for j in range(i+1,len(s)):
            if s[j]==s[i]: #与i相当，则说明数字在重复
                count+=1
            else:
                break
    return count
print(nums('22252'))

5.8 移除字符串里面的'ab'

有一个字符串列表['aababbc', 'badabcab'] 将字符串中的'ab' 移除
比如'aababbc' 移除里面的ab后得到abc 需继续移除ab，得到c，直到字符串中不会出现连续的ab

def remove(n,str):
    for i in range(len(n)):
        # print(n[i])
        while str in n[i]:
            n[i]=n[i].replace(str,'')
    return n
 
a=['aababbc', 'badabcab']
print(remove(a,'ab'))

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

x="abc",y="def",z=["d","e","f"],
分别求出x.join(y) 和x.join(z)返回的结果

x="abc"
y="def"
z=["di","e","f"]
print(x.join(y)) #dabcdabcfab 错误，末尾不用分割
 
print(','.join(y))
print(',,'.join(y))
print(x.join(z)) #diabceabcf

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

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

class A(object):

    def __init__(self):
        self.__Gender()
        self.Name()

    def __Gender(self):
        print("A.__Gender()")

    def Name(self):
        print("A.Name()")

class B(A):

    def __Gender(self):
        print("B.__Gender()")

    def Name(self):
        print("B.Name()")
b = B()

1 2	`b` `=` `B()` `#默认先调B的构造方法，B没有，所以调用父类的构造方法；私有方法只有在自己的类中才可以访问` `#A.__Gender() B.Name()<br>#_Gender 一个下划线，是保护变量；<br>#__Gender 两个下划线，是私有变量；`

5.11 看代码得结果（闭包）

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

def fun():
    temp = [lambda x: i*x for i in range(4)]
    return temp

for everyLambda in fun():
    print(everyLambda(2))

参考：https://blog.csdn.net/qdPython/article/details/107938206

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

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

A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
A4 = [i for i in A1 if i in A3]
A5 = {i:i*i for i in A1}
A6 = [[i,i*i] for i in A1]

A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
A4 = [i for i in A1 if i in A3]
A5 = {i:i*i for i in A1}
A6 = [[i,i*i] for i in A1]
print("A0:{}".format(A0)) #{a:1,b:2...}
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,3:9...9:81}
print("A6:{}".format(A6)) #[[0,1][1,2]..[9,81]]

5.13 看代码得结果(函数)

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

def f(x,l=[]):
    for i in range(x):
        l.append(i*i)
    print l
 
f(2)
f(3,[3,2,1])
f(3)

def f(x, l=[]):
    for i in range(x):
        l.append(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 看代码得结果(深拷贝和浅拷贝)

写出以下程序的输出结果

from copy import deepcopy, 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)

from copy import deepcopy, 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.15 map reduce filter的使用

分别使用map reduce filter 函数完成下面的任务

1.计算 1- 100 的和
2.1-10,对每个数字的平方
3. ["a", "ab", "abc", "bc", "cd"] 输出含有c字符的元素，返回值是list

from functools import reduce
# 1.计算 1- 100 的和
def sum(x,y):
    return x+y
sums=reduce(sum,[x for x in range(1,101)])
print(sums)
# 2.1-10,对每个数字的平方
def s(x):
    return x**2
s=map(s,[x for x in range(1,11)])
print(list(s))
# 3. ["a", "ab", "abc", "bc", "cd"] 输出含有c字符的元素，返回值是list
def haves(strs):
    return 'c' in strs
ss=filter(haves,["a", "ab", "abc", "bc", "cd"])
print(list(ss))

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

有个字符串为"abcdefg.exe" 通过切片完成下面的任务
1.输出前3个字符
2.输出后2个字符
3.倒叙输出
4.间隔1个字符串输出

x="abcdefg.exe"
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(set(a)) #a的无重复列表
result=[]
for i in num:
    c=a.count(i)
    countl.append(c) #求出num中每个数字在a中出现的次数
news=sorted(set(countl),reverse=True) #无重复次数列表的降序
print(num,countl,news)
for i in news:
    while i in countl: #次数一直在列表，则循环
        indexs=countl.index(i) #求出首次出现的索引
        result.append(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=set(a)
result=[]
for i in onlya:
    cn=a.count(i)
    if cn not in dictc.keys():
        dictc[cn]=[i]
    else:
        dictc[cn]=dictc[cn]+[i]
print(dictc)
newd=dict(sorted(dictc.items(),key=lambda d:d[0],reverse=True))
print(newd)
for i in newd.values():
    result+=i
print(result)<br>
参考：https://www.runoob.com/python3/python3-func-sorted.html
# 字典根据“键”或“键值”进行不同顺序的排序
# 函数原型：sorted(dic,value,reverse)
# 解释：dic为比较函数，value 为排序的对象（这里指键或键值），
# reverse：注明升序还是降序，True--降序，False--升序（默认）

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

def print_directory_contents(sPath):
"""
这个函数接受文件夹的名称作为输入参数，
返回该文件夹中文件的路径，
以及其包含文件夹中文件的路径。
"""

import os
def file_name(file_dir):
    for root, dirs, files in os.walk(file_dir):
        print(root)  # 当前目录路径
        print(dirs)  # 当前路径下所有子目录
        print(files) #当前路径下的所有文件

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

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

a="helo"
b=set(a)
if len(a)!=len(b):
    print(True)
else:
    print(False)

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

给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。
示例1:
输入:" abcabcbb" 输出: 3
解释:因为无重复字符的最长子串是"abc"，所以其长度为3。
示例2:
输入: "bbbbb"" 输出: 1
解释:因为无重复字符的最长子串是"b"，所以其长度为1。
示例3:
输入: " pwwkew" 输出: 3
解释:因为无重复字符的最长子串是"wke"'，所以其长度为3。
请注意，你的答案必须是子串的长度，"pwke"是一个子序列，不是子串。

a='pwwkew'
n=len(set(a))
result=''
flag=True
print(n) #4
while flag:
    for i in range(len(a)-n+1): # 6-4+1=3; #6-3+1=4
        if len(set(a[i:n+i]))==n:
            result=a[i:n+i]
            # print("当前n：{}，字符串:{}".format(n,result))
            flag=False
            break
    n-=1#3,
print(result)

5.21 一个字符串中所有子串是回文的次数（子串）

回文是指正序（从左向右）和倒序（从右向左）读都是一样的。
例如：121 ，abcdedcba，123321等都是回文
这种的字符串“ABCABADCSABBAUYIIYU”找出回文出现的次数
子串回文是：'BB', 'II','ABA','ABBA', 'YIIY','UYIIYU' 总共有6个

def huiwen(str):
    l=len(str) #3 #字符串长度
    result=[]
    for i in range(2,l+1): #[2,4] #取的新的字符串长度
        for j in range(l-i+1): #2,1 #不同长度字符串，循环原字符串的次数
            sstr=str[j:j+i]  #[0,2],[1,3];,[0:3] 
            sl=len(sstr)//2
            if sstr[:sl]==sstr[-1:-sl-1:-1]:
                result.append(sstr)
    return result
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(set(a))
print(b)
start=""
result=[]
for i in range(len(b)-1):
    if b[i+1]-b[i]==1:
        if not start:
            start=b[i]
    else:
        if start:
            end=b[i]
            result.append((start,end))
            start = ""
 
print(result)

posted on 2021-08-02 22:54 星空6 阅读(1287) 评论(2) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· C#/.NET/.NET Core技术前沿周刊 | 第 29 期（2025年3.1-3.9）
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异

历史上的今天：
2020-08-02 python函数装饰器
2020-08-02 pytest（三十八）--元数据使用(pytest-metadata)
2020-08-02 pytest（三十七）--fixture参数化params
2020-08-02 pytest（三十六）--参数化ids用例描述为中文时，控制台输出unicode编码问题（pytest_collection_modifyitems）
2020-08-02 pytest（三十五）--pytest.ini配置用例查找规则
2020-08-02 pytest（三十四）--参数化（parametrize）结合allure.title()生成不同标题报告

python3 练习题100道，孰能生巧，之前要想一个下午的内容，马上就有了答案

第1章 字符串练习题

1.1交换

1.2回文

1.3字符串切割

1.4拼接字符串

1.5 替换字符

1.6 九九乘法表

1.7字符下标

1.8 统计字符出现的次数

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

1.10 判断字符a含b

1.11 查找字符首次出现位置

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

1.13判断奇数偶数

1.14判断一个姓名是否姓王

1.15 判断是不是数字

1.16 字符串大小写转换

1.17 字符串去掉首尾空格

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

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

1.20 去除字符串里面所有的空格

1.21字符串去重后排序

1.22字符串去重保留顺序

1.23画菱形

1.24 输入一个正整数，判断是几位数

第2章 小学数学题

2.1.水仙花数

2.2完全数

2.3 数字1-100求和

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

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

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

2.7 n个自然数的立方和

2.8 阶乘10!

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

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

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

第3章 列表练习题

3.1 反转（判断对称）

3.2列表切片

3.3列表大小排序

3.4 取出最大值最小值

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

3.6 切片取出列表中最大的三个数

3.7列表按绝对值排序

3.8按字符串长度排序

3.9去重与排序

3.10 去重保留顺序

3.11 列表合并

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

3.13 列表成员的平方

3.14 找出列表大于0的数

3.15统计列表有多少大于0

3.16列表排除筛选

3.17列表过滤(filter)

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

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

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

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

3.22 列表查找元素位置

3.23列表查找两数之和

3.24二维数组取值(矩阵)

3.25 二维数组拼接

3.26 列表转字符串

3.27 两个列表如何得到字典

3.28列表按age从小到大排序

3.29列表插入元素

3.30打乱列表顺序随机输出

第4 章 元祖字典集合

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

4.2 把2个元祖转字典

4.3 把字典的value值转成str

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

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

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

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

4.8 reduce函数计算1-100的和

4.9 reduce函数计算10！

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

第1章字符串练习题

　1.5 替换字符

　1.8 统计字符出现的次数

第2章小学数学题

第3章列表练习题

第4 章元祖字典集合

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