python面向自律编程：每天写一个编程时遇到的问题，和对它的死缠烂打（一.奇妙的enumerate,max,min）
每天写一篇在python中遇到的一个问题，和对它的追根究底，从今天开始面向自律编程。
一.奇妙的enumerate,max,min（菜鸟篇）
目录
一.在做力扣时遇到（数值求和+索引查询）
二.对enumerate() 函数的加深学习：
三.对min,max两种方法的加深学习（max取序列最大，使用和min相同，不累述）
附录
一.在做力扣时遇到（数值求和+索引查询）
- 给定一个整数数组 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