wordpress 静态IP Mxnet 做推广 CPU docker安装 image mobile sms Web Uploader pmp视频 easyui视频 多商户商城模板 mysql增删改查语句 网络游戏server编程 java接收数组 docker保存镜像 kubernetes视频 mysql新建数据库 mysql入门 python搭建网站 java获取当前年份 java运行环境 java文档 java重载和重写的区别 flash相册制作 p6软件 抖音代码 spss20安装教程 ie拒绝访问 4k对齐是什么意思 摇骰子表情包 斐讯k3刷机 趣学python编程 ps描边怎么用 cdr群组快捷键 包图小白体 1000kbps php递归函数 unpack
当前位置: 首页 > 学习教程  > 编程语言

CS231N 01:Python Numpy Tutorial

2021/1/13 19:54:48 文章标签: 测试文章如有侵权请发送至邮箱809451989@qq.com投诉后文章立即删除

CS231N教程链接:HTML 说明:本文为个人学习笔记,省略了教程中的一些基础知识,同时扩充了一部分内容。 文章目录PythonBasic data typesContainers1. List2. Dictinary3. Set4. TuplesFunctionsClassesNumPyArraysArray indexingDat…

CS231N教程链接:HTML


说明:本文为个人学习笔记,省略了教程中的一些基础知识,同时扩充了一部分内容。


文章目录

  • Python
    • Basic data types
    • Containers
      • 1. List
      • 2. Dictinary
      • 3. Set
      • 4. Tuples
    • Functions
    • Classes
  • NumPy
    • Arrays
    • Array indexing
    • Datatypes
    • Array math
    • Broadcasting


Python

Basic data types

字符串对象具有一些有用的方法,例如:

s = 'hello'

print(s.capitalize())  # Capitalize a string; prints "Hello"
print(s.upper())       # Convert a string to uppercase; prints "HELLO"
print(s.rjust(7))      # Right-justify a string, padding with spaces; prints "  hello"
print(s.center(7))     # Center a string, padding with spaces; prints " hello "
print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another;
                                # prints "he(ell)(ell)o"
print('  world '.strip())  # Strip leading and trailing whitespace; prints "world"

Containers

Python 包括几种内置的容器类型:列表(list)、字典(dictionary)、集合(set)和元组(tuple)。

1. List

列表相当于一个数组,但它是可调整大小的,并且可以包含不同类型的元素。

xs = [3, 1, 2]    # Create a list

print(xs, xs[2])  # Prints "[3, 1, 2] 2"
print(xs[-1])     # Negative indices count from the end of the list; prints "2"

xs[2] = 'foo'     # Lists can contain elements of different types
print(xs)         # Prints "[3, 1, 'foo']"

xs.append('bar')  # Add a new element to the end of the list
print(xs)         # Prints "[3, 1, 'foo', 'bar']"

x = xs.pop()      # Remove and return the last element of the list
print(x, xs)      # Prints "bar [3, 1, 'foo']"

其他方法(官方文档):

- list.extend(iterable)
- list.insert(i, x)
- list.remove(x)
- list.pop([i])
- list.clear()
- list.index(x[, start[, end]])
- list.count(x)
- list.sort(key=None, reverse=False)
- list.reverse()
- list.copy()

切片(Slicing)。除了一次访问一个列表元素之外,Python 还提供了简明的语法来访问子列表,即切片。注:Python切片为前闭后开

nums = list(range(5))     # range is a built-in function that creates a list of integers
print(nums)               # Prints "[0, 1, 2, 3, 4]"

print(nums[2:4])          # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print(nums[2:])           # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print(nums[:2])           # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"

print(nums[:])            # Get a slice of the whole list; prints "[0, 1, 2, 3, 4]"

print(nums[:-1])          # Slice indices can be negative; prints "[0, 1, 2, 3]"

nums[2:4] = [8, 9]        # Assign a new sublist to a slice
print(nums)               # Prints "[0, 1, 8, 9, 4]"

List comprehension:

nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)   # Prints [0, 1, 4, 9, 16]

List comprehensions can also contain conditions:

nums = [0, 1, 2, 3, 4]
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(even_squares)  # Prints "[0, 4, 16]"

2. Dictinary

字典(Dictinary)存储键值对,类似于Java中的Map或Javascript中的对象。常用方法如下:

