def test(a:int, b:str) -> str:
    print(a, b)
    return 1000

if __name__ == '__main__':
    test('test', 'abc')

可以用*，**定义和解包

# not 会先于 and 执行
if not flag1 and flag2 == True

judge = index == 0 and num1 or num2

# 使用store_true属性，就可以执行默认的True or False
parser.add_argument("--bool_chose",default=False ,action='store_true',help='a switch of bool variable')
# 👇选择上与原本完全是相反的
parser.add_argument("--bool_chose",default=True ,action='store_true',help='a switch of bool variable')

list = [1,2,3,4,5]
choose = random.sample(list,2)

c_r = np.arange(20)
for i in range(10):
    c_i = random.choice(c_r)
    print(c_i)

A = [1,2,3,4,5,6]
# 得到index的列表
B = np.arange(len(A))
# 对该列表进行打乱，通过打乱的列表进行索引
random.shuffle(B)
print(B)

import logging
logging.debug('this message should only show up in log file')
logging.info('so do this one ')
logging.warning('this one will also show up in the console')
logging.error('And non-ASCII stuff, too, like resund and Malm')

logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s ', datefmt='%Y-%m-%d %I:%M:%S %p',   filename="exampleFile.log",level=logging.DEBUG)
# 这里设置了文件的输出名称和输出的格式，以及相应的记录到文件中的等级

--log = INFO
# getattr 这个方法目前好像还有点问题，

import logging

# create logger to record log messages
logger = logging.getLogger('textlogger')
# 避免等级c
logger.propagate = 0
logger.setLevel(logging.DEBUG)
# create file handler which logs even debug messages
fh = logging.FileHandler('exampleFile.log')
fh.setLevel(logging.WARNING)
# creatr console handler...
ch = logging.amHandler()
ch.setLevel(logging.DEBUG)
# create output format  for all the handler
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s ',
                    datefmt='%Y-%m-%d %I:%M:%S %p')
ch.setFormatter(formatter)
fh.setFormatter(formatter)
# add handler to logger
logger.addHandler(ch)
logger.addHandler(fh)
# record logs
logger.debug('this message should only show up in log file {}'.format('test is'))
logger.info('so do this one ')
logger.warning('this one will also show up in the console')
logger.error('show up twice')

再同个文件中我们只需要进行getlogger使用同一个名字即可获得同一个logger，但是跨文件的话可能还是需要传递logger把。

import os
p,f = os.path.split(origin)
print("path == ",p)
print("file == ",f)

dev,left = os.path.splitdrive(origin)

f,ext = os.path.splittext(origin)

os.walk(top,topdown,onerror,followlinks)

# T：奇偶性不一致 F：奇偶性一致
(a ^ b) & 1

# 将字符串变成Unicode码位
symbols = 'sdac@#'
codes = [ord(symbol) for symbol in symbols if ord(symbol) >127]
# 与map和filter的比较
lists(filter(lambda c:c>127, map(ord,symbols)))

colors = ['black','blue','red']
sizes = ['S','M','L']
# 先按颜色循环再按size循环，内外层循环的关系
tshirts = [(color,size) for color in colors for size in sizes]

tuple(ord(symbol) for symbol in symbols)
import array
array.array('I',ord(symbol) for symbol in symbols)

# 这样可以更好的体现逐个生成的特性？但是实际上列表推导式也可以把？
# 但是总之是由这样的特性的，能够避免额外的内存占用
for tshirt in ('%s %s' %(c,s) for c in colors for s in sizes):
    print(tshirt)

# np.random.randint?
A = np.random.randint(0,3,5)
B = np.random.randint(0,3,5)
print('origin A　is {} \n And B is {}'.format(A,B))
# style 1 相当于转换成一个ToF的list，然后对这样的list直接进行sum
same = (A == B).sum()
print('\nthe num of same element in same posi is', same)

'''列表的+=，也就是简单拼接操作'''
[1,2,3]+[2,3,4]

value = 5
unlist = [value]
outlist = unlist * 5
print('the output is like that : {}'.format(outlist))

reallist = list(range(20))
# range的步长设置
for i in range(0,20,5):
    print(i)

# 纯数字的情况就按基本方式进行排列
list1 = [1,2,4,5,6,23,4]
list1.sort()
list1

# 类似的string就按找字母表进行逐项排序吧，我是这样理解的

basker = {'apple', 'organge', 'apple', 'pear'}
print('basker:', basker)
'orange' in basker

a = set('go straight forward')
# 可以在集合中做交并等等集合的操作

