# 1.计算字符串中子串出现的次数。
a = 'shgoerohowaijsdgblsnabafnfafaabsaajabajifjfjvnblks;abaajsorfja;bbabpjfabajpfirbnbpajigjaba'
b = 'aba'
print(a.count(b, 0, len(a)))
1
2
3
4
'运行

# 2.一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
c = [12345, 12321, 45654, 78987, 14741, 25825, 36936]
for i in c:
    if i // 10000 % 10 == i % 10 and i // 1000 % 10 == i // 10 % 10:
        print(str(i), '是回文数')
    else:
        print(str(i), '不是回文数')
1
2
3
4
5
6
7
'运行

# 3.请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母,继而判断是星期几。
def function1():
    d = input('请输入星期几的第一个字母')
    # python中没有switch，一般用字典代替switch
    week = {'M': 'Monday', 'T': 'Tuesday', 'W': 'Wednesday', 'Th': 'Thursday', 'F': 'Friday', 'S': 'Saturday',
            'Sn': 'Sunday'}
    if d.upper() == 'M':
        print('{}代表{}'.format(d, week[d.upper()]))
    elif d.upper() == 'T' or d.upper() == 'S':
        e = input('请输入第二个字母：')
        if e == 'h':
            print('{}代表{}'.format(d + e, week['Th']))
        elif e == 'n':
            print("{}代表{}".format(d + e, week['Sn']))
        elif e == 'u' and d.upper() == 'T':
            print('{}代表{}'.format(d, week['T']))
        elif e == 'a' and d.upper() == 'S':
            print("{}代表{}".format(d, week['S']))
        else:
            print('有错误')
    elif d.upper() == 'W':
        print('{}代表{}'.format(d, week['W']))
    elif d.upper() == 'F':
        print('{}代表{}'.format(d, week['F']))
    else:
        print('找不到是星期几')


function1()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
'运行

# 4.按相反的顺序输出列表的值
f = ['a', 1, 2, 'b', 3, 'c']
f.reverse()  # 把列表给反向了，没有返回值
print(f)
1
2
3
4
'运行

# 5.列表转换为字典。i = ['a', 'b'] l = [1, 2], {'a': 'b', 1: 2}
g, h, j = ['a', 'b'], [1, 2], {}
i_ = g + h
for i in range(0, 4, 2):
    j[i_[i]] = i_[i + 1]
print(j)
1
2
3
4
5
6
'运行

# 6.统计一下所有数字出现的个数[1,2,1,2,3,3,3,3]
k = [1, 2, 1, 2, 3, 3, 3, 3]
print(k.count(1), k.count(2), k.count(3))
1
2
3
'运行

# 7.打印歌曲列表 songslist 中的曲目。歌曲列表中有4首歌，播放到每首时显示对应歌手名字。
songlist = {1: 'abc', 2: 'efg', 3: 'hij', 4: 'klm'}
print(songlist[1], songlist[2], songlist[3], songlist[4])  # 就是练习字典的取值，我懒得写循环if什么的了
1
2
3
'运行

# 8.假定有下面的列表:names = [‘fentiao’,‘fendai’,‘fensi’,‘apple’],输出结果为: ‘I have fentiao, fendai, fensi and apple.’
names = ['fentiao', 'fendai', 'fensi', 'apple']
print('I have {},{},{} and {}.'.format(names[0], names[1], names[2], names[3]))

1
2
3
4
'运行

# 9.用列表来实现栈的工作原理：入栈、出栈、查看栈顶元素、栈的长度、栈是否为空。注意：空栈不能出栈,且此时无栈顶元素
list_zhan = []  # 栈


def Stackempty():  # 判断栈是否为空
    if len(list_zhan) == 0:
        return 0
    else:
        return 1


def push(tem):  # 压栈
    list_zhan.append(tem)


def pop():  # 弹栈
    if Stackempty() == 0:
        print('栈空')
        return
    else:
        return list_zhan.pop(-1)


def get():  # 取栈顶元素
    if Stackempty() == 0:
        print('栈空')
    else:
        return list_zhan[-1]


def get_len():  # 得到栈的长度
    return len(list_zhan)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'运行

# 10.元素分类：有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key中，将小于66值保存至第二个key的值中
mm = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
mmm = {1: [], 2: []}
for i in mm:
    if i <= 66:
        mmm[1].append(i)
    else:
        mmm[2].append(i)
print(mmm)

1
2
3
4
5
6
7
8
9
10
'运行

# 11.输出商品列表，用户输入序号，显示用户选中的商品。商品 li = ["手机", "电脑", "鼠标垫", "游艇" ]，a. 允许用户添加商品b. 用户输入序号显示内容
li = ["手机", "电脑", "鼠标垫", "游艇"]


def ooo():
    print(li)
    oo = input(r'输入序号：（从一开始），如果输入‘w''会添加商品,输入‘m''会结束')
    if oo == 'm':
        return
    elif oo == 'w':
        li.append(input('输入要插入的东西：'))
        ooo()

    elif oo.isdigit() and 0 <= int(oo) <= len(li) - 1:
        print(li[int(oo)])
        ooo()
    else:
        print('error')
        ooo()


