1. Introduction to Python

Python is a high-level dynamically typed multiparadigm programming language that also resembles pseudocode, for example, sorting data

def quicksort(arr) :
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

print(quicksort([3.6.8.10.1.2.1]))
# Prints "[1, 1, 2, 3, 6, 8, 10]"
Copy the code

Python’s official Chinese learning document: docs.python.org/zh-cn/3.8/c…

2. Python data types

Python includes integers, floating point numbers, booleans, and strings,

2.1 digital type

x = 3
print(type(x)) # Prints "<class 'int'>"
print(x)       # Prints "3"
print(x + 1)   # Addition; prints "4"
print(x - 1)   # Subtraction; prints "2"
print(x * 2)   # Multiplication; prints "6"
print(x ** 2)  # Exponentiation; prints "9"
x += 1
print(x)  # Prints "4"
x *= 2
print(x)  # Prints "8"
y = 2.5
print(type(y)) # Prints "<class 'float'>"
print(y, y + 1, y * 2, y ** 2) # Prints "2.5 3.5 5.0 6.25"
Copy the code

2.2 the Boolean

t = True
f = False
print(type(t)) # Prints "<class 'bool'>"
print(t and f) # Logical AND; prints "False"
print(t or f)  # Logical OR; prints "True"
print(not t)   # Logical NOT; prints "False"
print(t ! = f)# Logical XOR; prints "True"
Copy the code

Python Boolean calculation through and the or not to express in English letters, and through matlab && | | there’s a difference

2.3 character

hello = 'hello'    # String literals can use single quotes
world = "world"    # or double quotes; it does not matter.
print(hello)       # Prints "hello"
print(len(hello))  # String length; prints "5"
hw = hello + ' ' + world  # String concatenation
print(hw)  # prints "hello world"
hw12 = '%s %s %d' % (hello, world, 12)  # sprintf style string formatting
print(hw12)  # prints "hello world 12"
Copy the code

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"
Copy the code

More strings using learning: docs.python.org/3.5/library…

3 Containers

3.1 the list

A list is like an array, but can contain different, similar data

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']"
Copy the code

The list slice

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]"
Copy the code

The list of the loop

animals = ['cat'.'dog'.'monkey']
for animal in animals:
    print(animal)
# Prints "cat", "dog", "monkey", each on its own line.
Copy the code

To extract the data index for each loop, use the enumerate function

animals = ['cat'.'dog'.'monkey']
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))
# Prints "#1: cat", "#2: dog", "#3: monkey", each on its own line
Copy the code

List comprehensions convert list data to other data, for example, square list data

General for practices

nums = [0.1.2.3.4]
squares = []
for x in nums:
    squares.append(x ** 2)
print(squares)   # Prints [0, 1, 4, 9, 16]
Copy the code

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

Add judgment condition

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]"
Copy the code

3.2 the dictionary

Dictionary storage key and the value, similar to a Java map, for more information see: docs.python.org/3.5/library…

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"
Copy the code

Field traversal: Traverses dictionary keys through for

d = {'person': 2.'cat': 4.'spider': 8}
for animal in d:
    legs = d[animal]
    print('A %s has %d legs' % (animal, legs))
# Prints "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"
Copy the code

If you want to get both key and value, use the items method

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"
Copy the code

You can do the same thing for a list, for a dictionary

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}"
Copy the code

3.3 the collection

Python collections: Unordered sequences of non-repeating elements

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"
Copy the code

Collection traversal is the same as list

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

Set derivation

from math import sqrt
nums = {int(sqrt(x)) for x in range(30)}
print(nums)  # Prints "{0, 1, 2, 3, 4, 5}"
Copy the code

3.4 yuan group

Tuples can be used with dictionaries and collections, as shown in the following example

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"
Copy the code

4 function

Python functions are defined using the def keyword

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"
Copy the code

In addition, the function can define initial input arguments. In the following example, loud defaults to False

def hello(name, loud=False) :
    if loud:
        print('HELLO, %s! ' % name.upper())
    else:
        print('Hello, %s' % name)

hello('Bob') # Prints "Hello, Bob"
hello('Fred', loud=True)  # Prints "HELLO, FRED!"
Copy the code

5 classes

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!"
Copy the code

6 Numpy

Numpy is python’s core scientific computing library, which is similar to MATLAB for computing data

6.1 Numpy arrays

import numpy as np

a = np.array([1.2.3])   # Create a rank 1 array
print(type(a))            # Prints "<class 'numpy.ndarray'>"
print(a.shape)            # Prints "(3,)"
print(a[0], a[1], a[2])   # Prints "1 2 3"
a[0] = 5                  # Change an element of the array
print(a)                  # Prints "[5, 2, 3]"