# 二维数组为例
array1 = np.random.rand(3,4)
array1_t = tuple(map(tuple,array1))
resume = np.array(array1_t)
# 进行转换的时候注意不要进行过度的拆分，上述的方法只适用于二维数组的情况，
text = ['abcsd','dsdc','cdsda']
text = tuple(text)
# 即可，不然可能会将其中的文本全部拆分出来
# 后续补充一下map的其他用法。[func,iterator?]

>>> 'key1' in dict1
false

>>> d.get('key1')
>>> d.get('key1', -1)
-1

# 指定list类型用于未定义类别的填充
from collections import defaultdict
dict1 = {}
dict2 = defaultdict(list)
try:
    print(dict1['a'])
except:
    print('dict1 print key error')
    print('dict2 is like ', dict2['a'])

# 用法2，避免keyerror更容易对其进行赋值
from collections import defaultdict
bags = ['apple', 'orange', 'cherry', 'apple','apple', 'cherry', 'blueberry']
count = defaultdict(int)
for fruit in bags:
    count[fruit] += 1
print('the count output is like \n', count)
# print(locals().keys())

# 用法3：可以自定义函数作为初始化的函数参数
# 基于这样的方法我们可以定义各种各样的默认值
from collections import defaultdict
def defaultvalue(value=2): return value
dict3 = defaultdict(defaultvalue)
dict3['hello']

import time
from datetime import datetime
def get_time(type=1):
    if type == 0: now = time.strftime('%m/%d:%H:%M')
    else: now = datetime.now().strftime('%m/%d:%H:%M')
    return now
get_time(0)

from decimal import Decimal
a = Decimal('4.2')
b = Decimal('2.1')
print(a + b, a+b==Decimal('6.3'))
# 注意数据的类型实际上也是Decimal
# 能控制计算的每一方面，包括数字位数和四舍五入之类的，需要创建一个本地的上下文
from decimal import localcontext
# 精确度控制
with localcontext() as ctx:
    ctx.prec = 3
    print(a/b)

import math
nums = [1.23e+18，1，-1.23e+18]
assert sum(nums) != math.fsum(nums), 'the correct ans is fsum {}, error ans is sum {}'.format(math.fsum(nums),sum(nums))
# we can find it what we meet and waht we want.

x = 1234.56789
anslist = []
value = format(x, '0.2f')   # 👈 两位小数
anslist.append(value)

import time
from functional import wraps
def timethis(func):
    '''Decorator that report the execution time.
    this Decorator can not accept parameters'''
    # 通过下面这个内置的装饰器来保留func的元信息 __name__ __doc___之类的
    @wraps(func)
    def wrapper(*args,**kwargs):
        # * ** 来保证可以对func传入各种参数
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(func.__name__, end - start)
        return result
    return wrapper

# 实际上直观的理解的话，就是在外面再多嵌套一层函数，通过这个函数来对我们的decorator传递需要的参数
from functional import wraps
import logging

# 实现对装饰器的参数传递，同时和
def logged(level, name=None,message=None):
    '''通过最外层接受参数并将其传递到内层的装饰器中'''
    def decorate(func):
        # setting paramter we passing here
        logname = name if name else func.__moudule__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__

        @wraps(func)
        def wrapper(*args,**kwargs):
            log.log(level,logmsg)
            return func(*args,**kwargs)
        return wrapper
    return decorate

# 但是实际上我们要传递的就是一些输出结果，所以我们不需要用到这一点，只要再内部赋予logging就行了，所以这里我们设定的就是基本的level和logger_nanme

# 这里有个模块就比较猎奇了，以前倒是没见过
from functional import wraps,partial
import logging

# utility decorator to attach a functional as an attribute of obj
def attach_wrapper(obj, func=None):
    if func is None:
        return partial(attach_wrapper, obj)
    setattr(obj, func.__name__,func)
    return func

#原有装饰器上面添加东西即可
def logged(level, name=None,message=None):
    '''通过最外层接受参数并将其传递到内层的装饰器中'''
    def decorate(func):
        # setting paramter we passing here
        logname = name if name else func.__moudule__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__

        @wraps(func)
        def wrapper(*args,**kwargs):
            log.log(level,logmsg)
            return func(*args,**kwargs)

        '''使用nonlocal添加属性修改的模块'''
        @attach_wrapper(wrapper)
        def set_level(newlevel):
            nonlocal level
            level = newlevel

        @attach_wrapper(wrapper)
        def set_message(newmsg):
            nonlocal logmsg
            logmsg = newmsg

        return wrapper
    return decorate

@logged(logging.DEBUG)
def add(x,y):
    return x + y

@logged(logging.CRITICAL,'example')
def spam():
    print('Spam')

# 使用范例:可以再类外调用内内的属性设置了
add.set_message('add called')
add(2,3)

add.set_level(logging.WARNING)
add(2,3)

