Python 使用

a,b,c = [1,2,3]
print("1:", a,b,c)
a,b,c = "xyz"
print("2:", a,b,c)
a,*b,c = "1234567"
print("3:", a,b,c)
# 带*的解压出来都是list类型
a,*b,c="13"
print("4:", a,b,c)

def f1(a,*b):
    print("5:", a,b)
f1(1,3,4,5)

def f2(a,b):
    print("6:", a,b)
f2(*(1,2))

from collections import Counter
words = [
    'look', 'into', 'my', 'eyes', 'look', 'into', 'my', 'eyes',
    'the', 'eyes', 'the', 'eyes', 'the', 'eyes', 'not', 'around', 'the',
    'eyes', "don't", 'look', 'around', 'the', 'eyes', 'look', 'into',
    'my', 'eyes', "you're", 'under'
]
word_counts = Counter(words)
print(word_counts.most_common(3))
print(word_counts['into'])
word_counts.update(['into','into','eyes'])
print(word_counts.most_common(3))

from collections import Counter
words1 = ['in', 'the', 'a', 'an', 'in', 'the', 'the']
words2 = ['the', 'a', 'with', 'in']
a = Counter(words1)
b = Counter(words2)
print(a)
print(b)
print(a+b)
print(a-b)

rows = [
    {'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},
    {'fname': 'David', 'lname': 'Beazley', 'uid': 1005},
    {'fname': 'John', 'lname': 'Cleese', 'uid': 1001},
    {'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
]
print("---sort by fname---")
for i in sorted(rows, key=lambda r:r['fname']):
    print(i)
print("\n---sort by uid (reverse)---")
for i in sorted(rows, key=lambda r:r['uid'], reverse=True):
    print(i)

print("\n---sort by multi-keywords(1)---")
for i in sorted(rows, key=lambda r:(r['lname'],r['fname'])):
    print(i)

# 使用 itemgetter 速率会稍稍快点
print("\n---sort by multi-keywords(2)---")
from operator import itemgetter
for i in sorted(rows, key=itemgetter('lname','fname')):
    print(i)

# max / min
print("\n---max / min---")
print(max(rows,key=lambda r:r['uid']))
print(min(rows, key=lambda r:r['fname']))

class User:
    def __init__(self, user_id):
        self.user_id = user_id
    def __repr__(self):
        return f"User ({self.user_id})"
users = [User(23), User(3), User(99)]
print(sorted(users, key=lambda u:u.user_id))
from operator import attrgetter
print(sorted(users, key=attrgetter('user_id')))

from itertools import groupby
from operator import itemgetter
rows = [
    {'address': '5412 N CLARK', 'date': '07/01/2012'},
    {'address': '5148 N CLARK', 'date': '07/04/2012'},
    {'address': '5800 E 58TH', 'date': '07/02/2012'},
    {'address': '2122 N CLARK', 'date': '07/03/2012'},
    {'address': '5645 N RAVENSWOOD', 'date': '07/02/2012'},
    {'address': '1060 W ADDISON', 'date': '07/02/2012'},
    {'address': '4801 N BROADWAY', 'date': '07/01/2012'},
    {'address': '1039 W GRANVILLE', 'date': '07/04/2012'},
]
# groupby 之前需要先排序
rows.sort(key=itemgetter('date'))
for date, items in groupby(rows, key=itemgetter('date')):
    print(date, ":")
    for item in items:
        print("   ", item)

mylist = [1,4,-5,10,-7,2,3,1]
# 求出大于0的元素
# 列表推导：缺点--输出非常大时需要产生一个大结果集，占内存
print([i for i in mylist if i>0])
# 生成器
g = (i for i in mylist if i>0)
for i in g:
    print(i, end=" ")
print()
# 将负数变为正数
print([i if i>0 else -i for i in mylist])

# 对于复杂情况 用filter，返回迭代器
values = ['1','2','-3','-','4','N/A','5']
def is_int(val):
    try:
        int(val)
        return True
    except ValueError:
        return False
print(list(filter(is_int, values)))

# 输出指定位置的数据 compress返回迭代器
from itertools import compress
output_e = [True]*len(mylist)
output_e[0]=output_e[3]=output_e[4]=False
print(list(compress(mylist, output_e)))

prices = {
    'ACME':45.23,
    'AAPL':612.78,
    'IBM':205.55,
    'HPQ':37.20,
    'FB':10.75
}
# 求键值最小/最大的键名
print(f"1 : {min(prices)}")
print(f"2 : {max(prices)}")
print(f"3 : {sorted(prices)}")
# 求值最小/最大的键名
print(f"4-1 : {min(zip(prices.values(), prices.keys()))[-1]}")
# lambda 后面跟的s是通过 in 可取的迭代器中的值
print(f"4-2 : {min(prices, key=lambda s:prices[s])}")
print(f"5-1 : {max(zip(prices.values(), prices.keys()))[-1]}")
print(f"5-2 : {max(prices, key=lambda s:prices[s])}")
print(f"6 : {[i[-1] for i in sorted(zip(prices.values(), prices.keys()))]}")

# 当值存在重复时 max的结果为key较大的
prices = {'AAA':20, 'ZZZ':20, 'BBB':20}
print(f"7 : {max(zip(prices.values(), prices.keys()))[-1]}")

# 寻找两个字典系统的键
a = {'x':1, 'y':2, 'z':3}
b = {'w':10, 'x':11, 'y':2}
# 集合求交操作
print(f"8-1 : {[i for i in a if i in b]}")
print(f"8-2 : {a.keys() & b.keys()}")
# 集合求差操作
print(f"9-1 : {[i for i in a if i not in b]}")
print(f"9-2 : {a.keys() - b.keys()}")
# 集合求异操作
print(f"10 : {a.keys()^b.keys()}")
# 集合并操作
print(f"11 : {a.keys()|b.keys()}")

# 寻找两字典键值对相等的item
print(f"12-1 : {[(i,a[i]) for i in a if i in b and a[i]==b[i] ]}")
print(f"12-2 : {a.items() & b.items()}")

# 输出指定键名的item
print(f"13-1 : { {i:a[i] for i in a.keys()-{'x'}} }")
print(f"13-2 : { {i:a[i] for i in a if i not in ['x']} }")

prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}
# 获得值大于200的items
# 使用字典推导
p1 = {k:v for k,v in prices.items() if v>200}
print(p1)
tech_names = ["FB", "IBM", "ACME"]
p2 = {k:v for k,v in prices.items() if k in tech_names}
print(p2)

from collections import ChainMap
a = {'x':1, 'z':2}
b = {'y':2, 'z':4}
c = ChainMap(a, b)
print("ChinaMap result:")
print(c['x'])
print(c['y'])
print(c['z'])
print(c)
print(list(c.keys()))
print(list(c.values()))
# ChainMap 只是存储了一个视图而已
print("\nChainMap just store a view:")
a['x'] = 10
print(c)
print(list(c.values()))
c['z'] = 20
print(a)

print("\ndict.update demo:")
# 也可使用update进行合并
d = dict(b)
d.update(a)
print(d)
# dict.update进行了拷贝而非视图
d['x'] = 30
print(a)

from collections import namedtuple
Subscriber = namedtuple('Subscriber', ['addr', 'joined'])
sub = Subscriber('jonesy@example.com', '2012-10-19')
print(sub)
print(sub.addr)
print(sub.joined)

# 支持所有的普通元组操作
print(len(sub))
print(sub[-1])
addr, joined = sub
print(addr, joined)

from collections import namedtuple
Stock = namedtuple('Stock', ['name', 'shares', 'price'])
s = Stock('ACME', 100, 73.5)
print(s)
s = s._replace(shares=80)
print(s)

nums = [1,2,3,4,5]
# 求平方和
s = sum(x**2 for x in nums)
print(s)

def f(x):
    print("call f")
    return x**2
a = [1,2,3,4,5,6,7]
print("---test 1---")
sum(x for x in range(f(3)))

print("\n---test 2---")
sum(f(x) for x in range(3))

print("\n---test 3---")
sum(x for x in a if x < f(3))

nums = [1,2,3,4,5]
print(sum(n for n in nums))
print(sum((n for n in nums)))

a = [1,5,2,1,9,1,5,10]
# 会打乱顺序
print(1, ":", list(set(a)))
def dedupe(items):
    seen = set()
    for item in items:
        if item not in seen:
            yield item
        seen.add(item)
print(2, ":", list(dedupe(a)))

a = [{'x':1, 'y':2}, {'x':1, 'y':3}, 
{'x':1, 'y':2}, {'x':2, 'y':4}]
def dedupe(items, key=None):
    seen = set()
    for item in items:
        val = item if key==None else key(item)
        if val not in seen:
            yield item
        seen.add(val)
print(list(dedupe(a, lambda s:(s['x'],s['y']))))
print(list(dedupe(a, lambda s:s['x'])))

record = '....................100 .......513.25 ..........'
# 硬切片方式
print(int(record[20:23])*float(record[31:37]))
# 命名切片方式
SHARES = slice(20, 23)
PRICE = slice(31,37)
print(int(record[SHARES])*float(record[PRICE]))

items = [0,1,2,3,4,5,6]
a = slice(2,5,2)
print(a)
print(a.start, a.stop, a.step)
items[a] = [10,20]
print(items)

from collections import defaultdict
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)

