python面向自律编程：每天写一个编程时遇到的问题，和对它的死缠烂打（一.奇妙的enumerate,max,min）

每天写一篇在python中遇到的一个问题，和对它的追根究底，从今天开始面向自律编程。

一.奇妙的enumerate,max,min（菜鸟篇）

目录

一.在做力扣时遇到（数值求和+索引查询）

二.对enumerate() 函数的加深学习：

三.对min,max两种方法的加深学习（max取序列最大，使用和min相同，不累述）

附录

---

---

一.在做力扣时遇到（数值求和+索引查询）

1. 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

 
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]


问题分析：列表里有重复元素 》》》 导致一个元素使用多遍》》》查询多个同值元素，不同索引》》》不能用暴力破解
注意：target是可以拿出来用的 通过这个(target - num )来找符合条件的比用==对比好

自己写了个笨的，看了个高效的解法如下

class Solution:
    def twoSum(seelf,nums, target):
        hashmap={}
        for i,num in enumerate(nums):
            if hashmap.get(target - num) is not None:
                return [i,hashmap.get(target - num)]
            hashmap[num] = i 

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

• 总结：对列表求索引，且有重复值，enumerate() 函数很好用

 

二.对enumerate() 函数的加深学习：

通过解决问题学习
1.问题： 查找列表里那个数字出现次数最多,并返回列表里这个数字的所有索引


l = [1, 2, 2, 3, 2, 3, 2]


#2.想把数据结构转为dictionary条件很苛刻，要数据结构容器内数据量为偶数,但最妙的是和enumerate天作之合
# 用list dict  之所以要list，因为返回的其实是多个单个tuple,单用dict要注意它整合了多个tuple（）（）为字典


tup = dict(list(enumerate(l)))
tup2 = dict()
for k, v in tup.items():
    if k == l.index(v):
        tup2[v] = [k]
    else:
        tup2[v].append(k)

# a = max(tup2, key= lambda x :x.values())   'int' object has no attribute 'values'
# 说明max 是把tup2里的key拿出来比较

# 3.思维突破：对于容器数据内比较，特别是对于有索引的要求，可以用enumerate转换为字典
a = max(tup2.values(), key=lambda x: len(x))
print(a)

 

三.对min,max两种方法的加深学习（max取序列最大，使用和min相同，不累述）

min和max都是通过对比ASCII 码来对比大小的
     ASCII 码使用指定的7 位或8 位二进制数组合来表示128 或256 种可能的字符。
     a-z:97-122   A-Z:65-90      0-9:48-57

max和min主要是迭代序列，逐个对比数据大小，返回序列最小（字符串类型，单个字符串对比，只要得到，不会往后对比）

初步探究
# 特性先知：min max 只能比同一数据类型

# 无论比字符串还是整型结果都一样
a = ['1', '2', '3', '4', '5']
b = [1, 2, 3, 4, 5]
print(min(a), min(b))  # 1 1


# 对单一字母比较
a = ['a', 'b', 'c', 'd', 'e']
b = ['A', 'B', 'C', 'D', 'E']
c = ['A', 'a', 'b', 'D', 'E']

print(min(a), min(b), min(c))  # a A  A


# 对多个字母比较
a = ['aa', 'ab', 'ac', 'ad', 'ae']
b = ['aCa', 'aCa', 'aA', 'aD', 'aE']
c = ['aAg', 'aAa', 'aC', 'aD', 'aEa']
print(min(a), min(b), min(c))   # aa aA aAa
# 结论：对比长字符串，是逐一对比，把相同的放到下一轮对比，当对比到只要一个最小时输出这个字符串
# 如 对比 aab  aaa  abc  adf
# 第一轮对比a 全留下，
# 第二轮对比 aa aa ab ad  剩下 aab 和 aaa
# 第三轮对比 b 和 a 最后得aaa

进阶运用

# 能够对镶嵌容器类型拆开比较
# a = [[[1, 2]], [3, 4]]  # '<' not supported between instances of 'int' and 'list'
a = [[1, 2], [3, 4]]  # [1, 2]
b = [[1, 2, 10], [3, 4]]  # [1, 2, 10]
c = [[4, 0], [3, 4]]  # [3, 4]
print(min(a), min(b), min(c))
# 说明：min会拆开到其中一部分没法拆，因此只能对同级别镶嵌列表间比较,同样也只比较到有结果马上返回


# 针对以上情况使用函数来改变比较方法和对象
# 如通过比较镶嵌列表里第二位来选出最小的排序
a = [[1, 2], [3, 0]]  # [3, 0]
b = [[1, 2, 10], [3, 1]]  # [3, 1]
c = [[4, 0], [3, 4]]  # [4, 0]
print(min(a, lambda x:x[1]), min(b, lambda x:x[1]), min(b, lambda x:x[1]))


n = 0
def test(x):
    global n
    print(x)  # [1, 2]   [3, 0] 
    n += 1    # 1         2
    print(n)
    return x[1]
print(min(a, key= test))
# 总结：min会拆开容器，依次返回里面可对比序列[]给对自定义函数,接收的是列表，对对比对象进行重新定义，再进入对比

 

 

附录

我的力扣题解：

class Solution:
    def twoSum(self, nums, target):
        count = 0
        l = list()
        while True:
            print(count)
            if count == len(nums) - 1:
                break
            m = nums[count]
            for n in nums[count + 1:]:
                if n + m == target:
                    # 对上一次运行结果处理，如果找到了前一个重复的，替换掉前一个
                    if nums.index(n) in l:
                        nums[nums.index(n)] = target + 1
                    #如果是两个相同的数
                    if n == m:
                        nums[count] = target + 1
                    l.extend([count, nums.index(n)])
            count += 1
        print(l)
        return l