Welcome to LeaCoder's Blog!

持之以恒终有收获，自律自强方至成功

LeetCode-120--三角形最小路径和(Triangle)

2019-04-25

leacoder

Algorithm

Algorithm Leetcode

120. 三角形最小路径和
Python3 实现
- 动态规划

120. 三角形最小路径和

三角形最小路径和

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
例如，给定三角形：
[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
说明：
如果你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题，那么你的算法会很加分。

Python3 实现

动态规划

#@author:leacoder
#@des:  动态规划  三角形最小路径和

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        if triangle == None:
            return 0
        for i in range(len(triangle)-2,-1,-1): # 从下至上
            for j in range(len(triangle[i])):
                triangle[i][j] += min(triangle[i+1][j],triangle[i+1][j+1]) 
                # DP状态方程：dp[i, j] = min(dp(i+1, j), dp(i+1, j+1)) + triangle[i, j]
        return triangle[0][0]

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

LeetCode-70--爬楼梯(Climbing-Stairs)

2019-04-22

leacoder

Algorithm

Algorithm Leetcode

70. 爬楼梯
Python3 实现
- 动态规划计算所有 f(n)
- 动态规划优化

70. 爬楼梯

70. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

    注意：给定 n 是一个正整数。
    示例 1：
    输入： 2
    输出： 2
    解释： 有两种方法可以爬到楼顶。
    1.  1 阶 + 1 阶
    2.  2 阶

    示例 2：
    输入： 3
    输出： 3
    解释： 有三种方法可以爬到楼顶。
    1.  1 阶 + 1 阶 + 1 阶
    2.  1 阶 + 2 阶
    3.  2 阶 + 1 阶

Python3 实现

动态规划计算所有 f(n)

#@author:leacoder
#@des:  动态规划 计算所有 f(n) 爬楼梯

class Solution:
    def climbStairs(self, n: int) -> int:
        dicttmp = {0:1,1:1}
        if n == 1 or n == 0:
            return dicttmp[n]
        for i in range(2,n+1):
            dicttmp[i] = dicttmp[i-1] + dicttmp[i-2]  # 递推公式 f(n) = f(n-1) + f(n-2)
        return dicttmp[n]

动态规划优化

#@author:leacoder
#@des:  动态规划  爬楼梯

class Solution:
    def climbStairs(self, n: int) -> int:
        f0 = f1 = 1
        for i in range(1,n):
            f0,f1 = f1, f0+f1 # 递推公式 f(n) = f(n-1) + f(n-2)只关心 f(n-1) f(n-2)不必要所有f
        return f1

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

Python3内置函数

2019-04-21

leacoder

python

abs(x)
all(iterable)
any(iterable)
ascii(object)
bin(x)
class bool([x])
breakpoint(*args, **kws)
class bytearray([source[, encoding[, errors]]])
class bytes([source[, encoding[, errors]]])
callable(object)
chr(i)
@classmethod
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
class complex([real[, imag]])
delattr(object, name)
dict()
dir([object])
divmod(a, b)
enumerate(iterable, start=0)
eval(expression, globals=None, locals=None)
exec(object[, globals[, locals]])
class float([x])
format(value[, format_spec])
class frozenset([iterable])
getattr(object, name[, default])
globals()
hasattr(object, name)
hash(object)
help([object])
hex(x)
id(object)
input([prompt])
class int(x, base=10)
isinstance(object, classinfo)
issubclass(class, classinfo)
iter(object[, sentinel])
len(s)
class list([iterable])
locals()
map(function, iterable, …)
max()
memoryview(obj)
min()
next(iterator[, default])
- class object
- oct(x)
- open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
- ord(c)
- pow(x, y[, z])

Python Standard Library based on Python 3.7.3 https://docs.python.org/3/library/

Python标准库 - 内置函数

Link: https://docs.python.org/3/library/functions.html

说明 print 后的 # 注释为输出和相关说明，包含所有 Python3.7.3 官方文档中的内置函数

GitHub Code : Built-in Functions.py

abs(x)

'''
@Description: 
    abs(x) 函数返回数字的绝对值 
@Param: 
    x -- 数值表达式。
@Return: 
    函数返回x（数字）的绝对值。
'''
# abs(x) 
print ("abs(-45) : ", abs(-45)) # abs(-45) :  45
print ("abs(100.12) : ", abs(100.12))   # abs(-45) :  45
print ("abs(complex(2,-2)) : ", abs(complex(2,-2))) # abs(complex(2,-2)) :  2.8284271247461903
# abs(x)  End

all(iterable)

'''
@Description: 
    all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
    元素除了是 0、空、None、False 外都算 True。
@Param: 
    iterable -- 元组或列表。
@Return: 
    如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
    注意：空元组、空列表返回值为True，这里要特别注意。
等价于
    def all(iterable):
        for element in iterable:
            if not element:
                return False
        return True
'''
# all(iterable)
print(all(['a', 'b', 'c', 'd']))    # True
print(all(['a', 'b', '', 'd']))     # False
print(all([0, 1, 2, 3]))    # False
print(all((0, 1, 2, 3)))    # False
print(all([]))  # True
print(all(()))  # True
# all(iterable) End

any(iterable)

'''
@Description: 
    any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
    元素除了是 0、空、FALSE 外都算 TRUE。
@Param: 
    iterable -- 元组或列表。
@Return: 
    如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。

等价于：
    def any(iterable):
        for element in iterable:
            if element:
                return True
        return False
'''
# any(iterable)
print(any(['a', 'b', '', 'd']) )    # True
print(any([0, '', False]) ) # False
print(any((0, '', False)))  # False
print(any([]))  # False
print(any(()))  # False
# any(iterable) End

ascii(object)

'''
@Description:  
    调用对象的__repr__()方法，获得该方法的返回值.
@Param: 
@Return: 
    返回一个包含对象的可打印表示的字符串
'''
# ascii(object)
print(ascii('!@#$%^1234abcvn\\\n')) # '!@#$%^1234abcvn\\\n'
# ascii(object) End

bin(x)

'''
@Description: 
    bin() 返回一个整数 int 或者长整数 long int 的二进制表示.。
@Param: 
    x -- int 或者 long int 数字
    如果x不是Python int对象，则必须定义一个返回整数的__index __（）方法。
@Return: 
    字符串。
'''
# bin(x)
print(bin(10))  # 0b1010
print(bin(-10)) # -0b1010
# print(bin(-3.1415926))  # TypeError: 'float' object cannot be interpreted as an integer
class Test:
    def __init__(self,x):
        self.intdata = x
    def __index__(self):
        return int(self.intdata)
test = Test(-3.1415926)
print(bin(test))    # -0b11
# bin(x) End

class bool([x])

'''
@Description: 
    bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
    bool 是 int 的子类。
@Param: 
    x -- 要进行转换的参数。
@Return: 
    返回 Ture 或 False。
'''
# class bool([x])
print(bool())   # False
print(bool(0))  # False
print(bool(2))  # True
print(issubclass(bool, int))    # True
# class bool([x]) End

breakpoint(*args, **kws)

'''
@Description: 
    3.7新增
    此函数会将您置于调试器中在你放置位置
    具体来说，它调用sys.breakpointhook（），直接传递args和kws。
    默认情况下，sys.breakpointhook（）调用pdb.set_trace（）期望没有参数。
@Param: 
@Return: 
'''
# breakpoint(*args, **kws)
breakpoint()
print("Here is a break point") # 在这里暂停 Here is a break point
# breakpoint(*args, **kws) End

class bytearray([source[, encoding[, errors]]])

'''
@Description: 
    bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
@Param: 
    如果 source 为整数，则返回一个长度为 source 的初始化数组；
    如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
    如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
    如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
    如果没有输入任何参数，默认就是初始化数组为0个元素。
@Return: 
    新字节数组。
'''
# class bytearray([source[, encoding[, errors]]])
print(bytearray())  # bytearray(b'')
print(bytearray([1,2,3]))   # bytearray(b'')
print(len(bytearray([1,2,3])))  # 3
tmpstr = bytearray('leacoder', 'utf-8')
print(tmpstr)   #bytearray(b'')
print(len(tmpstr)) # 8
tmpstr[0] = ord('d') # 它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值
print(tmpstr) #  bytearray(b'deacoder')  d 的 ascii 为 100
# class bytearray([source[, encoding[, errors]]]) End

class bytes([source[, encoding[, errors]]])

'''
@Description:
    bytes是bytearray的不可变版本
@Param: 

@Return: 
    返回一个新的“字节”对象,它是一个不可变的整数序列，范围为0 <= x <256。
'''
# class bytes([source[, encoding[, errors]]])
print(bytes())  # bytearray(b'')
print(bytes([1,2,3]))   # bytearray(b'')
print(len(bytes([1,2,3])))  # 3
tmpstr = bytes('leacoder', 'utf-8')
print(tmpstr)   #bytearray(b'')
print(len(tmpstr)) # 8
# tmpstr[0] = ord('d') # 'bytes' object does not support item assignment  'bytes'对象不支持项目分配
# class bytes([source[, encoding[, errors]]]) End

callable(object)

'''
@Description:
    callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
    对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
@Param: 
    object -- 对象
@Return: 
    可调用返回 True，否则返回 False。
'''
# callable(object)
print(callable(0))  # False
print(callable('leacock'))  # False
print(callable(lambda x, y: x + y)) # True
def add( x, y):
    return x + y
print(callable(add))    # True

class A:
    def func(self):
        return 0
print(callable(A))  # True
a = A() # A类的实例
print(callable(a))  # False
class B:
    def __call__(self):
        return
print(callable(B))  # True
b = B() # B类的实例
print(callable(b))  # True
# callable(object) End

chr(i)

'''
@Description: 
    chr(i) 返回表示Unicode代码点为整数i的字符的字符串。
    这是ord（）的反转。
@Param: 
    i -- 可以是10进制也可以是16进制的形式的数字。参数的有效范围是0到1,114,111（基数为16的0x10FFFF）。如果i超出该范围，则会引发ValueError。
@Return: 
    返回值是当前整数对应的 ASCII 字符。
'''
# chr(i)
print(chr(0x30), chr(0x31), chr(0x61))  # 0 1 a
print(chr(48), chr(49), chr(97) )   # 0 1 a
print(chr(0o60), chr(0o61), chr(0o141) )   # 0 1 a
print(chr(0b110000), chr(0b110001), chr(0b1100001) )   # 0 1 a
# print(chr(1114112)) # ValueError: chr() arg not in range(0x110000)
# chr(i) End

@classmethod

'''
@Description: 
    classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
@Param: 
@Return: 
    返回函数的类方法。
'''
# @classmethod
class C(object):
    bar = 1
    def func1(self):  
        print ('foo') 
        print (self.bar)
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   
 
C.func2() # 不需要实例化   func2    1   foo     1
# @classmethod End

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

'''
@Description: 
    compile() 将source编译为代码或AST对象。代码对象可以由exec（）或eval（）执行。 source可以是普通字符串，字节字符串或AST对象
@Param: 
    source -- 字符串或者AST（Abstract Syntax Trees）对象。。
    filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
    mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
    flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
    flags和dont_inherit是用来控制编译源码时的标志
    optimize  -- 参数optimize指定编译器的优化级别;
@Return: 
    返回表达式执行结果。
'''
# compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
strtmp = "for i in range(0,10): print(i)" 
c = compile(strtmp,'','exec')   # 编译为字节代码对象 
print(c)    # <code object <module> at 0x7f11505769c0, file "", line 1>
exec(c)  # 0 1 2 3 4 5 6 7 8 9
strtmp = "3 * 4 + 5"
a = compile(strtmp,'','eval')
print(eval(a))  # 17
# compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) End

class complex([real[, imag]])

'''
@Description: 
    complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。第二个参数永远不能是字符串。
    如果省略imag，则默认为零，构造函数用作int和float之类的数字转换。如果省略两个参数，则返回0j。
@Param: 
    real -- int, long, float或字符串；
    imag -- int, long, float；
@Return: 
    返回值为real + imag * 1j的复数或将字符串或数字转换为复数。
'''
# class complex([real[, imag]])
print(complex(1, 2))    # (1+2j)
print(complex(1))   # (1+0j)
print(complex())    # 0j
print(complex("10"))    # (10+0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
print(complex("1+2j"))  # (1+2j)
# print(complex("1 + 2j"))    # ValueError: complex() arg is a malformed string
# class complex([real[, imag]]) End

delattr(object, name)

'''
@Description: 
    delattr 函数用于删除属性。delattr(x, 'foobar') 相等于 del x.foobar。
    与setattr()相对，
@Param: 
    object -- 对象。
    name -- 必须是对象的属性。
@Return: 
'''
# delattr(object, name)
class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
delattr(Coordinate, 'z')
del Coordinate.y
print('x = ',point1.x)  # x =  10
# print('y = ',point1.y)  # 触发错误    AttributeError: 'Coordinate' object has no attribute 'y'
# print('z = ',point1.z)  # 触发错误  AttributeError: 'Coordinate' object has no attribute 'z'
# delattr(object, name) End

dict()

'''
@Description: 
    dict() 函数用于创建一个字典。
    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg)
@Param: 
    **kwargs -- 关键字
    mapping -- 元素的容器。
    iterable -- 可迭代对象。
@Return: 
    返回一个字典。
'''
# dict() 
print(dict())   # {}
# 关键字
print(dict(a='a', b='b', t='t'))    # {'a': 'a', 'b': 'b', 't': 't'}    
# 映射函数方式来构造字典 zip 返回 iterabl 
print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))    # {'one': 1, 'two': 2, 'three': 3}  
# 可迭代对象方式来构造字典
print(dict([('one', 1), ('two', 2), ('three', 3)]))     # {'one': 1, 'two': 2, 'three': 3}
# 可迭代对象 + 关键字
print(dict([('one', 1), ('two', 2), ('three', 3)],a='a', b='b', t='t')) # {'one': 1, 'two': 2, 'three': 3, 'a': 'a', 'b': 'b', 't': 't'}
# dict()  End