e = defaultdict(set)
e['a'].add(1)
e['a'].add(2)
e['b'].add(4)
print(d)
print(e)

d = {}
d.setdefault('a',[]).append(1)
d.setdefault('a',[]).append(2)
d.setdefault('b',[]).append(4)
print(d)

from collections import defaultdict
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)
print(d)

import heapq
nums = [12,33,41,64,75,27,94,67,28]
print(heapq.nlargest(3, nums))
print(heapq.nsmallest(3, nums))

import heapq
portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
print(heapq.nlargest(2, portfolio, lambda s:s['price']))
print(heapq.nsmallest(2, portfolio, lambda s:s['price']))

import heapq
nums = [12,33,41,64,75,27,94,67,28]
a = list(nums) # 相当于 nums.copy()
heapq.heapify(a)
print(a)

import heapq
class PriorityQueue:
    def __init__(self):
        self._queue = []
        self._index = 0
    def push(self, item, priority):
        heapq.heappush(self._queue, (-priority, self._index, item))
        self._index += 1
    def pop(self):
        return heapq.heappop(self._queue)[-1]
class Item:
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return f"Item({self.name})"
q = PriorityQueue()
q.push(Item('foo'), 1)
q.push(Item('bar'), 5)
q.push(Item('spam'), 4)
q.push(Item('grok'), 1)
print(q.pop())
print(q.pop())
print(q.pop())
print(q.pop())

