列表和字典的操作

字典(Dictionary) (items)

• items()函数以列表返回可遍历的(键值)对元组数组.
• items()语法

d={'a':24,'g':52,'i':12,'k':33}
d.items()
# 结果是:[('a', 24), ('g', 52), ('i', 12), ('k', 33)]
# 按照值对d进行排序
d1=sorted(d.items(),key=lambda x:x[1])
print(d1)
#结果是:[('g', 52), ('k', 33), ('a', 24), ('i', 12)]

• sorted() 函数,可以接收一个key函数来实现自定义的排序,例如按绝对值大小排序
• time.clock()是统计cpu时间 的工具，这在统计某一程序或函数的执行速度最为合适。两次调用time.clock()函数的差值即为程序运行的cpu时间。

# 自己实现列表count函数
l = [1,2,3,4,5,7,2,2,2,3,3]
d = {}
for i in l:
    if i in d.keys():
        d[i] += 1
    else:
        d[i] = 1
print(d)

• 5 输入某年某月某日，判断这一天是这一年的第几天?

import datetime 
def dayofyear(): 
    year = input("请输入年份：") 
    month = input("请输入月份：") 
    day = input("请输入天：") 
    date1=datetime.date(year=int(year)，month=int(month)，day=int(day)) 
    date2=datetime.date(year=int(year)，month=1，day=1) 
    return "今天是今年的第{}天".format((date1 - date2).days + 1)

• 对元素是字典的列表排序