d = {'cat': 'cute', 'dog': 'furry'}  # Create a new dictionary with some data
print(d['cat'])       # Get an entry from a dictionary; prints "cute"
print('cat' in d)     # Check if a dictionary has a given key; prints "True"
d['fish'] = 'wet'     # Set an entry in a dictionary
print(d['fish'])      # Prints "wet"
# print(d['monkey'])  # KeyError: 'monkey' not a key of d
print(d.get('monkey', 'N/A'))  # Get an element with a default; prints "N/A"
print(d.get('fish', 'N/A'))    # Get an element with a default; prints "wet"
del d['fish']         # Remove an element from a dictionary
print(d.get('fish', 'N/A')) # "fish" is no longer a key; prints "N/A"

其他方法(官方文档):

- len(d)
- key not in d
- iter(d):equalent to iter(d.keys())
- d.clear()
- d.copy()
- d.get(key[, default])
- d.items()
- d.keys()
- d.pop(key[, default])
- d.popitem()
- d.setdefault(key[, default])
- d.update([other])
- d.keys()
- d.values()

如果想访问键和对应的值,可使用 items 方法:

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal, legs in d.items():
    print('A %s has %d legs' % (animal, legs))
# Prints "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"
nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print(even_num_to_square)  # Prints "{0: 0, 2: 4, 4: 16}"

3. Set

集合(set)是由不同元素组成的无序集合。常用方法如下:

animals = {'cat', 'dog'}
print('cat' in animals)   # Check if an element is in a set; prints "True"
print('fish' in animals)  # prints "False"
animals.add('fish')       # Add an element to a set
print('fish' in animals)  # Prints "True"
print(len(animals))       # Number of elements in a set; prints "3"
animals.add('cat')        # Adding an element that is already in the set does nothing
print(len(animals))       # Prints "3"
animals.remove('cat')     # Remove an element from a set
print(len(animals))       # Prints "2"

其他方法(官方文档)。

在集合上迭代的语法与在列表上迭代的语法相同;但由于集合是无序的,所以不能假设访问集合元素的顺序。

animals = {'cat', 'dog', 'fish'}
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))
# Prints "#1: fish", "#2: dog", "#3: cat"

4. Tuples

元组是一个(不可改变的)有序值列表。元组在许多方面与列表相似;其中最重要的区别是元组可以作为字典中的键和集合的元素使用,而列表不能。下面是一个简单的例子。

d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys
t = (5, 6)        # Create a tuple
print(type(t))    # Prints "<class 'tuple'>"
print(d[t])       # Prints "5"
print(d[(1, 2)])  # Prints "1"

Functions

def sign(x):
    if x > 0:
        return 'positive'
    elif x < 0:
        return 'negative'
    else:
        return 'zero'

for x in [-1, 0, 1]:
    print(sign(x))
# Prints "negative", "zero", "positive"

更多信息可参考官方文档:Python Functions。


Classes

在Python中定义类的语法是直接的。

class Greeter(object):
    # Constructor
    def __init__(self, name):
        self.name = name  # Create an instance variable

    # Instance method
    def greet(self, loud=False):
        if loud:
            print('HELLO, %s!' % self.name.upper())
        else:
            print('Hello, %s' % self.name)

g = Greeter('Fred')  # Construct an instance of the Greeter class
g.greet()            # Call an instance method; prints "Hello, Fred"
g.greet(loud=True)   # Call an instance method; prints "HELLO, FRED!"

更多信息可参考官方文档:Python Classes。


NumPy

numpy数组是一个值的网格,所有的值都是相同的类型,由一个非负整数元组索引。数组的维数是数组的等级;数组的形状是一个整数元组,给出了数组在每个维度上的大小。可以从嵌套的 Python 列表中初始化 numpy 数组,并使用方括号访问元素。

Arrays

import numpy as np

a = np.zeros((2,2))   # Create an array of all zeros
print(a)              # Prints "[[ 0.  0.]
                      #          [ 0.  0.]]"

b = np.ones((1,2))    # Create an array of all ones
print(b)              # Prints "[[ 1.  1.]]"

c = np.full((2,2), 7)  # Create a constant array
print(c)               # Prints "[[ 7.  7.]
                       #          [ 7.  7.]]"