from collections import deque
q = deque(maxlen=3)
q.append(1)
q.append(2)
q.append(3)
print(q)
q.append(4)
print(q)
q.appendleft(5)
print(q)
q.pop()
print(q)
q.popleft()
print(q)

a = [x*x for x in range(3)]
print(a)
for i in a:print(i, end=" ")
else: print()
for i in a:print(i, end=" ")
else: print()

b = (x*x for x in range(3))
print(b)
for i in b:print(i, end=" ")
else: print()
for i in b:print(i, end=" ")
else: print()

def create_generator():
    for i in range(3):
        yield i
g = create_generator()
for i in g:print(i, end=" ")
print()
for i in g:print(i, end=" ")

a = 5
b = 9
console.log(a>b?a:b)

a = 5
b = 9
print(a if a>b else b)

for(i=0; i<10; ++i){
    if(i%2==0){
        console.log(i)
    }
}

[print(i, end=" ") for i in range(10) if i%2==0]

name = 'Fred'
height = 176.23
print("My name is %s, height is %.1f cm" %(name, height))

name = 'Fred'
height = 176.23
print("My name is {0}, height is {1:.1f} cm".format(name, height))
print("My name is {sname}, height is {sheight:.1f} cm".format(sheight=height, sname=name))

name = 'Fred'
height = 176.23
print(f"My name is {name}, height is {height:.1f} cm")

def public_func():
    print("I am aviliable")
def _private_func():
    print("I am not aviliable")

from test import *
public_func()
_private_func()

from test import _private_func
_private_func()

print(list("abc"))
list = 12
print(list("abc"))

print(list("abc"))
list_ = 12
print(list("abc"))

is=12

class A:
    def __foo1(self):
        print("called A::__foo1")
    def foo2(self):
        print("called A::foo2")
    def f(self):
        print("\n--- f ---")
        self.__foo1()
        self.foo2()
        print("-"*9, end="\n"*2)

a = A()
print(dir(a)[:3], "...")
# 实现了变名
a._A__foo1()

a.f()

class B(A):
    def __foo1(self):
        print("called B::__foo1")
    def foo2(self):
        print("called B::foo2")
b = B()
b.f()

class A:
    def __repr__(self):
        return "I am A"
print(A())

import itertools
for i in itertools.permutations("abc"):
    print(i)

line = "asdf  fjk;  fj,ek, foo"
import re
print(re.split(r'[\s\;\,]+', line))
fields = re.split(r'([;,\s]+)', line)
print(fields)
print(fields[::2])

# 捕获与非捕获
print(re.split(r'(\s|,|;)+',line))
# (?:...)表示非捕获
print(re.split(r'(?:\s|,|;)+',line))

import re
# 使用 str.startswith str.endswith
filename = "spam.txt"
print(filename.startswith('file:'))
print(filename.endswith('.txt'))
print(filename[-4:]==".txt")
print(re.match('[\s\S]*\.(txt|c)$', filename))
print(filename.endswith(('.txt','c')))

# 检查匹配并归类
filenames = ['Makefile','foo.c','bar.py','spam.c','spam.h']
print([f for f in filenames if f.endswith(('.c','.h'))])
print(any(f.endswith('py') for f in filenames))

from fnmatch import fnmatch, fnmatchcase
print(fnmatch('foo.txt', '*.txt'))
print(fnmatch('foo.txt', '?oo.txt'))
print(fnmatch('Dat45.csv','Dat[0-9]*'))
# 大小写敏感(mac os)
print(fnmatch('foo.txt', '*.TXT'))
print(fnmatchcase('foo.txt', '*.TXT'))