ooo()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 12.有两个列表：l1 = [11, 22, 33]，l2 = [22, 33, 44]，a. 获取内容相同的元素列表，b. 获取l1中有， l2中没有的元素列表。c. 获取l2 中有，l1中没有的元素列表。d. 获取l1 和 l2 中内容都不同的元素
li11, li22, li_tem1, li_tem2, li_tem3 = [11, 22, 33], [22, 33, 44], [], [], []
for i in li11:
    for j in li22:
        if j == i:
            li_tem1.append(j)  # a
        if j not in li11 + li_tem3:
            li_tem3.append(j)  # c
    if i not in li22:
        li_tem2.append(i)  # b

print('a:{}\nb:{}\nc:{}\nd:{}'.format(li_tem1, li_tem2, li_tem3, li_tem2 + li_tem3))

1
2
3
4
5
6
7
8
9
10
11
12
13
'运行

# 13.转换练习：a. 将字符串 s = "alex"转换为列表，b. 将字符串s = "alex"转换为元组，c. 将列表li = ["alex", "seven"]转换为元组，d. 将元组 tu = ("Alex", "seven")转换为列表。
str_s = 'alex'
li_str = ["alex", "seven"]
tu_str = ("Alex", "seven")
print(list(str_s))  # a
print(tuple(str_s))  # b
print(tuple(li_str))  # c
print(list(tu_str))  # d
1
2
3
4
5
6
7
8
'运行

# 16.输入两个字符串，从第一字符串中删除第二个字符串中所有的字符
str_aa = input('输入第一个字符串：')
str_bb = input('输入第二个字符串：')
str_sfj = list(str_aa)
str_see = ''
for i in str_bb:
    while i in str_sfj:
        str_sfj.remove(i)
for i in str_sfj:
    str_see = str_see + i
print(str_see)

1
2
3
4
5
6
7
8
9
10
11
12

# 17.假设有两个字符串s1和s2，计算通过增添、删除、替换三种操作后，从s1转变为s2所需要的操作次数
# 解析：采用下标匹配的方法,s1，s2长度不相等：需要操作的次数是s2的长度加1。s1，s2长度相等：需要操作的次数是s2的长度
s1 = 'avdhpwf6fwefojfm vb '
s2 = 'haofcn a4\ 24e'
new = [i for i in s1]
for i in range(0, len(new)):
    new[i] = s2[i]
s1 = ''
for i in new:
    s1 += i
print(s1)

1
2
3
4
5
6
7
8
9
10
11
12

# 18.请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy
st110 = 'We Are Happy    '
print(st110.replace(' ', '%20'))
s1 = s1[0:len(s2)]

1
2
3
4
5

# 19.输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba
# 解析：python不需要swap函数，a，b=b，a就是swap的功能
count = 0
str_19 = 'ahgief'  # 输入的字符串
list_str = list(str_19)  # 把输入的字符串转换为列表，方便不同位置的字符交换位置
tem_list = ['' for i in str_19]  # 这是用于存储排列出来的字符串的列表
lock_str19 = ['unlock' for i in str_19]  # 锁，如果一个位置的字符被确定了，那么就给它加一个锁，加了锁之后下一次递归时，不能使用加了锁的位置（锁住的是位置，不是元素）


def function_19(index):  # 参数index是list_str的下标，如果str_19有五个字符，那么会有5层递归，第一层递归负责确定第一个位置的元素是多少，每一层的index都会从0到5遍历一次
    global count
    if index == len(list_str):  # 如果下标等于字符串的长度，说明已经确定的一种排列，这时候就可以把这一种排列打印出来了
        count += 1
        print(''.join(tem_list), count)  # str.join(sequence)是把一个序列（sequence）以str为连接符组合成一个新的字符串
        return  # 有没有return都行，但是加上return可以在打印完一种排列之后不再执行下面的for循环，可以提高效率。
    for i in range(0, len(str_19)):  # 在每一层i都是从0开始逐个遍历，目的是寻找没有加锁的位置，如果找着没有加锁的位置，那这个位置就会被固定在这一层，并加锁不让下一层继续使用
        if lock_str19[i] == 'unlock':  # 如果i所指的位置没有加锁，说明这个位置可以被这一层使用
            tem_list[index] = list_str[i]  # 因为i所指的位置没有加锁,所以i所指的位置被这一层使用，（index代表层，如果index=0，就说明现在是在第0层，以此类推）
            lock_str19[i] = 'lock'  # 第i个位置被使用了就要向第i个位置加锁，这样下一层就不能使用这个位置的元素了
            function_19(index + 1)  # 第index层确定了元素之后就要去下一层，以确定下一层的元素
            lock_str19[
                i] = 'unlock'  # 如果从function_19(index+1)跳出来了，就说明第i个位置已经被使用完成了，并且完成了一种排列，这时候就可以解开这个位置的锁了，以供下一种排列所使用


function_19(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'运行

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/836755