EMA的python代码 python ema函数

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

语法：

enumerate(sequence, [start=0])

参数：

• sequence – 一个序列、迭代器或其他支持迭代对象。
• start – 下标起始位置。

返回值：返回 enumerate(枚举) 对象。

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three

案例：罗马数字转整数
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

• I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
• X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
• C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
  给定一个罗马数字，将其转换成整数。

class Solution:
    def romanToInt(self, s: str) -> int:
        # 通过字典存储key value值，将对应的value值进行求和
        # IV = 1+3=4, 因为第一次遇到I时已经将1加了，所以字典中将IV的value值设为3
        # 判断当前和上一个字符组合是否存在于字典中，不存在就获取默认值，存在的话为了防止下标越界，通过s[max(i-1, 0):i+1]解决
        d = {'I':1, 'V':5, 'IV':3, 'X':10, 'IX':8, 'XL':30, 'L':50, 'XC':80, 'C':100, 'CD':300, 'D':500, 'CM':800, 'M':1000}
        return sum(d.get(s[max(i-1, 0):i+1], d[n]) for i,n in enumerate(s))

方法2：

class Solution:
    def romanToInt(self, s: str) -> int:
        # 通过字典的方式存储key-value值，如果左边的value值小于右边的value值，则减去左边的value值，反之加上，这里也要注意下标越界问题
        d = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
        result = 0
        for i in range(len(s)-1):
            if d.get(s[i]) < d.get(s[i+1]):
                result -= d.get(s[i])
            else:
                result += d.get(s[i])
            
        return result + d.get(s[-1])

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

语法：

map(function, iterable, ...)

参数：

• function – 函数
• iterable – 一个或多个序列

>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

3、zip()函数
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

zip语法：

zip([iterable, ...])

返回值：返回元组列表。

实例应用：

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

zip案例：最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        # 通过zip函数,返回的是由元组组成的列表
        ans = ''
        for item in zip(*strs):
            if len(set(item)) == 1:
                ans += item[0]
            else:
                break
        return ans