addresses = [
    '5412 N CLARK ST',
    '1060 W ADDISON ST',
    '1039 W GRANVILLE AVE',
    '2122 N CLARK ST',
    '4802 N BROADWAY',
]
print([addr for addr in addresses if fnmatch(addr, '* ST')])
print([addr for addr in addresses if fnmatch(addr, '54[0-9]*CLARK*')])

# 简单的搜索
text = 'yeah, but no, but yeah, but no, but yeah'
print(text.find('no'))
# 对于复杂的匹配，使用 re 模块
import re
text1 = '11/27/2012'
text2 = 'Nov 27, 2012'
datepat = re.compile(r'\d+/\d+/\d+')
# 方式1：re.match
print('yes' if re.match(datepat, text1) else 'no')
# 方式2：pat.match
print('yes' if datepat.match(text2) else 'no')

text = 'Today is 11/27/2012. PyCon starts 3/13/2013.'
# re.match 总是从字符串开始去匹配
print('yes' if datepat.match(text) else 'no')
# 任意位置查找
print(datepat.findall(text))

# 在定义正则式时，通常会利用括号去捕获分组
datepat = re.compile(r'(\d+)/(\d+)/(\d+)')
m = datepat.match('11/27/2012')
print(m.group(0), m.group(1), m.group(2), m.group(3))
print(m.groups())

print(datepat.findall(text))
# 时间格式转换
for month, day, year in datepat.findall(text):
    print(f'{year}-{month}-{day}')
# findall 以列表形式返回，finditer 以生成器方式返回
for m in datepat.finditer(text):
    month, day, year = m.groups()
    print(f'{year}-{month}-{day}')

# match 只检查字符串的开头部分
m = datepat.match("11/27/2012ddasdf")
print('yes' if m else 'no')

# 简单的字符串替换
text = 'yeah, but no, but yeah, but no'
print(text.replace('yeah', 'yep'))
# 复杂的字符串替换
import re
text = 'Today is 11/27/2012. PyCon starts 3/13/2013.'
datepat = re.compile(r'(\d+)/(\d+)/(\d+)')
print(datepat.sub(r'\3-\1-\2', text))

# 可读性更强的一种方式
# (?P<name>\d+) 表示捕获为name变量
# \g<name> 使用name
datepat = re.compile(r'(?P<month>\d+)/(?P<day>\d+)/(?P<year>\d+)')
print(datepat.sub(r'\g<year>-\g<month>-\g<day>', text))

import re
from calendar import month_abbr
text = 'Today is 11/27/2012. PyCon starts 3/13/2013.'
datepat = re.compile(r'(?P<m>\d+)/(?P<d>\d+)/(?P<y>\d+)')
def change_date(m):
    mon_name = month_abbr[int(m.group('m'))]
    return f"{m.group('d')} {mon_name} {m.group('y')}"
print(datepat.sub(change_date, text))
# 第一个返回值为替换结果，第二个返回值为替换次数
print(datepat.subn(change_date, text))

import re
text = 'UPPER PYTHON, lower python, Mixed Python'
print(re.findall(r'python', text, flags=re.IGNORECASE))
print(re.sub(r'python', 'snake', text, flags=re.IGNORECASE))

def matchCase(word):
    def replace(m):
        text = m.group()
        if text.isupper():
            return word.upper()
        elif text.islower():
            return word.lower()
        elif text[0].isupper():
            return word.capitalize()
        else:
            return word
    return replace
print(re.sub('python',matchCase('snake'),
    text ,flags=re.IGNORECASE))

import re
text1 = 'Computer says "no."'
text2 = 'Computer says "no." Phone says "yes."'
str_pat = re.compile(r'\"(.*)\"')
print(str_pat.findall(text1))
# 最长匹配的例子(贪婪模式)
print(str_pat.findall(text2))
# 使用最短匹配 在匹配模式后加上 ? (懒惰模式)
print(re.findall(r'\"(.*?)\"', text2))

import re
comment = re.compile(r'/\*(.*?)\*/')
text1 = '/* This is one-line of comment */'
text2 = """
/*This is multi-line
 comment*/
"""
print(comment.findall(text1))
print(comment.findall(text2))
# '?'在后面表示最短匹配，'?:'在捕获组的前面表示不进行捕获
comment = re.compile(r'/\*([\s\S]*?)\*/')
print(comment.findall(text2))
comment = re.compile(r"/\*((?:.|\n)*)\*/")
print(comment.findall(text2))
# 使用 re.DOTALL 让点匹配所有字符
print(re.findall(r'/\*(.*)\*/', text2, flags=re.DOTALL))

import re
# 使用 str.strip、str.lstrip、str.rstrip
# 删除开头/结尾的指定字符串 不会删除中间的字符
s = '   hello   world  '
print(f"'{s.strip()}'")
print(f"'{s.lstrip()}'")
print(f"'{s.rstrip()}'")
# strip 的参数中字符是或的关系
print(f"'{s.strip(' hd')}'")
# 删除中间的空格
print(f"'{s.strip().replace(' ','')}'")
# 删除中间多余的空格

