Python的一些小知识点

pycharm  python2的环境下，print输出单个和多个的区别

print '你好'
>> 你好

# 直接打印list,那么list里边的unicode编码的元素就会输出unicode,其实你只需要遍历一遍list,单个元素输出,就会打印中文了

print(['你好','世界'])
>> ('\xe4\xbd\xa0\xe5\xa5\xbd', '\xe4\xb8\x96\xe7\x95\x8c')

dir(object)        可以查看对象拥有的属性和方法

>>> str = 'qwer'
>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> 

hasattr() getattr() setattr() 函数

hasattr(object, 'name')        判断一个对象里面是否有name属性或者name方法

1 >>> class test():
 2 ...     name="best_fish"
 3 ...     def lol(self):
 4 ...             print("pentakill")
 5 ...
 6 >>> t=test()
 7 >>> hasattr(t, "name") #判断对象有name属性
 8 True
 9 >>> hasattr(t, "lol")  #判断对象有lol方法
10 True


"""通过getattr来调用实例的方法"""
...     func = getattr(t, 'lol')
...     func()
>>>     pentakill

兼容python2，python3的导包方法

# 来个2、3兼容的导队列的方法：
try:
    from Queue import Queue  # 2
except:
    from queue import Queue  # 3  还可以命别名  as q

异步处理的map_async 和 apply_async的区别

...
pool = Pool(5)
# map_async(目标函数, 参数, 回调函数)  参数是可迭代的，因此处理结果传给回调函数也是一个迭代对象
poo1.map_async(self.send_request, self.url_list, callback=self.parse_page)


# apply_async(目标函数, 参数, 回调函数)  参数是不可迭代的
pool.apply_async(self.send_request, args=(sel.url,), callback=self.parse_page)

pool.close()
pool.join()

列表推导式解决两个循环

    def main(self):
        # job_list = []
        # for url in self.url_list:
        #     job = gevent.spawn(self.send_request,url)
        #     job_list.append(job)
        # g_list = gevent.joinall(job_list)
        # for ge in g_list:
        #     response = ge.get()
        #     self.parse_page(response)

        [self.parse_page(ge.get()) for ge in gevent.joinall([gevent.spawn(self.send_request, url) for url in self.url_list])]

小数字缓冲池

python中，所有的对象都存在于系统堆上。 
如果某个小整数出现的次数非常多，那么python将会出现大量的malloc/free操作，这样大大降低了运行效率，而且会造成大量的内存碎片，严重影响Python的整体性能。 
所以在python2.5乃至3.6中，将小整数位于[-5,257)之间的数，缓存在小整型对象池中。

python2中解决ascii编码问题， 在要操作的文件上方加入如下代码

    import sys
    reload(sys)
    sys.setdefaultencoding("utf-8")

断言处理：大多数情况下，我们要进行验证的假设，只是属于偶然性事件，又或者我们仅仅想测试一下，一些最坏情况是否发生，所以这里有了assert().其表达的意思就是，程序在我的假设条件下，能够正常良好的运作，其实就相当于一个if语句：

if(假设成立)
{
     程序正常运行；
}
else
{
      报错&&终止程序！（避免由程序运行引起更大的错误）  
}

xrange（py2） 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器

工厂模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类的实例化推迟到子类

递归求1到100的和

def sum(n):
    if 0 <= n <= 100:
        return n + sum(n-1)
    else:
        return 0

print(sum(100))

RSA加密算法（非对称加密，公玥，私钥）

In [1]: import rsa

In [2]: (public_key, private_key) = rsa.newkeys(512)

In [3]: message = "hello world".encode('utf-8')

In [4]: sha = rsa.encrypt(message, public_key)

In [5]: sha
Out[5]: '|\xd4\xfa\xf3\xa4\xdb\x14l`\xc1\xcd8\xac\xb5\x8b\xdf\xbdN^\x8c\x9a\xbd(\xda\x1cf\x8bP\xee\x807\xc3\xc2\xdcK\xb8\xdf\x0b\x04\xc4\xb9\xb1\xbfmf\xd9Si\x86\xd03\xc8\xcf\x12\x06\xe5\xf6f\xf10n-\x13\x92'

In [6]: sha_code = rsa.decrypt(sha, private_key)

In [7]: sha_code
Out[7]: 'hello world'

In [8]: 

python实现单例模式的几种方法

"""1.重写object类的__new__方法"""
class Foo(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Foo, cls).__new__(cls, *args, **kw)  
        return cls._instance  

"""2.使用模块:
Python 的模块就是天然的单例模式，因为模块在第一次导入时，
会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。
因此，我们只需把相关的函数和数据定义在一个模块中，
就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做："""

# 先写一个模块single.py，创建一个类并实例化一个对象
class Single:
    def __init__(self):
        self.name = "danli"

    def describ(self):
        print "im danli"
        
foo = Foo()

# 再在另一个模块导入此模块的实例即可
from single import foo

foo.describe()


"""3.使用装饰器
可以使用装饰器来装饰某个类，使其只能生成一个实例"""
from functools import wraps
 
def singleton(cls):
    instances = {}
    @wraps(cls)
    def getinstance(*args, **kw):
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return getinstance
 
@singleton
class MyClass(object):
    a = 1




"""4.使用元类"""
class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]
 
# Python2
class MyClass(object):
    __metaclass__ = Singleton
 
# Python3
class MyClass(metaclass=Singleton):
    pass

python特殊函数__call__()

所有函数都是可调用的对象， 一个类的实例也可以变成一个可调用的对象， 只要实现一个特殊的方法__call__()

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __call__(self):
        print("hua is beautiful")

pe = Person("best_fish", 27)
pe()

>>> 'hua is beautiful'

subprocess通过子进程来执行外部指令，并通过input/output/error管道，获取子进程的执行的返回信息。

import subprocess

# 通过call方法调用外部(系统)命令
subprocess.call(["tesseract", "-l", "chi_sim", filePath, "paixu"])

几种排序

"""冒泡排序"""
def bubble(a_list):
    for j in range(len(a_list), 0, -1):
        for i in range(1, j):
            if a_list[i - 1] > a_list[i]:
                a_list[i - 1], a_list[i] = a_list[i], a_list[i - 1]
    return a_list

if __name__ == '__main__':
    a_list = [2, 4, 1, 7, 5]  # len:5
    print(bubble(a_list))


"""选择排序"""
def select(a_list):
    n = len(a_list)
    for j in range(n - 1):  # 0 1 2
        min_index = j
        for i in range(1 + j, n):
            if a_list[i] < a_list[min_index]:
                a_list[min_index], a_list[i], =a_list[i], a_list[min_index]
    return a_list

if __name__ == '__main__':
    a_list = [3, 8, 1, 4]
    print(select(a_list))

map(func, Itera)和reduce(func, Itera), 前者是func作用于每个元素，返回的仍是迭代对象， 后者func参数必须是两个元素，返回一个不可迭代对象

>>> def add(x,y): #定义一个相加函数
        return x+y

>>> reduce(add,[1,2,3,4,6])
16


>>> def foo(x, y):
        return 10*x + y  # 相当于组合成xy

>>> reduce(add,[1,2,3,4,6])
123456