Python 练习题99 持续更新

Python基础练习题 精选 主要都是从基础开始进阶

变量值替换

"""
已知 a 的值为 "hello"，b 的值为 "world"，如何交换 a 和 b 的值？
得到 a 的值为 "world"，b 的值为 "hello"
"""
a = "hello"
b = "world"
# 中间变量解决,几乎所有的语言都支持
tmp = a
a = b
b = tmp

# python里面可以这样写
a, b = b, a

判断回文

"""
回文的定义： "回文"就是正读倒读都一样的。
如奇数个： "98789" ，这个数字正读是"98789" 倒读也是"98789"。
偶数个数字"3223"也是回文数。

字母 "abcba" 也是回文。

判断一个字符串是否是回文字符串，是打印True， 不是打印False
"""

a = "abcba"

# 反转字符串，如果结果相等则为真
print(a == a[::-1])

# 使用内置方法 .reversed 【 就是迭代器 】
b = reversed(a)
c = "".join(b)
print(c)

print(a == "".join(reversed(a)))

字符串切分

"""
1.已知一个字符串为"hello_world_yoyo",
如何得到一个队列 ["hello", "world", "yoyo"]

2.让用户输入任意的用户名与密码，然后将他输入的用户名与 密码打印出来，如用户输入 abc/123 ，则打印
您输入的用户名是: abc
密码是:123

"""

a = "hello_world_yoyo"
b = a.split("_", 1)

c = input("用户输入账号密码（user/password）: ")
d = c.split("/")

print(f"您输入的用户名是:{d[0]}\n密码是:{d[1]}")

split() 通过指定符号 对字符串进行切分，如果第二个参数num有指定值，则切分为num+1个字符串。

字符串拼接

"""
有个列表 ["hello", "world", "yoyo"]

如何把把列表里面的字符串联起来，

得到字符串 "hello_world_yoyo"
"""

a = ["hello", "world", "yoyo"]
b = "_".join(a)

join方法可用于所有的被迭代对象、列表 字符串 元组 集合 字典

替换字符串

把字符串 s 中的每个空格替换成"%20"
输入：s = "We are happy."
输出："We%20are%20happy."

s = "We are happy."
print(s.replace(" ", "%20"))
# 打印 We%20are%20happy.

print(s.replace(" ", "%20", 1))
# 打印 We%20are happy.

replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

打印九九乘法表

1 * 1 = 1   
1 * 2 = 2   2 * 2 = 4   
1 * 3 = 3   2 * 3 = 6   3 * 3 = 9   
1 * 4 = 4   2 * 4 = 8   3 * 4 = 12  4 * 4 = 16  
1 * 5 = 5   2 * 5 = 10  3 * 5 = 15  4 * 5 = 20  5 * 5 = 25  
1 * 6 = 6   2 * 6 = 12  3 * 6 = 18  4 * 6 = 24  5 * 6 = 30  6 * 6 = 36  
1 * 7 = 7   2 * 7 = 14  3 * 7 = 21  4 * 7 = 28  5 * 7 = 35  6 * 7 = 42  7 * 7 = 49  
1 * 8 = 8   2 * 8 = 16  3 * 8 = 24  4 * 8 = 32  5 * 8 = 40  6 * 8 = 48  7 * 8 = 56  8 * 8 = 64  
1 * 9 = 9   2 * 9 = 18  3 * 9 = 27  4 * 9 = 36  5 * 9 = 45  6 * 9 = 54  7 * 9 = 63  8 * 9 = 72  9 * 9 = 81 

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j} * {i} = {j * i} ", end="\t")
    print()

字符串下标

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

从下标0开始索引
# 语法： string.index(value, start, end)

a = "Hello, welcome to my world."
print(a.index("welcome"))

# 在位置下标 5 - 10 之间查找 e
a = "Hello, welcome to my world."
print(a.index("e", 5, 10))

# 考虑找不到的情况
a = "Hello, welcome to my world."

if "welcome" in a:
    print(a.index("welcome"))
else:
    print("-1")

# 三元表达式
print(a.index("welcome") if "welcome" in a else -1)

index()函数用于从列表中找出某个值第一个匹配项的索引位置。

统计字符出现的次数

a = "Hello, welcome to my world."
print(a.count("l"))

count()方法用于统计字符串里某个字符出现的次数

统计每个字符出现的次数

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

解决思路：
利用 collections 库的 Counter方法统计字符串每个单词出现的次数

# 统计所有字符出现的次数
from collections import Counter

a = "gbgkkdehh"
b = Counter(a)
for i, j in dict(b).items():
    print(f"字符：{i} 出现{j}次")

# 找出所有出现n次的字符
from collections import Counter

a = "gbgkkdehh"
m = 2  # 第m个
n = 2  # 出现次数n
b = Counter(a)
s = []
for i, j in dict(b).items():
    if j == n:  # 出现n次
        s.append(i)
print(s)
print(s[m - 1])  # 第一个索引是m-1

# 列表推导式
s = [i for i, j in dict(Counter(a)).items() if j == n]
print(s)

items() 函数以列表返回可遍历的(键, 值) 元组数组。

判断字符是否包含

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

a = "welcome to my world"
b = "gogo"