print("'{0}'".format(re.sub(r'\s+', ' ', s.strip())))

# 改写指定字母
text = 'life is short, please use python'
print(text.translate({
    ord('s'):'S',
    ord('p'):'pop'
}))

hw = "hello,world"
print(f"'{hw.ljust(20)}'")
print(f"\'{format(hw, '<20')}\'")
print("'{:<20}'".format(hw))

print(f"'{hw.rjust(20)}'")
print(f"\'{format(hw, '>20')}\'")
print("'{:>20}'".format(hw))

print(f"'{hw.center(20)}'")
print(f"\'{format(hw, '^20')}\'")
print("'{:^20}'".format(hw))

print(f"'{hw.center(20,'*')}'")
print(f"\'{format(hw, '*^20s')}\'")
print("'{:*^20s}'".format(hw))

print(f"\'{hw:*^20s}\'")

# 格式化数字
x = 1.2345
print(f"{x:>10}|")
print(f"{x:<10}|")
# 默认 . 后面是精确位数
print(f"{x:^+10.3}|")
# 加了f后表示小数点后几位
print(f"{x:^+10.3f}|")
print(f"{x:$^10.2}|")

# 如果要合并的字符串时一个序列或iterable
parts = ['Is', 'Chicago', 'Not', 'Chicago']
parts_dic = {'a':'Is', 'd':'Chicago', 'b':'Not', 'c':'Chi'}
print(' '.join(parts))
print(' , '.join(parts))
print(''.join(parts))
print(' '.join(parts_dic))
# 用 + 连接
a = 'Is Chicago'
b = "Not Chicago"
print(a + ' ' + b)
# 两个字符串字面量直接并排合并
print('Hello' ' ' 'world')

data = ['ACME', 50, 91.1]
# 不可取的做法, +操作符存在大量内存复制、垃圾回收
s = ''
for i in data:
    # + 操作存在
    s += str(i) + ','
print(s[:-1])
# 好一些的做法
s = ','.join(str(i) for i in data)
print(s)

a = '1'; b='b'; c='3'
# ugly mode
print(a + ':' + b + ':' +c)
# still ugle
print(':'.join([a,b,c]))
# better
print(a,b,c,sep=":")

def sample():
    yield 'Is'
    yield 'Chicago'
    yield 'Not'
    yield 'Chicago'

print(' '.join(sample()))
for i in sample():
    print(i)

name = 'Fred'
weight = 71.32
# 原始版本
print('I am %s, weight is %.1f' %(name, weight))
# f 字符串版本
print(f'I am {name} ,weight is {weight:#^10.1f}' %vars())

import re
# 定义令牌
NAME = r'(?P<NAME>[a-zA-Z][a-zA-Z0-9_]*)'
NUM = r'(?P<NUM>\d+)'
PLUS = r'(?P<PLUS>\+)'
TIMES = r'(?P<TIMES>\*)'
EQ = r'(?P<EQ>=)'
WS = r'(?P<WS>\s+)'
master_pat = re.compile('|'.join([NAME, NUM, PLUS, TIMES, EQ, WS]))
# 使用scanner进行扫描 方法1
print("{:*^30s}".format(' scanner method 1 '))
scanner = master_pat.scanner('foo = 42')
while True:
    m = scanner.match()
    if m:
        print((m.lastgroup, m.group()))
    else:
        break
print('{:*^30s}'.format(' scanner method 2 '))
# 方式2
scanner = master_pat.scanner('foo = 42')
for m in iter(scanner.match, None):
    print((m.lastgroup, m.group()))
# 方式3
print('{:*^30s}'.format(' scanner method 3 '))
from collections import namedtuple
def generate_token(pat, text):
    Token = namedtuple('Token', ['type','value'])
    scanner = pat.scanner(text)
    for m in iter(scanner.match, None):
        yield Token(m.lastgroup, m.group())
for tok in generate_token(master_pat, 'foo = 42'):
    print(tok)
# 过滤生成的符号
print('{:*^30s}'.format(' filter the tokens '))
tokens = (t for t in generate_token(master_pat, 'foo = 42') 
    if t.type!='WS')
for t in tokens:
    print(t)

import re
PRINT = r'(?P<PRINT>print)'
NAME = r'(?P<NAME>[a-zA-Z_][a-zA-Z0-9_]*)'
master_pat = re.compile('|'.join([PRINT, NAME]))
scanner = master_pat.scanner('printer')
for m in iter(scanner.match, None):
    print((m.lastgroup, m.group()))

from ply.yacc import yacc
from ply.lex import lex

