本文题目来自:上海-悠悠 的Python3 收集100+练习题(面试题笔试题) 

实际只有93题....答案仅供参考,并非唯一答案,有错欢迎指正

下面上题目和答案:

# 博客园 - C、小明
'''
1.1交换
已知 a的值为"hello",b的值为"world",如何交换a和b的值?
得到a的值为"world",b的值为"hello"
'''
def a_1():
    a = "hello"
    b = "world"
    a,b = b,a
    return a,b

'''
1.2回文
回文的定义:"回文" 就是正读倒读都一样的。
如奇数个:"98789",这个数字正读是"98789" 倒读也是"98789"。
偶数个数字"3223"也是回文数。
字母 "abcba" 也是回文。
判断一个字符串是否是回文字符串,是打印True, 不是打印False
'''
def a_2():
    a = "98789"
    return a == a[::-1]

'''
1.3字符串切割
已知一个字符串为 "hello_world_yoyo", 如何得到一个队列 ["hello","world","yoyo"]
'''
def a_3():
    a = "hello_world_yoyo"
    return a.split('_')

'''
1.4拼接字符串
有个列表 ["hello", "world", "yoyo"]如何把把列表里面的字符串联起来,
得到字符串 "hello_world_yoyo"
'''
def a_4():
    a =  ["hello", "world", "yoyo"]
    return '_'.join(a)

'''
1.5替换字符
把字符串 s 中的每个空格替换成"%20"
输入:s = "We are happy."
输出:"We%20are%20happy."
'''
def a_5():
    a = "We are happy."
    return a.replace(' ','%20')

'''
1.6九九乘法表
打印99乘法表
'''
def a_6():
    j = 1
    for i in range(1,10):
        j += 1
        a = ''
        for n in range(1,j):
            m = i*n
            print ('%sX%s=%s'%(n,i,m),end = ' ')
        print ()

'''
1.7字符下标
找出单词 "welcome" 在 字符串"Hello, welcome to my world." 中出现的位置,找不到返回-1
从下标0开始索引
'''
def a_7():
    a = "welcome"
    b = "Hello, welcome to my world."
    if a in b:
        n = b.find(a)
    else:
        n = -1
    return n

'''
统计字符串“Hello, welcome to my world.” 中字母w出现的次数
统计单词 my 出现的次数
'''
def a_8():
    a = 'Hello, welcome to my world.'
    n = a.count('w')
    m = a.count('my')
    return n,m

'''
题目:输入一个字符串str, 输出第m个只出现过n次的字符,如在字符串 gbgkkdehh 中,
找出第2个只出现1 次的字符,输出结果:d
'''
def a_9():
    a = 'gbgkkdehh'
    c = {}
    d = []
    for i in a:
        if i in c:
            c[i] = c[i] + 1
        else:
            c[i] = 0
    for e,r in c.items():
        if r == 1:
            d.append(e)
    j = 2
    if len(d) > j+1:
        return None
    else:
        return d[j-1]        
    
'''
判断字符串a=”welcome to my world” 是否包含单词b=”world”
包含返回True,不包含返回 False
'''
def a_10():
    a = 'welcome to my world'
    b = 'world1'
    if b in a:
        return True
    else:
        return False


'''
输出指定字符串A在字符串B中第一次出现的位置,如果B中不包含A,则输出-1
从 0 开始计数
A = “hello”
B = “hi how are you hello world, hello yoyo !”
'''
def a_11():
    a = 'hello'
    b = 'hi how are you hello world, hello yoyo !'
    if a in b:
        return b.find(a)
    else:
        return -1

'''
输出指定字符串A在字符串B中最后出现的位置,如果B中不包含A, 出-1从 0 开始计数
A = “hello”
B = “hi how are you hello world, hello yoyo !”
'''
def a_12():
    a = 'hello'
    b = 'hi how are you hello world, hello yoyo !'
    print (a,b)
    if a in b:
        return b.rfind(a)
    else:
        return -1

'''
给定一个数a,判断一个数字是否为奇数或偶数
a1 = 13
a2 = 10
'''
def a_13():
    a = 10
    if type(a) != int or a < 0:
        return '请输入大于0的数字'

    b = a % 2 
    if b == 0:
        return '偶数'
    else:
        return '奇数'

'''
输入一个姓名,判断是否姓王
a = “王五”
b = “老王”
'''
def a_14():
    a = '王五'
    if type(a) != str:
        return '请输入字符串'
    if a[0] == '王' and len(a) > 0:
        return True
    else:
        return False

'''
如何判断一个字符串是不是纯数字组成
a = “123456”
b = “yoyo123”
'''
def a_15():
    a = 'yoyo123'
    for i in a:
        try:
            int(i)
        except:
            return False
    return True

