>>> A = np.mat("1 -1; 1 1")
>>> A
matrix([[ 1, -1],
        [ 1,  1]])
>>> inverse = np.linalg.inv(A)
>>> inverse
matrix([[ 0.5,  0.5],
        [-0.5,  0.5]])

>>> import numpy as np
>>> A = np.mat("1 -2 1; 0 2 -8; -4 5 9") # mat函数可以将目标数据的类型转换为矩阵（matrix）
>>> A
matrix([[ 1, -2,  1],
        [ 0,  2, -8],
        [-4,  5,  9]])
>>> b = np.array([0, 8, -9])
>>> b
array([ 0,  8, -9])

>>> x = np.linalg.solve(A, b)
>>> x
array([29., 16.,  3.])

>>> np.dot(A, x)
matrix([[ 0.,  8., -9.]])

# Multiply two arrays 
>>> x = [1, 2, 3]
>>> y = [2, 3, 4]
>>> product = []
>>> for i in range(len(x)):
...     product.append(x[i] * y[i])
...
>>> product
[2, 6, 12]

# Linear algebra version
>>> import numpy as np
>>> x = np.array([1,2,3])
>>> y = np.array([2,3,4])
>>> x * y
array([ 2,  6, 12])

>>> x = np.array([1,2,3])
>>> y = np.array([2,3,4])
>>> x + y
array([3, 5, 7])
>>> x - y
array([-1, -1, -1])
>>> x / y
array([0.5       , 0.66666667, 0.75      ])

>>> x = np.array([1,2,3])
>>> y = np.array([4,5,6])
>>> x * y
array([ 4, 10, 18])

a = np.array([
 [1,2,3], 
 [4,5,6]
])
a.shape == (2,3)

b = np.array([
 [1,2,3]
])
b.shape == (1,3)

>>> a = np.array([[2, 3], [2, 3], [2, 3]])
>>> a + 1
array([[3, 4],
       [3, 4],
       [3, 4]])

a = np.array([
 [1,2],
 [3,4]
])
b = np.array([
 [1,2],
 [3,4]
])

a + b
[[2, 4],
 [6, 8]]

a — b
[[0, 0],
 [0, 0]]

a = np.array([
 [1],
 [2]
])
b = np.array([
 [3,4],
 [5,6]
])
c = np.array([
 [1,2]
])

# Same no. of rows
# Different no. of columns
# but a has one column so this works
a * b
[[ 3, 4],
 [10, 12]]

# Same no. of columns
# Different no. of rows
# but c has one row so this works
b * c
[[ 3, 8],
 [5, 12]]

# Different no. of columns
# Different no. of rows
# but both a and c meet the 
# size 1 requirement rule
a + c
[[2, 3],
 [3, 4]]

a = np.array(
[[2,3],
 [2,3]])
b = np.array(
[[3,4],
 [5,6]])

# Uses python's multiply operator
a * b
[[ 6, 12],
 [10, 18]]

a = np.array([
   [1, 2], 
   [3, 4]])

a.T
[[1, 3],
 [2, 4]]

[2*5 + 3*3, 2*4 + 3*5]
[1*5 + 4*3, 1*4 + 4*5]

[3*1, 3*2, 3*3]
[5*1, 5*2, 5*3]

[1*4 + 2*5 + 3*6]

a = np.array([
 [1, 2]
 ])
a.shape == (1,2)

b = np.array([
 [3, 4],
 [5, 6]
 ])
b.shape == (2,2)

# Multiply
mm = np.dot(a,b)
mm == [13, 16]
mm.shape == (1,2)

class Bloomfilter(object):
    """
    A Bloom filter is a probabilistic data-structure that trades space for accuracy
    when determining if a value is in a set.  It can tell you if a value was possibly
    added, or if it was definitely not added, but it can't tell you for certain that
    it was added.
    """
    def __init__(self, size):
        """Setup the BF with the appropriate size"""
        self.values = [False] * size
        self.size = size
    def hash_value(self, value):
        """Hash the value provided and scale it to fit the BF size"""
        return hash(value) % self.size
    def add_value(self, value):
        """Add a value to the BF"""
        h = self.hash_value(value)
        self.values[h] = True
    def might_contain(self, value):
        """Check if the value might be in the BF"""
        h = self.hash_value(value)
        return self.values[h]
    def print_contents(self):
        """Dump the contents of the BF for debugging purposes"""
        print(self.values)

bf = Bloomfilter(10)
bf.add_value('dog')
bf.add_value('fish')
bf.add_value('cat')
bf.print_contents()
bf.add_value('bird')
bf.print_contents()
# Note: contents are unchanged after adding bird - it collides
for term in ['dog', 'fish', 'cat', 'bird', 'duck', 'emu']:
    print('{}: {} {}'.format(term, bf.hash_value(term), bf.might_contain(term)))

