Python 内置函数及一些常用方法的封装

• next()

next 语法：
next(iterator[, default])
参数说明：
iterator -- 可迭代对象
default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

• 列表的方法extend()

extend 向列表中追加多个元素。

#例：
>>> a=[]
>>> a.extend([1,2])
>>> a
[1, 2]
>>> a.extend([13,214,41234,3,352,45,])
>>> a
[1, 2, 13, 214, 41234, 3, 352, 45]

• 有关时间模块的操作

#1.将本地时间内的时间元转换为自纪元以来的秒数。
>>>int(time.mktime(datetime.date.today().timetuple()))
1523116800.0

• 有关字典的合并

第一种方法

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> x.update(y)
>>>x
{'a': 1, 'b': 10, 'c': 11}

第二种

>>>z = dict(list(x.items()) + list(y.items()))
>>>z
{'a': 1, 'b': 10, 'c': 11}

如果你用的是Python3的话稍微有点麻烦:

>>> z = dict(list(x.items()) + list(y.items()))
>>> z
{'a': 1, 'c': 11, 'b': 10}

还可以这样:

z = x.copy()
z.update(y)

• 字典排序

import operator
x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
# sorted_x是一个元组列表,用每个元组的第二个元素进行排序.dict(sorted_x) == x.
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
#如果想要用键来进行排序:
sorted_x = sorted(x.items(), key=operator.itemgetter(0))
#
sorted(d.items(), key=lambda x: x[1])

• #####列表有序去重
  python 内置函数。
  m = sorted(set(list),key=list.index)
  例如：将list1=[1,1,2,2,3,3,4,4]有序去重代码如下

list1 = [1,1,2,2,3,3,4,4]
list2 = sorted(set(list1),key=list1.index)
print(list2)
#运行结果如下：
[1,2,3,4]

sorted 排序默认是从小排到大

• 字典列表去重

def dedupe(items, key=None):
    """
    :param items:字典列表
    :param key:为一个偏函数
    :return:
    """
    seen = set()
    for item in items:
        val = item if key is None else key(item)
        if val not in seen:
            yield item
            seen.add(val)

调用方法：

dedupe(m_json_data, key=lambda x: (x.get('m_id'), x.get('q_id')))

• 字典列表分组

例将类似于persons = [
{“user_id”: 2009, “name”: “zpf”},
{“user_id”: 2010, “name”: “ly”} ,
{“user_id”: 2009, “name”: “lc”} ,
{“user_id”: 2009, “name”: “yw”},
{“user_id”: 2011, “name”: “dl”},
{“user_id”: 2012, “name”: “zpf”}
]
转换成如下的数据格式（即按user_id进行分组）：
[{‘user_id’: 2009, ‘name’: [‘zpf’, ‘lc’, ‘yw’]},
{‘user_id’: 2010, ‘name’: [‘ly’]},
{‘user_id’: 2011, ‘name’: [‘dl’]},
{‘user_id’: 2012, ‘name’: [‘zpf’]}]
有如下处理方式：
方法一

from operator import itemgetter
from itertools import groupby
persons = [
    {"user_id": 2009, "name": "zpf"},
    {"user_id": 2010, "name": "ly"} ,
    {"user_id": 2009, "name": "lc"} ,
    {"user_id": 2009, "name": "yw"},
    {"user_id": 2011, "name": "dl"},
    {"user_id": 2012, "name": "zpf"}
]
persons_list = list()
persons.sort(key=itemgetter('user_id')) #对以上列表按照user_id将列表中的字典进行排序，在执行goupby进行分组时必须先进行排序。
for user_id, items in groupby(persons, key=itemgetter('user_id')):
    person = {}
    person['user_id'] = user_id
    person['name'] = [a.get('name') for a in items]
    persons_list.append(person)
print(persons_list)

方法一有一问题即items为<itertools._grouper object at 0x00000000022E6320>对象，若你讲其进行强转换成list(),再进行对其进行排序时，则返回空列表

persons = [
    {"user_id": 2009, "name": "zpf"},
    {"user_id": 2010, "name": "ly"} ,
    {"user_id": 2009, "name": "lc"} ,
    {"user_id": 2009, "name": "yw"},
    {"user_id": 2011, "name": "dl"},
    {"user_id": 2012, "name": "zpf"}
]
user_id_list = set(a.get('user_id') for a in persons)
persons_list=[]
for user_id in user_id_list:
    person = {}
    person['user_id'] = user_id
    some_person = filter(lambda x:x['user_id']==user_id,persons) #此方法查找出相同的user_id的数据
    person['name'] = [a.get('name') for a in some_person]
    persons_list.append(person)

• 时间戳格式化

import time
need_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(1535937479))
print(need_time)
结果：
'2018-09-03 09:17:59'

• 将时间转化为时间戳

import time
a = time.mktime(time.strptime("2018-10-12", "%Y-%m-%d"))
print(a)
结果：
'1539273600.0’

• 根据时间戳获取某时间戳当天最早的时间戳即当天00:00:00的时间戳

import time
import datetime

start_timetuple = int(time.mktime(datetime.datetime.combine(datetime.datetime.fromtimestamp(1543312708),
                                                                datetime.time.min).timetuple()))

# 此为将时间戳转化为data对象
print(datetime.datetime.fromtimestamp(1543312708))
#获取天中最早的时间对象
print(datetime.time.min)
print(datetime.datetime.combine(datetime.datetime.fromtimestamp(1543312708),
                                                                datetime.time.min))
print(datetime.datetime.combine(datetime.datetime.fromtimestamp(1543312708),
                                                                datetime.time.min).timetuple())
print(start_timetuple)

执行结果：

• 获取当天零点的时间戳

today_min = int(time.mktime(time.strptime(str(datetime.date.today()),'%Y-%m-%d')))
# 获取两天前的凌晨的时间
before_tow_min = int(time.mktime(time.strptime(str(datetime.date.today()-datetime.timedelta(days=2)),'%Y-%m-%d')))

• django 获取post请求的数据

post = json.loads(request.body, strict=False)

• django 对数据进行分页

from django.core.paginator import Paginator, EmptyPage
#首先要获取要查询的页码，及每页要获取的数据量
 page = request.GET.get('page', '')  # 获取要查询的页码
 per_page = request.GET.get('per_page', '')  # 获取每页要获取的数据量

paginator = Paginator(users, per_page) # 此处users对象是一个列表，即将users从数据库中查询出来，并缓存起来返回每页想要请求的数据量

data.count = paginator.count
data.num_pages = paginator.num_pages
try:
       users = paginator.page(page)
except EmptyPage:
        users = []

• 将列表按照某种顺进行打乱，其中包含python列表交叉合并

def sort_list(value):
    """
    对列表重排序，按照某种规则排序,打乱
    :param value:
    :return:need_list
    """
    a = value[0:len(value) - int(len(value) / 2)]
    b = value[int(len(value) / 2) + 1:len(value)]

    need_list = []
    for i in range(max(len(a), len(b))):
        if a:
            need_list.append(a.pop())
        if b:
            need_list.append(b.pop())
    return need_list