'''
将字符串 a = “This is string example….wow!” 全部转成大写
字符串 b = “Welcome To My World” 全部转成小写
print(str.upper())          # 把所有字符中的小写字母转换成大写字母
print(str.lower())          # 把所有字符中的大写字母转换成小写字母
print(str.capitalize())     # 把第一个字母转化为大写字母,其余小写
print(str.title())          # 把每个单词的第一个字母转化为大写,其余小写 
'''
def a_16():
    a = 'Welcome To My World'
    return a.upper()


'''
将字符串 a = “ welcome to my world “首尾空格去掉
python提供了strip()方法,可以去除首尾空格
rstrip()去掉尾部空格
lstrip()去掉首部空格
replace(" ", “”) 去掉全部空格
'''
def a_17():
    a = ' welcome to my world '
    if a[0] == ' ':
        a = a[1:]
    if a[-1] == ' ':
        b = len(a) -1
        a = a[:b]
    return a

'''
s = “ajldjlajfdljfddd”,去重并从小到大排序输出”adfjl”
'''
def a_18():
    s = 'ajldjlajfdljfddd'
    s = list(set(s))
    s.sort()
    return ''.join(s)
  
'''
题目 打印出如下图案(菱形):
在这里插入图片描述
   *
  ***  
 *****
******* 
 *****
  ***  
   *
'''
def a_19():
    j = 1
    m = 3
    n = True
    y = ''
    for i in range(7):
        y += ' '*m + '*'*j + '\n'
        if j == 7:
            n = False
        if n:
            j += 2
            m -= 1
        else:
            j -= 2
            m += 1
    return y


'''
题目 给一个不多于5位的正整数,要求:
一、求它是几位数,
二、逆序打印出各位数字。
a = 12345
'''
def a_20():
    a = 12345
    return len(str(a)),''.join(list(str(a))[::-1])


'''
如果一个 3 位数等于其各位数字的立方和,则称这个数为水仙花数。
例如:153 = 1^3 + 5^3 + 3^3,因此 153 就是一个水仙花数
那么问题来了,求1000以内的水仙花数(3位数)
'''
def a_21():
    a = []
    for i in range(100,1000):
        j = str(i)
        if int(j[0]) ** 3 +  int(j[1]) ** 3 + int(j[2]) ** 3 == i:
            a.append(i)
    return a

'''
求1+2+3…+100和
'''
def a_22():
    i = 0
    for j in range(101):
        i = j + i
    return i
    '''
    a = 100
    return a * (a / 2) + (a / 2)
    '''

'''
计算求1-2+3-4+5-…-100的值
'''
def a_23():
    a = 0
    for i in range(101):
        if i % 2 == 0:
            a -= i
        else:
            a += i
    return a

'''
计算公式 1*1*1 + 2*2*2 + 3*3*3 + 4*4*4 + 5*5*5 + …….+ n*n*n
实现要求:
输入 : n = 5
输出 : 225
对应的公式 : 1*1*1 + 2*2*2 + 3*3*3 + 4*4*4 + 5*5*5 = 225
'''
def a_24():
    a = 5
    b = 0
    for i in range(1,a+1):
        b += i**3
    return b

'''
阶乘10!
阶乘的意思: 10!=10x9x8x7x6x5x4x3x2x1
求10!
'''
def a_25():
    a = 10
    b = 1
    for i in range(1,a+1):
        b = i*b
    return b

'''
求1+2!+3!+...+10!的和
求1+2!+3!+...+10!的和
'''
def a_26():
    a = 10
    b = 0
    for i in range(1,a+1):
        c = 1
        for j in range(1,i+1):
            c = c*j
        b += c
    return b

'''
求s=a+aa+aaa+aaaa+aa...a的值
'''
def a_27():
    a,n,c = 3,5,0
    for i in range(1,n+1):     
        c += int(str(a) * i)
    return c

'''
斐波那契数列1、1、2、3、5、8、13 .....
已知一个数列:1、1、2、3、5、8、13、。。。。的规律为从 3 开始的每一项都等于其前两项的和,这是斐波那契数列。
求满足规律的 100 以内的所有数据
'''
def a_28():
    a = [1,1]
    while a[-1] + a[-2] <= 100:
        a.append(a[-1] + a[-2])
    return a

'''
反转(判断对称)
如何判断一个数组是对称数组:
要求:判断数组元素是否对称。例如[1,2,0,2,1],[1,2,3,3,2,1]这样的都是对称数组
用Python代码判断,是对称数组打印True,不是打印False,如:
x = [1, "a", 0, "2", 0, "a", 1]
'''
def a_29():
    x = [1, "a", 0, "2", 0, "a", 1]
    a = len(x) // 2
    if len(x) % 2 != 0:
        a = a+1

    for i in range(a):
        if x[i] == x[-(i+1)]:
            d = True
        else:
            d = False
    return d

