In [58]: p.parts Out[58]: ('/', 'Users', 'aaron', 'tmp', 'c.py')
In [59]: p.parent Out[59]: PosixPath('/Users/aaron/tmp')
In [60]: p.resolve() Out[60]: PosixPath('/Users/aaron/tmp/c.py')
In [61]: p.exists() Out[61]: True
In [62]: p.is_dir() Out[62]: False
In [63]: p.is_file() Out[63]: True
In [64]: p.owner() Out[64]: 'aaron'
In [65]: p.group() Out[65]: 'staff'
In [66]: p.name Out[66]: 'c.py'
In [67]: p.suffix Out[67]: '.py'
In [68]: p.suffixes Out[68]: ['.py']
In [69]: p.stem Out[69]: 'c'
路径的连接 join
相比 os.path.join，使用一个 / 是不是更为直观和便捷？
>>> p = PurePosixPath('foo') >>> p / 'bar' PurePosixPath('foo/bar') >>> p / PurePosixPath('bar') PurePosixPath('foo/bar') >>> 'bar' / p PurePosixPath('bar/foo')
from functools import reduce
data = [{"a": 1}, {"a": 1}, {"a": 3}, {"b": 4}]
result = []
def unduplicate(result, data):
if data not in result:
result = result + [data]
return result
for i in data:
result = unduplicate(result, i)
>>> result
>>> [{'a': 1}, {'a': 3}, {'b': 4}]
稍显复杂，如果使用reduce函数和lambda函数，代码能简化很多：
def delete_duplicate(data):
func = lambda x, y: x + [y] if y not in x else x
data = reduce(func, [[], ] + data)
return data
>>> delete_duplicate(data)
>>> [{'a': 1}, {'a': 3}, {'b': 4}]
当然， 我也能一行写完这个功能：
data = reduce(lambda x, y: x + [y] if y not in x else x, [[], ] + data)
只不过有可能会被打死在工位上，所以不建议这么干。
2.奇怪的技巧
就如文章开头提到的，字典之所以不能用set去重，是因为它是可变对象。
但是…如果我们把它变成不可变对象呢？
data = [{"a": 1}, {"a": 1}, {"a": 3}, {"b": 4}]
def delete_duplicate(data):
immutable_dict = set([str(item) for item in data])
data = [eval(i) for i in immutable_dict]
return data
>>> delete_duplicate(data)
>>> [{'a': 1}, {'a': 3}, {'b': 4}]
没错，这能成。
1.遍历字典，将每个子项变成字符串存放到数组中，再通过set函数去重。
2.通过eval函数，将去重后的数组里的每个子项重新转化回字典。
如此Python，怎能不好玩？
3.高效的方式
上面讲了两种骚操作，其实都不太建议在实际工作中使用。
一个原因是真的太骚了，怕被打趴在工位上。
另一个原因是，它们在应对较大数据量的时候，性能不太行。
下面是最正统的方式：
data = [dict(t) for t in set([tuple(d.items()) for d in data])]
>>>data
>>>[{'a': 1}, {'b': 2}]
data2 = [{"a": {"b": "c"}}, {"a": {"b": "c"}}]
def delete_duplicate_str(data):
immutable_dict = set([str(item) for item in data])
data = [eval(i) for i in immutable_dict]
return data
print(delete_duplicate_str(data2))
>>> [{'a': {'b': 'c'}}]
>>> class ObjectCreator(object):
... pass
...
>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>
但是，在Python中，类不仅能用来描述如何生成一个对象，类本身也是对象。
在你使用关键词 class 的时候，Python就会执行它，并创建一个对象。
>>> class ObjectCreator(object):
... pass
...
上述指令在内存中创建了一个“ObjectiveCreator”的对象。
这个对象（类）本身具有创建对象（实例）的能力，因此它也是一个类。你可以对它做以下操作：
1.将其分配给变量 2.复制它 3.为其添加属性 4.将其作为函数参数传递
例如：
>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
... print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>
2.动态创建类
由于类是对象，因此你可以像创建任何对象（数组、字典等）一样，随时随地创建类。
你甚至可以在函数里创建类：
>>> def choose_class(name):
... if name == 'foo':
... class Foo(object):
... pass
... return Foo # return the class, not an instance
... else:
... class Bar(object):
... pass
... return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>
>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>
如果你想给它赋予属性，可以这样玩：
>>> class Foo(object):
... bar = True
等同于
>>> Foo = type('Foo', (), {'bar':True})
用来继承也是可以的：
>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True
