10 个实用的 Python 编程技巧
作者：互联网
字典翻转
首先我们来看字典的翻转，假设我们有下面类似的一个字典对象与数据
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}
标签：10,args,name,Python,Age,编程,list,print,output 来源： https://www.cnblogs.com/yingzili/p/16654900.html