'''
列表切片
如果有一个列表a=[1,3,5,7,11]
问题:1如何让它反转成[11,7,5,3,1]
2.取到奇数位值的数字,如[1,5,11]
'''
def a_30():
    a = [1,3,5,7,11]
    c = a.copy()
    a.sort()
    a = a[::-1]
    b = []
    for i in range(len(c)+1):
        if i%2 == 0:
            b.append(c[i])
    return a,b

'''
列表大小排序
问题:对列表a 中的数字从小到大排序
a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8]
'''
def a_31():
    a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8]
    a.sort()
    return a

'''
取出最大值最小值
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
找出列表中最大值和最小值
'''
def a_32():
    L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
    return max(L1),min(L1)

'''
找出列表中单词最长的一个
a = ["hello", "world", "yoyo", "congratulations"]
找出列表中单词最长的一个
'''
def a_33():
    a = ["hello", "world", "yoyo", "congratulations"]
    b = ''
    for i in a:
        if len(i) >= len(i):
            b = i
    return b

'''
切片取出列表中最大的三个数
取出列表中最大的三个值
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
'''
def a_34():
    L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
    L2 = list(set(L1))
    L2.sort()
    return L2[-3:]

'''
列表按绝对值排序
a = [1, -6, 2, -5, 9, 4, 20, -3] 按列表中的数字绝对值从小到大排序
'''
def a_35():
    a = [1, -6, 2, -5, 9, 4, 20, -3]
    b = []
    for i in a:
        b.append(abs(i))
    b.sort()
    return b

'''
按字符串长度排序
b = ["hello", "helloworld", "he", "hao", "good"]
按list里面单词长度倒叙
'''
def a_36():
    b = ["hello", "helloworld", "he", "hao", "good"]
    # key:用列表元素的某个属性或函数进行作为关键字,有默认值,迭代集合中的一项;
    # reverse 默认False 升序,True降序
    b.sort(key=lambda x:len(x),reverse = True)
    return b

'''
去重与排序
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,还是[])
'''
def a_37():
    L = [1, 2, 3, 4, 5]
    L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
    '''
    sort 与 sorted 区别:
    sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
    list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
    
    '''
    return L[10:],sorted(set(L1)),L1

    
'''
去重保留顺序
将列表中的重复值取出(仅保留第一个),要求保留原始列表顺序
如a=[3, 2, 1, 4, 2, 6, 1] 输出[3, 2, 1, 4, 6]
'''
def a_38():
    a=[3, 2, 1, 4, 2, 6, 1]
    b = []
    for i in a:
        if i not in b:
            b.append(i)
    return b

'''
列表合并
a = [1, 3, 5, 7]
b = ['a', 'b', 'c', 'd']
如何得到[1, 3, 5, 7, 'a', 'b', 'c', 'd']
'''
def a_39():
    a = [1, 3, 5, 7]
    b = ['a', 'b', 'c', 'd']
    return a+b

'''
生成列表(列表推导式)
用一行代码生成一个包含 1-10 之间所有偶数的列表
'''
def a_40():
    a = [i for i in range(1,11) if i % 2 == 0]
    return a

'''
列表成员的平方
列表a = [1,2,3,4,5], 计算列表成员的平方数,得到[1,4,9,16,25]
'''
def a_41():
    a = [1,2,3,4,5]
    b = [i*i for i in a]
    return b

'''
找出列表大于0的数
使用列表推导式,将列表中a = [1, 3, -3, 4, -2, 8, -7, 6]
找出大于0的数,重新生成一个新的列表
'''
def a_42():
    a = [1, 3, -3, 4, -2, 8, -7, 6]
    b = [i for i in a if i > 0]
    return b

'''
统计列表有多少大于0
统计在一个队列中的数字,有多少个正数,多少个负数,如[1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
'''
def a_43():
    a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
    e,f = 0,0
    b = len([i for i in a if i >= 0])
    c = len(a) - b
    return b,c

'''
列表排除筛选
a = ["张三","张四","张五","王二"] 如何删除姓张的
'''
def a_44():
    a = ["张三","张四","张五","王二"]
    b = [i for i in a if i[0] != '张']
    return b

'''
列表过滤(filter)
题1:有个列表a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8] 使用filter 函数过滤出大于0的数
题2:列表b = ["张三", "张四", "张五", "王二"] 过滤掉姓张的姓名
'''    
def a_45():
    '''
    filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
    该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
    '''
    a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
    b = ["张三", "张四", "张五", "王二"] 
    a = list(filter(lambda i:i>0,a))
    b = list(filter(lambda i:i[0]!='张',b))
    return a,b