dir([object])

'''
@Description: 
    dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
    如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
@Param: 
    object -- 对象、变量、类型。
@Return: 
    返回模块的属性列表。
'''
# dir([object])
print(dir())    #  获得当前模块的属性列表
print(dir([ ]))     # 查看列表的方法
class Shape:
    def __dir__(self):
        return ['area', 'perimeter', 'location']
print(dir(Shape())) # ['area', 'location', 'perimeter']
# dir([object]) End

divmod(a, b)

'''
@Description: 
    divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
@Param: 
    a: 数字非复数
    b: 数字非复数    
@Return: 
    返回一个包含商和余数的元组(a // b, a % b)。
'''
# divmod(a, b)
print(divmod(10, 3))    # (3, 1)
print(divmod(10.0, 3.0))    # (3.0, 1.0)
# print(divmod(1+2j,1+0.5j))  # 报错 TypeError: can't take floor or mod of complex number.
# divmod(a, b) End

enumerate(iterable, start=0)

'''
@Description: 
    enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
@Param: 
    sequence -- 一个序列、迭代器或其他支持迭代对象。
    start -- 下标起始位置。
@Return: 
    返回 enumerate(枚举) 对象。
'''
# enumerate(iterable, start=0)
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(enumerate(seasons))   # <enumerate object at 0x7f897c4ada20>
print(list(enumerate(seasons))) # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(list(enumerate(seasons, start=1)))    # [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
# 相当于：
def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1
# enumerate(iterable, start=0) End