b = np.array([[1.2.3], [4.5.6]])    # Create a rank 2 array
print(b.shape)                     # Prints "(2, 3)"
print(b[0.0], b[0.1], b[1.0])   # Prints "1 2 4"
Copy the code

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]]"
Copy the code

6.2 Array Indexes

An array index is the same as a list. Since an array is multi-dimensional, the index must specify each dimension

import numpy as np

# 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]
# 7 [6]]
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"
Copy the code

The array slicing is different from matlab. The array slicing is different from Mix Interger (ex :1) and only slice(ex: 1:2)

import numpy as np

# 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]])

# Two ways of accessing the data in the middle row of the array.
# Mixing integer indexing with slices yields an array of lower rank,
# while using only slices yields an array of the same rank as the
# original array:
row_r1 = a[1To:]# Rank 1 view of the second row of a
row_r2 = a[1:2To:]# Rank 2 view of the second row of a
print(row_r1, row_r1.shape)  # Prints "[5 6 7 8] (4,)"
print(row_r2, row_r2.shape)  # Prints "[[5 6 7 8]] (1, 4)"

# We can make the same distinction when accessing columns of an array:
col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print(col_r1, col_r1.shape)  # Prints "[ 2 6 10] (3,)"
print(col_r2, col_r2.shape)  # Prints "[[ 2]
                             # [6]
                             # [10]] (3, 1)"
Copy the code

 

import numpy as np

a = np.array([[1.2], [3.4], [5.6]])

# An example of integer array indexing.
# The returned array will have shape (3,) and
print(a[[0.1.2], [0.1.0]])  # Prints "[1 4 5]"
Shape (3,)
# The above example of integer array indexing is equivalent to this:
print(np.array([a[0.0], a[1.1], a[2.0]]))  # Prints "[1 4 5]"

# When using integer array indexing, you can reuse the same
# element from the source array:
print(a[[0.0], [1.1]])  # Prints "[2 2]"

# Equivalent to the previous integer array indexing example
print(np.array([a[0.1], a[0.1]]))  # Prints "[2 2]"
Copy the code

A useful trick for integer array indexing is to select or change an element from each row of the matrix:

import numpy as np

# Create a new array from which we will select elements
a = np.array([[1.2.3], [4.5.6], [7.8.9], [10.11.12]])

print(a)  # prints "array([[ 1, 2, 3],
          # [4, 5, 6],
          # [7, 8, 9],
          # [10, 11, 12]])"

# Create an array of indices
b = np.array([0.2.0.1])

# Select one element from each row of a using the indices in b
print(a[np.arange(4), b])  # Prints "[ 1 6 7 11]"

# Mutate one element from each row of a using the indices in b
a[np.arange(4), b] += 10

print(a)  # prints "array([[11, 2, 3],
          # [4, 5, 16],
          # [17, 8, 9].
          # [10, 21, 12]])
Copy the code

Boolean operations on arrays are used to extract numbers that satisfy certain conditions

import numpy as np

a = np.array([[1.2], [3.4], [5.6]])

bool_idx = (a > 2)   # Find the elements of a that are bigger than 2;
                     # this returns a numpy array of Booleans of the same
                     # shape as a, where each slot of bool_idx tells
                     # whether that element of a is > 2.

print(bool_idx)      # Prints "[[False False]
                     # [ True True]
                     # [ True True]]"

# We use boolean array indexing to construct a rank 1 array
# consisting of the elements of a corresponding to the True values
# of bool_idx
print(a[bool_idx])  # Prints "[3 4 5 6]"

# We can do all of the above in a single concise statement:
print(a[a > 2])     # Prints "[3 4 5 6]"
Copy the code

6.3 Array Data Types

Numpy provides a large number of numeric data types. When you create an array, Numpy goes back to guessing your data type, but you can also specify the data type

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"
Copy the code

6.4 Array numerical calculation

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.41421356] 1.
# [1.73205081 2.]]
print(np.sqrt(x))
Copy the code

Matlab * is matrix multiplication.* is dot product, in NUMpy is through dot matrix multiplication

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, w variable changes to [2,1], v is [1,2]
print(v.dot(w))
print(np.dot(v, w))

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

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

Numpy provides the sum function

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]"
Copy the code

See more function: docs.scipy.org/doc/numpy/r…

The transpose goes through 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]"
Copy the code

Numpy’s Broadcasting capabilities, Broadcasting is a powerful mechanism that allows NUMpy to use arrays of different shapes when performing arithmetic operations. Typically, we have a smaller array and a larger array, and we want to use the smaller array multiple times to do something on the larger array. For example, we want to add a constant row to each row of the matrix.

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 13] [11]
print(y)
Copy the code