'''
过滤列表中不及格学生(filter)
过滤掉列表中不及格的学生
a = [
{"name": "张三", "score": 66},
{"name": "李四", "score": 88},
{"name": "王五", "score": 90},
{"name": "陈六", "score": 56},
]
'''
def a_46():
    a = [
        {"name": "张三", "score": 66},
        {"name": "李四", "score": 88},
        {"name": "王五", "score": 90},
        {"name": "陈六", "score": 56},
        ]
    b = list(filter(lambda i:i['score']>=60,a))
    return b

'''
找出列表中最大数出现的位置
有个列表 a = [1, 2, 3, 11, 2, 5, 88, 3, 2, 5, 33]
找出列表中最大的数,出现的位置,下标从0开始
'''
def a_47():
    a = [1, 2, 3, 11, 2, 5, 88, 3, 2, 5, 33]
    return a.index(max(a))

'''
找出列表中出现次数最多的元素
a = [
'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
'need', 'skills', 'more', 'my', 'ability', 'are',
'so', 'poor'
]
找出列表中出现次数最多的元素
'''
def a_48():
    a = [
        'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
        'need', 'skills', 'more', 'my', 'ability', 'are',
        'so', 'poor'
        ]
    b = {}
    c = []
    for i in a:
        if i in b:
            b[i] = b[i] + 1
        else:
            b[i] = 1
    
    for j,k in b.items():
        if k == max(b.values()):
            c.append(j)
    return c

'''
分别统计列表中每个成员出现的次数
a = [
'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
'need', 'skills', 'more', 'my', 'ability', 'are',
'so', 'poor'
]
'''
def a_49():
    a = [
    'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
    'need', 'skills', 'more', 'my', 'ability', 'are',
    'so', 'poor'
    ]
    b = {}
    for i in a:
        if i in b:
            b[i] = b[i] + 1
        else:
            b[i] = 1
    return b

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

'''
列表查找两数之和
给定一个整数数组nums 和一个目标值target ,请你在该数组中找出和为目标值的那两个整数,并返回他
们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素不能使用两遍。
示例:
给定nums=[2,7,11,15],target=9
因为nums[0] + nums[1] =2+7 = 9
所以返回[0, 1]
'''
def a_51():
    nums = [2,7,11,15]
    target = 9
    # for i in range(len(nums)-1):
    #     for j in range(i+1,len(nums)):
    #         if nums[i] + nums[j] == target:
    #             return i,j
    # return -1
    a = [[i,j] for i in range(len(nums)-1) for j in range(i+1,len(nums)) if nums[i] + nums[j] == target]
    return a[0] if a else -1

'''
二维数组取值(矩阵)
有 a = [["A", 1], ["B", 2]] ,如何取出 2
'''
def a_52():
    a = [["A", 1], ["B", 2]]
    return a[1][1]

'''
二维数组拼接
a = [[1,2],[3,4],[5,6]] 如何一句代码得到 [1, 2, 3, 4, 5, 6]
'''
def a_53():
    a = [[1,2],[3,4],[5,6]]
    return [j for i in a for j in i]

'''
列表转字符串
L = [1, 2, 3, 5, 6],如何得出 '12356'?
'''
def a_54():
    L = [1, 2, 3, 5, 6]
    n = ''.join([str(i)for i in L])
    return n

'''
两个列表如何得到字典
a = ["a", "b", "c"]
b = [1, 2, 3]
如何得到 {'a': 1, 'b': 2, 'c': 3}
'''
def a_55():
    a = ["a", "b", "c"]
    b = [1, 2, 3]
    c = {}
    if len(a) != len(b) or len(a) == 0:
        return -1
    for i in range(len(a)):
        c[a[i]] = b[i]
    return c

'''
列表按age从小到大排序
如下列表
people = [
{"name":"yoyo", "age": 20},
{"name":"admin", "age": 28},
{"name":"zhangsan", "age": 25},
]
按年龄age从小到大排序
'''
def a_56():
    people = [
    {"name":"yoyo", "age": 20},
    {"name":"admin", "age": 28},
    {"name":"zhangsan", "age": 25},
    ]
    people.sort(key=lambda i:i['age'])
    return people

'''
列表插入元素
现有 nums=[2, 5, 7] ,如何在该数据最后插入一个数字 9 ,如何在2后面插入数字0
'''
def a_57():
    nums=[2, 5, 7]
    nums.append(9)
    # insert() 函数用于将指定对象插入列表的指定位置。
    # list.insert(index, obj)
    nums.insert(1,0)
    return nums

