Python易错总结

发表于 | 分类于

摘要：易错点

1. range(),arange()函数区别

Python 中的range,以及numpy包中的arange函数

1.1 range()函数：

  • 函数说明： range(start, stop[, step]) -> range object，根据start与stop指定的范围以及step设定的步长，生成一个序列，步长不能为float,，默认为1。

  • 参数含义：start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）;

    end:技术到end结束，但不包括end.例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

       scan：每次跳跃的间距，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
  • range返回一个list
1
2
3
4
5
6
7
8
>>> range(0,5) 			 	#生成一个range object,而不是[0,1,2,3,4] 
range(0, 5)   
>>> c = [i for i in range(0,5)] 	 #从0 开始到4，不包括5，默认的间隔为1
>>> c
[0, 1, 2, 3, 4]
>>> c = [i for i in range(0,5,2)] 	 #间隔设为2
>>> c
[0, 2, 4]

1.2 arrange()函数

  • 函数说明：arange([start,] stop[, step,], dtype=None)根据start与stop指定的范围以及step设定的步长，步长可以是float，生成一个 ndarray。 
1
2
3
4
5
6
7
8
9
10
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0.,  1.,  2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])
>>> arange(0,1,0.1)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

#2. list、array、matrix的区别

2.1 numpy

NumPy的主要对象是同种元素的多维数组。这是一个所有的元素都是一种类型、通过一个正整数元组索引的元素表格(通常是元素是数字)。在NumPy中维度(dimensions)叫做轴(axes)，轴的个数叫做秩(rank，但是和线性代数中的秩不是一样的，在用python求线代中的秩中，我们用numpy包中的linalg.matrix_rank方法计算矩阵的秩。

列表属于python的三种基本集合类型之一, 其他两种是元组(tuple)和字典(dict). tuple和list区别主要在于是不是mutable（可变）的.

list和java里的数组不同之处在于, python的list可以包含任意类型的对象, 一个list里可以包含int, string或者其他任何对象, 另外list是可变长度的(list有append, extend和pop等方法).

所以, python内建的所谓”列表”其实是功能很强大的数组, 类比一下可以说它对应于java里面的ArrayList .

2.2 ndarray多维数组

  • ndarray是numpy的基石, 其实它更像一个java里面的标准数组: 所有元素有一个相同数据类型(dtype), 不过大小不是固定的.
  • ndarray对于大计算量的性能非常好, 所以list要做运算的时候一定要先转为np.array(a_list)).数组转化为列表：a.tolist()
  • ndarray带有一些非常实用的函数, 列举几个常用的: sum, cumsum, argmax, reshape, T, …
  • ndarray有fancy indexing, 非常实用, 比如: a[a>3] 返回数组里大于3的元素
  • ndarray之间的乘法: 如果用乘法运算符*的话, 返回的是每个位置元素相乘(类似matlab里面的.*), 想要矩阵相乘需要用dot().
  • 常见矩阵的生成: ones, zeros, eye, diag, …

2.3 matrix矩阵

matrix是ndarray的子类, 所以前面ndarray那些优点都保留了.

同时, matrix全部都是二维的, 并且加入了一些更符合直觉的函数, 比如对于matrix对象而言, 乘号运算符得到的是矩阵乘法的结果. 另外mat.I就是逆矩阵…

不过应用最多的还是ndarray类型.

3. multiply、dot、 * 和matmul

3.1. np.multiply()函数

函数作用： 数组和矩阵对应位置相乘，输出与相乘数组/矩阵的大小一致

3.2 np.dot()函数

函数作用：

  • 对于秩为1的数组，执行对应位置相乘，然后再相加；
  • 对于秩不为1的二维数组或者矩阵，执行矩阵乘法运算；超过二维的可以参考numpy库介绍。

3.3 星号（*）乘法运算

函数作用：

  • 对数组执行对应位置相乘

  • 对矩阵执行矩阵乘法运算

    参考链接

3.4 matmul()

两个数组的矩阵乘积。不允许使用标量乘法，*可以使用

matmul与dot基本一样，但有两个方面的不同：

  • 不允许使用标量进行乘法运算。
  • 矩阵堆栈一起广播，就好像矩阵是元素一样。

4. randn()与rand()的区别

numpy中有一些常用的用来产生随机数的函数，randn()和rand()就属于这其中。

numpy.random.randn(d0, d1, …, dn)是从标准正态分布中返回一个或多个样本值。

numpy.random.rand(d0, d1, …, dn)的随机样本位于[0, 1)中。

1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np 

arr1 = np.random.randn(2,4)
print(arr1)
print('*****************************')
arr2 = np.random.rand(2,4)
print(arr2)

[[-1.03021018  0.5197033   0.52117459 -0.70102661]
 [ 0.98268569  1.21940697 -1.095241   -0.38161758]]
**********************************
[[ 0.19947349  0.05282713  0.56704222  0.45479972]
 [ 0.28827103  0.1643551   0.30486786  0.56386943]]

5. filter()

1
filter(function, iterable)

用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

1
2
3
4
5
6
7
8
def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)

[1, 3, 5, 7, 9]

6. lambda 表达式

1
lambda argument_list: expression

参数列表由逗号分隔的参数列表组成，表达式是使用这些参数的算术表达式。您可以将函数分配给变量以为其指定名称。

1
2
3
>>> sum = lambda x，y：x + y
>>>sum(3,4）
7

7. zip()

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

可以使用 list() 转换来输出列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

1
zip([iterable, ...])
  • iterabl – 一个或多个迭代器;
  • 返回一个对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> 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]

8. set()

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

1
class set([iterable])
  • iterable – 可迭代对象对象
1
2
3
4
5
6
7
8
9
10
>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])

9. format

格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

# 通过元组设置参数
site = ("name", "菜鸟教程", "url", "www.runoob.com")
print('{}-{}-{}-{}'.format(*site))
>>> name-菜鸟教程-url-www.runoob.com