[False, False, False, False, True, True, False, False, False, True]
[False, False, False, False, True, True, False, False, False, True]
dog: 5 True
fish: 4 True
cat: 9 True
bird: 9 True
duck: 5 True
emu: 8 False

def major_segments(s):
    """
    Perform major segmenting on a string.  Split the string by all of the major
    breaks, and return the set of everything found.  The breaks in this implementation
    are single characters, but in Splunk proper they can be multiple characters.
    A set is used because ordering doesn't matter, and duplicates are bad.
    """
    major_breaks = ' '
    last = -1
    results = set()
    # enumerate() will give us (0, s[0]), (1, s[1]), ...
    for idx, ch in enumerate(s):
        if ch in major_breaks:
            segment = s[last+1:idx]
            results.add(segment)
            last = idx
    # The last character may not be a break so always capture
    # the last segment (which may end up being "", but yolo)
    segment = s[last+1:]
    results.add(segment)
    return results

def minor_segments(s):
    """
    Perform minor segmenting on a string.  This is like major
    segmenting, except it also captures from the start of the
    input to each break.
    """
    minor_breaks = '_.'
    last = -1
    results = set()
    for idx, ch in enumerate(s):
        if ch in minor_breaks:
            segment = s[last+1:idx]
            results.add(segment)
            segment = s[:idx]
            results.add(segment)
            last = idx
    segment = s[last+1:]
    results.add(segment)
    results.add(s)
    return results

def segments(event):
    """Simple wrapper around major_segments / minor_segments"""
    results = set()
    for major in major_segments(event):
        for minor in minor_segments(major):
            results.add(minor)
    return results

for term in segments('src_ip = 1.2.3.4'):
	print(term)

src
1.2
1.2.3.4
src_ip
3
1
1.2.3
ip
2
=
4

class Splunk(object):
    def __init__(self):
        self.bf = Bloomfilter(64)
        self.terms = {}  # Dictionary of term to set of events
        self.events = []
    def add_event(self, event):
        """Adds an event to this object"""
        # Generate a unique ID for the event, and save it
        event_id = len(self.events)
        self.events.append(event)
        # Add each term to the bloomfilter, and track the event by each term
        for term in segments(event):
            self.bf.add_value(term)
            if term not in self.terms:
                self.terms[term] = set()
            self.terms[term].add(event_id)
    def search(self, term):
        """Search for a single term, and yield all the events that contain it"""
        # In Splunk this runs in O(1), and is likely to be in filesystem cache (memory)
        if not self.bf.might_contain(term):
            return
        # In Splunk this probably runs in O(log N) where N is the number of terms in the tsidx
        if term not in self.terms:
            return
        for event_id in sorted(self.terms[term]):
            yield self.events[event_id]

s = Splunk()
s.add_event('src_ip = 1.2.3.4')
s.add_event('src_ip = 5.6.7.8')
s.add_event('dst_ip = 1.2.3.4')
for event in s.search('1.2.3.4'):
    print(event)
print('-')
for event in s.search('src_ip'):
    print(event)
print('-')
for event in s.search('ip'):
    print(event)

src_ip = 1.2.3.4
dst_ip = 1.2.3.4
-
src_ip = 1.2.3.4
src_ip = 5.6.7.8
-
src_ip = 1.2.3.4
src_ip = 5.6.7.8
dst_ip = 1.2.3.4

class SplunkM(object):
    def __init__(self):
        self.bf = Bloomfilter(64)
        self.terms = {}  # Dictionary of term to set of events
        self.events = []
    def add_event(self, event):
        """Adds an event to this object"""
        # Generate a unique ID for the event, and save it
        event_id = len(self.events)
        self.events.append(event)
        # Add each term to the bloomfilter, and track the event by each term
        for term in segments(event):
            self.bf.add_value(term)
            if term not in self.terms:
                self.terms[term] = set()
            self.terms[term].add(event_id)
    def search_all(self, terms):
        """Search for an AND of all terms"""
        # Start with the universe of all events...
        results = set(range(len(self.events)))
        for term in terms:
            # If a term isn't present at all then we can stop looking
            if not self.bf.might_contain(term):
                return
            if term not in self.terms:
                return
            # Drop events that don't match from our results
            results = results.intersection(self.terms[term])
        for event_id in sorted(results):
            yield self.events[event_id]
    def search_any(self, terms):
        """Search for an OR of all terms"""
        results = set()
        for term in terms:
            # If a term isn't present, we skip it, but don't stop
            if not self.bf.might_contain(term):
                continue
            if term not in self.terms:
                continue
            # Add these events to our results
            results = results.union(self.terms[term])
        for event_id in sorted(results):
            yield self.events[event_id]