'''
打乱列表顺序随机输出
有个列表a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
如何打乱列表a的顺序,每次得到一个无序列表
'''
def a_58():
    import random
    a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    # shuffle() 方法将序列的所有元素随机排序。
    random.shuffle(a)
    return a

'''
输出1-100除3余1 的数,结果为tuple
'''
def a_59():
    a = (i for i in range(1,101) if i % 2 == 1)
    return tuple(a)

'''
把2个元祖转字典
将('a', 'b', 'c', 'd', 'e') 和 (1,2, 3, 4, 5)两个tuple转成
(1, 2, 3, 4, 5)为key, ('a', 'b', 'c', 'd', 'e') 为value的字典
'''
def a_60():
    a = ('a', 'b', 'c', 'd', 'e')
    b = (1,2, 3, 4, 5)
    c = {}
    if len(a) != len(b) or len(a) <= 0:
        return -1
    for i in range(len(a)):
        c[b[i]] = a[i]
    return c

'''
把字典的value值转成str
将字典里的值是数值型的转换为字符串,如a = {'aa': 11, 'bb': 222}
得到{'aa': '11', 'bb': '222'}
'''
def a_61():
    a = {'aa': 11, 'bb': 222}
    for i,j in a.items(): 
        a[i] = str(j)
    return a

'''
(1)和(1,)区别,[1]和[1,]
a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的区别?
'''
def a_62():
    a,b = (1),(1,)
    c,d = [1],[1,]
    # 只有一个元素没有逗号时,数据类型是元素本身
    print (type(a),type(b))
    print (type(c),type(d))

'''
map函数将[1,2,3,4]处理成[1,0,1,0]
map函数,有个列表a = [1, 2, 3, 4] 计算列表中每个数除以2 取出余数 得到 [1,0,1,0]
'''
def a_63():
    # map() 会根据提供的函数对指定序列做映射。
    # 第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。
    a = [1,2,3,4]
    # 返回迭代器,用list()变为列表
    return list(map(lambda i: i%2,a))

'''
map函数将列表[1,2,3,4,5]转变成[1,4,9,16,25]
map函数将列表 [1,2,3,4,5] 使用python方法转变成 [1,4,9,16,25]
'''
def a_64():
    a = [1,2,3,4,5]
    return list(map(lambda i:i*i,a))

'''
map函数a=[1,3,5],b=[2,4,6]相乘得到[2,12,30]
map函数对列表a=[1,3,5],b=[2,4,6]相乘得到[2,12,30]
'''
def a_65():
    a,b = [1,3,5],[2,4,6]
    return list(map(lambda i,j:i*j,a,b))

'''
reduce函数计算1-100的和
reduce函数计算1-100的和
'''
def a_66():
    # reduce() 函数会对参数序列中元素进行累积。
    # Python3.x reduce() 已经被移到 functools 模块里
    from functools import reduce
    return reduce(lambda i,j:i+j,[i for i in range(1,101)])

'''
reduce函数计算10!
reduce函数计算1!+2!+3!+。。。+10!
'''
def a_67():
    from functools import reduce
    return reduce(lambda i,j:i*j,[i for i in range(1,11)])

'''
两个字典合并a={"A":1,"B":2},b={"C":3,"D":4}
'''
def a_68():
    a,b = {"A":1,"B":2},{"C":3,"D":4}
    # **,函数将参数以字典的形式导入
    #return {**a,**b}

    # update() 方法,第二个参数合并第一个参数
    a.update(b)
    return a

'''
{'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']}
'''
def a_69():
    m1 = {'a':1,'b':2,'c':1} 
    a = {}
    for i,j in m1.items():
        if j not in a:
            a[j] = [i]
        else:
            a[j].append(i)
    return a 

'''
字典按key排序d={"name":"zs","age":18,"}
d={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}
字典根据键从小到大排序
'''
def a_70():
    d={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}
    a = {}
    for i in sorted(d.items(),key=lambda i:i[0]):
        a[i[0]] = i[1]
    return a

'''
集合(交集、差集、并集)
a = [2, 3, 8, 4, 9, 5, 6]
b = [2, 5, 6, 10, 17, 11]
1.找出a和b中都包含了的元素
2.a或b中包含的所有元素
3.a中包含而集合b中不包含的元素
'''    
def a_71():
    a = [2, 3, 8, 4, 9, 5, 6]
    b = [2, 5, 6, 10, 17, 11]
    # c = a | b          # 并集  
    # c = a & b          # 交集  
    # c = a – b          # 差集
    
    # union(并集), intersection(交集), difference(差集)
    return set(a).intersection(set(b)),set(a).union(set(b)),set(a).difference(set(b))

