python---进阶篇【函数使用技巧/注意事项】

1. 函数使用

map()

• map(func, seq1[, seq2,…])：处理值到函数的映射。func表示函数名，seq为序列，若函数的参数有多个则需多个序列。返回以序列为参数的func的结果序列，是一个可迭代对象，也可以直接遍历。
  注：在python2中结果以list对象返回，在python3中结果以map对象返回，一般会在外层将其转化为list。

# example 1
x = list(map(lambda x: x % 2, range(7)))
x  # [0, 1, 0, 1, 0, 1, 0]

# example 2
def f1(a):
    return 2*a

def f2(a,b):
    return a+b

x = list(map(f1,[1,2,3,4]))
print(x)
y = list(map(f2,[1,2,3,4],[4,3,2,1]))
print(y)
# [2, 4, 6, 8]
# [5, 5, 5, 5]

# example 3
a = map(f1,[0,2,3,4])
for i in a:
    print(i,end=' ')
# 0 4 6 8 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

reduce()

• reduce(function, sequence, initial=None):会对参数序列中元素进行function操作。
• ps：Python3.x reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：

from functools import reduce

def add(x, y) :            # 两数相加
    return x + y
sum1 = reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
sum1 = reduce(add, [1,2,3,4,5], 6) #设置初始值为6，则结果为6+1+2+3+4+5
print(sum1)  #15
print(sum2)  #15
print(sum2)  # 21
1
2
3
4
5
6
7
8
9
10

to_2tuple()

• 说明：将其他数据转换为tuple数据类型，中间的数字表示心新元组的长度
• ps:需要导入第三方库
• to_3tuple()：转换为长度为3的tuple

from timm.models.layers import to_2tuple,to_3tuple  # 导入
a = 224
b = to_2tuple(a)
c = to_3tuple(a)
print("a:{},b:{},c:{}".format(a,b,c))  # a:224,b:(224, 224),c:(224, 224, 224)
print(type(a),type(b))   #  
1
2
3
4
5
6

shutil.copy2(src,dst)

用于将src的文件复制到dst，dst可以是目录或文件名

import shutil
# shutil.copy2(【要被复制的文件】,【复制后存放的位置】)
shutil.copy2("D:/TOOLS/public.txt","D:/fart/a/b/c/d/e/kok/")  #文件名没指定默认为src文件名

import shutil

#shutil.copy2(【要被复制的文件】,【复制后存放的文件】)，指定文件名
shutil.copy2("D:/TOOLS/public.txt","D:/fart/a/b/c/d/e/kok/HH.txt")
shutil.copy2("D:/TOOLS/public.txt","D:/fart/a/b/c/d/e/kok/HH.so")
shutil.copy2("D:/TOOLS/public.txt","D:/fart/a/b/c/d/e/kok/666")
1
2
3
4
5
6
7
8
9
10

zip()

zip([iterable, ...])：zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。注意返回的是对象，通常会将其转换成列表进行访问

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped

>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在处理数据方面可以实现数据打乱

import random
X = [1, 2, 3, 4, 5, 6]
y = [0, 1, 0, 0, 1, 1]
zipped_data = list(zip(X, y))  
# 将样本和标签一 一对应组合起来,并转换成list类型方便后续打乱操作

random.shuffle(zipped_data)  
# 使用random模块中的shuffle函数打乱列表，原地操作，没有返回值

new_zipped_data = list(map(list, zip(*zipped_data)))  
# zip(*)反向解压，map()逐项转换类型，list()做最后转换

new_X, new_y = new_zipped_data[0], new_zipped_data[1] 
1
2
3
4
5
6
7
8
9
10
11
12
13

sort()和sorted()

区别：sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

• sorted(iterable, cmp=None, key=None, reverse=False)
  iterable：可迭代对象
  cmp：比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0
  key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  reverse：排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

参考链接：教程文档

vars()

vars(obj) ---> dictionary

• 作用：将对象转换为字典对象并返回。常常用于将opt（初始化参数）转化为字典写入本地

opt = opts.parse_opts()
vars(opt)
1
2

getattr()

• getattr(obj, attr[, default]：返回一个对象的属性值，若该对象没有该属性，返回默认值default

以下实例展示了 getattr 的使用方法：
 
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
3
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 其他使用

assert用法

• 用于判断一个表达式，在表达式条件为 false 的时候触发异常。断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况，例如代码只能在 Linux 系统下运行，可以先判断当前系统是否符合条件。

def  zero(s):
    a = int(s)
    assert a > 0,"a超出范围"   #这句的意思：如果a确实大于0，程序正常往下运行
    return a

zero("-2")  #但是如果a是小于0的，程序会抛出AssertionError错误，报错为参数内容“a超出范围”

# 报错
Traceback (most recent call last):
  File "e:\Python_list\class_student\temp.py", line 6, in 
    zero("-2")
  File "e:\Python_list\class_student\temp.py", line 3, in zero
    assert a > 0,"a超出范围"
AssertionError: a超出范围
1
2
3
4
5
6
7
8
9
10
11
12
13
14

bytes 和 string 相互转换

• bytes一般用于在文件中存储（计算机识别），string一般用于输出打印（人识别）。string经过编码（encode）转化为二进制对象，用于计算机识别；bytes经过解码（decode）转化为string，用于打印输出给人看
  字节对象：b'example'； 字符串对象：'example'
• 将string转化为bytes

s = 'hello'
# 方式1：必须指定编码方式
b = bytes(s,encoding='utf8')
print(b)  # b'hello'

# 方式2：
b1 = s.encode()  # b'hello'
b2 = str.encode(s)  # b'hello'
1
2
3
4
5
6
7
8

• 将bytes转化为string

s1 = bytes.decode(b)  # hello
s2 = b.decode()  # hello
1
2

*和**的用法

• 在算术计算中*和**分别表示乘法和乘方运算

（1）*的使用

• 在函数定义中作为参数（打包）：*parameter表示接收任意多个参数并将其放在一个元组中

 def demo(*p):
    print(p)
    
demo(1,2,3)
# (1, 2, 3)
1
2
3
4
5

• 在函数调用中作为参数（解包）：* sequence在列表、元组、集合等可迭代对象前作为实参，解释器将自动进行解包将可迭代对象中的元素对应传给参数

z = (1,2,3)
print(*z)
#123
1
2
3

• 用于元组拆包

>>> fruits = ['lemon', 'pear', 'watermelon', 'tomato']
>>> first, second, *remaining = fruits
>>> remaining
['watermelon', 'tomato']
>>> first, *remaining = fruits
>>> remaining
['pear', 'watermelon', 'tomato']
>>> first, *middle, last = fruits
>>> middle
['pear', 'watermelon']
1
2
3
4
5
6
7
8
9
10

（2）**的使用

• 在函数定义中作为参数：将该函数的参数转换为字典，打包

def demo(**p):
	return p

demo(a=1, b=2)
# {'a':1, 'b':2}
1
2
3
4
5

• 用于可迭代变量前：将其解包

dic  = {'a':1, 'b':2, 'c':3}
str = '{a}-{b}-{c}'.format(**dic)  # '1,2,3'
1
2

参考链接：详解python中*号的用法
python中*的用法
python中的*与**