eval(expression, globals=None, locals=None)

'''
@Description: 
    eval() 函数用来执行一个字符串表达式，并返回表达式的值。
    只能是单个运算表达式（注意eval不支持任意形式的赋值操作），而不能是复杂的代码逻辑，这一点和lambda表达式比较相似。
    exec()动态执行Python代码。也就是说exec可以执行复杂的Python代码，而不像eval函数那么样只能计算一个表达式的值。
@Param: 
    expression -- 表达式。
    globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
    locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
@Return: 
    返回表达式计算结果。
'''
# eval(expression, globals=None, locals=None)
x = 7
result = eval( '3 * x' )
print(result)   # 21
result = eval('pow(2,2)')
print(result)   # 4
strtmp = "for i in range(0,10): print(i)" 
# evaltest = compile(strtmp,'','eval')   # 报错 SyntaxError: invalid syntax 
evaltest = compile(strtmp,'','exec')
exec(evaltest)  # 0 1 2 3 4 5 6 7 8 9
result = exec('3 * x')
print(result)   # None
# eval(expression, globals=None, locals=None) End
# eval()函数与exec()函数的区别：
# eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
# eval()函数可以有返回值，而exec()函数返回值永远为None。

exec(object[, globals[, locals]])

'''
@Description: 
    exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
@Param: 
    object：必选参数，表示需要被指定的Python代码。
    它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。
    如果object是一个code对象，那么它只是被简单的执行。
    globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
    locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
@Return: 
    exec 返回值永远为 None。
'''
# exec(object[, globals[, locals]])
# 见 eval
# exec(object[, globals[, locals]])End 