'''
有1、2、3、4组成无重复数的三位数(排列组合)
有1、2、3、4数字能组成多少互不相同无重复数的三位数?
分别打印这些三位数的组合
'''
def a_72():
    a = []
    for i in range(1,5):
        for j in range(i+1,5):
            a.append(str(i)+str(j))

    return a

'''
冒泡排序
a = [11, 2, 33, 1, 5, 88, 3]

冒泡排序:
依次比较两个相邻的元素,如果顺序(如从小到大、首字母从A到Z)
错误就把他们交换过来
'''
def a_73():
    a = [11, 2, 33, 1, 5, 88, 3]
    for i in range(len(a)-1):
        for j in range(i+1,len(a)):
            if a[i] > a[j]:
                a[i],a[j] = a[j],a[i]
    return a

'''
文本中每行中长度超过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']]]
'''
def a_74():
    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'''
    # b = []
    # for k in a.split('\n'):
    #     q = []
    #     for h in k.split(' '):
    #         if len(h)>3:
    #             q.append(h)
    #     b.append(q)

    b = [[h for h in k.split(' ') if len(h)>3] for k in a.split('\n')]
    return b

'''
有一个数据list of dict如下
a = [
{"yoyo1": "123456"},
{"yoyo2": "123456"},
{"yoyo3": "123456"},
]
写入到本地一个txt文件,内容格式如下:
yoyo1,123456
yoyo2,123456
yoyo3,123456
'''    
def a_75():
    a = [
        {"yoyo1": "123456"},
        {"yoyo2": "123456"},
        {"yoyo3": "123456"},
        ]
    with open('./a_75.txt','w') as b:
        for k in a:
            for i,j in k.items():
                b.write('%s,%s\n'%(i,j))

'''
写一个小程序:控制台输入邮箱地址(格式为 username@companyname.com), 程序识别用户名和公司名后,将用户名和公司名输出到控制台。
要求:
1.校验输入内容是否符合规范(xx@yy.com), 如是进入下一步,如否则抛出提 示"incorrect email format"。注意必须以.com 结尾
2.可以循环“输入--输出判断结果”这整个过程
3.按字母 Q(不区分大小写)退出循环,结束程序
'''
def a_76():
    import re
    while True:
        a = input('输入邮箱地址:')
        if a == 'Q' or a == 'q':
            break
        # \b匹配一个单词边界
        b = re.findall(r'(.*?)@(.*?).com\b', a)
        if len(b) == 1:
            print ('用户名:%s是,公司名称:%s'%(b[0][0],b[0][1]))
        else:
            print ('incorrect email formatincorrect email format')
        
'''
判断一个字符串的括号自否闭合(包括大小中括号)
左括号和右括号必须是一一对应
比如:{[{()}]()}  就是一个闭合的字符串
{[{()}]([)]} 这个里面 ([)] 这种就是不闭合
'''
def a_77():
    # 每次[{(,则往b中加入元素,)}]则弹出最后一个加入的元素,b长度为0或弹出的元素错误,则返回false
    # a = list('{[{()}]()}')
    # b = []
    # for i in a:
    #     if i in '[{(':
    #         b.append(i)
    #     elif i == ')':
    #         if len(b) == 0 or b.pop() != '(':
    #             return False

    #     elif i == '}':
    #         if len(b) == 0 or b.pop() != '{':
    #             return False
        
    #     elif i == ']':
    #         if len(b) == 0 or b.pop() != '[':
    #             return False
    # return True
    
    # 通过replace每次去除一对括号,最后为空则是闭合
    a = '{[{()}]()}'
    for i in a:
        a = a.replace('()','')
        a = a.replace('[]','')
        a = a.replace('{}','')
    if a:
        return False
    else:
        return True

'''
计算纯数字子串组成的单一数字(子串)
有一个纯数字组成的字符串, 返回连续单一数字子串的个数
输入字符串: “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 a_78():
    a = list('22252')
    # 需要计算的数字
    d = set(a)
    # 出现次数统计
    e = 0
    # 循环单一数字连续出现1至5个的次数
    for i in range(5):
        b = 1 + i
        for k in d:
            # 循环查找,当前元素+1,len(a)-连续出现个数的范围
            for j in range(len(a)+1-b):
                if ''.join(a[j:j+b]) ==  k*b:
                    e += 1
    return e

'''
移除字符串里面的'ab'
有一个字符串列表['aababbc', 'badabcab'] 将字符串中的'ab' 移除
比如'aababbc' 移除里面的ab后得到abc 需继续移除ab,得到c,直到字符串中不会出现连续的ab
'''
def a_79():
    a = ['aababbc', 'badabcab']
    for i in range(len(a)):
        a[i] = a[i].replace('ab','')

    return a