alist =[{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
print(sorted(alist,key=lambda x:x['age'],reverse=True))
#结果是:[{'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}, {'name': 'a', 'age': 20}]

zip函数的使用和数据的分组计算

all_doc = ['Chinese Beijing Chinese','Chinese Chinese Shanghai','Chinese Macao','Tokyo Japan Chinese']
target = [1,1,1,0]
c1_dic = {}
c2_dic = {}

c1 = []
c2 = []

for a,b in zip(all_doc,target):
    if b == 1:
        c1.append(a)
    else:
        c2.append(a)

for i in c1:
    for j in i.split(' '):
        if j in c1_dic.keys():
            c1_dic[j] += 1
        else:
            c1_dic[j] = 1

for i in c2:
    for j in i.split(' '):
        if j in c2_dic.keys():
            c2_dic[j] += 1
        else:
            c2_dic[j] = 1

print(c1_dic)
print(c2_dic)
#c1_dic: {'Chinese': 5, 'Beijing': 1, 'Shanghai': 1, 'Macao': 1}
#c2_dic: {'Tokyo': 1, 'Japan': 1, 'Chinese': 1}

用set不打乱顺序给列表去重

l1 = ['b','c','d','b','c','a','a']
set1 = set(l1)
l2 = sorted(list(set1),key=l1.index)
print(l2)
#结果:['b', 'c', 'd', 'a']

函数参数为list中的坑

def f(x,li=[]):
    for i in range(x):
        li.append(i*i)
    print(li)
f(4)
#运算结果:[0, 1, 4, 9]
f(5)
#运算结果:[0, 1, 4, 9, 0, 1, 4, 9, 16]

当定义函数时，会保存函数中默认参数 list的值，也就是列表 li=[]；

在每次调用的时候如果传递了新的列表，则使用传递的列表，没有传递，使用定义函数时保存的默认参数（li=[]）；

上面两次调用中，都没有传递新的列表（使用默认列表 li=[] ），程序会调用定义函数时保存的默认参数(（li=[]）);

列表在append的时候会在 li=[] 原来的基础上append追加值，所以会产生以上结果.

• 通过打印列表的ID进行辨识

def f(x,li=[]):
    print('id:',id(li))
    for i in range(x):
        li.append(i*i)
    print(li)

f(4)
#id: 2154086435336
#结果:[0, 1, 4, 9]
f(5)
#id: 2154086435336
#结果:[0, 1, 4, 9, 0, 1, 4, 9, 16]

• 会发现ID值是相同的;
• 说明两次执行时使用的都是定义函数时的默认参数 li=[ ]

执行时往里面传新的列表

def f(x,li=[]):
    for i in range(x):
        li.append(i*i)
    print(li)
f(4)
#结果:[0, 1, 4, 9]
f(5,[])
#结果:[0, 1, 4, 9, 16]
f(6)
#结果:[0, 1, 4, 9, 0, 1, 4, 9, 16, 25]

• 当传递空列表时,函数体当中会使用传递的空列表，没有传递时，使用函数默认值 li=[ ], 所以会产生以上结果。

优化方案

• 如果想要达到预期的结果,只需要在函数体里进行判断即可:

def f(x, li=[]):
    if not li:
        # 如果li不为空的话,就往下走(清空列表); 为空就不走
        li = []
    for i in range(x):
        li.append(i * i)
    print(li)
f(4)
#结果:[0, 1, 4, 9]
f(5)
#结果:[0, 1, 4, 9,16]
f(6)
#结果:[0, 1, 4, 9,16,25]

高级函数

• map(func,iter);两个参数,前面是一个函数,后面的是一个可迭代对象
• 将后面可迭代对象遍历,每个元素用前面函数处理一遍,然后返回,保存这种算法的迭代器

lt = [1, 2, 3, 4, 5]
ret = list(map(lambda x:x+1, lt))
print(ret)
#结果: [2, 3, 4, 5, 6]

• filter(func,iterable);
• 使用func依次作用于可迭代对象中的每个元素,当返回结果为True时保留该元素,返回filter对象,是一个迭代器

lt = [1, 2, 3, 4, 5]
ret = list(filter(lambda x:x%2==0,lt))
print(ret)
#结果: [2,4]

• reduce(func,sequence);前面函数,后面序列
• 首先从序列中取出前两个元素,作为前面函数的参数处理一下
• 处理完的结果与下一个元素在用函数处理
• 处理结束,最后返回的是一个计算结果

from functools import reduce
lt = [1, 2, 3, 4, 5]
ret = reduce(lambda x,y: x*10 + y, lt)
print(ret)
# 结果: 12345

• enumerate()函数

li = [5,7,20,34,6]
l2 = [i for i in enumerate(li)]
print(l2)
#结果:[(0, 5), (1, 7), (2, 20), (3, 34), (4, 6)]

d = {x:y for x,y in enumerate(li)}
print(d)
#结果:{0: 5, 1: 7, 2: 20, 3: 34, 4: 6}

• zip()函数,可以把两个 list 变成一个 list

print({i:j for i,j in zip([1,2,3],['a','b','c'])})
#结果:{1: 'a', 2: 'b', 3: 'c'}

手写一个单例模式

class Afirst(object):
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = object.__new__(cls)
            return cls._instance
        else:
            return cls._instance
obj = Afirst()
obj2 = Afirst()
print(id(obj))
print(id(obj2))
#结果:2554933905336
#结果:2554933905336

单例模式的应用场景

• 日志文件,应用配置
• 控制资源的情况下，方便资源之间的互相通信。
• 如:1.网站计数器;2.多线程池;3.数据库配置;4.数据库连接池;5.应用程序的日志应用

装饰器的作用

• 装饰器本质上是一个 Python 函数，它可以在让其他函数在不需要做任何代码的变动的前提下增加额外的功能。装饰器的返回值也是一个函数的对象，它经常用于有切面需求的场景。比如：插入日志、性能测试、事务处理、缓存,权限的校验等场景 有了装饰器就可以抽离出大量的与函数功能本身无关的雷同代码并发并继续使用。

def timelapses(func):
    def wrapper():
        start = time.clock()
        func()
        end = time.clock()
        print(end - start)
    return wrapper

@timelapses
def f():
    print('info:')
f()
#结果: 2.1460448859283836e-05

• @property
• 负责把一个方法变成属性调用的：

列表生成式

• 将list中得大写字符转为小写

res = ['HWt', 'Python',456, 'Random', 'BEST', 123]
print([x.lower() if isinstance(x, str) else x for x in res])
#结果:['hwt', 'python', 456, 'random', 'best', 123]

• 把1-100中数每三个一组放入列表

print([[x for x in range(1,100)][i:i+3] for i in range(0,100,3)])

• ajax跨域? 怎么解决?

当前发起的请求的域与该请求指向的资源所在的域不一致,当协议+域名+端口号均相同，那么就是同一个域,

• 服务端解决
• #django的解决办法:

# 1.安装django-cors-headers
# 2.配置settings.py文件
INSTALLED_APPS = [
    ...
    'corsheaders'，
    ...
 ] 
 MIDDLEWARE_CLASSES = (
    ...
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware', # 注意顺序
    ...
)
#跨域增加忽略
CORS_ALLOW_CREDENTIALS = True
CORS_ORIGIN_ALLOW_ALL = True
CORS_ORIGIN_WHITELIST = (
    '*'
)

• #flask的解决办法:

• 客服端解决

# 使用jsonp 解决