## filter(function, iterable)
```python
'''
@Description: 
    filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
    该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
@Param: 
    function -- 判断函数。
    iterable -- 可迭代对象。
@Return: 
    返回一个迭代器对象
'''
# filter(function, iterable)
tmplist = filter(lambda n : n % 2 == 1, range(1, 11))
print(tmplist)  # <filter object at 0x7f3494520940>
print(list(tmplist))    # [1, 3, 5, 7, 9]
# filter(function, iterable) End

class float([x])

'''
@Description: 
    float() 函数用于将整数和字符串转换成浮点数。
    对于一般Python对象x，float（x）委托给x .__ float __（）。
    如果没有给出参数，则返回0.0。
@Param: 
    x -- 整数或字符串
    如果参数是一个字符串，它应该包含一个十进制数字，可选地以符号开头，并且可选地嵌入在空格中。
    可选符号可以是“+”或“ - ”; “+”符号对产生的值没有影响。
    参数也可以是表示NaN（非数字）或正或负无穷大的字符串。
    在删除前导和尾随空格字符后，输入必须符合以下语法：
    sign           ::=  "+" | "-"
    infinity       ::=  "Infinity" | "inf"
    nan            ::=  "nan"
    numeric_value  ::=  floatnumber | infinity | nan
    numeric_string ::=  [sign] numeric_value
@Return: 
    返回浮点数。
'''
# class float([x])
print(float())  # 0.0
print(float('   -12345\n')) # -12345.0
print(float('-Infinity'))   # -inf
print(float('NAN')) # nan
print(float('+1E6'))    # 1000000.0
print(float('1e-003'))  # 0.001
# class float([x]) End

format(value[, format_spec])

'''
@Description: 
    将值转换为“格式化”表示，由format_spec控制。
@Param: 
@Return: 
'''
# format(value[, format_spec])
# 参见 string 库  格式字符串语法示例 Format String Syntax   https://www.jianshu.com/p/faaa48f4c511
# format(value[, format_spec]) End

class frozenset([iterable])

'''
@Description: 
    frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
    参见 https://blog.csdn.net/lilong117194/article/details/78522459
@Param: 
    iterable -- 可迭代的对象，比如列表、字典、元组等等。
@Return: 
    返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
'''
# class frozenset([iterable])
a = frozenset(range(10))     # 生成一个新的不可变集合
print(a)    # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
# a.add(10) # AttributeError: 'frozenset' object has no attribute 'add'
# class frozenset([iterable]) End

getattr(object, name[, default])

'''
@Description: 
    getattr() 函数用于返回一个对象属性值。
@Param: 
    object -- 对象。
    name -- 字符串，对象属性。
    default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
@Return: 
    返回对象属性值。
'''
# getattr(object, name[, default])
class D(object):
    bar = 'leacoder'
d = D()
print(getattr(d, 'bar') )       # 获取属性 bar 值   
# print(getattr(a, 'bar2') )  #  报错 AttributeError: 'D' object has no attribute 'bar2'
print(getattr(d, 'bar2', '123456') )   # 属性 bar2 不存在，但设置了默认值
# getattr(object, name[, default]) End

globals()

'''
@Description: 
    globals() 函数会以字典类型返回当前位置的全部全局变量。
@Param: 
@Return: 
    返回全局变量的字典。
'''
# globals()
print(globals())
# globals() End

hasattr(object, name)

'''
@Description: 
    hasattr() 函数用于判断对象是否包含对应的属性。
@Param: 
    bject -- 对象。
    name -- 字符串，属性名。
@Return: 
    如果对象有该属性返回 True，否则返回 False。
'''
# hasattr(object, name)
class Coordinate1:
    x = 10
    y = -5
point1 = Coordinate1()   
print(hasattr(point1, 'x')) # True
print(hasattr(point1, 'y')) # True
print(hasattr(point1, 'z')) # False
# hasattr(object, name) End

hash(object)

'''
@Description: 
    hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
@Param: 
    object -- 对象；
@Return: 
    返回对象的哈希值（如果有的话）。哈希值是整数。
    它们用于在字典查找期间快速比较字典键。比较相等的数字值具有相同的哈希值（即使它们具有不同的类型，如1和1.0的情况）。
'''
# hash(object)
print(hash('test'))            # 字符串 # 8918808336926749410
print(hash(str([1,2,3])))     # 集合    # -5376174432533403617
print(hash(300.0))      # 300
print(hash(300))    # 300
# hash(object) End

help([object])

'''
@Description: 
    help() 函数用于查看函数或模块用途的详细说明。
@Param: 
    object -- 对象；
@Return: 
    返回对象帮助信息。
'''
# help([object])
a = [1,2,3]
help(a.append)             # # 查看列表 list 帮助信息
# help([object]) End

hex(x)

'''
@Description: 
    hex() 函数用于将一个指定数字转换为 16 进制数。
    如果x不是Python int对象，则必须定义一个返回整数的__index __（）方法。参见 bin() 
@Param: 
    x -- 一个整数
@Return: 
    返回一个字符串，以 0x 开头。
'''
# hex(x)
result = hex(255)
print(result)   # 0xff
print(type(result)) # <class 'str'>
# hex(x) End

id(object)

'''
@Description: 
    id() 函数用于返回对象的“标识”,这是一个整数，在该生命周期内保证该对象是唯一且恒定的。
@Param: 
    object -- 对象。
@Return: 
    返回对象的“标识”
'''
# id(object)
a = 'leacoder'  
print(id(a))    # 140597046261744
b = 'leacoder'
print(id(b))    # 140597046261744
# id(object) End

input([prompt])

'''
@Description: 
    input() 函数接受一个标准输入数据，返回为 string 类型。
@Param: 
    prompt: 提示信息
    如果存在prompt参数，则将其写入标准输出而不带尾随换行符。该函数从输入中读取一行，将其转换为字符串（剥离尾部换行符），然后返回该行。
    读取EOF时，会引发EOFError。
@Return: 
'''
# input([prompt])
s = input('--> ')  # 输入 leacoder  # --> leacoder
# input([prompt])

class int(x, base=10)

'''
@Description: 
    int() 函数用于将一个字符串或数字转换为整型。
    如果x定义__int __（），则int（x）返回x .__ int __（）。如果x定义__trunc __（），则返回x .__ trunc __（）。对于浮点数，这会截断为零。
    如果x不是数字或者给定了base，则x必须是字符串，字节或bytearray实例，表示以radix为基数的整数文字。
    可选 文字可以在前面加+或 - （之间没有空格）并且用空格包围。
@Param: 
    x -- 字符串或数字。
    base -- 进制数，默认十进制。
@Return: 
    返回整型数据。
'''
# class int(x, base=10)
print(int())   # 不传入参数时，得到结果0  # 0
print(int(3))  # 3
print(int(3.6))     # 3
print(int('12',16))     # 18
# print(int(12,16))   # 报错 TypeError: int() can't convert non-string with explicit base
# class int(x, base=10) End

isinstance(object, classinfo)

'''
@Description: 
    如果object参数是classinfo参数的实例，或者是（直接，间接或虚拟）子类的实例，则返回true。
    如果object不是给定类型的对象，则该函数始终返回false。
    如果classinfo是类型对象的元组（或递归，其他此类元组），object是其中任何类型的实例，则返回true。
    如果classinfo不是类型和元组的类型或元组，则会引发TypeError异常。
@Param: 
    object -- 实例对象。
    classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
    对于基本类型来说 classinfo 可以是： int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple
@Return: 
'''
# isinstance(object, classinfo)
a = 2
print(isinstance (a,int))   # True
print(isinstance (a,str))   # False
print(isinstance (a,(str,int,list)))    # True
'''
isinstance() 与 type() 区别：
    type() 不会认为子类是一种父类类型，不考虑继承关系。
    isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
'''
class AClass:
    pass
class BClass(AClass):
    pass
print(isinstance(AClass(), AClass)) # True
print(type(AClass()) == AClass) # True     
print(isinstance(BClass(), AClass)) # True  
print(type(BClass()) == AClass) # False     
# isinstance(object, classinfo) End

issubclass(class, classinfo)

'''
@Description: 
    如果class是classinfo的子类（直接，间接或虚拟），则返回true。
    类被认为是其自身的子类。
@Param: 
    class -- 类。
    classinfo -- 类。
    classinfo可以是类对象的元组，在这种情况下，将检查classinfo中的每个条目。
@Return: 
    如果 class 是 classinfo 的子类返回 True，否则返回 False。
'''
# issubclass(class, classinfo)
class AClass1:
    pass
class BClass1(AClass1):
    pass
print(issubclass(AClass1,AClass1))  # True
print(issubclass(BClass1,AClass1))  # True
print(issubclass(BClass1,(str,int,list,AClass1)))  # True
# issubclass(class, classinfo) End

iter(object[, sentinel])

'''
@Description: 
    iter() 函数用来生成迭代器。
@Param: 
    object -- 支持迭代的集合对象。
    sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），
    此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
@Return: 
    迭代器对象。
'''
# iter(object[, sentinel])
settmp = {'a':1,'b':2,'c':3}
# next(settmp)    # TypeError: 'dict' object is not an iterator
print(next(iter(settmp)))   # a
# iter(object[, sentinel]) End

len(s)

'''
@Description: 
    len() 方法返回对象（字符、列表、元组等）长度或项目个数。
@Param: 
    s -- 对象。可以是序列（例如字符串，字节，元组，列表或范围）或集合（例如字典，集合或冻结集）。
@Return: 
    返回对象长度。
'''
# len(s)
strtmp = "leacdoer"
print(len(strtmp))  # 8
l = [1,2,3,4,5]
print(len(l))   # 5
# len(s) End

class list([iterable])

'''
@Description: 
    list() 方法用于将元组或字符串转换为列表。
@Param: 
    iterable -- 要转换为列表的元组或字符串。
@Return: 
    返回列表。
'''
# class list([iterable])
strtmp="leacoder"
list2=list(strtmp)
print ("列表元素 : ", list2)    # 列表元素 :  ['l', 'e', 'a', 'c', 'o', 'd', 'e', 'r']
# class list([iterable]) End

locals()

'''
@Description: 
    locals() 函数更新并返回表示当前本地符号表的字典。
    在模块级别，locals（）和globals（）是相同的字典。
@Param: 
@Return: 
'''
# locals()
def funtestlocals(arg):    # 两个局部变量：arg、z
    a = 2
    print (locals()) 
funtestlocals(123)  # {'arg': 123, 'a': 2}
# locals() End

map(function, iterable, …)

'''
@Description: 
    map() 会根据提供的函数对指定序列做映射。
    第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
@Param: 
    function -- 函数
    iterable -- 一个或多个序列
    对于多个迭代，迭代器在最短的iterable耗尽时停止。
@Return: 
    迭代器。
'''
# map(function, iterable, ...)
result = map(lambda x: x ** 2, [2, 3, 4, 5])
print(result)  # 使用 lambda 匿名函数   # <map object at 0x7ff9203c2438>
print(next(result)) # 4
result = map(lambda x, y: x + y, [1,3,5,7],[2,4])
print(next(result)) # 3
print(next(result)) # 7
# print(next(result)) # StopIteration
# map(function, iterable, ...) End

max()

'''
@Description: 
    max(iterable, *[, key, default])
    max(arg1, arg2, *args[, key])
@Param: 
    如果提供了一个位置参数，则它应该是可迭代的。返回iterable中的最大项。
    如果提供了两个或多个位置参数，则返回最大的位置参数。
    当key参数不为空时，就以key的函数对象为判断的标准。
@Return: 
    返回可迭代中的最大项或两个或多个参数中的最大项。
    如果多个项是最大的，则该函数返回遇到的第一个项。
'''
# max() 
print ("max(80, 100, 1000) : ", max(80, 100, 1000)) # max(80, 100, 1000) :  1000
listtmp1 = [80, 100, 1000]
print ("max(listtmp1) : ", max(listtmp1)) # max(listtmp) :  1000
listtmp2 = [-20,200,5000,1]
print ("max(listtmp1,listtmp2) : ", max(listtmp1,listtmp2))   # max(listtmp,listtmp2) :  [80, 100, 1000]  默认以第一个进行比较
print ("max('123','32') : ", max('123','32'))   # max('123','32') :  32 以第一个进行比较
print ("max(listtmp1,listtmp2) : ", max(listtmp1,listtmp2,key = lambda x:x[1]))  #  max(listtmp1,listtmp2) :  [-20, 200, 5000, 1] key的函数对象为判断的标准。

def mymax(x):
    return -x
print (max(123, 321, key=mymax))    # 123
print (max(listtmp1, key=mymax))    # 80
# max()  End

memoryview(obj)

'''
@Description: 
    memoryview() 函数返回给定参数的内存查看对象(Momory view)。
    所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
@Param: 
    obj -- 对象
@Return: 
    返回元组列表
'''
# memoryview(obj)
# v = memoryview("abcefg")    # TypeError: memoryview: a bytes-like object is required, not 'str'
v = memoryview(bytes("abcefg",'utf-8'))
print(v[0]) # ascii   # 97  
print(v[0:1]) # <memory at 0x7f56a574c408>
print(v[0:1].tobytes()) # b'a'
print(v[1:4])   # <memory at 0x7f56a574c408>
print(v[1:4].tobytes()) # b'bce'
# memoryview(obj) End

min()

'''
@Description: 
    min(iterable, *[, key, default])
    min(arg1, arg2, *args[, key])
@Param:
    如果提供了一个位置参数，则它应该是可迭代的。返回iterable中的最小项。
    如果提供了两个或多个位置参数，则返回最小的位置参数。
    当key参数不为空时，就以key的函数对象为判断的标准。
@Return: 
    返回可迭代中的最小项或两个或多个参数中的最小项。
    如果多个项目是最小的，则该函数返回遇到的第一个项目。
'''
# min() 
print ("min(80, 100, 1000) : ", min(80, 100, 1000))     # min(80, 100, 1000) :  80
listtmp1 = [80, 100, 1000]
print ("min(listtmp1) : ", min(listtmp1))   # min(listtmp1) :  80
listtmp2 = [-20,200,5000,1]
print ("min(listtmp1,listtmp2) : ", min(listtmp1,listtmp2))   #min(listtmp1,listtmp2) :  [-20, 200, 5000, 1]  默认以第一个进行比较
print ("min('123','32') : ", min('123','32'))   # min('123','32') :  123   以第一个进行比较
print ("min(listtmp1,listtmp2) : ", min(listtmp1,listtmp2,key = lambda x:x[1]))  #  min(listtmp1,listtmp2) :  [80, 100, 1000] key的函数对象为判断的标准。

def mymin(x):
    return -x
print (min(123, 321, key=mymin))    # 321
print (min(listtmp1, key=mymin))    # 1000
# min()  End

next(iterator[, default])

'''
@Description: 
    通过调用__next __（）方法从迭代器中检索下一个项。
@Param: 
    iterator -- 可迭代对象
    default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
@Return: 
    迭代器中下一个项
'''
# next(iterator[, default])
it = iter([1, 2, 3])
# 循环:
for i in range(5):
    # 获得下一个值:
    x = next(it,'leacoder')
    print(x)    # 1 2 3 leacoder leacoder
# next(iterator[, default]) End

class object

'''
@Description:
    返回一个新的无特征对象。
    object是所有类的基础。它具有所有Python类实例共有的方法。此函数不接受任何参数。
    object没有__dict__，因此您无法将任意属性分配给对象类的实例
@Param: 
@Return: 
'''
# class object
objecttest = object()
print(objecttest)   # <object object at 0x7eff046bfa10>
print(dir(objecttest)) 
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', 
# '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', 
# '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
# class object End

oct(x)

'''
@Description: 
    oct() 函数将一个整数转换成8进制字符串。
    将整数转换为前缀为“0o”的八进制字符串。结果是一个有效的Python表达式。如果x不是Python int对象，则必须定义一个返回整数的__index __（）方法。
    参见 bin()
@Param: 
    x -- 整数。
@Return: 
    返回一个字符串，以 0o 开头。
'''
# oct(x)
print(oct(9))   # 0o11
# oct(x) End

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

'''
@Description: 
    open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
    注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
    open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
    pen(file, mode='r')
    参见 https://docs.python.org/3.7/library/functions.html#open
@Param: 
    file: 必需，文件路径（相对或者绝对路径）。
    mode: 可选，文件打开模式
    buffering: 设置缓冲
    encoding: 一般使用utf8
    errors: 报错级别
    newline: 区分换行符
    closefd: 传入的file参数类型
    opener:
@Return: 
'''
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# f = open('test.txt')
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) End

ord(c)

'''
@Description: 
    ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
@Param: 
    c -- 字符。
@Return: 
    返回值是对应的十进制整数。
'''
# ord(c)
print(ord('a')) #97
# ord(c) End

pow(x, y[, z])

'''
@Description: 
    返回x的y次方，如果z存在，返回 x的y次方再模z（比pow（x，y）％z更有效地计算）。两个参数形式pow（x，y）相当于使用幂运算符：x ** y。
    如果存在z，则x和y必须是整数类型，y必须是非负的
@Param: 
    x -- 数值表达式。
    y -- 数值表达式。
    z -- 数值表达式。
    参数必须具有数字类型
@Return:
'''
# pow(x, y[, z])
print( pow(100, 2))     # 10000
print( pow(100, -2))    # 0.0001
print( pow(100, 2, 3))  # 1
# print( pow(100, -2, 3))  # 报错 ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
import math
print( math.pow(100, 2))    # 10000.0 和内置函数区别
# pow(x, y[, z]) End

Read All

Python3-标准库函学习合集

2019-04-18

leacoder

程序员练级之旅

程序员练级之旅 Python
Python Standard Library based on Python 3.7.3 https://docs.python.org/3/library/

Python3内置函数

Python3内置函数

Python3内置异常

Python3内置异常

文本处理服务 Text Processing Services

Python标准库之string 库
Read All

LeetCode-52--N皇后-II(N-Queens-II)

2019-04-18

leacoder

Algorithm

Algorithm Leetcode

52. N皇后 II
Python3 实现
- DFS 深度优先
- 位运算 + DFS 深度优先

52. N皇后 II

N皇后 II n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

上图为 8 皇后问题的一种解法。

给定一个整数 n，返回 n 皇后不同的解决方案的数量。

示例:

输入: 4
输出: 2
解释: 4 皇后问题存在如下两个不同的解法。
[
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]

Python3 实现

DFS 深度优先

可参见 LeetCode 51. N皇后(N-Queens)

# @author:leacoder 
# @des:  DFS 深度优先  N皇后II

class Solution:
    def totalNQueens(self, n: int) -> int:
        if n < 1 : return []  #
        self.count = 0
        shu = [] # 竖方向是否被攻击
        pie = [] # 撇方向是否被攻击  x y 坐标之和固定 x + y
        na = []  # 捺方向是否被攻击  x y 坐标之差固定 x - y
        
        self.DFS(n,shu,pie,na)
        
        return self.count
    
    def DFS(self,n,shu,pie,na): #深度优先搜索 
        p = len(shu) #  从 1 -> n
        if p == n :
            self.count += 1 #每层有且只能放一个
            return 
        for q in range(n): # 看成 x  每层枚举可能的 x
            if q not in shu and p - q not in na and p + q not in pie: #这一层存在可能位置，向下层搜索
                self.DFS(n,shu+[q],pie+[p+q],na+[p-q])  #深度优先搜索  将被攻击的 坐标记录下来 

位运算 + DFS 深度优先

+ 以 8 Q为例
从第一行开始   由于棋盘第一行没有放任何皇后那么 row 行 cols 列 pie 撇 na 捺 位没有不可放置的 
也就是 下方代码 self.DFS(n,0,0,0,0)处
+ 入参：1 表示被攻击，0表示可放置  ，下一行cols pie na 方向上被攻击位置
cols:  0 0 0 0 0 0 0 0
pie:    0 0 0 0 0 0 0 0
na:     0 0 0 0 0 0 0 0
本行（第1行） 所有被攻击位置  col | pie | na 
0 0 0 0 0 0 0 0   （1 表示被攻击，0表示可放置）
取反处理后的到：
bits:   1 1 1 1 1 1 1 1      （ 0 表示被攻击位  1 表示可放置位）
选取图中 黄色 Q放置皇后（代码是从右往左一次探索，这里假设在黄色Q处用于说明）
p：0 0 0 1 0 0 0 0   （ 0 表示被攻击位  1 表示可放置位）
+ 向下一层深度搜索(第 2层)：
self.DFS(n , row + 1, cols | p, (pie | p) << 1, (na | p) >> 1)  # 递归处理下一层
那么cols pie na 与 p 处理后得到新的入参 （1 表示被攻击，0表示可放置）：下一行cols pie na 方向上被攻击位置
cols: 0 0 0 1 0 0 0 0
pie :  0 0 1 0 0 0 0 0
na : 0 0 0 0 1 0 0 0 
本行（第2行） 所有被攻击位置  col | pie | na 
0 0 1 1 1 0 0 0  （1 表示被攻击，0表示可放置）
图中（第2行） 黄色 1
取反处理后的到：
bits:   1 1 0 0 0 1 1 1       （ 0 表示被攻击位  1 表示可放置位）
选取图中 蓝色 Q放置皇后（代码是从右往左一次探索，这里假设在蓝色Q处用于说明）
p：0 0 0 0 0 0 1 0    （ 0 表示被攻击位  1 表示可放置位）
+ 向下一层深度搜索(第 3层)： 
self.DFS(n , row + 1, cols | p, (pie | p) << 1, (na | p) >> 1)  # 递归处理下一层
那么cols pie na 与 p 处理后得到新的入参 （1 表示被攻击，0表示可放置）：下一行cols pie na 方向上被攻击位置
cols: 0 0 0 1 0 0 1 0
pie :  0 1 0 0 0 1 0 0
na : 0 0 0 0 0 1 0 1  
本行（第三行） 所有被攻击位置  col | pie | na 
0 1 0 1 0 1 1 1  （1 表示被攻击，0表示可放置）
图中（第三行） 黄色 1 + 蓝色 1

# @author:leacoder 
# @des:  位运算 + DFS 深度优先  N皇后II
class Solution:
    def totalNQueens(self, n: int) -> int:
        if n < 1: return []
        self.count = 0
        self.DFS(n,0,0,0,0) #从第一行开始   由于棋盘第一行没有放任何皇后那么 row 行 cols 列 pie 撇 na 捺 位没有不可放置的
        return self.count
    
    def DFS(self, n, row, cols, pie, na):
        if row >= n: #递归终止条件  深度搜索 n 个皇后均已放在棋盘上
            self.count += 1
            return
        # col | pie | na  (1 表示被攻击, 或了以后 等到本行 所有被攻击位置 )
        # ~( col | pie | na )  0 表示被攻击位  1 表示可放置位
        # (( 1<<n ) - 1)   形成 n位全1的二进制 筛子  用于 筛选出 n 位内的有效数据
        bits = ( ~( cols | pie | na )) & (( 1<<n ) - 1)
        
        while bits:
            p = bits & (-bits)  # 取出最低位的1 也就是最低位可以放置 皇后Q的位置
            # row + 1 下移一层   cols | p : p 上放置 Q 后  cols 列方向被攻击位刷新
            # (pie | p) << 1 下一层 pie撇方向被攻击位置刷新
            # (na | p) >> 1 下一层 na 捺方向被攻击位置刷新
            self.DFS(n , row + 1, cols | p, (pie | p) << 1, (na | p) >> 1)  # 递归处理下一层
            bits = bits & (bits - 1) #去掉最低位的 1 （表示这种可能已被探寻）

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

Python标准库之string-库

2019-04-17

leacoder

python

字符串常量 String constants :
格式字符串语法示例 Format String Syntax examples
模板字符串 Template strings
- 模板字符串的规则
- class string.Template 类
  - substitute(mapping, **kwds)
  - safe_substitute(mapping, **kwds)

Python Standard Library based on Python 3.7.3 https://docs.python.org/3/library/

Python标准库 - 文本处理服务 - string库

Source code: Lib/string.py

Link: https://docs.python.org/3/library/string.html#module-string

字符串常量 String constants :

GitHub Code : String constants.py

string.ascii_letters 大小写字母常数

# ascii_letters     大小写字母常数
print(string.ascii_letters)	# abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

string.ascii_lowercase 小写字母常数

# ascii_lowercase  小写字母常数   
print(string.ascii_lowercase) # abcdefghijklmnopqrstuvwxyz

string.ascii_uppercase 大写字母常数

# ascii_uppercase   大写字母常数
print(string.ascii_uppercase)	# ABCDEFGHIJKLMNOPQRSTUVWXYZ

string.digits 十进制数字常数

# digits    十进制数字常数
print(string.digits)	# 0123456789

string.hexdigits 十六进制数字常数

# hexdigits     十六进制数字常数
print(string.hexdigits)	 # 0123456789abcdefABCDEF

string.octdigits 八进制数字常数

# octdigits     八进制数字常数
print(string.octdigits)	# 01234567

string.punctuation ASCII字符串，在C语言环境中被视为标点字符

# punctuation   ASCII字符串，在C语言环境中被视为标点字符
print(string.punctuation)	# !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

string.printable 能够被打印的ASCII字符串

# printable     能够被打印的ASCII字符串
print(string.printable)
# 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~  还要加上 字符空间，制表符，换行符，返回页面，换页符和垂直选项卡

string.whitespace 字符空间，制表符，换行符，返回页面，换页符和垂直选项卡

# whitespace    包含所有被视为空格的ASCII字符的字符串
print(string.whitespace) # 字符空间，制表符，换行符，返回页面，换页符和垂直选项卡

自定义字符串格式 Custom String Formatting

GitHub Code : Custom String Formatting.py

介绍自定义字符串格式 class string.Formatter中主要的3个函数

format(format_string, *args, **kwargs)、vformat(format_string, args, kwargs)、parse(format_string)

format(format_string, *args, **kwargs)

主要的API方法。它采用格式字符串和一组任意位置和关键字参数。它只是一个调用vformat（）的包装器。

'''
@Description: 主要的API方法。它采用格式字符串和一组任意位置和关键字参数。它只是一个调用vformat（）的包装器。
@Param: 
format_string: 需要去格式化的目标字符串
*args: 任意位置 元组
**kwargs: 关键字参数 字典
@Return: 
'''
# string.Formatter.format(format_string, *args, **kwargs)
data = ("Pi = ",3.1415926)
strtmp = "This is a test:{}{:.4f}"
formatter  = string.Formatter()
strtmp = formatter.format(strtmp,*data) # 元组
print(strtmp)  # This is a test:Pi = 3.1416

data = {"Key1":3.1415926,"Key2":"Pi = "}
strtmp = "This is a test:{Key2}{Key1}"
formatter  = string.Formatter()
strtmp = formatter.format(strtmp,**data)  # 字典
print(strtmp)  # This is a test:Pi = 3.1415926

# string.Formatter.format(format_string, *args, **kwargs) End

vformat(format_string, args, kwargs)

此函数执行格式化的实际工作

'''
@Description: 此函数执行格式化的实际工作
@Param: 
format_string: 需要去格式化的目标字符串
args: 任意位置 元组
kwargs: 关键字参数 字典
@Return: 
'''
# string.Formatter.vformat(format_string, args, kwargs)
# 注意 Formatter.vformat的参数不是 (*args, **kwargs) 而是 (args, kwargs)
data = ("Pi = ",3.1415926)
strtmp = "This is a test:{}{:.4f}"
formatter  = string.Formatter()
strtmp = formatter.vformat(strtmp,data,{}) # 元组
print(strtmp)  # This is a test:Pi = 3.1416

data = {"Key1":3.1415926,"Key2":"Pi = "}
strtmp = "This is a test:{Key2}{Key1}"
formatter  = string.Formatter()
strtmp = formatter.vformat(strtmp,(),data)  # 字典
print(strtmp)  # This is a test:Pi = 3.1415926
# string.Formatter.vformat(format_string, args, kwargs) End

parse(format_string)

循环遍历format_string并返回一个可迭代的元组（literal_text，field_name，format_spec，conversion）。

'''
@Description: 循环遍历format_string并返回一个可迭代的元组（literal_text，field_name，format_spec，conversion）。 vformat（）使用它将字符串分解为文字文本或替换字段。
@Param: 
format_string：需要去格式化的目标字符串
@Return: 
tuples  元组
'''
# string.Formatter.parse(format_string)
strtmp = "This is a test:{}{:.4f}"
formatter  = string.Formatter()
strtuple = formatter.parse(strtmp)

for i, v in enumerate(strtuple):
    print(i, v)
    '''
    0 ('This is a test:', '', '', None)
    1 ('', '', '.4f', None)
    '''
strtmp = "This is a test:{Key2}{Key1}"
formatter  = string.Formatter()
strtuple = formatter.parse(strtmp)

for i, v in enumerate(strtuple):
    print(i, v)
    '''
    0 ('This is a test:', 'Key2', '', None)
    1 ('', 'Key1', '', None)
    '''
# string.Formatter.parse(format_string) End

格式字符串语法示例 Format String Syntax examples

GitHub Code : Format String Syntax.py

包含str.format（）语法的示例以及与旧的％-formatting的比较。

在大多数情况下，语法类似于旧的％-formatting，添加了{}和with：而不是％。例如，’％03.2f’可以翻译为’{：03.2f}’。

Accessing arguments by position: 按位置访问参数：

tupdata = ("This","is","a","test") # 元组
formatstr = '{0} {1} {2} {3}'.format("This","is","a","test") 
print(formatstr)    # This is a test
formatstr = '{} {} {} {}'.format(*tupdata) # *data 解包参数序列
print(formatstr)    # This is a test
formatstr = '{3} {2} {1} {0}'.format(*tupdata) # *data 解包参数序列
print(formatstr)    # test a is This
formatstr = '{2} {3} {1} {2} {3}'.format(*tupdata)  # 参数可以重复
print(formatstr)    # a test is a test

Accessing arguments by name：按关键字访问参数：

dicdata = {'Author':'leacoder','Time':'2019/04/17'}
formatstr = 'The author is {Author}，The time is {Time}'.format(Author='leacoder',Time='2019/04/17')
print(formatstr)    # The author is leacoder，The time is 2019/04/17
formatstr = 'The author is {Author}，The time is {Time}'.format(**dicdata)
print(formatstr)    # The author is leacoder，The time is 2019/04/17

Accessing arguments’ attributes: 访问参数的属性：

class Point:
    def __init__(self,x,y):
        self.x ,self.y = x, y
point = Point(4,2)
formatstr = 'Thie point is ({key.x},{key.y})'.format(key = point) # key 可为其他 
print(formatstr)  # Thie point is (4,2)
formatstr = 'Thie point is ({point.x},{point.y})'.format(point = point) # point 可为其他 
print(formatstr)  # Thie point is (4,2)

Accessing arguments’ items: 访问参数的各项：

tupdata = ("leacoder","2019/04/17") # 元组
formatstr = 'The author is {0[0]},The time is {0[1]}'.format(tupdata)
print(formatstr)    # The author is leacoder,The time is 2019/04/17
formatstr = 'The author is {0[0]},The time is {0[1]}'.format(*tupdata)  # 注意区别
print(formatstr)    # The author is l,The time is e

Replacing %s and %r: 替换％s和％r：使用 !s !r

formatstr = "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
print(formatstr)    # repr() shows quotes: 'test1'; str() doesn't: test2

Aligning the text and specifying a width: 对齐文本并指定宽度：

formatstr = '{:<30}'.format('left aligned') # 左对齐 30位
print(formatstr)    # ‘left aligned                  ’  为了体现位数加了‘’
formatstr = '{:>30}'.format('right aligned')    # 右对齐 30位
print(formatstr)    # ‘                 right aligned’
formatstr = '{:^30}'.format('centered')  # 中间对齐 30位
print(formatstr)    # ‘           centered           ’
formatstr =  '{:*^30}'.format('centered')  # 使用* 作为填充字符
print(formatstr)    # ‘***********centered***********’

Replacing %+f, %-f, and % f and specifying a sign: 替换％+ f，％ - f和％f并指定符号:

formatstr = '{:+f}; {:+f}'.format(3.14, -3.14)  # 总是显示它符号
print(formatstr)    # ‘+3.140000; -3.140000’
formatstr = '{: f}; {: f}'.format(3.14, -3.14)  # 正数前显示空格
print(formatstr)    # ‘ 3.140000; -3.140000’
formatstr = '{:-f}; {:-f}'.format(3.14, -3.14)  # 只显示负号 同 '{:f}; {:f}'
print(formatstr)    # ‘3.140000; -3.140000’

Replacing %x and %o and converting the value to different bases: 替换％x和％o并将值转换为不同的进制：

formatstr = "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(64)
print(formatstr)  # int: 64;  hex: 40;  oct: 100;  bin: 1000000
formatstr = "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(64)
print(formatstr)  # int: 64;  hex: 0x40;  oct: 0o100;  bin: 0b1000000
formatstr = "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(0b1000001) # 也支持其他进制
print(formatstr)  # int: 65;  hex: 0x41;  oct: 0o101;  bin: 0b1000001

Using the comma as a thousands separator: 使用逗号作为千位分隔符：

formatstr = '{:,}'.format(1234567890)
print(formatstr)    # 1,234,567,890

Expressing a percentage: 表达百分比：

points = 1
total = 3
formatstr = 'points / total = {:.2%}'.format(points/total)
print(formatstr)    # points / total = 33.33%

Using type-specific formatting: 使用特定类型的格式：

import datetime
d = datetime.datetime(2019, 4, 17, 22, 49, 2) # 2019/04/17 22:49:02
formatstr = '{:%Y-%m-%d %H:%M:%S}'.format(d)
print(formatstr)    # 2019-04-17 22:49:02

模板字符串 Template strings

GitHub Code : Template strings.py

模板字符串的规则

'''
模板字符串提供更简单的字符串替换，如PEP 292中所述 https://www.python.org/dev/peps/pep-0292/
模板字符串支持基于$的替换，使用以下规则：
    1、$$是转义; 它被替换为单个$。
    2、$identifier 一个替换占位符，用于匹配映射关键字“identifier”默认情况下，
    “标识符”仅限于以下划线或ASCII字母开头的任何不区分大小写的ASCII字母数字字符串（包括下划线）。$字符后面的第一个非标识符字符结束此占位符。
    3、$ {identifier}相当于$ identifier。当有效标识符字符跟随占位符但不是占位符的一部分时，例如“$ {noun} ification”，则需要它。
    4、字符串中$的任何其他形式都将导致引发ValueError。
字符串模块提供实现这些规则的Template类。class string.Template(template)
'''

class string.Template 类

substitute(mapping, **kwds)

'''
@Description: 执行模板替换，返回一个新字符串。
@Param: 
mapping：任何类似字典的对象，其键与模板中的占位符匹配。
**kewds: 关键字参数，其中关键字是占位符。
当给出mapping和kwds并且存在重复时，来自kwds的占位符优先。
@Return: 返回一个新字符串
'''
# substitute(mapping, **kwds)
s = Template('The Author is $Author, The Time is $Time')    # 使用Template类构造函数
kewds = {'Author':'leacoder', 'Time':'2019/04/18 00:01:38'}
templatestr = s.substitute(Author='leacoder', Time='2019/04/18 00:01:38')  # **kewds
print(templatestr)  # The Author is leacoder, The Time is 2019/04/18 00:01:38
templatestr = s.substitute(**kewds)  # **kewds
print(templatestr)  # The Author is leacoder, The Time is 2019/04/18 00:01:38
templatestr = s.substitute(kewds)  # mapping
print(templatestr)  # The Author is leacoder, The Time is 2019/04/18 00:01:38
templatestr = s.substitute(kewds,Author='250',Time = 'No Time')  # mapping  **kewds
print(templatestr)  # The Author is 250, The Time is No Time

kewds1 = {'Author':'leacoder'}
templatestr = s.substitute(kewds1)
print(templatestr)  # KeyError: 'Time'
# substitute(mapping, **kwds) End

safe_substitute(mapping, **kwds)

'''
@Description:  
与substitute（）一样，如果map和kwds中缺少占位符，原始占位符将在结果字符串中完整显示，而不是引发KeyError异常
此外，与substitute（）不同，$的任何其他形式只会返回$而不是引发ValueError。
@Param: 
同 substitute（）
@Return: 
'''
# safe_substitute(mapping, **kwds)
kewds1 = {'Author':'leacoder'}
templatestr = s.safe_substitute(kewds1)
print(templatestr)  # The Author is leacoder, The Time is $Time
# safe_substitute(mapping, **kwds) End

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

4/12

Welcome to LeaCoder's Blog!

Python3 实现

动态规划

Python3 实现

动态规划 计算所有 f(n)

动态规划 优化

abs(x)

all(iterable)

any(iterable)

ascii(object)

bin(x)

class bool([x])

breakpoint(*args, **kws)

class bytearray([source[, encoding[, errors]]])

class bytes([source[, encoding[, errors]]])

callable(object)

chr(i)

@classmethod

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

class complex([real[, imag]])

delattr(object, name)

dict()

dir([object])

divmod(a, b)

enumerate(iterable, start=0)

eval(expression, globals=None, locals=None)

exec(object[, globals[, locals]])

class float([x])

format(value[, format_spec])

class frozenset([iterable])

getattr(object, name[, default])

globals()

hasattr(object, name)

hash(object)

help([object])

hex(x)

id(object)

input([prompt])

class int(x, base=10)

isinstance(object, classinfo)

issubclass(class, classinfo)

iter(object[, sentinel])

len(s)

class list([iterable])

locals()

map(function, iterable, …)

max()

memoryview(obj)

min()

next(iterator[, default])

class object

oct(x)

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

ord(c)

pow(x, y[, z])

Python3内置函数

Python3内置异常

文本处理服务 Text Processing Services

Python3 实现

DFS 深度优先

位运算 + DFS 深度优先

字符串常量 String constants :

string.ascii_letters 大小写字母常数

string.ascii_lowercase 小写字母常数

string.ascii_uppercase 大写字母常数

string.digits 十进制数字常数

string.hexdigits 十六进制数字常数

string.octdigits 八进制数字常数

string.punctuation ASCII字符串，在C语言环境中被视为标点字符

string.printable 能够被打印的ASCII字符串

string.whitespace 字符空间，制表符，换行符，返回页面，换页符和垂直选项卡

自定义字符串格式 Custom String Formatting

format(format_string, *args, **kwargs)

vformat(format_string, args, kwargs)

parse(format_string)

格式字符串语法示例 Format String Syntax examples

Accessing arguments by position: 按位置访问参数：

Accessing arguments by name：按关键字访问参数：

Accessing arguments’ attributes: 访问参数的属性：

Accessing arguments’ items: 访问参数的各项：

动态规划计算所有 f(n)

动态规划优化

Replacing %s and %r: 替换％s和％r：使用 !s !r