'''
看代码得结果(join用法)
x="abc",y="def",z=["d","e","f"],
分别求出x.join(y) 和x.join(z)返回的结果
'''
def a_80():
    # join():连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
    return 'x.join(y):dabceabcf,x.join(z):dabceabcf'

'''
看代码得结果(类和继承)
阅读以下代码,打印结果是什么?

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()

 '''
def a_81():
    # 子类无法直接访问父类的私有属性和私有方法,但父类可以访问自己内部的私有属性和私有方法
    # B类重写A类的Name()方法
    return 'A.__Gender(),B.Name()'

'''
看代码得结果(闭包)
阅读以下代码,得到的结果是什么

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

for everyLambda in fun():
    print(everyLambda(2))
'''
def a_82():      
    def fun():
        # 等同于下面的例子,i是外部变量,x是内部变量,即最后,return i * x 相当于 return 3 * x
        # temp = []
        # for i in range(4):
        #     def p(x):
        #         return i * x
        #     temp.append(p)
        temp = [lambda x: i*x for i in range(4)]

        # temp里面的是函数对象(没带括号),不需要等函数执行完成       
        # 带括号时,才是调用函数的return结果
        print (temp)   #输出:[<function a_82.<locals>.fun.<locals>.<listcomp>.<lambda> at 0x000001BEA485B048>, <function a_82.<locals>.fun.<locals>.<listcomp>.<lambda> at 0x000001BEA485B0D0>, <function a_82.<locals>.fun.<locals>.<listcomp>.<lambda> at 0x000001BEA485B158>, <function a_82.<locals>.fun.<locals>.<listcomp>.<lambda> at 0x000001BEA485B1E0>]
        return temp

    for everyLambda in fun():
        # 输出4次6
        print(everyLambda(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]
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]
'''
def a_83():
    A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
    # {'a':1,'b':2,'c':3,'d':4,'e':5}

    A1 = range(10)
    # range(0, 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]]
    
    return A0,A1,A2,A3,A4,A5,A6

'''
看代码得结果(函数)
阅读以下代码,得到什么结果

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 a_84():
    # f(3)为什么输出[0, 1, 0, 1, 4]?
    # 查阅资料发现:一个函数参数的默认值,仅仅在该函数定义的时候,被赋值一次。以后调用时,如果传入了参数,则用传入的参数;如果未传入参数,则去默认值的地址查找值并使用。
    # 打印
    def f(x,l=[]):
        # f(2)和f(3)中l的唯一id是一样的
        print (id(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]

'''
看代码得结果(深拷贝和浅拷贝)
写出以下程序的输出结果

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)
'''
def a_85():
    '''
    浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。
        1.对于子对象是可变对象,修改会影响其他浅拷贝对象
        2.对于子对象是不可变对象,修改不会影响其他浅拷贝对象
    深拷贝(deepcopy): 完全拷贝了父对象及其子对象。
        1.不管子对象是不是可变对象,修改都不会影响其他深拷贝对象
    关于可变对象与不可变对象:
        可变对象:list、set、dict...
        不可变对象:tuple、str...
    '''
    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)
    # [1, 2, [666, 4]] [1, 2, [666, 4]] [1, 2, [3, 4]]

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

1.计算 1- 100 的和
2.1-10,对每个数字的平方
3. ["a", "ab", "abc", "bc", "cd"] 输出含有c字符的元素,返回值是list
'''
def a_86():
    '''
    map() 会根据提供的函数对指定序列做映射。
    map() 函数语法:
    map(function, iterable, ...)
    参数
    function -- 函数
    iterable -- 一个或多个序列
    返回值
    Python 2.x 返回列表。
    Python 3.x 返回迭代器。


    reduce() 函数会对参数序列中元素进行累积。
    reduce() 函数语法:
    reduce(function, iterable[, initializer])
    参数
    function -- 函数,有两个参数
    iterable -- 可迭代对象
    initializer -- 可选,初始参数
    返回值
    返回函数计算结果。


    filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
    filter() 函数语法:
    filter(function, iterable)
    参数
    function -- 判断函数。
    iterable -- 可迭代对象。
    返回值
    Python2.7 返回列表
    Python3.x 返回迭代器对象 
    '''
    from functools import reduce
    a = reduce(lambda x,y:x+y,[i for i in range(1,101)])
    b = list(map(lambda x : x*x,list(range(1,11))))
    c = list(filter(lambda x:'c' not in x,["a", "ab", "abc", "bc", "cd"]))
    return a,b,c

'''
通过切片操作完成以下任务(切片)
有个字符串为"abcdefg.exe" 通过切片完成下面的任务
1.输出前3个字符
2.输出后2个字符
3.倒叙输出
4.间隔1个字符串输出
'''
def a_87():
    a = "abcdefg.exe"
    return a[0:3],a[-2:],a[::-1],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]
'''
def a_88():
    a = [1,2,1,2,2,2,3,4,5,6,56,7,1,3,4]
    b = {}
    for i in a:
        if i not in b:
            b[i] = 1
        else:
            b[i] = b[i] + 1
    # c = sorted(b,key = b.get,reverse = True)
    c = [i[0] for i in sorted(b.items(),key = lambda x : x[1],reverse = True)]
    # b.items()返回: dict_items([('key1', 'value2'),('key2', 'value2')])
    # key比较value的大小
    # reverse默认False,升序
    return c