if a.find(b) == -1:  # 值不存在返回-1
    print(False)
else:
    print(True)

find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。

查找字符串首次出现的位置

输出指定字符串A在字符串B中第一次出现的位置,如果B中不包含A,则输出-1
从 0 开始计数

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

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

输出指定字符串A在字符串B中最后出现的位置,如果B中不包含A,则输出-1 
从 0 开始计数
A = "hello"
B = "hi how are you hello world, hello yoyo !"

if A in B:
    print(B.rfind(A))
else:
    print(B.rfind(A))

rfind()返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。

判断奇数偶数

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

a = 200

if a % 2 == 0:
    print(f"{a} 是偶数")
else:
    print(f"{a} 是奇数")

根据奇数偶数的定义，若整数除以2没有余数，则为偶数，否则为奇数。
因此，偶数取余结果为0，奇数取余结果为非零

判断一个人是否姓王

name = input("请输入你的姓名：")
if name.startswith("王"):
    print(f"{name} 姓氏王")
else:
    print(f"{name} 不姓氏王")

startswith() 方法用于检查字符串是否以指定字符串开头，返回 True、False

判断文件后缀名

name = input("请输入你的文件名：")
if name.endswith("exe"):
    print("exe 后缀文件")
else:
    print("不是exe 后缀文件")

endswith() 方法用于判断字符串是否以指定后缀结尾，返回 True、False

判断纯数字

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

i = "111"
j = "abc123"

# 判断是否抛出异常
try:
    int(i)
    print(True)
except:
    print(False)

# 使用 isdigit方法
i = "111"
j = "abc123"

print(i.isdigit())
print(j.isdigit())

int() 函数用于将一个字符串或数字转换为整型，如果字符串不是数字类型抛异常

isdigit() 方法检测字符串是否只由数字组成，返回 True、Talse

大小写转换

将字符串 a = "This is string example....wow!" 全部转成大写
字符串 b =  "Welcome To My World" 全部转成小写

a = "This is string example....wow!"
b = "Welcome To My World"

print(a.upper())
print(b.lower())

upper() 方法将字符串中的小写字母转为大写字母。

lower() 方法将字符串中的小写字母转为小写字母。

字符串去除空格

将字符串 a = "   This is string example....wow!    "首尾空格去掉

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

strip() 方法用于移除字符串头尾指定的字符，默认空格

字符串去除 左/右 空格

a = "  Hello Sir "

a = "  Hello Sir  "
print(a.lstrip())
print(a.rstrip())
print(a.strip())

lstrip() 方法用于移除字符串指定左边字符，默认空格
rstrip() 方法用于移除字符串指定右边字符，默认空格
strip() 方法用于移除字符串左右空白字符，默认空格

字符串去除所有空格

l = "  Hello World !"

print(l.replace(" ", ""))
print("".join(l.split(" ")))

字符串去重并排序

s = "ajldjlabjfcdleejfddd"，去重并从小到大排序输出"abcdefjl"

s = "ajldjlabjfcdleejfddd"

l = []
for i in s:
    if i not in l:
        l.append(i)
print("".join(sorted(l)))

# 使用集合的特性来去重
s = "ajldjlabjfcdleejfddd"
t = set(s)
print("".join(sorted(t)))

sorted() 方法是python里面的内置函数，用于排序