# Token list
tokens=['NUM','PLUS','MINUS','TIMES','DIVIDE','LPAREN','RPAREN']
# Ignored characters
t_ignore = ' \t\n'
# Token specifications (as regexs)
t_PLUS = r'\+'
t_MINUS = r'\-'
t_TIMES = r'\*'
t_DIVIDE = r'/'
t_LPAREN = r'\('
t_RPAREN = r'\)'

# Token processing functions
def t_NUM(t):
    r'\d+'
    t.value = int(t.value)
    return t

# error handler
def t_error(t):
    print('Bad character: {!r}'.format(t.value[0]))
    t.skip(1)

# bulid the lexer
lexer = lex()

# Grammer rules and handler functions
def p_expr(p):
    '''
    expr : expr PLUS term
        | expr MINUS term
    '''
    if p[2] == '+':
        p[0] = p[1] + p[3]
    elif p[2] == '-':
        p[0] = p[1] - p[3]

def p_expr_term(p):
    '''
    expr : term
    '''
    p[0] = p[1]

def p_term(p):
    '''
    term : term TIMES factor
        | term DIVIDE factor
    '''
    if p[2] == '*':
        p[0] = p[1]*p[3]
    elif p[2] == '/':
        p[0] = p[1]/p[3]

def p_term_factor(p):
    '''
    term : factor
    '''
    p[0] = p[1]

def p_factor(p):
    '''
    factor : NUM
    '''
    p[0] = p[1]

def p_factor_group(p):
    '''
    factor : LPAREN expr RPAREN
    '''
    p[0] = p[2]

def p_error(p):
    print('Syntax error')

parser = yacc()

print(parser.parse('2'))
print(parser.parse('2+3'))
print(parser.parse('2*(3+4) + 5'))

# 字节字符串同样也支持大部分和文本字符串一样的内置操作
data = b'Hello World'
print(data[:5])
print(data.startswith(b'Hello'))
print(data.split())
print(data.replace(b'Hello', b'Hello Cruel'))
# 这些操作同样适用于字节数组
data = bytearray(b'Hello World')
print(data)
print(data.startswith(b'Hello'))
print(data.split())
print(data.replace(b'Hello', b'Hello Curel'))

# 可以用正则表达式匹配字节字符串
data = b'FOO:BAR,SPAM'
import re
print(re.split(b'[:,]+', data))

# 大多数情况下，在文本字符串上的操作均可以用于字节字符串
# 不同点1：字节字符串索引操作返回整数而不是单个字符
a = 'Hello World'
b = b'Hello World'
print(f'{a[0]} , 0x{b[0]:x}')
print(a[0], b[0])
# 不同点2：打印出来为 b'...'
print(b)
print(b.decode('ascii'))
# 不同点3：不能格式化
try:
    print(b'{:x}'.format(12))
except:
    print('catch a except')
# 实现的方式
print('{:x}'.format(12).encode('ascii'))

print(round(1.24,1))
# 当一个值更好在两个边界，round函数返回离它最近的偶数
print(round(1.5,0))
print(round(2.5,0))
# round(number [,ndigits]), ndigits可以为负，表示小数前几位
print(round(12345, -3))
# 如果仅仅是为了显示，用str.format
print('{:-.0f}'.format(1.5))
# 不要试着去舍入浮点来“修正”表面上看起来正确的问题
a = 2.1
b = 4.2
c = a + b
print(c)
c = round(c, 2)
print(c)

a = 0.2
b = 0.1
c = a + b
print(c)
print(c==0.3)
# 正确的判断
import math
print(math.isclose(c, 0.3))

from decimal import Decimal
from decimal import localcontext
a = Decimal('4.2')
b = Decimal('2.1')
print(a+b)
print(a+b==Decimal('6.3'))
a = Decimal('1.3')
b = Decimal('1.7')
print(a/b)
with localcontext() as ctx:
    ctx.prec = 3
    print(a/b)
with localcontext() as ctx:
    ctx.prec = 7
    print(a/b)

a = 1.23e+18
b = 1
c = -1.23e+18
# 1 被“丢失了”
print(a+b+c)
# 使用 math.fsum 进行精确运算
from math import fsum
print(fsum([a,b,c]))

x = 1234.56789
print(f"'{x:.2f}'")
print(f"'{x:>10.1f}'")
print(f"'{x:<10.1f}'")
print(f"'{x:^10.1f}'")
print(f"'{x:,}'")
print(f"'{x:e}'")
print(f"'{x:.3E}'")
# 同时制定宽度和精度的一般形式是：[<>^]?width[,]?(.digits)?
print(f"'{x:,.2f}'")
#上述方法同样使用与Decimal
from decimal import Decimal
x = Decimal('1234.56789')
print(f'{x:*^15,.3f}')

x = 1234
print(bin(x))
print(f'{x:b}')

print(oct(x))
print(f'{x:o}')

print(hex(x))
print(f'{x:x}')

