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"]

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
import re
a="123456"
b=re.findall('d',a)
if len(a)==len(b):
    print("{} 是纯数字；".format(a))
else:
    print("{} 不是纯数字；".format(a))

#方式2

a="12345c6"
if a.isdigit():
    print("数字字符串")
else:
    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 ！"左边的空格去掉

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 ! "里面的所有空格都去掉

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的顺序,每次得到一个无序列表

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('
',' ')
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]+"
")

　　

5.5 判断邮箱程序（正则）

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

1. 校验输入内容是否符合规范（xx@yy.com）, 如是进入下一步，如否则抛出提 示"incorrect email format"。注意必须以.com 结尾
2. 可以循环“输入--输出判断结果”这整个过程
3. 按字母 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]) #同一类型括号，第一个右括号的左边，一定是它的当前字符串左边最后一个左括号；
                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()

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

参考：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)