参数说明:
iterable 可迭代对象，如：str、list、tuple、dict都是可迭代对象（这里就不局限于list了）
key 用列表元素的某个属性或函数进行作为关键字（此函数只能有一个参数）
`reverse 排序规则. reverse = True 降序或者 reverse = False 升序，默认升序
return 有返回值，返回新的队列

字符串去重后 保留顺序

s = "ajldjlabjfcdleejfddd"
t = set(s)
print("".join(sorted(t, key=lambda x: s.index(x))))

打印棱形图案

    *
   ***
  *****
 *******
  *****
   ***
    *

line = 7
lines = (line + 1) // 2  # 得到棱形的一半

# 每行*号的数量
start = [1 + 2 * i for i in range(0, lines)] + [2 * ii - 1 for ii in range(lines - 1, 0, -1)]

# 根据每行*号的数量和行数，计算出空格数
for star in start:
    kong = (line - star) // 2
    print(" " * kong, "*" * star)

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

a = input("请输入整数：")

print("a的位数是：", len(str(a)), "逆序打印：", str(a)[::-1])

len() 方法返回对象(字符、列表、元组等)长度或项目个数。

水仙花数

如果一个 3 位数等于其各位数字的立方和，则称这个数为水仙花数。  
例如：153 = 1^3 + 5^3 + 3^3，因此 153 就是一个水仙花数

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

for i in range(100, 1000):
    for j in str(i):
        if i == sum([int(j) ** 3]):
            print(i)

完全数

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

求1000以下的完全数?

for a in range(2, 1000):
    s = []
    for i in range(1, a):
        if a % i == 0:  # 判断正整数
            s.append(i)
    if sum(s) == a:
        print(a)

# 列表生成式
for j in range(2, 1000):
    if sum([i for i in range(1, j) if j % i == 0]) == j:
        print(j)

数字1-100的和

求数字 1+2+3+4+5+...+100之和

# 使用for循环
su = 0
for i in range(1, 101):
    su += i
print(su)

# 使用while循环
a = 1
s = 0
while a < 101:
    a += 1
    s += a
print(s)

# 使用sum求和
print(sum(range(101)))

1-2+3-4+5-....-100的和

su = 0
for i in range(1, 101):
    if i % 2 == 0:
        su -= i
    else:
        su += i
print(su)

a = 1
s = 0
while a < 100:
    if a % 2 == 0:
        s += a
    else:
        s -= a
    a += 1
print(s)

print(sum([1 * i if i % 2 else -1 * i for i in range(1, 101)]))

根据题目判断出的规律就是偶数相减，级数相加

1+2-3+4-5+.....+100的和

su = 0
for i in range(1, 101):
    if i % 2 == 0 or i == 1:
        su += i
    else:
        su -= i
print(su)

a = 1
s = 0
while a <= 100:
    if a % 2 == 0 or a == 1:
        s += a
    else:
        s -= a
    a += 1
print(s)

根据题目判断出的规律就是偶数相加，奇数相减

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

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

n = 100
s = 0
for i in range(1, n+1):
    if i % 5 == 0:
        s += i
print(s)

a = 1
b = 0
n = 100

while a <= 100:
    if a % 5 == 0:
        b += a
    a += 1
print(b)

print(sum([i for i in range(1, n+1) if i % 5 == 0]))

# 最终形成函数
def func5(n=100):
    s = 0
    for i in range(1, n + 1):
        if i % 5 == 0:
            s += i
    return s

    # return sum([i for i in range(1, n + 1) if i % 5 == 0])

if __name__ == '__main__':
    print(func5())

计算 n个自然数的立方和

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

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

n = int(input("请输入一个自然数："))
s = 0
for i in range(1, n + 1):
    s += i ** 3

print(sum(i ** 3 for i in range(1, n + 1)))

# 使用pow函数
n = int(input("请输入一个自然数："))
s = 0
for i in range(1, n + 1):
    s += pow(i, 3)

print(sum(pow(i, 3) for i in range(1, n + 1)))

pow() 方法返回 xy（x 的 y 次方） 的值

阶乘 10

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

n = 10
s = 1
while n >= 1:
    s *= n
    n -= 1
print(s)

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

阶乘累加和 求1+2!+3!+...+10!的和

n = 10
a = 1
s = 0
for i in range(1, n + 1):
    a *= i
    print(a)
    s += a
print(s)

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

n = 3
s = 0
a = 0
for i in range(1, 6):
    s = str(n) * i
    a += int(s)

for i in range(5):
    s += 3 * 10 ** i  # 3乘10的次方
    a += s
print(a)

斐波那契数列

已知一个数列：1、1、2、3、5、8、13、。。。。
规律为从 3 开始的每一项都等于其前两项的和，这是斐波那契数列。
求满足规律的 100 以内的所有数据

num = 100
a = 0
b = 1
n = 1
while n <= num:
    n = a + b
    a, b = b, n
    if n >= 100:
        break
    else:
        print(n)

列表 反转

如何判断一个数组（python里面叫list 列表，其他语言叫数组）是对称数组：
要求：判断数组元素是否对称。例如[1，2，0，2，1]，[1，2，3，3，2，1]这样的都是对称数组
用Python代码判断，是对称数组打印True，不是打印False,如：
x = [1, "a",  0, "2", 0, "a", 1]

print(x == x[::-1])

print(reversed(x))
print(x == list(reversed(x)))

# 使用copy模块
import copy

b = copy.deepcopy(x)  # 深拷贝
x.reverse()  # 反转值 x
print(x == b)

reversed() 函数返回一个反转的迭代器。

列表切片

如果有一个列表a=[1,3,5,7,11]
问题：
1如何让它反转成[11,7,5,3,1]
2.取到奇数位值的数字，如[1,5,11]

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

s = a[::-1]
ss = a[::2]

a.reverse()  # # 不会生成新列表
print(a)

b = reversed(a)  # 生成新列表
print(list(b))

反转的时候 a.reverse() 不会生成新的列表，reversed(a) 会生成新的列表（可迭代对象）

列表顺序 排序

问题：对列表a 中的数字从小到大排序
a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8] 

a.sort()
print(sorted(a))

python的排序有两个方法， 一个是list对象的sort方法，另外一个是builtin函数里面sorted，主要区别：
sort仅针对于list对象排序，无返回值, 会改变原来队列顺序
sorted是一个单独函数，可以对可迭代（iteration）对象排序，不局限于list，它不改变原生数据，重新生成一个新的队列

取 最大值 最小值

L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
找出列表中最大值和最小值

print(min(L1))
print(max(L1))

A = ["b", "b", "a", "c", "d", "r", "f", "z"]
print(min(A))
print(max(A))

列表 最长值

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

print(min(a, key=lambda x: len(x)))
print(max(a, key=lambda x: len(x)))

列表 取最大三个值

取出列表中最大的三个值
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]

print(sorted(L1)[-3::])
print(sorted(L1, reverse=True)[:3])

列表 按绝对值排序

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

a.sort(key=lambda x:abs(x))
print(sorted(a,key=lambda x:abs(x)))

列表 按长度排序

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

a.sort(key=lambda x: len(x), reverse=True)
print(a)

reverse=True 默认是倒叙，False 就是顺序

列表 去重复保留顺序

将列表中的重复值取出(仅保留第一个)，要求保留原始列表顺序
如 a = [3, 2, 1, 4, 2, 6, 1]  输出[3, 2, 1, 4, 6]

a = [3, 2, 1, 4, 2, 6, 1]
b = []
for i in a:
    if i not in b:
        b.append(i)
print(b)

print(sorted(set(a), key=lambda x: a.index(x)))

列表 合并列表

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

print(a+b)

a.extend(b)

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

列表 列表生式（推导式）

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

listss = [i for i in range(1, 11) if i % 2 == 0]

列表 计算成员的平方

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

a = [1, 4, 9, 16, 25]
for i in a:
    i **= 2
    print(i, end=" ")

listss = [i**2 for i in a]

找出大于0的数

使用列表推导式，将列表中a = [1, 3, -3, 4, -2, 8, -7, 6]
找出大于0的数，重新生成一个新的列表

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

for i in a:
    if i > 0:
        x.append(i)

lists1 = [i for i in a if i > 0]
listss = [x.append(i) for i in a if i > 0]

列表 正数/负数 统计

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

a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
d = len([i for i in a if i > 0])  # 大于零的都是正数
b = len([i for i in a if i < 0])

列表 排除筛选

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

b = []
for i in a:
    if not i.startswith("张"):
        b.append(i)

print([i for i in a if not i.startswith("张")])

函数 过滤

题1：有个列表a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8] 
使用filter 函数过滤出大于0的数
题2：列表b = ["张三", "张四", "张五", "王二"] 过滤掉姓张的姓名

a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
def great_then_0(x):
    return x > 0

print(filter(great_then_0, a))
print(list(filter(great_then_0, a)))

b = ["张三", "张四", "张五", "王二"]
def remove_zhang(x):
    return not str(x).startswith("张")

print(list(filter(remove_zhang, b)))

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

filter() 方法的语法: filter(function, iterable)
参数:
function -- 判断函数。
iterable -- 可迭代对象。
返回filter object 迭代器对象

过滤列表中不及格的学生

a = [
        {"name": "张三", "score": 66},
        {"name": "李四", "score": 88},
        {"name": "王五", "score": 90},
        {"name": "陈六", "score": 56},
     ]

def score_60(x):
    """小于60都不及格，就不返回了"""
    return x.get("score") >= 60

print(filter(score_60, a))
print(list(filter(score_60, a)))

lis = list(filter(lambda x: x.get("score") >= 60, a))
print(lis)

使用匿名函数过滤不及格学生

a = [
    {"name": "张三", "score": 66},
    {"name": "李四", "score": 88},
    {"name": "王五", "score": 90},
    {"name": "陈六", "score": 56},
]

lis = list(filter(lambda x: x.get("score") >= 60, a))
print(lis)

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

有个列表 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]
print(max(a))
print(a.index(max(a)))

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

a = [
    'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
    'need', 'skills', 'more', 'my', 'ability', 'are',
    'so', 'poor'
]
找出列表中出现次数最多的单词

dict1 = {}
for i in a:
    if i not in dict1.keys():
        dict1[i] = a.count(i)
print(dict1)

print(list(dict1.items()))
print(sorted(list(dict1.items()), key=lambda x: x[1])[-1][0])

print(max(a, key=lambda x: a.count(x)))

如果能数量掌握max函数的使用，可以一行代码解决

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

a = [
    'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
    'need', 'skills', 'more', 'my', 'ability', 'are',
    'so', 'poor'
]

# 分别统计了每个值对应的次数
dicta = {}
for i in a:
    if i not in dicta.keys():
        dicta[i] = a.count(i)
# print(dicta)

# 将字典转换为列表
aa = list(dicta.items())

# 使用sorted进行排序，使用下标取值得到结果
print(sorted(aa, key=lambda x: x[1])[-1][0])

# 使用max函数
print(max(a, key=lambda x: a.count(x)))

# 使用内置方法
from collections import Counter

b = Counter(a)
print(dict(b))

max() 方法返回给定参数的最大值，参数可以为序列。
collections() 内置函数与，提供很多集合的方法。

列表 查找元素的位置

给定一个整数数组A及它的大小n，同时给定要查找的元素val，
请返回它在数组中的位置(从0开始)，若不存在该元素，返回-1。

若该元素出现多次请返回第一个找到的位置
如 A1=[1, "aa", 2, "bb", "val", 33]
或 A2 = [1, "aa", 2, "bb"]

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

s = "val"

if s in A1:
    print(A1.index(s))
else:
    print("-1")

result1 = A1.index(s) if s in A1 else -1
result2 = A2.index(s) if s in A2 else -1

index查找不到会抛异常，在这里最好用上判断

列表查找两数之和

给定一个整数数组nums 和一个目标值target ，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定nums=[2，7，11，15]，target=9
因为nums[0] + nums[1] =2+7 = 9
所以返回[0， 1]

nums = [2, 7, 11, 15]
target = 9
for i in range(len(nums)):
    # print(i, nums[i])
    for j in range(i + 1, len(nums)):
        if nums[i] + nums[j] == target:
            print(i, j)

第一层循环值的下标，第二层循环判断值

列表 二维数组取值（矩阵）

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

aa = a[1][1]
print(aa)

列表拼接

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

# 常规写法
a = [[1, 2], [3, 4], [5, 6]]
for i in a:
    for j in i:
        print(j, end=" ")

# 三元表达式写法
print([j for i in a for j in i])

列表转字符串

L = [1, 2, 3, 5, 6]，如何得出 ‘123456’？

for i in L:
    print(i)

lis = [i for i in L]
print(lis)

lis = [str(i) for i in L]
print("".join(lis))

需注意的是列表中元素都是数字类型，不能直接用join(),必须是字符串才能join()拼接

两个列表如何得到字典

a = ["a", "b", "c"]
b = [1, 2, 3]
如何得到 {'a': 1, 'b': 2, 'c': 3}

dic = {}
for i, j in zip(a, b):
    dic[i] = j
print(dic)

dic = dict(zip(a, b))

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

列表 按指定排序

如下列表
people = [
    {"name": "yoyo", "age": 20},
    {"name": "admin", "age": 28},
    {"name": "zhangsan", "age": 25},
]
按年龄age从小到大排序

# 使用sorted函数
people_1 = sorted(people, key=lambda x: x["age"])
# 使用sort方法
people.sort(key=lambda x: x["age"])

sorted 和 sort的区别、sorted会生成新的列表，sort是不会生成新的列表在原来的规则上排序

列表 插入数据

现有 nums = [2, 5, 7] ，

如何在该数据最后插入一个数字 9 ，
如何在2后面插入数字0

nums = [2, 5, 7]
nums.append(9)
nums.insert(1, 0)
nums.insert(nums.index(2) + 1, 0)  # 配合index动态获取2的位置进行追加
print(nums)

append方法是追加到列表末尾
insert方法是指定下标插入数据

列表 打乱随机随机输出

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

import random
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(a)
print(a)

random.shuffle() 是改变原来的列表顺序，返回值是None

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

a = []
for i in range(1, 100 + 1):
    if i % 3 == 1:
        a.append(i)
print(tuple(a))

aa = [i for i in range(1, 101) if i % 3 == 1]
print(tuple(aa))

b = (i for i in range(1, 100 + 1) if i % 3 == 1)
print(tuple(b))

注意！ 元组是没有推导式，小括号是用的生成器

把两个元组转字典

将('a', 'b', 'c', 'd', 'e')  和 (1,2, 3, 4, 5)两个tuple转成
（1， 2， 3， 4， 5）为key, ('a', 'b', 'c', 'd', 'e') 为value的字典

ab = dict(zip(b, a))

同样可以使用zip函数实现

将字典的 value转换为str

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

dic = {}
for i, j in a.items():
    dic[i] = str(j)
print(dic)

for i, j in a.items():
    a[i] = str(j)
print(a)

items() 函数以列表返回可遍历的(键, 值) 元组数组。

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

# 列表定义只有一个成员可以省略逗号
a1 = [1]
a2 = [1, ]

# 小括号代表的是运算符，表示优先计算
b = (1 + 1) * 10

# 元组，只有一个值得时候不加逗号表示运算符
c1 = (1)
# 加上逗号表示这是元组
c2 = (1,)

a = [1, 2, 3]
b = [(1), (2), (3)]
c = [(1,), (2,), (3,)]
print(a)  # [1, 2, 3]
print(b)  # [1, 2, 3]
print(c)  # [(1,), (2,), (3,)]

圆括号又可以表示元组，所以这里有个规定：
当圆括号里面只有一个成员的时候，那么圆括号没啥意义，是可以去掉的
如果元组只有一个成员，需在后面加一个逗号

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

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

a = [1, 2, 3, 4]

def get_yushu(x):
    return x % 2

print(list(map(get_yushu, a)))  # [1, 0, 1, 0]

# 使用匿名函数
print(list(map(lambda x: x % 2, a)))

map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

function -- 函数、
iterable -- 一个或多个序列

map函数 计算平方数

请将列表 [1,2,3,4,5] 使用python方法转变成 [1,4,9,16,25]

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

def seq(x):
    return x ** 2

print(list(map(seq, a)))  # [1, 4, 9, 16, 25]
# 匿名函数
print(list(map(lambda x: x ** 2, a)))

map函数的功能可以理解成，对可迭代对象中的成员分别做一个功能计算，得到一个新的可迭代对象

两个列表相乘

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

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

def chengji(x, y):
    return x * y

print(list(map(chengji, a, b)))
# 匿名函数
print(list(map(lambda x, y: x * y, a, b)))

reduce函数 计算1-100的和

reduce 函数计算1-100的和

from functools import reduce

def add(x, y):
    return x + y

print(reduce(add, range(1, 101)))
# 匿名函数
print(reduce(lambda x, y: x + y, range(1, 101)))

在 Python3 中，reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 functools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数

reduce函数是把多个参数合并的操作

reduce函数 计算10的阶乘

1.计算阶乘10！
10！= 10*9*8*7*6*5*4*3*2*1
2.计算阶乘累加
1！+2！+3！+。。。+10！

# 计算10的阶乘
from functools import reduce

def add(x, y):
    return x * y

print(reduce(add, range(10, 0, -1)))

print(reduce(lambda x, y: x * y, range(10, 0, -1)))

# 生成阶乘并计算阶乘
i = 6
print(reduce(lambda x, y: x * y, range(1, i + 1)))

a_lis = [reduce(lambda x, y: x * y, range(1, i + 1)) for i in range(1, 11)]
print(a_lis)

print(reduce(lambda m, n: m + n, a_lis))

合并字典

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

a = {'A': 1, 'B': 2}
b = {'C': 3, 'D': 4}

a.update(b)
print(a)

update 字典使用方法

{'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}
print(m1.items())

a = [(i[1], i[0]) for i in m1.items()]  # 使用元组取值反转
print(a)  # [(1, 'a'), (2, 'b'), (1, 'c')]

d = {}  # 定义空列表，添加新值
for i in a:
    if i[0] not in d.keys():
        d[i[0]] = [i[1]]
    else:
        d[i[0]].append(i[1])
print(d)

字典按key排序

d={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}
字典根据键（key）从小到大(a-z)排序

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

print(d.items())
f = sorted(d.items(), key=lambda x: x[0])  # 转成列表进行排序，后续再转换回字典
print(f)
dd = dict(f)
print(dd)

集合 （交集&、差集-、并集|）

a = [2, 3, 8, 4, 9, 5, 6]
b = [2, 5, 6, 10, 17, 11]

1.找出a和b中都包含了的元素(交集)
print(set(a) & set(b))
2.a或b中包含的所有元素(并集)
print(set(a) | set(b))
3.a中包含而集合b中不包含的元素(差集)
print(set(a) - set(b))

不同时包含于 a和b的元素
print(set(a) ^ set(b))

• 并集

  对于两个给定集合A、B，由两个集合所有元素构成的集合，叫做A和B的并集。
  记作：AUB 读作“A并B”
  例： {3,5}U{2,3,4,6}= {2,3,4,5,6}

• 交集

  对于两个给定集合A、B，由属于A又属于B的所有元素构成的集合，叫做A和B的交集。
  记作： A∩B 读作“A交B”
  例： A={1,2,3,4,5}，B={3,4,5,6,8}，A∩B={3,4,5}

• 差集

  记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B
  记作： A-B
  例： A={1,2,3,4,5}, B={3,4,5,6,8}， A-B={1, 2}

1、2、3、4 组成无重复的三位数

有1、2、3、4数字能组成多少互不相同无重复数的三位数?
分别打印这些组合

count = 0
for i in range(1, 4 + 1):
    for j in range(1, 4 + 1):
        for n in range(1, 4 + 1):
            if n != j and j != i and i != n:
                print(n, j, i)
                count += 1
print(f"1-4的三位数组合有 {count}")

# 使用内置模块处理
from itertools import combinations, permutations

for i, j, k in permutations(['1', '2', '3', '4'], 3):
    print(i, j, k)
print(len(list(permutations(['1', '2', '3', '4'], 3))))

Itertools 是python内置的模块，使用简单且功能强大，里面有个 permutations 方法就是专门生成排列组合的生成器。

冒泡排序

a = [11, 2, 33, 1,  5, 88, 3]
冒泡排序：
依次比较两个相邻的元素，如果顺序（如从小到大、首字母从A到Z）
错误就把他们交换过来

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

for i in range(len(a) - 1, 0, - 1):
    print(i)  # 需要比较的次数
    for j in range(i):
        if a[j] > a[j + 1]:  # 比较两个相邻的数，交换位置
            a[j], a[j + 1] = a[j + 1], a[j]
        print(a)

解决思路：
n个元素，依次比较相邻2个元素，第一轮保证最大的数在最后一个位置 需比较n-1次
第二轮（最后一个数不用管），保证第二大的数在倒数第二个位置，需比较n-2次
依此类推。。。
直到最后前面2个数比较，需比较1次

文本中长度超过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_1 = a.split("\n")  # 多行转为大列表
a_2 = [i.split(" ") for i in a.split("\n")]  # 列表格式处理
a_3 = [[j for j in i.split(" ") if len(j) > 3] for i in a.split("\n")]  # 筛选出大于3的值

# 常见循环
list_1 = []
for i in a.split("\n"):
    for j in i.split(" "):
        if len(j) > 3:
            list_1 += j.split(" ")
print(list_1)

列表内容写入txt

有一个数据list of dict如下
a = [
    {"yoyo1": "123456"},
    {"yoyo2": "123456"},
    {"yoyo3": "123456"},
]

写入到本地一个txt文件，内容格式如下：
yoyo1,123456
yoyo2,123456
yoyo3,123456

with open("file.txt", "a", encoding="utf-8") as f:
    for i in a:
        for key, value in i.items():
            f.write(f"{key},{value}\n")

判断合法邮箱

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

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

import re

while True:
    mail = input("请输入你的邮箱号(q/Q 退出)：")
    if mail == "q" or mail == "Q":
        break
    if re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.com$', mail):
        username = re.findall("^(.+?)@", mail)
        print(username[0])
        companyname = re.findall("@(.+?).com", mail)
        print(companyname[0])
    else:
        print("incorrect email format")

re.match (pattern, string, flags=0)
如果 string 开始的0或者多个字符匹配到了正则表达式样式，就返回一个相应的 匹配对象 。 如果没有匹配，就返回 None ；注意它跟零长度匹配是不同的。

re.findall (pattern, string, flags=0)
返回 pattern 在 string 中的所有非重叠匹配，以字符串列表或字符串元组列表的形式。对 string 的扫描从左至右，匹配结果按照找到的顺序返回。 空匹配也包括在结果中。
返回结果取决于模式中捕获组的数量。如果没有组，返回与整个模式匹配的字符串列表。如果有且仅有一个组，返回与该组匹配的字符串列表。如果有多个组，返回与这些组匹配的字符串元组列表。非捕获组不影响结果。

判断字符串的括号自否闭合

判断一个字符串的括号自否闭合（包括大小中括号）
左括号和右括号必须是一一对应
比如：
{[{()}]()}  就是一个闭合的字符串
{[{()}]([)]} 这个里面 ([)] 这种就是不闭合

a = "{[{()}]()}"
d = []
flag = True
for i in a:
    if i == "{" or i == "[" or i == "(":  # 入栈：从左边开始添加
        d.append(i)
    elif i == "}":  # 遇到右边}括号弹出最后面的一个{
        if len(d) == 0 or d.pop() != "{":
            flag = False
    elif i == "]":  # 遇到右边]括号弹出最后面的一个[
        if len(d) == 0 or d.pop() != "[":
            flag = False
    elif i == ")":  # 遇到右边)括号弹出最后面的一个(
        if len(d) == 0 or d.pop() != "(":
            flag = False
# 判断列表中的左边括号是否全部弹出
if len(d) != 0:
    flag = False

• 这里的解决思路是用到出入栈
  

  栈：限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；
  pop内置方法：删除并返回索引处的项目（默认最后一个）。如果列表为空或索引超出范围，则引发 IndexError。

计算字符串中的单一数字

有一个纯数字组成的字符串, 返回连续单一数字子串的个数
输入字符串： “22252”
只含单一数字的子串是
1个字符：2出现4次，5出现1次
2个字符  22 出现2 次
3个字符  222 出现1 次
4个子串 0次
5个字符 0次
总共 4+1+2+1 =8
输出结果：8
示例:
输入：22252
输出： 8

a = input("输入计算字符：")
s = 0
for i in range(1, len(a) + 1):
    b = []
    for j in range(len(a)):
        new_a = a[j:j + i]
        print(new_a)
        if new_a.count(new_a[0]) == i:
            b.append(new_a)
    s += len(b)

print("计算结果为：", s)

移除字符串的字符

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

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

a = ['aababbc', 'badabcab']
b = []
for i in a:
    while 'ab' in i:
        i = i.replace('ab', '')
    b.append(i)
print(b)

看代码得出结果(join 用法)

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

这一题主要考join的语法: str. join(iterable)
字符串调用join方法，参数传一个可迭代对象，y是字符串，z是一个列表，都是可迭代对象，所以上面的x.join(y) 和x.join(z) 返回结果是一样的。

--------------
先回顾下"hello_world_yoyo" 转成 ["hello", "world", "yoyo"]
然后["hello", "world", "yoyo"]  转成 "hello_world_yoyo"

a = "hello_world_yoyo"
print(a.split("_")) # 运行结果 ['hello', 'world', 'yoyo']
b = ["hello", "world", "yoyo"]
print("_".join(b)) # 运行结果 hello_world_yoyo

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类继承了A类
• B()实例化的时候会自动运行init()方法
• A类里的__Gender() 是私有方法，所以只会执行A类里面的
• Name 是实例方法，继承后B类的Name会覆盖掉A类的Name方法

看代码得结果（闭包）

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

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

----------------------

def fun():
    tmp = []
    for i in range(4):
        def inner(x):
            return i * x
        tmp.append(inner)
    return tmp

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

这里只定义了一个函数 inner(), 有 2 个变量，i 是函数外部的变量，x 是函数内部的变量。
外部变量i是可变的0， 1， 2，3.但最后会被3覆盖前面的
内部变量x是不可变的，传值是2

看代码得结果（列表推导式）

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]  # [1, 2, 3, 4, 5]
A4 = [i for i in A1 if i in A3]  # [1, 2, 3, 4, 5]
A5 = {i: i * i for i in A1}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
A6 = [[i, i * i] for i in A1]  # [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]

看代码的结果（函数）

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

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

List参数是可变对象，使用append方法添加新元素并不会造成list对象的重新创建，地址的重新分配。这样，‘恰好’就在默认参数指向的地址处修改了对象，下一次调用再次使用这个地址时，就可以看到上一次的修改了。

看代码得结果（深拷贝和浅拷贝）

• 不可变对象：int、str、tuple

• 可变对象：list、set、dict

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)  # [1, 2, [666, 4]]
print(li_copied)  # [1, 2, [666, 4]]
print(li_deep_copied)  # [1, 2, [3, 4]]

• 深拷贝 deepcopy

  是将原来的数据完整拷贝一份，互不同步/影响

• 浅拷贝 copy

  相当于拷贝的是原有数据的内存地址，内部延续使用原来数据

map、reduce、filter

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

1.计算 1- 100 的和
from functools import reduce

print(reduce(lambda x, y: x + y, range(1, 101)))

2.1-10,对每个数字的平方
print(list(map(lambda x: x * x, range(1, 11))))

3. ["a", "ab", "abc", "bc", "cd"] 输出含有c字符的元素，返回值是list
a = ["aa", "ab", "abc", "bc", "cd"]
print(list(filter(lambda x: "c" in x, a)))

切片任务

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

a = "abcdefg.exe"
print(a[:3])
print(a[-2:])
print(a[::-1])
print(a[::2])

统计排序并去重列表

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]

# 先set 去重得到 {1, 2, 3, 4, 5, 6, 7, 56} 无序 print(set(a))
print(set(a))

# 根据set(a)里面成员在a列表中的次数排序
a = [1, 2, 1, 2, 2, 2, 3, 4, 5, 6, 56, 7, 1, 3, 4]
print(sorted(set(a), key=lambda x: a.count(x), reverse=True))

--------------------分别统计每个成员的次数

# 先统计元素和对应的次数（元素，次数）
b = [(i, a.count(i)) for i in set(a)]
print(b)  # [(1, 3), (2, 4), (3, 2), (4, 2), (5, 1), (6, 1), (7, 1), (56, 1)]

# 对统计的元素和次数进行排序
b.sort(key=lambda x: x[1], reverse=True)
print(b)  # [(2, 4), (1, 3), (3, 2), (4, 2), (5, 1), (6, 1), (7, 1), (56, 1)]

# 使用map对列表成员进行计算得到x[0]
e = list(map(lambda x: x[0], b))
print(e)  # [2, 1, 3, 4, 5, 6, 7, 56]

-----------------------使用Counter分别统计每个成员的次数

from collections import Counter

# 分别统计每个元素出现的次数
b = dict(Counter(a))
print(b)  # {1: 3, 2: 4, 3: 2, 4: 2, 5: 1, 6: 1, 56: 1, 7: 1}
# 按照字典的value排序
c = sorted(b.items(), key=lambda x: x[1], reverse=True)
print(c)  # [(2, 4), (1, 3), (3, 2), (4, 2), (5, 1), (6, 1), (56, 1), (7, 1)]
# map对列表重新取值
d = list(map(lambda x: x[0], c))
print(d)

补全代码（递归）

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

def print_directory_contents(sPath):
    # 判读是否是文件
    import os
    for file_name in os.listdir(sPath):
        # 拼接绝对路径
        child = os.path.join(sPath, file_name)
        # 判断文件和文件夹
        if os.path.isfile(child):
            print(f"文件{child}")
        else:
            print(f"文件夹{child}")
            # 递归（自己调用自己）
            print_directory_contents(child)

if __name__ == '__main__':
    sPath = r'C:\Users\liux\Desktop\2022-08'
    print_directory_contents(sPath)

os.listdir(path) 返回path路径下所有的文件夹名称和文件名称，返回list 类似cmd的dir命令
os.path.join(path, filename) 拼接路径和文件名称，返回一个新的路径
os.path.isfile(filepath) 判断是否是一个文件，返回True或False
os.path.isdir(filepath) 判断是否是一个文件夹 ，返回True或False
os.path.isabs(path) 判断是绝对路径 ，返回True或False
os.path.exists 判断文件或文件夹是否存在

判断是否有重复字符

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

# 通过比较字符串的长度判断是否重复
print(True if not len(a) == len(set(a)) else False)

def isdup(a):
    for i in a:
        # print(a.count(i))
        if a.count(i) > 1:
            return True
    return False

if __name__ == '__main__':
    print(isdup("hello"))
    print(isdup("world"))

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

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

示例1:
输入:"abcabcbb"  输出: 3
解释:因为无重复字符的最长子串是"abc"， 所以其长度为3。

示例2:
输入: "bbbbb""   输出: 1
解释:因为无重复字符的最长子串是"b"， 所以其长度为1。

示例3:
输入: "pwwkew"  输出: 3
解释:因为无重复字符的最长子串是"wke"'， 所以其长度为3。
请注意，你的答案必须是子串的长度，"pwke"是一个子序列，不是子串。

a = "pwwwkew"
b = []
for i in range(1, len(a) + 1):  # 子串长度
    for j in range(len(a) - i + 1):  # 字符切片
        new_s = a[j:j + i]
        if len(new_s) == len(set(new_s)):  # 子串不含重复字符
            b.append(new_s)
print(max(b, key=lambda x: len(x)))  # 取出最长子串
print("最长的子串个数:", len(max(b, key=lambda x: len(x))))

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

回文是指正序（从左向右）和倒序（从右向左）读都是一样的。例如：121 ，abcdedcba，123321等都是回文

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

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

a = "ABCABADCSABBAUYIIYU"
b = []
for i in range(2, len(a) + 1):
    for j in range(len(a) - i + 1):
        new_s = a[j:j + i]
        if new_s == new_s[::-1]:
            b.append(new_s)
print(b)
print("子串回文数：", len(b))