# 整数是有符号的
x = -x
print(bin(x))
print(f'{x:b}')
# 显示负数对应的无符号二进制表示
# 32 位对应的无符号表示
print(f'{2**32+x:b}')
print(f'{2**32+x:x}')

# 将不同进制字符串转换为整数
print(int('4d2', 16))
print(int('10011010010', 2))

data = b'\x00\x124V\x00x\x90\xab\x00\xcd\xef\x01\x00#\x004'
print(len(data))
print(f"{int.from_bytes(data, 'little'):x}")
print(f"{int.from_bytes(data, 'big'):x}")
print(int.from_bytes(data, 'big'))

x = 94522842520747284487117727783387188
print(x.to_bytes(16, 'big'))

a = complex(2,4)
b = 2+4j
print(a)
print(a==b)
print(a.real, a.imag)
# 共轭复数
print(a.conjugate())

a = 2+4j
b = 1-3j
print(a+b)
print(a-b)
print(a*b)
print(a/b)

import numpy as np
a = np.array([2+3j,4+5j,6-7j,8+9j])
print(a)
print(a+2)
print(np.sin(a))

import math
print(math.sqrt(-1))

import cmath
print(cmath.sqrt(-1))
# 或者是 ** 运算符
print((-1)**.5)

import math
a = float('inf')
b = float('-inf')
c = float('nan')
print(a) # inf
print(math.isinf(a)) # True
print(b) # -inf
print(math.isinf(b)) # True
print(c) # nan
print(math.isnan(c)) # True
# 无穷大的运算
print(a+100) # inf
print(a*100) # inf
print(10000/a) # 0.0
print(a/a) # nan
print(a+b) # nan
# NaN会在所有操作中传播
print(c + 20) # nan
print(c / 20) # nan
# 两个NaN值不相等
print(c==float('nan')) # False

from fractions import Fraction
a = Fraction(5, 4)
b = Fraction(7, 16)
print(a+b) # 27/16
print(a*b) # 35/64

# 获取 numerator / denominator
c = a * b
print(c.numerator) # 35
print(c.denominator) # 64

# 转换为小数
print(float(c)) # 0.546875

# 限制分母大小
print(c.limit_denominator(8)) # 4/7

# 小数转换为分数
x = 3.75
print(Fraction(*x.as_integer_ratio()))

# Python list
x = [1, 2, 3, 4]
y = [5, 6, 7, 8]

print(x * 2)

print(x+10)

print(x+y)

import numpy as np
ax = np.array([1,2,3,4])
ay = np.array([5,6,7,8])

print(ax*2)

print(ax+10)

print(ax+ay)

print(ax*ay)

def f(x):
    return 3*x**2 - 2*x + 7
print(f(ax))

print(np.sqrt(ax))
print(np.cos(ax))

import numpy as np
grid = np.zeros(shape=(10000, 10000), dtype=float)

print(grid)

grid += 10

print(grid)

print(np.sin(grid))

import numpy as np
a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(a, end='\n'*2)
print(a[1], end='\n'*2)
print(a[:, 1], end='\n'*2)
a[1:,1:3] += 10
print(a, end='\n'*2)
print(a+[100, 101, 102, 103], end='\n'*2)
print(a+[[100],[101],[102]], end='\n'*2)
print(np.where(a<10, a, 10))

import numpy as np
m = np.matrix([[1, -2, 3], [0, 4, 5], [7, 8, -9]])
print(m, end='\n'*2)
print(m.T, end='\n'*2)
# 返回矩阵的逆
print(m.I, end='\n'*2)
# m·m.I = identity matrix
print(m*m.I, end='\n'*2)

v = np.matrix([[2],[3],[4]])
print(v, end='\n'*2)

print(m*v)

import numpy as np
# determinant 矩阵行列式的值
m = np.matrix([[1, -2, 3], [0, 4, 5], [7, 8, -9]])
v = np.matrix([[2],[3],[4]])
print(np.linalg.det(m), end='\n'*2)
# eigenvalues 特征值
print(np.linalg.eigvals(m), end='\n'*2)
# 解方程 mx=v
x = np.linalg.solve(m, v)
print(x, end='\n'*2)
print(m*x, end='\n'*2)

import random
values = [1,2,3,4,5,6]
# 随机选出 list 中的一个元素
print(random.choice(values))
print(random.choice(values))
# 随机选出 list 中的若干个元素
print(random.sample(values, 3))
# 打乱序列中元素的顺序
random.shuffle(values)
print(values)
# 随机生成整数，范围为 [0, 100] 的闭区间
print(random.randint(0,100))
# 随机生成 0~1 范围内的浮点数
print(random.random())
# 以等概率均匀分布生成 0~1 的随机数
print(random.uniform(0, 1))
# 以均值为0，标准差为1，生成高斯分布
print(random.gauss(0, 1))
# 获取 N 为随机位（二进制）的整数
print(f'{random.getrandbits(200):x}')

