python's Issues
python list 操作
1.list 的字典按某字段直排序
data = sorted(data, key=lambda k: (k.get('sum_score')), reverse=True) 按sum_score排序
darta =sorted([dict['key'] for dict in list])(这个也行)
answers.sort(key=lambda x: x['time']) 按时间排序
2.获取list下面dict某字段的直
value_list = {dict['value'] for dict in list}
3.删除某元素
list.remove(obj) 按对象来
list.pop(index) 按下标来
4.添加元素
list.append()
5.多个list合并
list1.extend(list2) -----合并list1和list2
>>> list_test =[0,1,2,3,4,5,6,7,8,9,10]
>>> print list_test[1,4]
>> print list_test[1:4]
[1, 2, 3]
>>> print list_test[1:-1]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print list_test[1:-2]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> print list_test[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> print list_test[1:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> print list_test[:-1]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
每个数出现的次数
>>> print list_test.count(8)
1
>>> print list_test.count(0)
1
list的长度
>>> print len(list_test)
11
list的拼接
>>> list_test.extend([11,12,13])
>>> print list_test
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
>>> list_test
[13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> list_test.reverse()
>>> list_test
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
>>> list_test.reverse()
>>> list_test
[13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
list.sort()可以排序
python 获取当前文件名函数名,行数
python yield分析
1. 包含yield的函数
假如你看到某个函数包含了yield,这意味着这个函数已经是一个Generator,它的执行会和其他普通的函数有很多不同。比如下面的简单的函数:
def h():
print 'To be brave'
yield 5
h()
可以看到,调用h()之后,print 语句并没有执行!这就是yield,那么,如何让print 语句执行呢?这就是后面要讨论的问题,通过后面的讨论和学习,就会明白yield的工作原理了。
2. yield是一个表达式
Python2.5以前,yield是一个语句,但现在2.5中,yield是一个表达式(Expression),比如:
m = yield 5
表达式(yield 5)的返回值将赋值给m,所以,认为 m = 5 是错误的。那么如何获取(yield 5)的返回值呢?需要用到后面要介绍的send(msg)方法。
3. 透过next()语句看原理
现在,我们来揭晓yield的工作原理。我们知道,我们上面的h()被调用后并没有执行,因为它有yield表达式,因此,我们通过next()语句让它执行。next()语句将恢复Generator执行,并直到下一个yield表达式处。比如:
def h():
print 'Wen Chuan'
yield 5
print 'Fighting!'
c = h()
c.next()
c.next()
执行之后输出为
>python -m test_yield
Wen Chuan
Fighting!
如果没有yield ,print会直接输出
def h():
print 'Wen Chuan'
#yield 5
print 'Fighting!'
c = h()
执行之后输出为
>python -m test_yield
Wen Chuan
Fighting!
4. 如果没有next()则不会输出,应为c是个生成器,只有对它进行遍历才会输出
def h():
print 'Wen Chuan'
yield 5
print 'Fighting!'
c = h()
print type(c)
输出为
G:\资料\nova-stable-queens\nova-stable-queens>python -m test_yield
<type 'generator'>
返回生成器的示例
def h():
test_list =[1,23,4,5,67,8,9,0]
for i in test_list:
if i >2:
yield i
#print i
c = h()
print type(c)
print c.next() #相当于c.send(None)
print c.next()
print c.next()
输出为
G:\资料\nova-stable-queens\nova-stable-queens>python -m test_yield
<type 'generator'>
23
4
5
67
8
5.也可以把上面返回的生成器转化为list
list(c)
输出为
[23, 4, 5, 67, 8, 9]
python 编译某文件
python -mpy_compile 文件名
获取字典所有的value
dict.values()
openstack 将类转化为字典
第一个参数为类对象,第二个参数为属性的list
to_dict (object,attr_list):
obj = {}
for key in attr_list:
obj[key] = getattr(object, key, None)
return obj
比如要获取 cat 的eat ,color,size ,age ,long,weight等属性
attr_list = [eat ,color,size ,age ,long,weight]
调用方法为 to_dict(cat,attr_list)
python with 修饰符
python中with可以明显改进代码友好度
with 语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的“清理”操作,释放资源,比如文件使用后自动关闭、线程中锁的自动获取和释放等
假设要对一个文件进行操作
with open(os.path.join(self.SAMPLE_ROOT, sample_file), 'r') as f:
sample_content = f.read()
而如果我们用try catch finally
somefile = open(r'somefileName')
try:
for line in somefile:
print line
# ...more code
finally:
somefile.close()
代码显得没那么友好
with 语句的执行过程
context_manager = context_expression
exit = type(context_manager).__exit__
value = type(context_manager).__enter__(context_manager)
exc = True # True 表示正常执行,即便有异常也忽略;False 表示重新抛出异常,需要对异常进行处理
try:
try:
target = value # 如果使用了 as 子句
with-body # 执行 with-body
except:
# 执行过程中有异常发生
exc = False
# 如果 __exit__ 返回 True,则异常被忽略;如果返回 False,则重新抛出异常
# 由外层代码对异常进行处理
if not exit(context_manager, *sys.exc_info()):
raise
finally:
# 正常退出,或者通过 statement-body 中的 break/continue/return 语句退出
# 或者忽略异常退出
if exc:
exit(context_manager, None, None, None)
# 缺省返回 None,None 在布尔上下文中看做是 False
执行 context_expression,生成上下文管理器 context_manager
调用上下文管理器的 __enter__() 方法;如果使用了 as 子句,则将 __enter__() 方法的返回值赋值给 as 子句中的 target(s)
执行语句体 with-body
不管是否执行过程中是否发生了异常,执行上下文管理器的 __exit__() 方法,__exit__() 方法负责执行“清理”工作,如释放资源等。如果执行过程中没有出现异常,或者语句体中执行了语句 break/continue/return,则以 None 作为参数调用 __exit__(None, None, None) ;如果执行过程中出现异常,则使用 sys.exc_info 得到的异常信息为参数调用 __exit__(exc_type, exc_value, exc_traceback)
出现异常时,如果 __exit__(type, value, traceback) 返回 False,则会重新抛出异常,让with 之外的语句逻辑来处理异常,这也是通用做法;如果返回 True,则忽略异常,不再对异常进行处理
我们自己的类也可以使用with, 只要给这个类增加两个函数__enter__, __exit__即可:
>>> class A:
def __enter__(self):
print 'in enter'
def __exit__(self, e_t, e_v, t_b):
print 'in exit'
>>> with A() as a:
print 'in with'
in enter
in with
in exit
python库中还有一个模块contextlib,使你不用构造含有__enter__, __exit__的类就可以使用with:
>>> from contextlib import contextmanager
>>> from __future__ import with_statement
>>> @contextmanager
... def context():
... print 'entering the zone'
... try:
... yield
... except Exception, e:
... print 'with an error %s'%e
... raise e
... else:
... print 'with no error'
...
>>> with context():
... print '----in context call------'
...
entering the zone
----in context call------
with no error
python 装饰器
python装饰器
装饰器是一个很著名的设计模式,经常被用于AOP(面向切面编程)的场景,较为经典的有插入日志,性能测试,事务处理,Web权限校验, Cache等。
from functools import wraps
def my_decorator(f):
@wraps(f)
def wrapper(*args, **kwds):
print "Calling decorated function"
print f.__name__
return f(*args, **kwds)
return wrapper
@my_decorator
def example():
"""DocString"""
print "Called example function"
example()
print example.__name__
print example.__doc__
控制台输出:
Calling decorated function
example
Called example function
example
DocString
可以看到,最终调用函数example时,是经过 @my_decorator装饰的,装饰器的作用是接受一个被包裹的函数作为参数,对其进行加工,返回一个包裹函数,代码使用 @functools.wraps装饰将要返回的包裹函数wrapper,使得它的 name, module,和 doc 属性与被装饰函数example完全相同,这样虽然最终调用的是经过装饰的example函数,但是某些属性还是得到维护。
如果在 @my_decorator的定义中不使用 @function.wraps装饰包裹函数,那么最终example.name 将会变成'wrapper',而example.doc 也会丢失。
Calling decorated function
example
Called example function
wrapper
None
比如我们统计某函数执行时间,并输出日志:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import functools
import time
def wrap_performance(func):
@functools.wraps(func)
def wrapper(self, *args, **kwargs):
t_begin = time.time()
print 'before'
result = func(self, *args, **kwargs)
print 'end'
t_end = time.time()
print("Time: %f " % (t_end - t_begin))
return result
return wrapper
class Test:
def __init__(self):
pass
@wrap_performance
def test(self):
time.sleep(1)
t = Test()
t.test()
输出结果为:
before
end
Time: 1.001000
js
调用其他html定义的js的方法,include该html
pyhton 后台延时 time.sleep(单位秒)
前台延时 setTimeout()
重新加载页面 window.location.reload()
ajax :
iconfirm确认弹框
swal通知弹框
function delete_item(url,id){
iconfirm(gettext('x_confirm_delete'), function () {
$.ajax({ viewspy中直接 return Response(res_data)
type: "get",
url: url,
contentType: "application/json",
data: { id: id },
success: function (data, status) {
if (status == "success") {
swal({
title: "{% trans "x_deleted_successfully" %}",
type: "success",
confirmButtonText: "{% trans "x_confirm" %}"
})
setTimeout(function () {
window.location.reload();
}, 1500);
}
}})
});
模态框上面再弹一个模态框的方案
https://codepen.io/anon/pen/dYQMER
返回json 直接 return Response(res_data)
返回list return list_view(request, image_detail_list, ImageListSerializer)
python Json和字典之间的转换
json.dumps() --字典转为JSON
json.loads() --JSON转为字典
Python字典:
字典声明: dict ={}
打印字典值:
dict = {'Name': 'Zara', 'Age': 7}
print "Value : %s" % dict.values()
Value : [7, 'Zara'] ---输出为一个数组
判断字典有没有某个字段
dict.has_key('字段')
pyhton list 集合和数组
list增加 list.append()
list声明 list= []
遍历
for item in list_test:
item.xxx
python获取前台Django返回的list
request.data.getlist('ids')
用常规的request.data['ids']只能取到后一个
时间和字符串之间的转换
字符串转时间:
datetime.strptime(str,'%Y-%m-%d')
时间转字符串:
timestr.strftime('%Y-%m-%d')
获取当前时间:
datetime.now()
python创建虚拟环境
1.进入项目目录
2.pip install virtualenv
3.pip install virtualenvwrapper
4.mkvirtualenv 虚拟环境名
5.workon 虚拟环境名 ---进入虚拟环境
6.pip install -r requirement.txt
python 的继承
python中什么是继承:
新类不必从头编写
新类从现有的类继承,就自动拥有了现有类的所有功能
新类只需要编写现有类缺少的新功能
继承的好处:
复用已有代码
自动拥有了现有类的所有功能
只需要编写缺少的新功能
继承的特点:
子类和父类是is关系
python继承的特点:
总是从某个类继承
- python中继承一个类
复制代码
1 class Person(object):
2 def __init__(self, name, gender):
3 self.name = name
4 self.gender = gender
5 class Teacher(Person):
6 def __init__(self, name, gender, course):
7 super(Teacher, self).__init__(name, gender)
8 self.course = course
9
10 t = Teacher('Alice', 'Female', 'English')
11 print t.name
12 print t.course
调用父类的方法:
super(object, self).sub_perform_create(serializer)
3.当继承的有多个父类而且父类有同名方法时,默认调用第一个父类的方法
4.getattr()、setattr()以及hasattr()
if hasattr(obj,'attr') ---判断某个类有没有什么属性
getattr(obj,'attr') ---获取某个类的什么属性
setattr(obj,'attr',a) --将某个类某属性的直设为a
django queryset
django queryset:
1.如果对queryset进行遍历,那么每一行都是一个字典
set的取值方法: set.属性
dict的取值方法: dict["属性"]
2.聚合函数,分组queryset.values.annotate(
别名1:sum("属性1")
别名2:sum("属性2")
)
3.order_by()按某个属性那个进行排序
order_by("属性1") 递增排序
order_by("-属性1") 递减排序
4.字典dict 集合list
声明方法: dict res_dict={}
list res_list=[]
res_dict = {
'name': name,
'sum_score': ad["sum_score"],
'last_edit_time': ad["last_edit_time"],
'sid': ad["user_id"]
}
将dict存入list
list.append("dict")
5.外键查询 event_task是外键
id_event_tasks = {row.id: row for row in ems}
answers = event_models.EventUserSubmitLog.objects.filter(event_task__in=id_event_tasks.keys())
values_list('username') 取某一字段的值
first() 取集合第一个
6.extra 取别名
SELECT name AS tag_name FROM blog_tag;
这样的语句,就可以用 select 来实现,如下:
tags = Tag.objects.all().extra(select={'tag_name': 'name'})
7.values_list 取这两个字段的值
User.objects.values_list('id','name')
8.除什么以外
User.objects.exclude(status=User.USER.DELETE)
9.给某字段取别名
extra(select={'submit_time': 'create_time'})
执行原生SQL
#
# from django.db import connection, connections
# cursor = connection.cursor() # cursor = connections['default'].cursor()
# cursor.execute("""SELECT * from auth_user where id = %s""", [1])
# row = cursor.fetchone()
一些常用的筛选
# 获取个数
#
# models.Tb1.objects.filter(name='seven').count()
# 大于,小于
#
# models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值
# models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值
# models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
# in
#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
# isnull
# Entry.objects.filter(pub_date__isnull=True)
# contains
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
# models.Tb1.objects.exclude(name__icontains="ven")
# range
#
# models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and
# 其他类似
#
# startswith,istartswith, endswith, iendswith,
# order by
#
# models.Tb1.objects.filter(name='seven').order_by('id') # asc
# models.Tb1.objects.filter(name='seven').order_by('-id') # desc
# group by
#
# from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
# limit 、offset
#
# models.Tb1.objects.all()[10:20]
# regex正则匹配,iregex 不区分大小写
#
# Entry.objects.get(title__regex=r'^(An?|The) +')
# Entry.objects.get(title__iregex=r'^(an?|the) +')
# date
#
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
# year
#
# Entry.objects.filter(pub_date__year=2005)
# Entry.objects.filter(pub_date__year__gte=2005)
# month
#
# Entry.objects.filter(pub_date__month=12)
# Entry.objects.filter(pub_date__month__gte=6)
# day
#
# Entry.objects.filter(pub_date__day=3)
# Entry.objects.filter(pub_date__day__gte=3)
# week_day
#
# Entry.objects.filter(pub_date__week_day=2)
# Entry.objects.filter(pub_date__week_day__gte=2)
# hour
#
# Event.objects.filter(timestamp__hour=23)
# Event.objects.filter(time__hour=5)
# Event.objects.filter(timestamp__hour__gte=12)
# minute
#
# Event.objects.filter(timestamp__minute=29)
# Event.objects.filter(time__minute=46)
# Event.objects.filter(timestamp__minute__gte=29)
# second
#
# Event.objects.filter(timestamp__second=31)
# Event.objects.filter(time__second=2)
# Event.objects.filter(timestamp__second__gte=31)
联表查询
obj1.get(id=1).obj2_id # 获取到关联obj2对象
obj.get_user_type_display() # 显示choice定义的名称:“model字段的参数里有choice”,
html里的写法:{{ obj.get_user_type_display }}
反向操作:
在被关联的类里定义方法
def get_obj_num(self):
return obj_set.all() # 获取到所有被关联的对象,obj无论大小写
Django reverse 用法
参考网址
from django.urls import reverse # django 1.10.x 新的,更加规范了
reverse('add2', args=(4,5))
实际 url为 add2/4/5
python 元类 metaclass
元类是可以让你定义某些类是如何被创建的。从根本上说,赋予你如何创建类的控制权。
元类也是一个类,是一个type类。
元类一般用于创建类。在执行类定义时,解释器必须要知道这个类的正确的元类,如果此属性没有定义,它会向上查找父类中的__metaclass__属性。如果还没发现,就查找全局变量。
对于传统类来说,它们的元类是types.ClassType。
元类也有构造器,传递三个参数:类名,从基类继承数据的元组,和类属性字典
我们都知道通过类可以创建出实例对象,而元类就是创建出类对象的类。type可以创建出类对象也就是说type就是一个元类。
MyClass = MetaClass()
type可以做同样的事情:
MyClass = type('MyClass', (), {})
python的国际化
1.` 如果要翻译的内容只是单纯的传输
python manage.py compilemessages 编译翻译
标准翻译
使用函数ugettext()指定翻译字符串。 按惯例将其导入为较短的别名_以保存输入。
Python的标准库gettext模块将_()安装到全局名称空间中,作为gettext()的别名。 在Django中,我们选择不采取这种做法,原因如下:
对于国际字符集(Unicode)支持,ugettext()比gettext()更有用。 有时,您应该使用ugettext_lazy()作为特定文件的默认翻译方法。 如果在全局名称空间中没有_(),开发人员必须考虑哪个是最适合的翻译功能。
下划线字符()用于表示Python的交互式shell和doctest测试中的以前的结果。 安装全局()函数会导致干扰。 显式导入ugettext()作为_()可以避免这个问题。
当要翻译的东西会作为参数传入传出时:
from django.utils.translation import gettext, ugettext
用法ugettext('x_name')
translation的源码
class TranslatorCommentWarning(SyntaxWarning):
pass
# Here be dragons, so a short explanation of the logic won't hurt:
# We are trying to solve two problems: (1) access settings, in particular
# settings.USE_I18N, as late as possible, so that modules can be imported
# without having to first configure Django, and (2) if some other code creates
# a reference to one of these functions, don't break that reference when we
# replace the functions with their real counterparts (once we do access the
# settings).
class Trans(object):
"""
The purpose of this class is to store the actual translation function upon
receiving the first call to that function. After this is done, changes to
USE_I18N will have no effect to which function is served upon request. If
your tests rely on changing USE_I18N, you can delete all the functions
from _trans.__dict__.
Note that storing the function with setattr will have a noticeable
performance effect, as access to the function goes the normal path,
instead of using __getattr__.
"""
def __getattr__(self, real_name):
from django.conf import settings
if settings.USE_I18N:
from django.utils.translation import trans_real as trans
else:
from django.utils.translation import trans_null as trans
setattr(self, real_name, getattr(trans, real_name))
return getattr(trans, real_name)
_trans = Trans()
# The Trans class is no more needed, so remove it from the namespace.
del Trans
def gettext_noop(message):
return _trans.gettext_noop(message)
ugettext_noop = gettext_noop
def gettext(message):
return _trans.gettext(message)
def ngettext(singular, plural, number):
return _trans.ngettext(singular, plural, number)
def ugettext(message):
return _trans.ugettext(message)
def ungettext(singular, plural, number):
return _trans.ungettext(singular, plural, number)
def pgettext(context, message):
return _trans.pgettext(context, message)
def npgettext(context, singular, plural, number):
return _trans.npgettext(context, singular, plural, number)
gettext_lazy = lazy(gettext, str)
ugettext_lazy = lazy(ugettext, six.text_type)
pgettext_lazy = lazy(pgettext, six.text_type)
def lazy_number(func, resultclass, number=None, **kwargs):
if isinstance(number, six.integer_types):
kwargs['number'] = number
proxy = lazy(func, resultclass)(**kwargs)
else:
original_kwargs = kwargs.copy()
class NumberAwareString(resultclass):
def __bool__(self):
return bool(kwargs['singular'])
def __nonzero__(self): # Python 2 compatibility
return type(self).__bool__(self)
def __mod__(self, rhs):
if isinstance(rhs, dict) and number:
try:
number_value = rhs[number]
except KeyError:
raise KeyError(
"Your dictionary lacks key '%s\'. Please provide "
"it, because it is required to determine whether "
"string is singular or plural." % number
)
else:
number_value = rhs
kwargs['number'] = number_value
translated = func(**kwargs)
try:
translated = translated % rhs
except TypeError:
# String doesn't contain a placeholder for the number
pass
return translated
proxy = lazy(lambda **kwargs: NumberAwareString(), NumberAwareString)(**kwargs)
proxy.__reduce__ = lambda: (_lazy_number_unpickle, (func, resultclass, number, original_kwargs))
return proxy
def _lazy_number_unpickle(func, resultclass, number, kwargs):
return lazy_number(func, resultclass, number=number, **kwargs)
def ngettext_lazy(singular, plural, number=None):
return lazy_number(ngettext, str, singular=singular, plural=plural, number=number)
def ungettext_lazy(singular, plural, number=None):
return lazy_number(ungettext, six.text_type, singular=singular, plural=plural, number=number)
def npgettext_lazy(context, singular, plural, number=None):
return lazy_number(npgettext, six.text_type, context=context, singular=singular, plural=plural, number=number)
常见的几种国际化的场景
翻译调用
**在Python中使用国际化:**
导入ugettext_lazy
from django.utils.translation import ugettext_lazy as _
调用
_("x_user")
**在模板中使用国际化:**
在模板中直接使用 {% trans “x_xxx” %}进行翻译,例如:{% trans ‘x_user’ %}
**在Js中使用国际化:**
在Js中使用 gettext(“x_xxx”)进行翻译,例如:gettext(“x_user”)
**在veubatim中使用国际化:**
在{% veubatim %}代码块中,使用{{ “x_xxx” | trans }}进行翻译
例:
{% veubatim %}
<h2>{{ "x_user" | trans}}</h2>
{% endveubatim %}
翻译调用
在Python中使用国际化:
导入ugettext_lazy
from django.utils.translation import ugettext_lazy as _
调用
_("x_user")
在模板中使用国际化:
在模板中直接使用 {% trans “x_xxx” %}进行翻译,例如:{% trans ‘x_user’ %}
在Js中使用国际化:
在Js中使用 gettext(“x_xxx”)进行翻译,例如:gettext(“x_user”)
在veubatim中使用国际化:
在{% veubatim %}代码块中,使用{{ “x_xxx” | trans }}进行翻译
例:
{% veubatim %}
<h2>{{ "x_user" | trans}}</h2>
{% endveubatim %}
**带有变量的国际化**
例:翻译
`msgid "x_nickname"`
`msgstr "昵称:{nickname}" `
调用:
`text: gettext("x_nickname").format({nickname:name}) #name为原代码中的变量`
例:翻译
`msgid "x_nickname"`
`msgstr "昵称:{nickname}" `
调用:
`text: gettext("x_nickname").format({nickname:name}) #name为原代码中的变量
python zip函数
zip函数的原型为:zip([iterable, …])
参数iterable为可迭代的对象,并且可以有多个参数。该函数返回一个以元组为元素的列表,其中第 i 个元组包含每个参数序列的第 i 个元素。返回的列表长度被截断为最短的参数序列的长度。只有一个序列参数时,它返回一个1元组的列表。没有参数时,它返回一个空的列表。
a=[1,2,3,4,5]
b=(1,2,3,4,5)
c="zhang"
zz=zip(a,b,c)
print(zz)
输出为
[(1, 1, 'z'), (2, 2, 'h'), (3, 3, 'a'), (4, 4, 'n'), (5, 5, 'g')]
当多个参数长度不同的时候
import numpy as np
a=[1,2,3]
b=[1,2,3,4]
c=[1,2,3,4,5]
zz=zip(a,b,c)
print(zz)
输出:
[(1, 1, 1), (2, 2, 2), (3, 3, 3)]
zip() 和 * 操作符一起操作可以用来 unzip 一个列表,看下面的代码:
import numpy as np
a=[1,2,3]
b=[4,5,6]
c=[7,8,9]
zz=zip(a,b,c)
print(zz)
x,y,z=zip(*zz)
print(x)
print(y)
print(z)
输出:
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
(1, 2, 3)
(4, 5, 6)
(7, 8, 9)
注意这里输出的每个都是元组,而不一定是原来的类型,但是值不会发生变化(除非原来的参数列表长度不一样,看下面的代码)
import numpy as np
a=[1,2,3]
b=[4,5,6,7]
c=[8,9,10,11,12]
zz=zip(a,b,c)
print(zz)
x,y,z=zip(*zz)
print(x)
print(y)
print(z)
输出:
[(1, 4, 8), (2, 5, 9), (3, 6, 10)]
(1, 2, 3)
(4, 5, 6)
(8, 9, 10)
unzip后的列表b和c的值都少了。
bootstrap table
table的ckeckbox pageWidgets.registerCheckTableRow($("#instanceTable"));
每行checkbox的value默认为该行ID字段的值,如果没有则为空
$('#tableid').bootstrapTabel('getCheckedValues') 可以获取选中项的ID
分页:
data-pagination="true" 表示开始分页。默认每页10条
data-page-size="10" 设置每页条数
动态刷新数据:
1.用load data的方法
$table.bootstrapTable('load', data);
data为json,各属性要和表各字段一致
2.改url
把对url的设置作为refresh方法的参数,如下:
$('#table-large-columns').bootstrapTable('refresh',{url:'meter_data.php?bm=2'});
python 几个快捷键
Alt + 1 从打开的文件到项目目录
esc 从项目目录到打开的文件
eclipse风格:
ctrl +shift + f 标准化格式
ctrl + h 全局搜索
ctrl + f 当前文件搜索
ctrl + home 返回当前文件开头
ctrl + end 返回当前文件结尾
ctrl +(数字栏的) 展开当前代码块
ctrl - (数字栏的) 关闭当前代码块
python 字符串
python abc 和six
abc 讲解参考
Python本身不提供抽象类和接口机制,要想实现抽象类,可以借助abc模块
abc是Abstract Base Classes的缩写
一般用 @abc.abstractmethod装饰器修饰抽象方法
一般用@six.add_metaclass(abc.ABCMeta)装饰器修饰抽象类
例:
@six.add_metaclass(abc.ABCMeta)
class PluginBase(object):
@abc.abstractmethod
def func_a(self, data):
@six.add_metaclass(abc.ABCMeta)用于指定元类,兼容python2和3
@abc.abstractmethod用于声明抽象方法;
abc.ABCMeta.register方法用于将任意类注册为虚拟子类
通过标准方式继承抽象类的类,必须全部实现抽象类的抽象方法,否则不能实例化
虚拟子类不影响subclasses, 可以不实现抽象方法,只要不调用。
python 单引号,双引号,三引号的区别
一、单引号,双引号,三引号的区别
分别阐述3种引号用的场景和区别
1),单引号和双引号主要用来表示字符串
比如:
单引号:'python'
双引号:"python"
2),三引号
三单引号:'''python ''',也可以表示字符串一般用来输入多行文本,或者用于大段的注释
三双引号:"""python""",一般用在类里面,用来注释类,这样省的写文档,直接用类的对象__doc__访问获得文档
区别:
若你的字符串里面本身包含单引号,必须用双引号
比如: "can't find the log\n"
进rest_framework后台
这里面只能看 api的,看不到views的
在url.py里面加一条
url(r'^api-auth/', include('rest_framework.urls')),
然后在rest_framework配置的地方settings.py里面
DEFAULT_RENDERER_CLASSES,如果该字段值为rest_framework.renderers.JSONRenderer
则注释掉
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework.authentication.SessionAuthentication',
),
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.IsAuthenticated',
],
# 'DEFAULT_RENDERER_CLASSES': (
# 'rest_framework.renderers.JSONRenderer',
# ),
python 获取某服务pid
import re
import string
import uuid
import psutil
def get_pid(name):
procs = list(psutil.process_iter())
regex = "pid=(\d+),\sname='" + name + "'"
pid = 0
for line in procs:
process_info = str(line)
ini_regex = re.compile(regex)
result = ini_regex.search(process_info)
if result != None:
pid = string.atoi(result.group(1))
return pid
python 判断远程机端口状态
import socket
def is_port_open(ip, port):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(2)
try:
s.connect((ip, int(port)))
s.close()
return True
except:
s.close()
return False
GROUP BY 和 ORDER BY一起使用
通常order by 和group by 没有太多的关系,但是它们常常组合在一起用,完成分组加排序的功能.
order by 中列,应该出现在group by 子句中。这是一个很显然的道理。
如果order by的关键字在group by中没出现过,则group by 分组会生效
例子:
以下是正确引用片段:
SELECT dep.department_name, MAX(emp.salary), MIN(emp.salary)
FROM departments dep
LEFT JOIN employees emp
ON (dep.department_id = emp.department_id)
GROUP BY dep.department_name
--order by 的列,必须是出现在group by 子句里的列
ORDER BY dep.department_name DESC
以下是错误引用片段:
SELECT dep.department_name, MAX(emp.salary), MIN(emp.salary) FROM departments dep LEFT JOIN employees emp ON (dep.department_id = emp.department_id) GROUP BY dep.department_name
--order by 的列,应该出现在group by 子句中 ORDER BY dep.department_id DESC
--
GROUP BY 和 ORDER BY一起使用时,ORDER BY要在GROUP BY的后面。
group by a,b,c 则a,b,c三个字段是按照先按a字段对数据行进行排序,再按b字段对那些字段a为同一个值的数据行进行排序,再再按c字段对那些字段a为同一个值且字段b为同一个值的数据行进行排序
order by a,b,c 也是如此
故而
表T 有a,b,c三个字段,按a分组再按c排序的方法如下:
select * from T order by a,c//两个字段顺序不能颠倒
或者
select * from T group by a,c//两个字段顺序不能颠倒
向前台ajax返回错误的一种方法
在异常处写:
return response.Response({'error_code': 'xxx'})
直接返回给前台,前台在接受时进行判断:
success: function (res) {
if (res.error_code == 'xxx')
$('#元素').html("{% trans 'x_xxx_error' %}");
用某元素显示异常
lambda 相关
if __name__ == "__main__" 的作用
参考连接
python 中__name__ = 'main' 的作用,到底干嘛的?
有句话经典的概括了这段代码的意义:
“Make a script both importable and executable”
意思就是说让你写的脚本模块既可以导入到别的模块中用,另外该模块自己也可执行。
这句话,可能一开始听的还不是很懂。下面举例说明:
先写一个模块:
#module.py
def main():
print "we are in %s"%__name__
if __name__ == '__main__':
main()
这个函数定义了一个main函数,我们执行一下该py文件发现结果是打印出”we are in main“,说明我们的if语句中的内容被执行了,调用了main():
但是如果我们从另我一个模块导入该模块,并调用一次main()函数会是怎样的结果呢?
其执行的结果是:we are in module
但是没有显示”we are in main“,也就是说模块__name__ = 'main' 下面的函数没有执行。
这样既可以让“模块”文件运行,也可以被其他模块引入,而且不会执行函数2次。这才是关键。
总结一下:
如果我们是直接执行某个.py文件的时候,该文件中那么”name == 'main'“是True,但是我们如果从另外一个.py文件通过import导入该文件的时候,这时__name__的值就是我们这个py文件的名字而不是__main__。
这个功能还有一个用处:调试代码的时候,在”if name == 'main'“中加入一些我们的调试代码,我们可以让外部模块调用的时候不执行我们的调试代码,但是如果我们想排查问题的时候,直接执行该模块文件,调试代码能够正常运行!
当你打开一个.py文件时,经常会在代码的最下面看到if name == 'main':,现在就来介 绍一下它的作用.
模块是对象,并且所有的模块都有一个内置属性 __name__。一个模块的 __name__ 的值取决于您如何应用模块。如果 import 一个模块,那么模块__name__ 的值通常为模块文件名,不带路径或者文件扩展名。但是您也可以像一个标准的程序样直接运行模块,在这 种情况下, __name__ 的值将是一个特别缺省"__main__"。
在cmd 中直接运行.py文件,则__name__的值是'main';
而在import 一个.py文件后,__name__的值就不是'main'了;
从而用if name == 'main'来判断是否是在直接运行该.py文件
如:
#Test.py
class Test:
def __init(self):pass
def f(self):print 'Hello, World!'
if __name__ == '__main__':
Test().f()
#End
你在cmd中输入:
C:>python Test.py
Hello, World!
说明:"__name__ == '__main__'"是成立的
你再在cmd中输入:
C:>python
>>>import Test
>>>Test.__name__ #Test模块的__name__
'Test'
>>>__name__ #当前程序的__name__
'__main__'
无论怎样,Test.py中的"name == 'main'"都不会成立的!
所以,下一行代码永远不会运行到!
python的try catch
try…except…except…[else…][finally…]
执行try下的语句,如果引发异常,则执行过程会跳到except语句。
对每个except分支顺序尝试执行,如果引发的异常与except中的异常组匹配,执行相应的语句。
如果所有的except都不匹配,则异常会传递到下一个调用本代码的最高层try代码中。
try下的语句正常执行,则执行else块代码。如果发生异常,就不会执行
如果存在finally语句,最后总是会执行。
python 执行某系统命令
import subprocess
cmd = 'systemctl restart httpd'
subprocess.Popen('cmd',shell=True)
python 深拷贝和浅拷贝
深copy和浅copy
深copy新建一个对象重新分配内存地址,复制对象内容。浅copy不重新分配内存地址,内容指向之前的内存地址。浅copy如果对象中有引用其他的对象,如果对这个子对象进行修改,子对象的内容就会发生更改。(即拷贝对象会出问题)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import copy
numbers=['1','2','3',['4','5']]
num1=copy.copy(numbers)
num2=copy.deepcopy(numbers)
num1.append('6')
print('numbers:',numbers)
print('numbers memory address:',id(numbers))
print('numbers[3] memory address',id(numbers[3]))
print('num1:',num1)
print('num1 memory address:',id(num1))
print('num1[3] memory address',id(num1[3]))
print('aaa')
print('aaaa')
num1[3].append('6')
print('numbers:',numbers)
print('num1:',num1)
print('num2',num2)
numbers[3].append('7')
print('aaa')
print('aaaa')
print('numbers:',numbers)
print('num1:',num1)
print('num2',num2)
num1[3].append('8')
print('aaa')
print('aaaa')
print('numbers:',numbers)
print('num1:',num1)
print('num2',num2)
输出为
('numbers:', ['1', '2', '3', ['4', '5']])
('numbers memory address:', 81277192L)
('numbers[3] memory address', 81863112L)
('num1:', ['1', '2', '3', ['4', '5'], '6'])
('num1 memory address:', 81926920L)
('num1[3] memory address', 81863112L)
aaa
aaaa
('numbers:', ['1', '2', '3', ['4', '5', '6']])
('num1:', ['1', '2', '3', ['4', '5', '6'], '6'])
('num2', ['1', '2', '3', ['4', '5']])
aaa
aaaa
('numbers:', ['1', '2', '3', ['4', '5', '6', '7']])
('num1:', ['1', '2', '3', ['4', '5', '6', '7'], '6'])
('num2', ['1', '2', '3', ['4', '5']])
aaa
aaaa
('numbers:', ['1', '2', '3', ['4', '5', '6', '7', '8']])
Django 事务
它是这样工作的:当有请求过来时,Django会在调用视图方法前开启一个事务。如果请求却正确处理并正确返回了结果,Django就会提交该事务。否则,Django会回滚该事务。
with transaction.atomic():
下面的代码支持事务
下面是被当做上下文管理器来使用:
from django.db import transaction
def viewfunc(request):
# This code executes in autocommit mode (Django's default).
do_stuff()
with transaction.atomic():
# This code executes inside a transaction.
do_more_stuff()
一旦把atomic代码块放到try/except中,完整性错误就会被自然的处理掉了,比如下面这个例子:
from django.db import IntegrityError, transaction
@transaction.atomic
def viewfunc(request):
create_parent()
try:
with transaction.atomic():
generate_relationships()
except IntegrityError:
handle_exception()
add_children()
这个例子中,即使generate_relationships()中的代码打破了数据完整性约束,你仍然可以在add_children()中执行数据库操作,并且create_parent()产生的更改也有效。需要注意的是,在调用handle_exception()之前,generate_relationships()中的修改就已经被安全的回滚了。因此,如果有需要,你照样可以在异常处理函数中操作数据库。
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.