# 感觉没太理解这个文章中说到的不带参数的意思，难道可以不传入函数吗
# 先把模板放在这
def logged(func = None, *, level=logging.DEBUG,name=None, message=None):
    if func is None:
        return partial(logged,level=level,name=name,message=message)
    logname = name if name else func.__moudule__
    log = logging.getLogger(logname)
    logmsg = message if message else func.__name__

    @wraps(func)
    def wrapper(*args,**kwargs):
        log.log(level,logmsg)
        return func(*args,**kwargs)
    return wrapper

#主要依赖模块
import time
import sys

# 用try except的方式最好的一点在于，他不会终端程序的执行。
try:
    x = int(input("please type in NUMBER "))
except ValueError:
    print('your input is not NUMBER')

# if we donot use t-e
x = int(input("repeat you input"))

# 通过对比，我们可以知道这样执行的好处，在一些无关紧要的地方，
# 可以让程序继续运行而不必因为这些而中断。

# type 1
try:
    x = 123
except ValueError:
    t = 123
except TypeError:
    y = 123

# type 2
try:
    x = int(input("please type in NUMBER "))
except (ValueError,TypeError,NameError):
    print('your input is not NUMBER')

def try_import(package, message=None):
    try:
        return __import__(package)
    except ImportError as e:
        if not message:
            raise e
        raise ImportError(m)

x = 10
if x >= 5:
    raise Exception('x 不能大于5，当前值为 {} '.format(x))

bk1_a = np.array([1,2,3,4,5,6,7,8])
bk1_b = np.array([[1,1,1,1],[2,2,2,2]])
bk1_c = bk1_a.reshape(bk1_b.shape)
print("b's datashpe is {}".format(bk1_b.shape))
print("reshape by b。shape is ↓ \n {}".format(bk1_c))
# 测试是否改变原数据
print("b's shape is {} ".format(bk1_b.shape))
assert bk1_a ==  bk1_c, 'do not change the origin data, a is like {}'.format(bk1_a)

bk2_a= (2 ** np.arange(4,6))
# bk2_a
bk2_b = bk2_a.tolist()
# bk2_b

list1 = [1,2,3,4,12,3,4]
for i in range(len(list1)):
    temp = list1[i]-1
    list1[i] = np.zeros(13)
    list1[i][temp] = 1
list1

# A:flatten function B:flat function
bk3_a = np.random.rand(2,3)
print('A is just like\n {}'.format(bk3_a))
bk3_a2 = bk3_a.flatten()
print('A2 is just like\n {}'.format(bk3_a2))
printz('********************clip*************************')
bk3_b = np.random.rand(2,3)
print('B is just like \n{}'.format(bk3_b))
print(bk3_b.flat, 'as we can see, this is a iter')
for i in bk3_b.flat:
    print(i)

## numpy.pad
x = np.random.randint(0,5,(3,4,4))
x = np.pad(x,2)
print(x.shape)
h,w = x.shape[1:]
new_h,new_w = 3,3

top = np.random.randint(0,h-new_h)
left = np.random.randint(0,w-new_w)

x = x[:,top: top+new_h,left:left+new_w]
x.shape

a = np.random.rand(3,2,2)
print(a)
print('----------------------------')
a = a[:,::-1]
print(a)

x = np.array([12, 10, 12, 0, 6, 8, 9, 1, 16, 4, 6, 0])
index_val = np.argpartition(x, -5)[-5:]
index2 = np.argmin(x)
print(index2)
index_val

np.sort(x[index_val])

array1 = np.array([0.12,0.17,0.24,0.29])
array2 = np.array([0.13,0.19,0.26,0.31])
# with a tolerance of 0.1, it should return False:
print(np.allclose(array1,array2,0.1))
# with a tolerance of 0.2, it should return True:
print(np.allclose(array1,array2,0.2))

x = np.array([3, 17, 14, 23, 2, 2, 6, 8, 1, 2, 16, 0])
np.clip(x,2,5)

array = np.random.randint(20, size=12)
print('basic array is {} '.format(array))
#  Divide by 2 and check if remainder is 1
cond = np.mod(array, 2)==1
print('是否符合条件的list，条件list\n  {}'.format(cond))
# Use extract to get the values
# 提取出表现为True的哪些元素
print('按照条件提取出元素:\n {}'.format(np.extract(cond, array)))

# Apply condition on extract directly
# 更直接的指定条件
print('复杂条件下的表现情况')
print(np.extract(((array < 3) | (array > 15)), array))

y = np.array([1,5,6,8,1,7,3,6,9])
# Where y is greater than 5, returns index position
print(np.where(y>5))
# First will replace the values that match the condition,
# second will replace the values that does not
print(np.where(y>5, "Hit", "Miss"))

def test():
    if value == 1:
        a=b=1
        return a, b
a,b = test()
print(a,b)