# timedelta 表示一段时间间隔
from datetime import timedelta
a = timedelta(days=2, hours=14)
b = timedelta(hours=17.5)
c = a+b
print(c.days)
print(c.seconds)
print(c.seconds/3600)
print(c.total_seconds() / 3600)

from datetime import datetime
from datetime import timedelta
a = datetime(2018, 4, 9, 10, 49, 55)
# datetime 和 timedelta 的运算
print(a+timedelta(hours=10, minutes=5))
b = datetime(2012, 12,21)
# datetime 之间的运算
print(a-b)
# 获取当前时间
now = datetime.now()
print(now)

from datetime import datetime
a = datetime(2012,3,1)
b = datetime(2012,2,28)
print(a-b)
a = datetime(2100,3,1)
b = datetime(2100,2,28)
print(a-b)

from datetime import datetime, timedelta
weekdays = ['Monday', 'Tuesday', 'Wednesday',
    'Thursday', 'Friday', 'Saturday', 'Sunday']
def get_previous_byday(dayname, start_date=None):
    if start_date==None:
        start_date = datetime.today()
    day_delta = (7+start_date.weekday() -
        weekdays.index(dayname))%7
    day_delta = day_delta if day_delta else 7
    return start_date-timedelta(days=day_delta)
print(get_previous_byday('Sunday'))

# 2016年最后一个星期五
print(get_previous_byday('Friday', datetime(2017, 1, 1)))

cal 12 2016

from datetime import datetime
from dateutil.relativedelta import relativedelta
from dateutil.rrule import *
d = datetime(2017, 1, 1)
print(d+relativedelta(weekday=FR(-1)))
# 修改day属性
print(d.replace(day=10))

import calendar
# 返回 2017-2-1 星期几，共多少天
print(calendar.monthrange(2017, 2)) # 2表示周三
# 返回 2016-2-1 星期几，共多少天
print(calendar.monthrange(2016, 2)) # 0表示周一

from datetime import datetime
text = '2018-4-9'
y = datetime.strptime(text, '%Y-%m-%d')
print(y)
print(datetime.strftime(y, '%A %B %d, %Y'))

from datetime import datetime
def strptime(s):
    year_s, month_s, day_s = s.split('-')
    return datetime(int(year_s), int(month_s),int(day_s))
print(strptime('2018-4-9'))

# 计算平均值，参数数量不确定，至少为 1 个
def avg(first, *rest):
    return (first + sum(rest))/(1+len(rest))
print(avg(1,2,3,4))
print(avg(5))

def anyargs(*args, **kwargs):
    print(args) # a tuple
    print(kwargs) # a dict

def a(x, *args, y):
    pass
def b(x, *args, y, **kwargs):
    pass

def recv(maxsize, *, block):
    'Receives a message'
    pass
def test(func, *args, **kwargs):
    try:
        func(*args, **kwargs)
    except TypeError:
        print('Catch TypeError')
    else:
        print('No Error')

test(recv, 1024, True) # recv(1024, True)
test(recv, 1024, block=True) # recv(1024, block=True)

def minimum(*values, clip=None):
    m = min(values)
    if clip != None:
        m = clip if clip>m else m
    return m
print(minimum(1,5,2,-5,10))
print(minimum(1,5,2,-5,10,clip=0))

help(recv)

def add(x:int, y:int) -> int:
    return x+y
help(add)

def myfun():
    return 1, 2, 3
a, b, c = myfun()
print(a, b, c,)
d = myfun()
print(d)

def myfun():
    return (1,2,3)
a, b, c = myfun()
print(a, b, c)
d = myfun()
print(d)

a = (1)
print(a)
b = 1,
print(b)

def spam(a, b=24):
    print(a, b)
spam(1)
spam(1,2)

def spam(a, b:list=None) -> list:
    b = b if b is not None else []
    return []+b
help(spam)

_no_value = object()
def spam(a, b=_no_value):
    if b is _no_value:
        print('No b value supplied')
    else:
        print('b value has supplied')
spam(1)
spam(1, 2)
spam(1, None)

x = 42
def spam(a, b=x):
    print(a, b)
spam(10)
x = 43
spam(10)

def spam(a, b=[]):
    print(b)
    return b
x = spam(1)
x.append(99)
spam(1)

def spam(a, b=None):
    b = [] if b is None else b
    print(b)
    return b
x = spam(1)
x.append(99)
spam(1)

def spam(a, b=None):
    if not b: # NO! use 'b is None' instead
        print('b is None :', b)
        b = []
    else:
        print('b is not None')
x = []
spam(1)
spam(1, x)
spam(1, 0)
spam(1, '')

def spam(a, b=None):
    if b is None: # NO! use 'b is None' instead
        print('b is None :', b)
        b = []
    else:
        print('b is not None')
x = []
spam(1)
spam(1, x)
spam(1, 0)
spam(1, '')