sfppp / python Goto Github PK

python's People

Watchers

python's Issues

python 字符串

可以把字符串看作为字符数组

>>> str1
'just do it'
>>> len(str1)
10
>>> str1.upper()
'JUST DO IT'
>>> str1.count('t')
2

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()

python mysql-orm

一些常用的筛选


        # 获取个数
        #
        # 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无论大小写

时间和字符串之间的转换

字符串转时间：
datetime.strptime(str,'%Y-%m-%d')
时间转字符串：
timestr.strftime('%Y-%m-%d')
获取当前时间：
datetime.now()

进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',
    # ),

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'"都不会成立的!

所以,下一行代码永远不会运行到!

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 元类 metaclass

元类是可以让你定义某些类是如何被创建的。从根本上说，赋予你如何创建类的控制权。
元类也是一个类，是一个type类。

元类一般用于创建类。在执行类定义时，解释器必须要知道这个类的正确的元类，如果此属性没有定义，它会向上查找父类中的__metaclass__属性。如果还没发现，就查找全局变量。

对于传统类来说，它们的元类是types.ClassType。

元类也有构造器，传递三个参数：类名，从基类继承数据的元组，和类属性字典

我们都知道通过类可以创建出实例对象，而元类就是创建出类对象的类。type可以创建出类对象也就是说type就是一个元类。

MyClass = MetaClass()
type可以做同样的事情：
MyClass = type('MyClass', (), {})

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

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的try catch

try…except…except…[else…][finally…]

执行try下的语句，如果引发异常，则执行过程会跳到except语句。
对每个except分支顺序尝试执行，如果引发的异常与except中的异常组匹配，执行相应的语句。
如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。

try下的语句正常执行，则执行else块代码。如果发生异常，就不会执行

如果存在finally语句，最后总是会执行。

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

-1相当于最后一位

>>> 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装饰器

装饰器是一个很著名的设计模式，经常被用于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

python 编译某文件

python -mpy_compile 文件名

python 几个快捷键

Alt + 1 从打开的文件到项目目录
esc 从项目目录到打开的文件
eclipse风格：
ctrl +shift + f 标准化格式
ctrl + h 全局搜索
ctrl + f 当前文件搜索
ctrl + home 返回当前文件开头
ctrl + end 返回当前文件结尾
ctrl +（数字栏的）展开当前代码块
ctrl - （数字栏的）关闭当前代码块

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的值都少了。

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 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]

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']只能取到后一个

Django reverse 用法

参考网址
from django.urls import reverse # django 1.10.x 新的，更加规范了

reverse('add2', args=(4,5))
实际 url为 add2/4/5

获取字典所有的value

dict.values()

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

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 的继承

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

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']])

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 获取当前文件名函数名，行数

import sys

def function():
print(sys._getframe().f_code.co_filename) #当前位置所在的文件名
print(sys._getframe().f_code.co_name) #当前位置所在的函数名
print(sys._getframe().f_lineno) #当前位置所在的行号

if name == 'main':
function()

输出为

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//两个字段顺序不能颠倒

python 单引号，双引号，三引号的区别

一、单引号，双引号，三引号的区别

分别阐述3种引号用的场景和区别

1),单引号和双引号主要用来表示字符串

比如:

单引号:'python'
双引号:"python"
2),三引号

三单引号:'''python ''',也可以表示字符串一般用来输入多行文本,或者用于大段的注释
三双引号："""python"""，一般用在类里面,用来注释类,这样省的写文档,直接用类的对象__doc__访问获得文档
区别:

若你的字符串里面本身包含单引号,必须用双引号

比如: "can't find the log\n"

python 执行某系统命令

import subprocess
cmd = 'systemctl restart httpd'
subprocess.Popen('cmd',shell=True)

向前台ajax返回错误的一种方法

在异常处写：
return response.Response({'error_code': 'xxx'})
直接返回给前台，前台在接受时进行判断：

 success: function (res) {
                if (res.error_code == 'xxx')
                    $('#元素').html("{% trans 'x_xxx_error' %}");

用某元素显示异常

python创建虚拟环境

1.进入项目目录
2.pip install virtualenv
3.pip install virtualenvwrapper
4.mkvirtualenv 虚拟环境名
5.workon 虚拟环境名 ---进入虚拟环境
6.pip install -r requirement.txt

lambda 相关

lambda类似于java中的匿名函数，和C 中的宏定义

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()中的修改就已经被安全的回滚了。因此，如果有需要，你照样可以在异常处理函数中操作数据库。

sfppp / python Goto Github PK

python's People

Watchers

python's Issues

Recommend Projects

Recommend Topics

Recommend Org