第四章习题

1、从键盘输入两个数，并比较其大小，直到输入e/E退出程序

while 1:
    firstnum = input("please input a number or e to break the program:")
    if firstnum.lower() == "e":
        break
    secondnum = input("please input a number or e to break the program:")
    if secondnum.lower() == "e":
        break 
    if firstnum < secondnum:
        print("%s 大" %secondnum)
    elif firstnum > secondnum:
        print("%s 大" %firstnum)
    else:
        print("%s 等于%s "%(firstnum,secondnum))

2、将列表元素交替地作为建和值来创建字典

>>> d = {}
>>> for i in range(0,10,2):
...     d[i] = i+1
...
>>> print(d)
{0: 1, 2: 3, 4: 5, 6: 7, 8: 9}

3、分别输出字符串中奇数坐标和偶数坐标的字符

>>> s = "abcdefgh"
>>> print("偶数坐标的字符:",s[::2])
偶数坐标的字符: aceg
>>> print("奇数坐标的字符:",s[1::2])
奇数坐标的字符: bdfh

4、将一个字典的 key和value 互换

>>> d = {1:2,3:4,5:6}
>>> d_new = {}
>>> for k,v in d.items():
...     d_new[v] = k
...
>>> print(d_new)
{2: 1, 4: 3, 6: 5}

5、将一个多重嵌套的列表的元素进行互换，存到另一个同等维度的嵌套列表中，例如：
[[1,2,3],[4,5,6]]互换后变成[[1,4],[2,5],[3,6]]

>>> l = [[1,2,3],[4,5,6]]
>>> result = []
>>> for i in range(3):
...     temp = []
...     for j in l:
...         temp.append(j[i])
...     result.append(temp)
...
>>> print(result)
[[1, 4], [2, 5], [3, 6]]

6、有一个3 x 4的矩阵，要求编程求出其中值最大的那个元素的值，以及其所在的行号和
列号，矩阵可以通过嵌套列表来模拟

l = [[1,2,3,4],[9,6,4,7],[2,5,3,8]]
max_item = l[0][0]
for i in range(3):
    for j in range(4):
        if l[i][j] > max_item:
            max_item = l[i][j]
            m,n = i,j

print("%s行%s列元素最大为%s" %(m,n,max_item))

7、递归实现嵌套列表求和

>>> def sum_list(l,result=0):
...     for i in l:
...         if not isinstance(i,(list,tuple)):
...             result += i
...         else:
...             result += sum(i)
...     return result
...
>>> l = [1,2,3,[4,5],(6,7,8)]
>>> print(sum_list(l))
36

8、打印斐波拉契数列前n项

>>> def fab(n):
...     if n == 0 or n ==1:
...         return 1
...     else:
...         return fab(n-1) + fab(n-2)
...
>>> for i in range(10):
...     print(fab(i))
...
1
1
2
3
5
8
13
21
34
55

9、检查ipV4的有效性，有效则返回True，否则返回False，（提示使用split函数进行分
割）

def check_ip_valid(ip):
    ipList = ip.split(".")
    for i in ipList:
        if not i.isdigit() or len(i) > 1 and i.startswith("0"):
            return False
        elif len(ipList) < 4:
            return False
        else:
            if int(i) > 255:
                return False
    return True

print (check_ip_valid("12.1.2"))
print (check_ip_valid("12.1.256.1"))
print (check_ip_valid("12.1.255.1"))
print (check_ip_valid("12.1.1.1"))

10、检测密码强度
c1 : 长度>=8
c2: 包含数字和字母
c3: 其他可见的特殊字符
强：满足c1,c2,c3
中: 只满足任一2个条件
弱：只满足任一1个或0个条件

#encoding=utf-8
import string
def check_password_strength(password):
    flag1 = False  #状态位：是否超过8个字符
    flag2 = False  #状态位：是否包含数字和字母
    flag3 = False  #状态位：是否包含除数字和字母外的其他特殊字符
    flag4 = False  #状态位：是否为数字
    flag5 = False  #状态位：是否为字母
    if len(password) >= 8:
        flag1 = True
    for i in password:
        if i.isdigit():
            flag4 = True
        if i in string.ascii_letters:
            flag5 = True
        if flag4 and flag5:
            flag2 = True
        if i in string.punctuation:
            flag3 = True
    result = [flag1,flag2,flag3]
    if result.count(True) == 3:
        return "强"
    elif result.count(True) == 2:
        return "中"
    else:
        return "弱"

print(check_password_strength("12345678"))
print(check_password_strength("123d5678"))
print(check_password_strength("12#456H8"))
print(check_password_strength("1#46H8"))

11、求两个集合的交集和并集

def intersection_set(s1,s2):
    intersection = []
    for i in s1:
        if i in s2:
            intersection.append(i)
    return intersection

def union_set(s1,s2):
    d = {}
    union = []
    for i in s1:
        d[i] = None
    for i in s2:
        d[i] = None
    for k in d.keys():
        union.append(k)
    return union

s1 = [1,3,5,6,7,8]
s2 = [1,2,4,6,8,9]
print(intersection_set(s1,s2))
print(union_set(s1,s2))