d = np.eye(2)         # Create a 2x2 identity matrix
print(d)              # Prints "[[ 1.  0.]
                      #          [ 0.  1.]]"

e = np.random.random((2,2))  # Create an array filled with random values
print(e)                     # Might print "[[ 0.91940167  0.08143941]
                             #               [ 0.68744134  0.87236687]]"

Array indexing

与Python列表类似,numpy数组也可以被切片。由于数组可能是多维的,所以必须为数组的每个维度指定一个切片。

# Create the following rank 2 array with shape (3, 4)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

# Use slicing to pull out the subarray consisting of the first 2 rows
# and columns 1 and 2; b is the following array of shape (2, 2):
# [[2 3]
#  [6 7]]
b = a[:2, 1:3]

# A slice of an array is a view into the same data, so modifying it
# will modify the original array.
print(a[0, 1])   # Prints "2"
b[0, 0] = 77     # b[0, 0] is the same piece of data as a[0, 1]
print(a[0, 1])   # Prints "77"

Datatypes

每个numpy数组都是由相同类型的元素组成的网格。Numpy提供了大量的数字数据类型,可以用它们来构造数组。当创建一个数组时,Numpy会尝试猜测一个数据类型,但是构造数组的函数通常也会包含一个可选的参数来明确指定数据类型。

import numpy as np

x = np.array([1, 2])   # Let numpy choose the datatype
print(x.dtype)         # Prints "int64"

x = np.array([1.0, 2.0])   # Let numpy choose the datatype
print(x.dtype)             # Prints "float64"

x = np.array([1, 2], dtype=np.int64)   # Force a particular datatype
print(x.dtype)                         # Prints "int64"

Array math

基本数学函数在数组上进行元素操作,既可以作为运算符重载,也可以作为numpy模块中的函数。

import numpy as np

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

# Elementwise sum; both produce the array
# [[ 6.0  8.0]
#  [10.0 12.0]]
print(x + y)
print(np.add(x, y))

# Elementwise difference; both produce the array
# [[-4.0 -4.0]
#  [-4.0 -4.0]]
print(x - y)
print(np.subtract(x, y))

# Elementwise product; both produce the array
# [[ 5.0 12.0]
#  [21.0 32.0]]
print(x * y)
print(np.multiply(x, y))

# Elementwise division; both produce the array
# [[ 0.2         0.33333333]
#  [ 0.42857143  0.5       ]]
print(x / y)
print(np.divide(x, y))

# Elementwise square root; produces the array
# [[ 1.          1.41421356]
#  [ 1.73205081  2.        ]]
print(np.sqrt(x))

请注意,与MATLAB不同,*是元素乘法,而不是矩阵乘法。使用dot函数来计算向量的内积,dot既可以作为numpy模块中的函数,也可以作为数组对象的实例方法。

import numpy as np

x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])

v = np.array([9,10])
w = np.array([11, 12])

# Inner product of vectors; both produce 219
print(v.dot(w))
print(np.dot(v, w))

# Matrix / vector product; both produce the rank 1 array [29 67]
print(x.dot(v))
print(np.dot(x, v))

# Matrix / matrix product; both produce the rank 2 array
# [[19 22]
#  [43 50]]
print(x.dot(y))
print(np.dot(x, y))

Numpy 提供了许多有用的函数来对数组进行计算,其中最有用的是 sum:

import numpy as np

x = np.array([[1,2],[3,4]])

print(np.sum(x))  # Compute sum of all elements; prints "10"
print(np.sum(x, axis=0))  # Compute sum of each column; prints "[4 6]"
print(np.sum(x, axis=1))  # Compute sum of each row; prints "[3 7]"

要转置一个矩阵,只需使用数组对象的T属性。

import numpy as np

x = np.array([[1,2], [3,4]])
print(x)    # Prints "[[1 2]
            #          [3 4]]"
print(x.T)  # Prints "[[1 3]
            #          [2 4]]"

# Note that taking the transpose of a rank 1 array does nothing:
v = np.array([1,2,3])
print(v)    # Prints "[1 2 3]"
print(v.T)  # Prints "[1 2 3]"

Broadcasting

广播是一种强大的机制,它允许numpy在执行算术运算时对不同形状的数组进行操作。例如多次使用较小的数组对较大的数组进行一些操作。

