标签:完全 测试结果 适合 meta birt 文本文件 重写 logic start
>>>help(__builtins__)
位运算 (同位比较)
& 按位与 1011 & 1110 1010 一 0 则 0
| 按位或 1011 | 1110 1111 一 1 则 1
^ 按位异或 1011 ^ 1110 0101 相同为0 不同为1
<< 左异 1011 << 2 101100 移几位就乘几个2
>> 右异 1011 >> 2 10 去掉低位
重定向
1. HTML 重定向/Meta 刷新
将下面 HTML 重定向代码放在网页的 <head> 节点内:
<meta HTTP-EQUIV="REFRESH" content="0; url=http://www.yourdomain.com">
上述代码立即将访客重定向到另外一个页面,你可以修改 content 中 的 0 这个值来表示几秒钟后才进行重定向。
例如 content="3; url=http://www.oschina.net/" 表示三秒后再重定向。
2Javascript URL Redirect
<head>
<script type="text/javascript">
window.location.href=‘http://www.newdomain.com/‘;
</script>
</head>
在 Django中可以 location.href="{% url ‘url name‘ %}"
设置与获取
·设置Cookie
response =HttpResponse(‘ok‘)
response.set_cookie(‘hello‘, ‘django‘, expires=60 * 60 * 24 * 7)
return response
·获取Cookie
hello=request.COOKIES.get(‘hello‘)
return HttpResponse(hello)
·删除Cookie
response = HttpResponse(‘ok‘)
response.delete_cookie(‘hello‘)
return response
Cookie常用参数
·key:键
·value:值
·max_age:该Cookie失效的时间,单位秒。如果为正数,则该Cookie在maxAge秒之后失效。
如果为负数,该Cookie为临时Cookie,关闭浏览器即失效,浏览器也不会以任何形式保存
该Cookie。如果为0,表示删除该Cookie。默认为–1
·expires:过期时间,为具体时间
·path:该Cookie的使用路径。如果设置为“/sessionWeb/”,则只有contextPath为
“/sessionWeb”的程序可以访问该Cookie。如果设置为“/”,则本域名下
contextPath都可以访问该Cookie。注意最后一个字符必须为“/”
·domain:可以访问该Cookie的域名。如果设置为“.google.com”,则所有以“google.com”
结尾的域名都可以访问该Cookie。注意第一个字符必须为“.”
·secure:HTTPS传输时应设置为true
·httponly:值应用于http传输,JavaScript无法获取
obj.read():从文件中读取整个上传的数据,这个方法只适合小文件;
obj.chunks():按块返回文件,通过在for循环中进行迭代,可以将大文件按块写入到服务器中;
obj.multiple_chunks():这个方法根据myFile的大小,返回True或者False,当myFile文件大于2.5M(默认为2.5M,可以调整)时,该方法返回True,否则返回False,因此可以根据该方法来选择选用read方法读取还是采用chunks方法
obj.name:这是一个属性,不是方法,该属性得到上传的文件名,包括后缀,如123.exe;
obj.size:这也是一个属性,该属性得到上传文件的大小
class MyModel(models.Model):
name = models.CharField(max_length=150,null=True)
video = models.ImageField(upload_to=‘images‘,max_length=255)
def save_file(request):
mymodel = MyModel.objects.get(id=1)
# 读取上传的文件中的video项为二进制文件
file_content = ContentFile(request.FILES[‘video‘].read())
# ImageField的save方法,第一个参数是保存的文件名,第二个参数是ContentFile对象,里面的内容是要上传的图片、视频的二进制内容
mymodel.video.save(request.FILES[‘video‘].name, file_content)
图片的加载
<script language="JavaScript">
function setImageData(imageBase64) {
var myImg = document.getElementById("myImg");
myImg.src = "data:image/jpeg;base64," + imageBase64;
}
</script>
</head>
<body>
<img id="myImg" src="data:image/jpeg;base64,MyImageDataEncodedInBase64=" alt="My Image data in base 64" />
</body>
<html>
jquere 的oninput方法
$(‘input‘).bind(‘input propertychange‘,(function(){})
遇到有些编码不规范的文件,你可能会遇到UnicodeDecodeError,
因为在文本文件中可能夹杂了一些非法编码的字符。遇到这种情况,
open()函数还接收一个errors参数,表示如果遇到编码错误后如何处理。
最简单的方式是直接忽略:
>>> f = open(‘/Users/michael/gbk.txt‘, ‘r‘, encoding=‘gbk‘, errors=‘ignore‘)
类的 __base__属性
作用: 用来绑定此类的第一个基类类对象
__bases__属性
作用: 用来绑定此类的所有基类类对象,为元组
__new__() 方法的特性:
__new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
__new__() 方法是在类准备将自身实例化时调用。
__new__() 方法始终都是类的类方法,即使没有被加上类方法装饰器。
一个类可以有多个位置参数和多个命名参数,而在实例化开始之后,在调用 __init__() 方法之前,Python 首先调用 __new__() 方法:
如果当前类是直接继承自 object,那当前类的 __new__() 方法返回的对象应该为:
return object.__new__(cls)
事实上如果(新式)类中没有重写__new__()方法,即在定义新式类时没有重新定义__new__()时,
Python默认是调用该类的直接父类的__new__()方法来构造该类的实例,如果该类的父类也没有重写__new__(),
那么将一直按此规矩追溯至object的__new__()方法,因为object是所有新式类的基类。
而如果新式类中重写了__new__()方法,那么你可以自由选择任意一个的其他的新式类(必定要是新式类,
只有新式类必定都有__new__(),因为所有新式类都是object的后代,而经典类则没有__new__()方法)
的__new__()方法来制造实例,包括这个新式类的所有前代类和后代类,只要它们不会造成递归死循环。
通常来说,新式类开始实例化时,__new__()方法会返回cls(cls指代当前类)的实例,
然后该类的__init__()方法作为构造方法会接收这个实例(即self)作为自己的第一个参数,
然后依次传入__new__()方法中接收的位置参数和命名参数。
注意:如果__new__()没有返回cls(即当前类)的实例,那么当前类的__init__()方法是不会被调用的。
如果__new__()返回其他类(新式类或经典类均可)的实例,那么只会调用被返回的那个类的构造方法。
class Myclass(object):
def __init__(self, x):
self.x = x
c1 = Myclass(11)
c2 = Myclass.__new__(Myclass, 12)
if isinstance(c2, Myclass):
type(c2).__init__(c2, 12)
print c1.x, c2.x
通过构造函数创建实例,会调依次用__new__()方法和__init__()方法来实例化和初始化,
所以当__init__()方法中绑定了实例属性 x 时,通过构造函数传入的参数就被绑定到了该属性上。所以 c1 有属性 x 。
当在类体外调用__new__()方法,只是创建了一个实例,并没有传递到__init__()进行初始化,
所以 ‘c2.x‘ 就会出现属性不存在的错误。但只要显式调用 __init__()方法,就能创建 x 属性了。
类同样也是一种对象。是的,没错,就是对象。只要你使用关键字class,Python解释器在执行的时候就会创建一个对象。
>>> class ObjectCreator(object):
… pass
…
将在内存中创建一个对象,名字就是ObjectCreator。这个对象(类)自身拥有创建对象(类实例)的能力,
而这就是为什么它是一个类的原因。但是,它的本质仍然是一个对象,于是乎你可以对它做如下的操作:
1) 你可以将它赋值给一个变量
2) 你可以拷贝它
3) 你可以为它增加属性
4) 你可以将它作为函数参数进行传递
id(obj, /) 这里的 / 不代表任何参数,它指示前面的都是位置参数,没有关键词参数
next(...)
next(iterator[, default])
Return the next item from the iterator. If default is given and the iterator
is exhausted, it is returned instead of raising StopIteration.
iter(collection) -> iterator
iter(callable, sentinel) -> iterator
iter()函数有两种用法,一种是传一个参数,一种是传两个参数。结果都是返回一个iterator对象。
所谓的iterator对象,就是有个next()方法的对象。next方法的惯例或约定(convention)是,
每执行一次就返回下一个值(因此它要自己记录状态,通常是在iterator对象上记录),
直到没有值的时候raiseStopIteration。
传1个参数:参数collection应是一个容器,支持迭代协议(即定义有__iter__()函数),
或者支持序列访问协议(即定义有__getitem__()函数),否则会返回TypeError异常。
传2个参数:当第二个参数sentinel出现时,参数callable应是一个可调用对象(实例),
即定义了__call__()方法,当枚举到的值等于哨兵时,就会抛出异常StopIteration。
iter(callable, sentinel) -> iterator
如果是传递两个参数给 iter() , 第一个参数必须是callable ,它会重复地调用第一个参数,
直到迭代器的下个值等于sentinel:即在之后的迭代之中,迭代出来sentinel就立马停止。
关于Python中,啥是可调用的,可以参考:python callable()函数
>>> class IT(object):
def __init__(self):
self.l=[1,2,3,4,5]
self.i=iter(self.l)
def __call__(self): #定义了__call__方法的类的实例是可调用的
item=next(self.i)
print "__call__ is called,which would return",item
return item
def __iter__(self): #支持迭代协议(即定义有__iter__()函数)
print "__iter__ is called!!"
return iter(self.l)
>>> it=IT() #it是可调用的
>>> it1=iter(it,3) #it必须是callable的,否则无法返回callable_iterator
>>> callable(it)
True
>>> it1
<callable-iterator object at 0x0306DD90>
>>> for i in it1:
print i
__call__ is called,which would return 1
1
__call__ is called,which would return 2
2
__call__ is called,which would return 3
可以看到传入两个参数得到的it1的类型是一个callable_iterator,它每次在调用的时候,都会调用__call__函数,并且最后输出3就停止了。
!
查看父类
In [1]: class a(list):
...: pass
...:
In [2]: a.__bases__
Out[2]: (list,)
In [3]: a.mro()
Out[3]: [__main__.a, list, object]
动态给类绑定一个属性
class Student(object):
pass
Student.name=‘aaa‘
print(Student.name)
aaa
然后,尝试给实例绑定一个属性:
>>> s = Student()
>>> s.name = ‘Michael‘ # 动态给实例绑定一个属性
>>> print(s.name)
Michael
给实例绑定一个方法:
>>> def set_age(self, age): # 定义一个函数作为实例方法
... self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法
>>> s.age # 测试结果
25
给一个实例绑定的方法,对另一个实例是不起作用的:
>>> s2 = Student() # 创建新的实例
>>> s2.set_age(25) # 尝试调用方法
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘Student‘ object has no attribute ‘set_age‘
为了给所有实例都绑定方法,可以给class绑定方法:
>>> def set_score(self, score):
... self.score = score
...
>>> Student.set_score = set_score
给class绑定方法后,所有实例均可调用
使用__slots__ 来限制该class实例能添加的属性
class Student(object):
__slots__ = (‘name‘, ‘age‘) # 用tuple定义允许绑定的属性名称
使用__slots__要注意,__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的
除非在子类中也定义__slots__,这样,子类实例允许定义的属性就是自身的__slots__加上父类的__slots__
使用__slots__后,类属性里就没有默认的__dict__了
__slots__只能限制实例的属性及方法,对于类则没有影响
将方法绑定给类后,类调用方法后,类和实例都可以访问类中的属性与方法,这不受slots范围限制
#方法没有绑定给类而直接绑定给实例时,需要在slots规定范围中加入该方法和方法中的属性
1、当子类定义中没有slots时,父类的slots对子类不起作用。子类实例想加什么属性就加什么属性
2、当子类定义中有slots时,父类的slots会对子类起作用。子类会继承父类的slot,
那么子类实例能加的属性就是父类slots和子类本身slots规定的属性了。
使用@property
@property广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查,
这样,程序运行时就减少了出错的可能性。
神奇的@property,我们在对实例属性操作的时候,就知道该属性很可能不是直接暴露的,而是通过getter和setter方法来实现的。
如果使用@property进行自动生成getter and setter,属性前一定要加入一个 "_" 不然报RecursionError
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError(‘score must be an integer!‘)
if value < 0 or value > 100:
raise ValueError(‘score must between 0 ~ 100!‘)
self._score = value
>>> s = Student()
>>> s.score = 60 # OK,实际转化为s.set_score(60)
>>> s.score # OK,实际转化为s.get_score()
60
还可以定义只读属性,只定义getter方法,不定义setter方法就是一个只读属性
class Student(object):
@property
def birth(self):
return self._birth
@birth.setter
def birth(self, value):
self._birth = value
@property
def age(self):
return 2015 - self._birth
不能只设置setter,要先设置读:@property
python 多重继承之拓扑排序
https://kevinguo.me/2018/01/19/python-topological-sorting/
什么是拓扑排序:
从DAG途中选择一个没有前驱(即入度为0)的顶点并输出
从图中删除该顶点和所有以它为起点的有向边。
重复1和2直到当前DAG图为空或当前途中不存在无前驱的顶点为止。后一种情况说明有向图中必然存在环。
python多重继承:
把继承关系先构成一张图
利用拓扑排序的方法输出拓扑顺序,并列关系时遵循取最左原则
python继承顺序遵循C3算法,只要在一个地方找到了所需的内容,就不再继续查找
print(D.__mro__)
__getitem__
要使类实例表现得像list那样按照下标取出元素,需要实现__getitem__()方法:
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
>>> f = Fib()
>>> f[0]
1
>>> f[1]
1
>>> f[2]
2
但是list有个神奇的切片方法:
>>> list(range(100))[5:10]
[5, 6, 7, 8, 9]
对于Fib却报错。原因是__getitem__()传入的参数可能是一个int,也可能是一个切片对象slice,所以要做判断:
没有对step参数作处理,也没有对负数作处理:
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int): # n是索引
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice): # n是切片
start = n.start
stop = n.stop
if start is None:
start = 0
a, b = 1, 1
L = []
for x in range(stop):
if x >= start:
L.append(a)
a, b = b, a + b
return L
现在试试Fib的切片:
>>> f = Fib()
>>> f[0:5]
[1, 1, 2, 3, 5]
>>> f[:10]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
对象看成dict,__getitem__()的参数也可能是一个可以作key的object,例如str。
与之对应的是__setitem__()方法,把对象视作list或dict来对集合赋值。最后,还有一个__delitem__()方法,用于删除某个元素。
总之,通过上面的方法,我们自己定义的类表现得和Python自带的list、tuple、dict没什么区别,
这完全归功于动态语言的“鸭子类型”,不需要强制继承某个接口。
__getattr__
正常情况下,当我们调用类的方法或属性时,如果不存在,就会报错。比如定义Student类:
class Student(object):
def __init__(self):
self.name = ‘Michael‘
调用name属性,没问题,但是,调用不存在的score属性,就有问题了:
>>> s = Student()
>>> print(s.name)
Michael
>>> print(s.score)
Traceback (most recent call last):
...
AttributeError: ‘Student‘ object has no attribute ‘score‘
错误信息很清楚地告诉我们,没有找到score这个attribute。
要避免这个错误,除了可以加上一个score属性外,Python还有另一个机制,那就是写一个__getattr__()方法,动态返回一个属性。修改如下:
class Student(object):
def __init__(self):
self.name = ‘Michael‘
def __getattr__(self, attr):
if attr==‘score‘:
return 99
当调用不存在的属性时,比如score,Python解释器会试图调用__getattr__(self, ‘score‘)来尝试获得属性,这样,我们就有机会返回score的值:
>>> s = Student()
>>> s.name
‘Michael‘
>>> s.score
99
返回函数也是完全可以的:
class Student(object):
def __getattr__(self, attr):
if attr==‘age‘:
return lambda: 25
只是调用方式要变为:
>>> s.age()
25
注意,只有在没有找到属性的情况下,才调用__getattr__,已有的属性,比如name,不会在__getattr__中查找。
此外,注意到任意调用如s.abc都会返回None,这是因为我们定义的__getattr__默认返回就是None。要让class只响应特定的几个属性,我们就要按照约定,抛出AttributeError的错误:
class Student(object):
def __getattr__(self, attr):
if attr==‘age‘:
return lambda: 25
raise AttributeError(‘\‘Student\‘ object has no attribute \‘%s\‘‘ % attr)
这实际上可以把一个类的所有属性和方法调用全部动态化处理了,不需要任何特殊手段。
这种完全动态调用的特性有什么实际作用呢?作用就是,可以针对完全动态的情况作调用。
举个例子:
现在很多网站都搞REST API,比如新浪微博、豆瓣啥的,调用API的URL类似:
http://api.server/user/friends
http://api.server/user/timeline/list
如果要写SDK,给每个URL对应的API都写一个方法,那得累死,而且,API一旦改动,SDK也要改。
利用完全动态的__getattr__,我们可以写出一个链式调用:
class Chain(object):
def __init__(self, path=‘‘):
self._path = path
def __getattr__(self, path):
return Chain(‘%s/%s‘ % (self._path, path))
def __str__(self):
return self._path
__repr__ = __str__
试试:
>>> Chain().status.user.timeline.list
‘/status/user/timeline/list‘
这样,无论API怎么变,SDK都可以根据URL实现完全动态的调用,而且,不随API的增加而改变!
还有些REST API会把参数放到URL中,比如GitHub的API:
GET /users/:user/repos
调用时,需要把:user替换为实际用户名。如果我们能写出这样的链式调用:
Chain().users(‘michael‘).repos
就可以非常方便地调用API了。有兴趣的童鞋可以试试写出来。
__call__
一个对象实例可以有自己的属性和方法,当我们调用实例方法时,我们用instance.method()来调用。能不能直接在实例本身上调用呢?在Python中,答案是肯定的。
任何类,只需要定义一个__call__()方法,就可以直接对实例进行调用。请看示例:
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print(‘My name is %s.‘ % self.name)
调用方式如下:
>>> s = Student(‘Michael‘)
>>> s() # self参数不要传入
My name is Michael.
__call__()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样,所以你完全可以把对象看成函数,把函数看成对象,因为这两者之间本来就没啥根本的区别。
如果你把对象看成函数,那么函数本身其实也可以在运行期动态创建出来,因为类的实例都是运行期创建出来的,这么一来,我们就模糊了对象和函数的界限。
那么,怎么判断一个变量是对象还是函数呢?其实,更多的时候,我们需要判断一个对象是否能被调用,能被调用的对象就是一个Callable对象,比如函数和我们上面定义的带有__call__()的类实例:
>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable(‘str‘)
False
通过callable()函数,我们就可以判断一个对象是否是“可调用”对象。
标签:完全 测试结果 适合 meta birt 文本文件 重写 logic start
原文地址:https://www.cnblogs.com/yanhuazidi/p/10337322.html