12、一个包含多个数字的列表，请使用随机的方式，将每个数字+1后，生成新列表

import random
a = list(range(10))
random.shuffle(a)
result = []
for i in a:
    result.append(i+1)

print(result)   

a = [i+1 for i in list(range(10))]
random.shuffle(a)
print(a)

13、判断一个字符串是否为回文字符串
所谓回文字符串，就是一个字符串，从左到右读和从右到左读是完全一样的。比如
“level” 、 “aaabbaaa”

def is_huiwen_str(s):
    if s == s[::-1]:
        return True
    else:
        return False

print(is_huiwen_str("level"))
print(is_huiwen_str("aaabbaaa"))
print(is_huiwen_str("aaabbaac"))

def is_huiwen_str(s):
    if len(s) % 2 ==1:
        print(s[:len(s)//2],s[-1:-len(s)//2:-1])
        if s[:len(s)//2] == s[-1:-len(s)//2:-1]:
            return True
        else:
            return False
    if len(s) % 2 == 0:
        if s[:len(s)//2-1] == s[-1:-len(s)//2:-1]:
            return True
        else:
            return False

print(is_huiwen_str("level"))
print(is_huiwen_str("aaabbaaa"))
print(is_huiwen_str("aaabbaac"))

14、实现合并同类型的有序列表算法，要求不能有重复元素

#encoding=utf-8
def merge_two_lists(lista,listb):

    for i in lista:
        if type(i) != type(listb[0]):
            return None
    for i in listb:
        if type(i) != type(lista[0]):
            return None
    if type(lista[0]) != type(listb[0]):
        return None
    d = {}
    for i in lista:
        d[i] = None
    for j in listb:
        d[j] = None
    return sorted(d.keys())

print(merge_two_lists([1,2,'a'],[12,2,"b"]))
print(merge_two_lists([1,2,2,4,5],[2,15,15,16]))

15、不区分大小写对包含多个字符串对象的列表进行排序，显示排序后的结果还需要显示大小写不变的原字符串

>>> sorted(["Lucy","Jondan","Sam","bAg"],key = lambda x:x.lower())
['bAg', 'Jondan', 'Lucy', 'Sam']

16、一个数如果恰好等于它的因子之和，这个数就称为完数，例如6的因子为1,2,3，而
6=1+2+3，因此6是完数，编程找出1000之内的所有完数，并按6 its factors are 1,2,3
这样的格式输出

#遍历1000以内的数#用数自身遍历除以小于数自身的数，求约数，所有约数和等于数自身
for i in range(1,1000):
    result = []
    for value in range(1,i):
        if i%value ==0:
            result.append(value)
    if i == sum(result):
        print(i,"its factors are ",end="")
        for v in result:
            print(v,end=",")
        print()

>>> def obtainFactor(data):
...     factorList = []
...     for i in range(1,(data//2)+1):
...         if data % i == 0:
...             factorList.append(i)
...
...     if sum(factorList) == data:
...         return True
...
>>> list(filter(obtainFactor,range(1,1000)))
[6, 28, 496]

17、使用二分法实现在一个有序列表中查找指定的元素
18、分离list1与list2中相同部分与不同部分

lista = [1,3,4,5,6,7]
listb = [2,4,5,6,8,9]
same_part = []
diffrent_part = []
for i in lista:
    if i in listb:
        same_part.append(i)
    else:
        diffrent_part.append(i)

for j in listb:
    if j not in lista:
        diffrent_part.append(j)

print("相同部分：%s" %same_part)
print("不同部分：%s" %diffrent_part)

19、找出一个多维数组的鞍点，即该位置上的元素在该行上最大，在该列上最小，也可
能没有鞍点

#encoding=utf-8
l = [
    [13,2,6,4],
    [14,3,5,6],
    [16,8,9,0],
    [19,2,3,4]]
row_max_item_list = []
col_min_item_list = []
for i in range(len(l)):
    row_max_item_list.append(max(l[i]))
    print(row_max_item_list)
    #for i in range(len(l)):
    #存储每列的元素
    temp_list = []
    for j in range(len(l[i])):
        temp_list.append(l[j][i])
        col_min_item_list.append(min(temp_list))
        print(col_min_item_list)
for i in range(len(l)):
    for j in range(len(l[i])):
        if l[i][j] == row_max_item_list[i] and l[i][j] == col_min_item_list[j]:
            print("%d 行 %d 列 鞍点是 %d" %(i,j,l[i][j]))
        else:
            print("%d 行 %d 列 没有鞍点" %(i,j))

20、写一个函数，识别输入字符串是否是符合 python 语法的变量名（不能数字开头、
只能使用数字和字母以及‘_’）

import string
def is_var_valid(s):
    if s[0] in "0123456789":
        return False
    for i in s:
        if not (i in string.ascii_letters or i in string.digits or i == "_"):#not (i.isalnum() or v == "_"):
            return False
    return True

print(is_var_valid("3gr"))
print(is_var_valid("dgr3"))
print(is_var_valid("dg_3r"))
print(is_var_valid("d@gr"))