However, when x is very large, this loop is slow in Python, and now we can equivalent the matrix vv as a copy of v in each row, and then add x and vV, as follows

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]
                          # [0, 1]]"
y = x + vv  # Add x and vv elementwise
print(y)  # Prints "[[ 2 2 4
          # [5 5 7]
          # [8 8 10]
          # 11 13] [11]"
Copy the code

However numpy’s broadcasting runs we don’t have to create VVS to do this

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 13] [11]"
Copy the code

X is a 4*3 matrix and v is a 1*3 matrix. Due to numpy’s broadcasting capabilities, y = x+ V implements a v is a 4*3 matrix and each row in V is a copy of the original V

Broadcasting implements two matrix operations following the following rules:

1) If two matrices have different ranks, append the matrix with lower rank until the two matrices have the same rank

2) Two matrices are compatible only if they have the same dimension or one of them has dimension 1

3) If the array is in all dimensions, then the array can be broadcast

4) After broadcast, each array behaves as if its shape is equal to the maximum number of elements in the shape of the two input arrays.

5) In any dimension where one array is of size 1 and the other array is larger than 1, the first array behaves as if it were copied along that dimension

In other words, the matrix dimensions of (x, y) and (y,) or (x, y) and (x,1) can be broadcast

For more information see: docs.scipy.org/doc/numpy/u…

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]
# 15] [12]
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]
# 7 [5] 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)
Copy the code

Numpy SciPy and image processing

SciPy resources: docs.scipy.org/doc/scipy/r…

Imread, imsave, and imresize have been removed from scipy since 1.3.0. Imread and imsave are replaced by imwrite and imread in Imageio. Imresize uses np.array(image.fromarray (np.uint8(img_tinted)).resize()) instead, where img_tinted is a 3D array of type NP.ndarray

from imageio import imwrite,imread
import numpy as np
from PIL import Image
img = imread(r'Desktop\20200109215359.jpg')
print(img.dtype,img.shape)
img_tinted=img*[1.0.5.0.5]
img_tinted = np.array(Image.fromarray(np.uint8(img_tinted)).resize((300.300)))
imwrite(r'Desktop\new_20200109215359.jpg', img_tinted)
Copy the code

8 Numpy and MATLAB are used together

Scipy.io. Loadmat and scipy.io. Savemat can read matlab data

9 scipy application

9.1 Calculate the direct distance between points

import numpy as np
from scipy.spatial.distance import pdist, squareform

# Create the following array where each row is a point in 2D space:
# [[0, 1]
# [0] 1
#  [2 0]]
x = np.array([[0.1], [1.0], [2.0]])
print(x)

# Compute the Euclidean distance between all rows of x.
# d[i, j] is the Euclidean distance between x[i, :] and x[j, :],
# and d is the following array:
# [[0.1.41421356 2.23606798]
# [1.41421356 0.1.]
# [2.23606798 1.0.]
d = squareform(pdist(x, 'euclidean'))
print(d)
Copy the code

10 Matplotlib

10.1 the drawing

import numpy as np
import matplotlib.pyplot as plt

# Compute the x and y coordinates for points on sine and cosine curves
x = np.arange(0.3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)

# Plot the points using matplotlib
plt.plot(x, y_sin)
plt.plot(x, y_cos)
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('Sine and Cosine')
plt.legend(['Sine'.'Cosine'])
plt.show()
Copy the code

subplot

import numpy as np
import matplotlib.pyplot as plt

# Compute the x and y coordinates for points on sine and cosine curves
x = np.arange(0.3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)

# Set up a subplot grid that has height 2 and width 1,
# and set the first such subplot as active.
plt.subplot(2.1.1)

# Make the first plot
plt.plot(x, y_sin)
plt.title('Sine')

# Set the second subplot as active, and make the second plot.
plt.subplot(2.1.2)
plt.plot(x, y_cos)
plt.title('Cosine')

# Show the figure.
plt.show()
Copy the code

imshow

from imageio import imwrite,imread
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
img = imread(r'Desktop\20200109215359.jpg')
print(img.dtype,img.shape)
img_tinted=img*[1.0.5.0.5]
img_tinted = np.array(Image.fromarray(np.uint8(img_tinted)).resize((300.300)))
imwrite(r'Desktop\1.jpg', img_tinted)
plt.subplot(1.2.1)
plt.imshow(img)
plt.subplot(1.2.2)
# A slight gotcha with imshow is that it might give strange results
# if presented with data that is not uint8. To work around this, we
# explicitly cast the image to uint8 before displaying it.
plt.imshow(np.uint8(img_tinted))
plt.show()
Copy the code