My code changes a single RGB value by a set amount, then does the same changes over the other channels So I have the following code, that takes an image and modifies the RGB channels one at a time. It then creates a list of 9 images with the various modified channels.
The Red channel is modified by 0.1, then by 0.5, then by 0.9. This is then applied to the Green channel then the Blue Channel.
Resulting in a list of 9 images with the same modifications, but to different channels. The code works, but I just feel like there is a lot of repetition, and this really bugs me.
#%%

from PIL import Image

# Set the file and open it
file = &quot;Final/charlie.png&quot;

#Create an empty list to append the images to
images = []

#Image processing function, depending on the counter
def image_processing0(a):
    if count == 0 or count == 3 or count == 6:
        c = int(a * 0.1)
        return c
    elif count == 1 or count == 4 or count == 7:
        c = int(a * 0.5)
        return c
    elif count == 2 or count == 5 or count == 8:
        c = int(a * 0.9)
        return c

#Set the count to 0
count = 0

#Create PixelMap
while count &lt;9:
#Creat Pic at the start of each loop
    pic = Image.open(file)
#Convert the image to RGB, so we dont have to deal with the alpha channel
    pic = pic.convert('RGB')
    
#Get the RGB value for every pixel
    for x in range(pic.size[0]):
            for y in range(pic.size[1]):

                #Split the RGB value into variables r, g and b
                r,g,b = pic.getpixel((x,y))
                
#Check the count, use logic to appy the processing to the correct channel               
                if count &lt;3:
                    r = image_processing0(r)
                    pic.putpixel((x,y),(r,g,b))
                elif count &lt; 6:
                    g = image_processing0(g)
                    pic.putpixel((x,y),(r,g,b))
                elif count &lt; 9:
                    b = image_processing0(b)
                    pic.putpixel((x,y),(r,g,b))

#Add the images to the list                    
    images.append(pic)
#Increment the counter    
    count+=1  

Both my logic statement, and my function seem a bit repetitive:
 #---------------------------------------------------
    #Image processing function, depending on the counter
    def image_processing0(a):
        if count == 0 or count == 3 or count == 6:
            c = int(a * 0.1)
            return c

        elif count == 1 or count == 4 or count == 7:
            c = int(a * 0.5)
            return c

        elif count == 2 or count == 5 or count == 8:
            c = int(a * 0.9)
            return c
#---------------------------------------------------

#Check the count, use logic to apply the processing to the correct channel               
if count &lt;3:
    r = image_processing0(r)
    pic.putpixel((x,y),(r,g,b))

elif count &lt; 6:
    g = image_processing0(g)
    pic.putpixel((x,y),(r,g,b))

elif count &lt; 9:
    b = image_processing0(b)
    pic.putpixel((x,y),(r,g,b))
#---------------------------------------------------

I tried to change my logic to the following, but soon realized that when I put the pixel back, i had no way to specify exactly what channel I was placing back in the  pic.putpixel((x,y),(r,g,b)) statement.
if count &lt;3:
    channel = r
elif count &lt; 6:
    channel = g
elif count &lt; 9:
    channel = b

channel = image_processing0(channel)
pic.putpixel((x,y),(r,g,b))    #No way to define which channel is being changed
Some style advice and much simpler/shorter/faster solutions.
Style
Your comments break the structure, making the code harder to read. As PEP 8 says:

Block comments [...] are indented to the same level as that code. Each line of a block comment starts with a # and a single space

So
while count &lt;9:
#Creat Pic at the start of each loop
    pic = Image.open(file)
#Convert the image to RGB, so we dont have to deal with the alpha channel
    pic = pic.convert('RGB')

becomes
while count &lt;9:
    # Create pic at the start of each loop
    pic = Image.open(file)
    # Convert the image to RGB, so we dont have to deal with the alpha channel
    pic = pic.convert('RGB')

and I might remove the first comment, as it, unlike the second comment, doesn't contain any insight that's not easily seen in the code anyway.
NumPy
Taking tsh's solution further, to NumPy:
from PIL import Image
import numpy as np

file = &quot;Final/charlie.png&quot;

im = Image.open(file).convert('RGB')
images = []
for channel in range(3):
    for factor in 0.1, 0.5, 0.9:
        data = np.copy(im)
        ch = data[:, :, channel]
        np.multiply(ch, factor, ch, casting='unsafe')
        images.append(Image.fromarray(data))

Image.convert with matrix
Or using convert's matrix parameter:
from PIL import Image

file = &quot;Final/charlie.png&quot;

im = Image.open(file)
images = []
for channel in range(3):
    for factor in 0.1, 0.5, 0.9:
        matrix = [1, 0, 0, 0,
                  0, 1, 0, 0,
                  0, 0, 1, 0]
        matrix[channel * 5] = factor
        images.append(im.convert('RGB', matrix))

Speeds
Using some 575 x 575 sample image, I got roughly these times per new image:

Yours: 2.9 seconds
tsh's: 0.8 seconds
My NumPy one: 0.003 seconds
My convert one: 0.005 seconds