s = SplunkM()
s.add_event('src_ip = 1.2.3.4')
s.add_event('src_ip = 5.6.7.8')
s.add_event('dst_ip = 1.2.3.4')
for event in s.search_all(['src_ip', '5.6']):
    print(event)
print('-')
for event in s.search_any(['src_ip', 'dst_ip']):
    print(event)

src_ip = 5.6.7.8
-
src_ip = 1.2.3.4
src_ip = 5.6.7.8
dst_ip = 1.2.3.4

>>> def foo(x, y): print(x, y)
... 
>>> alist = [1,2]
>>> adict = {'x': 1, 'y': 2}
>>> foo(*alist)
1 2
>>> foo(**adict)
1 2
>>>

>>> a, b, *rest = range(10)
>>> a
0
>>> b
1
>>> rest
[2, 3, 4, 5, 6, 7, 8, 9]
>>>

>>> first, second, *rest, last = range(10)
>>> first
0
>>> second
1
>>> last
9
>>> rest
[2, 3, 4, 5, 6, 7, 8]

>>> 1 < x < 2
False
>>> 4 > x >= 3
True
>>>

# 按步长2取列表数据
>>> a = [1,2,3,4,5]
>>> a[::2] 
[1, 3, 5]
# 用步长-1来反转列表
>>> a[::-1]
[5, 4, 3, 2, 1]
# 用切片来删除列表的某一段
>>> a = [1,2,3,4,5]
>>> a[1:3] = []
>>> a
[1, 4, 5]
# 也可以用 del a[1:3]
>>> a = [1,2,3,4,5]
>>> del a[1:3]
>>> a
[1, 4, 5]

>>> [(i, j) for i in range(3) for j in range(i)]
[(1, 0), (2, 0), (2, 1)]

>>> a, b = {}, {}
>>> a['b'] = b
>>> b['a'] = a
>>> a
{'b': {'a': {...}}}

>>> a, b = [], []
>>> a.append(b)
>>> b.append(a)
>>> a
[[[...]]]

# _ 在Python解析器上返回上一次的值
>>> 1 + 1
2
>>> _
2

>>> pos = (1, 2)
>>> x, _ = pos

>>> def foo(x=[]):
...     x.append(1)
...     print x
...
>>> foo()
[1]
>>> foo()
[1, 1]

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
...
>>> foo()
[1]
>>> foo()
[1]
>>>

>>> name = "Hello" "World"
>>> name
'HelloWorld'

>>> name = "Hello" \
...     "World"
>>> name
'HelloWorld'

>>> class Foo(object): pass
...
>>> obj = Foo()
>>> setattr(o, 'hello world', 1)
>>> o.hello world
  File "<stdin>", line 1
    o.hello world
                ^
SyntaxError: invalid syntax

>>> getattr(o, 'hello world')
1

>>> six_figures  = 100_000
>>> six_figures
100000
>>> a = 10_00_0
>>> a
10000
>>> error  = 0xbad_c0ffee
>>> error
50159747054
>>> flags  = 0b_0111_0101_0001_0101
>>> flags
29973

>>> s = "%s is %d" % ('two', 2)
>>> s
'two is 2'

>>> s = "{fruit} is {color}".format(fruit='apple', color='red')
>>> s
'apple is red'

>>> name = 'Bob'
>>> f'Hello, {name}!'
'Hello, Bob!'

>>> a = 5
>>> b = 10
>>> f'Five plus ten is {a + b} and not {2 * (a + b)}.'
'Five plus ten is 15 and not 30.'

# 精度
>>> PI = 3.141592653
>>> f"Pi is {PI:.2f}"
>>> 'Pi is 3.14'
>>> error = 50159747054
#以16进制格式化
>>> f'Programmer Error: {error:#x}'
'Programmer Error: 0xbadc0ffee'
#以二进制格式化
>>> f'Programmer Error: {error:#b}'
'Programmer Error: 0b101110101101110000001111111111101110'

>>> def my_add(a: int, b: int) -> int:
...    return a + b

>>> some_list = [1, 2, 3, 4, 5]
>>> another_list = [ x + 1 for x in some_list ]
>>> another_list
[2, 3, 4, 5, 6]

>>> # Set Comprehensions
>>> some_list = [1, 2, 3, 4, 5, 2, 5, 1, 4, 8]
>>> even_set = { x for x in some_list if x % 2 == 0 }
>>> even_set
set([8, 2, 4])

>>> # Dict Comprehensions
>>> d = { x: x % 2 == 0 for x in range(1, 11) }
>>> d
{1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False, 10: True}

>>> my_set = {1, 2, 1, 2, 3, 4}
>>> my_set
set([1, 2, 3, 4])

>>> n = 10
>>> d = {'x': 1, 'y': 2}
>>> x = Foo()
>>> for obj in (n, d, x):
...     print(type(obj) is obj.__class__)
...
True
True
True

Out: called A.foo()

Out: called C.foo()