字典翻转

首先我们来看字典的翻转，假设我们有下面类似的一个字典对象与数据

car_dict = { 
    "brand":"Tesla", 
    "model": "Model Y", 
    "year": 2017
}

倘若我们想要翻转字典当中的键值对，可以这么来做

d2 = {}
for k, v in car_dict.items():
    d2[v] = k
print(d2)

output

{'Tesla': 'brand', 'Model Y': 'model', 2017: 'year'}

结果的键值对就产生了对调，当然我们也还有更加简单的方法，代码如下

d3 = dict(map(reversed, car_dict.items()))
print(d3)

output

{'Tesla': 'brand', 'Model Y': 'model', 2017: 'year'}

lambda()和map()

上面的代码当中用到了map()方法，那小编这里就着重说说，map()方法可以和lambda()方法联用，代码如下

li = [5, 10, 22, 30, 50, 65, 70]
final_list = list(map(lambda x: x*2, li))
print(final_list)

output

[10, 20, 44, 60, 100, 130, 140]

我们先有lambda()方法来定义一个函数，然后通过map()方法映射到列表当中的每一个元素，最后仍然以列表的形式返回，

给列表当中的字典排序

有时候我们也需要根据特定的条件针对列表当中的字典排序，例如

dicts_lists = [ 
  { 
    "Name" :  "Tony" , 
    "Age" : 20, 
  }, 
  { 
     "Name" :  "May" , 
     "Age" : 14, 
  }, 
  { 
    "Name" :  "Katy" , 
    "Age" : 23, 
  } 

我们需要根据字典当中的“Age”字段来进行排序，代码如下

dicts_lists.sort(key=lambda x:x.get('Age'))
print(dicts_lists)

output

[{'Name': 'May', 'Age': 14}, {'Name': 'Tony', 'Age': 20}, {'Name': 'Katy', 'Age': 23}]

上面的结果是按照升序来进行排序的，要是我们需要其以降序的方式来排序，可以这么来做，代码如下

dicts_lists.sort(key=lambda x:x.get('Age'), reverse = True)
print(dicts_lists)

output

[{'Name': 'Katy', 'Age': 23}, {'Name': 'Tony', 'Age': 20}, {'Name': 'May', 'Age': 14}]

给列表当中的字符串排序

要是列表当中的都是字符串，而我们需要对其进行排序，该如何进行呢？例如

my_list = ["blue", "red", "green" ]

我们根据首字母在字母表当中的顺序来排的话，代码如下

my_list.sort()
print(my_list)

output

['blue', 'green', 'red']

要是我们根据其字符串的长度来进行排序的话，可以这么来做，代码如下

my_list = sorted(my_list, key=len)
print(my_list)

output

['red', 'blue', 'green']

根据别的列表来进行排序

有时候我们需要根据其他的列表来对本列表来一个排序，例如有下面这两个列表

a = ['blue', 'green', 'orange', 'purple', 'yellow'] 
b = [3, 2, 5, 4, 1]

我们根据列表“b”来对列表“a”进行排序，具体该怎么操作呢？代码如下

sorted_list = [v for _, v in sorted(dict(zip(b, a)).items(), key=lambda x:x[0])]
print(sorted_list)

output

['yellow', 'green', 'blue', 'purple', 'orange']

取出列表当中最大/最小的几个数

代码如下

import heapq

scores = [1, 10, 11, 2, 5, 6]
print(heapq.nlargest(3, scores))  ## 最大的3个数
print(heapq.nsmallest(3, scores))  ## 最小的3个数

output

[11, 10, 6]
[1, 2, 5]

staticmethod()函数

Python当中的staticmethod()函数可以将一个方法定义成类的静态方法，这样在调用的时候无需实例化，例如

class MyClass(object):
    @staticmethod
    def print_name(name):
        print('My name is: ', name)

不需要实例化就可以使用，例如

MyClass.print_name("John")
MyClass.print_name("Mike")

output

My name is:  John
My name is:  Mike

当然也可以在实例化之后调用方法，例如

myclass = MyClass()
myclass.print_name("John")

output

My name is:  John

classmethod函数

classmethod修饰符对应的函数也不需要被实例化，不需要self参数，取而代之的是cls参数用来调用类的属性、方法以及实例化对象

class MyClass(object):
    test1 = 1

    def func1(self):
        print('foo')

    @classmethod
    def func2(cls):
        print('func2')
        print(cls.test1)
        cls().func1() 

我们不需要实例化对象就可以调用func2()方法，代码如下

MyClass.func2()

output

func2
1
foo

深拷贝和浅拷贝

相信有不少同学会在面试的时候被问到这个问题，小编就来聊聊这两者之间的区别。

浅拷贝指的是拷贝父对象，不会拷贝对象的内部的子对象，具体大家可以看下图，

b = a.copy()，a和b是一个独立的对象，但他们的子对象还是指向统一对象(是引用)，所以当a发生了变换的时候，对应的b也会发生变换，代码如下

a = [[1, 2, 3], [4, 3, 5]]
b = list(a) # 创建一个浅拷贝
a[0][0] = 'x'

print(a)
print(b)

而深拷贝完全拷贝了父对象以及子对象，两者完全是独立的，因此当a发生了变换的时候，不会影响到b，

代码如下，不过深拷贝需要调用Python内置的copy模块

import copy
a = [[1, 2, 3], [4, 3, 5]]
b = copy.deepcopy(a)
a[0][0] = 'x'

print(a)
print(b)

output

[['x', 2, 3], [4, 3, 5]]
[[1, 2, 3], [4, 3, 5]]

*args和**kwargs的区别

两者的区别在于*args用来将参数打包成tuple给函数体使用，如下

def function(*args):
    print(args, type(args))

function(1, 2, 3)

output

(1, 2, 3) <class 'tuple'>

又如

def function(x, y, *args):
    print(x, y, args)

function(1, 2, 3, 4, 5, 6)

output

1 2 (3, 4, 5, 6)

而**kwargs打包关键字参数成dict给函数体调用

def function(**kwargs):
    print(kwargs, type(kwargs))

function(a=1)

output

{'a': 1} <class 'dict'>

但要是遇到args、*args以及**kwargs三者同时使用的时候，顺序必须保持(arg,*args,**kwargs)这个顺序

def function(arg,*args,**kwargs):
    print(arg,args,kwargs)

function(10, 70, 70, 90, a=11, b=12, c=13)

output

10 (70, 70, 90) {'a': 11, 'b': 12, 'c': 13}