例如,假设我们想给矩阵的每一行添加一个常量向量。我们可以这样做。

import numpy as np

# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = np.empty_like(x)   # Create an empty matrix with the same shape as x

# Add the vector v to each row of the matrix x with an explicit loop
for i in range(4):
    y[i, :] = x[i, :] + v

# Now y is the following
# [[ 2  2  4]
#  [ 5  5  7]
#  [ 8  8 10]
#  [11 11 13]]
print(y)

这很有效;但是当矩阵 x 非常大时,在 Python 中计算显式循环可能会很慢。需要注意的是,将向量v加到矩阵x的每一行,相当于通过将v的多个副本垂直堆叠形成一个矩阵vv,然后对x和vv进行元素求和,我们可以这样实现这种方法。

import numpy as np

# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
vv = np.tile(v, (4, 1))   # Stack 4 copies of v on top of each other
print(vv)                 # Prints "[[1 0 1]
                          #          [1 0 1]
                          #          [1 0 1]
                          #          [1 0 1]]"
y = x + vv  # Add x and vv elementwise
print(y)  # Prints "[[ 2  2  4
          #          [ 5  5  7]
          #          [ 8  8 10]
          #          [11 11 13]]"

Numpy 广播允许在不实际创建 v 的多个副本的情况下进行这种计算,考虑使用广播的这个版本。

import numpy as np

# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = x + v  # Add v to each row of x using broadcasting
print(y)  # Prints "[[ 2  2  4]
          #          [ 5  5  7]
          #          [ 8  8 10]
          #          [11 11 13]]"

即使x的形状是(4,3),v的形状是(3,),由于广播的原因,这条线y=x+v也能用;这条线的工作原理就像v实际的形状是(4,3)一样,其中每一行都是v的副本,并按元素进行求和。

将两个数组一起广播遵循以下规则:

  • 如果两个数组的秩(rank)不一样,则在等级较低的数组的形状前加上1,直到两个形状的长度相同。
  • 如果两个数组在一个维度中具有相同的大小,或者其中一个数组在该维度中具有1的大小,则可以说这两个数组是兼容的。
  • 如果两个数组在所有维度上都兼容,那么它们可以一起广播。
  • 广播后,每个数组的形状等于两个输入数组的元素最大形状。
  • 在任何维度上,如果一个数组的大小为1,而另一个数组的大小大于1,则第一个数组的行为就像沿着这个维度复制一样。

更多信息可参考文档中的解释或这个解释。

支持广播的函数被称为通用函数(universal functions),可以在文档中找到所有通用函数的列表。

以下是广播的一些应用。

import numpy as np

# Compute outer product of vectors
v = np.array([1,2,3])  # v has shape (3,)
w = np.array([4,5])    # w has shape (2,)
# To compute an outer product, we first reshape v to be a column
# vector of shape (3, 1); we can then broadcast it against w to yield
# an output of shape (3, 2), which is the outer product of v and w:
# [[ 4  5]
#  [ 8 10]
#  [12 15]]
print(np.reshape(v, (3, 1)) * w)

# Add a vector to each row of a matrix
x = np.array([[1,2,3], [4,5,6]])
# x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),
# giving the following matrix:
# [[2 4 6]
#  [5 7 9]]
print(x + v)

# Add a vector to each column of a matrix
# x has shape (2, 3) and w has shape (2,).
# If we transpose x then it has shape (3, 2) and can be broadcast
# against w to yield a result of shape (3, 2); transposing this result
# yields the final result of shape (2, 3) which is the matrix x with
# the vector w added to each column. Gives the following matrix:
# [[ 5  6  7]
#  [ 9 10 11]]
print((x.T + w).T)
# Another solution is to reshape w to be a column vector of shape (2, 1);
# we can then broadcast it directly against x to produce the same
# output.
print(x + np.reshape(w, (2, 1)))

# Multiply a matrix by a constant:
# x has shape (2, 3). Numpy treats scalars as arrays of shape ();
# these can be broadcast together to shape (2, 3), producing the
# following array:
# [[ 2  4  6]
#  [ 8 10 12]]
print(x * 2)


本文链接: http://www.dtmao.cc/news_show_600199.shtml

附件下载

相关教程

    暂无相关的数据...

共有条评论 网友评论

验证码: 看不清楚?