'''
补缺失的代码-给个路径查找文件(递归)
def print_directory_contents(sPath):
"""
这个函数接受文件夹的名称作为输入参数,
返回该文件夹中文件的路径,
以及其包含文件夹中文件的路径。
"""
'''
def a_89(path):
    import os
    # 返回path指定的文件夹包含的文件或文件夹的名字的列表
    for i in os.listdir(path):
        # 目录和文件名合成一个路径
        apath = os.path.join(path,i)
        # 判断路径是否为目录
        if os.path.isdir(apath):
            a_89(apath)
        else:
            print (apath)

'''
如何判断一个字符串有没有重复字符
判断一个字符串是否包含重复字符。例如:“hello”就包含重复字符‘l’,而“world”就不包含重复字符, 有重复打印True, 没重复打印False
'''
def a_90():
    a = 'helo'
    b = list(a).copy()
    c = list(set(a))
    b.sort()
    c.sort()
    return c == b

'''
找出一个字符串中子串不含有重复字符的最长子串(子串)
给定一个字符串,请你找出其中不含有重复字符的最长子串的长度。
示例1:
输入:" abcabcbb" 输出: 3
解释:因为无重复字符的最长子串是"abc", 所以其长度为3。
示例2:
输入: "bbbbb"" 输出: 1
解释:因为无重复字符的最长子串是"b", 所以其长度为1。
示例3:
输入: " pwwkew" 输出: 3
解释:因为无重复字符的最长子串是"wke"', 所以其长度为3。
请注意,你的答案必须是子串的长度,"pwke"是一个子序列,不是子串。
'''
def a_91():
    a = 'pwywabcdfghwww'
    # 记录循环到的下标,出现相同字符就会加1
    c = 0
    # 记录最长子串
    b = []
    #如果记录最长子串的长度(len(b)) 大于 剩余循环需要循环的次数(len(a)-c),则可以跳出循环
    while len(b) < len(a) - c:
        # 存放循环时的子串长度,用来跟b比较	
        d = []
        # 在之前记录循环到的下标开始,字符出现在d中表示出现重复字符,跳出循环
        for i in range(c,len(a)):
            if a[i] not in d:
                d.append(a[i])   
            else:
                c += 1
                break
        # 跟之前最长子串比较长度
        if len(b) < len(d):
            b = d
            
    return len(b)
        
'''
一个字符串中所有子串是回文的次数(子串)
回文是指正序(从左向右)和倒序(从右向左)读都是一样的。
例如:121 ,abcdedcba,123321等都是回文
这种的字符串“ABCABADCSABBAUYIIYU”找出回文出现的次数
子串回文是:'BB', 'II','ABA','ABBA', 'YIIY','UYIIYU' 总共有6个
'''                
def a_92():
    a = 'ABCABADCSABBAUYIIYU'
    al = []
    # 最后一个不需要循环,回文需要>=2才成立
    for i in range(len(a)-1):
        for j in range(i+2,len(a)+1):
            b = a[i:j]   
            # 判断是否回文    
            if b == b[::-1]:
                al.append(b)

    return al

'''
找出列表中连续的数字,只取首尾(栈)
找出列表中连续的数字,然后只取首尾
有一个列表[1,2,3,4,8,6,7,11,15]
输出[(1,4),(6,8)]
'''
def a_93():
    a = [1,2,3,4,8,6,7,11,15]
    c = []
    b = []
    # 循环a中最大+1至最小范围(a中最大+1肯定不在a中,主要用来看最后一次的b是否符合)
    for i in range(min(a),max(a)+2):  
        # 如果在a中,则加入到b  
        if i in a:
            b.append(i)
        else:
            # 否则,如果b中的个数大于1,就加入到c中
            if len(b) > 1:
                c.append((min(b),max(b)))
            #  清空b
            b = []
    return c