First, I should say that the easiest way to do this is to use the prename or rename commands.

On Ubuntu, OSX (Homebrew package rename, MacPorts package p5-file-rename), or other systems with perl rename (prename):

Copyrename s/0000/000/ F0000*

or on systems with rename from util-linux-ng, such as RHEL:

Copyrename 0000 000 F0000*

That's a lot more understandable than the equivalent sed command.

But as for understanding the sed command, the sed manpage is helpful. If you run man sed and search for & (using the / command to search), you'll find it's a special character in s/foo/bar/ replacements.

Copy  s/regexp/replacement/
         Attempt  to match regexp against the pattern space.  If success‐
         ful,  replace  that  portion  matched  with  replacement.    The
         replacement may contain the special character & to refer to that
         portion of the pattern space  which  matched,  and  the  special
         escapes  \1  through  \9  to refer to the corresponding matching
         sub-expressions in the regexp.

Therefore, \(.\) matches the first character, which can be referenced by \1. Then . matches the next character, which is always 0. Then \(.*\) matches the rest of the filename, which can be referenced by \2.

The replacement string puts it all together using & (the original filename) and \1\2 which is every part of the filename except the 2nd character, which was a 0.

This is a pretty cryptic way to do this, IMHO. If for some reason the rename command was not available and you wanted to use sed to do the rename (or perhaps you were doing something too complex for rename?), being more explicit in your regex would make it much more readable. Perhaps something like:

Copyls F00001-0708-*|sed 's/F0000\(.*\)/mv & F000\1/' | sh

Being able to see what's actually changing in the s/search/replacement/ makes it much more readable. Also it won't keep sucking characters out of your filename if you accidentally run it twice or something.

To replace # by somethingelse for filenames in the current directory (not recursive) you can use the (Perl-)rename utility:

rename  's/#/somethingelse/' *

Characters like - must be escaped with a \.

For your case, you would want to use

rename 's/#U00a9/safe/g' *

Note that if you only want to operate on a certain selection of files, e.g., only *.jpg, adjust the final input to match that selection:

rename 's/#U00a9/safe/g' *.jpg

To perform a test before actually changing filenames, use the -n flag:

demo/> ls                               
Lucky-#U00a9NBC-125x125.jpg  
Lucky-#U00a9NBC-150x150.jpg 

demo/> rename -n 's/#U00a9/safe/g' *.jpg
rename(Lucky-#U00a9NBC-125x125.jpg, Lucky-safeNBC-125x125.jpg)
rename(Lucky-#U00a9NBC-150x150.jpg, Lucky-safeNBC-150x150.jpg)

For OS X, rename can be installed using homebrew: brew install rename.

There are a few issues here. First of all, your files are not in /00101234/, / is the root directory, kinda like Windows's C:. Your files are in ~/Desktop/images/00101234/ which means /home/yourUserName/Desktop/images/ (where yourUserName is your user name). The easiest way to deal with this, therefore, is to use relative paths. For example, consider this file:

/dir1/dir2/file

That's the absolute path to file. But if you are inside the dir1 directory, you can use a path that's relative to your current location: dir2/file.

With this in mind, let's have another look at your csv file:

/00101234/1101.jpg,/Jewellery/ALittleThankYouTeacher1101.jpg

These are relative paths. You can deal with this in two ways:

1. Move into the ~/Desktop/images directory and use the paths as they are.
2. Convert them to absolute paths.

I will focus on 2 since it is less likely to break. This command will not actually do anything, but it will print out the list of actions to be performed (run this from the directory containing your csv file and change yourCsv.csv to the actual name of your file):

while IFS=, read -r old new; do
    echo mv "~/Desktop/images${old}" "~/Desktop/images/Jewlery${new}"
done < yourCsv.csv

On my system, using the file you provided, this prints:

mv ~/Desktop/images/00101234/1101.jpg ~/Desktop/images/Jewlery/Jewellery/ALittleThankYouTeacher1101.jpg
mv ~/Desktop/images/00101234/1102.jpg ~/Desktop/images/Jewlery/Jewellery/ALittleThinkingOfYou1102.jpg
mv ~/Desktop/images/00101234/1155.jpg ~/Desktop/images/Jewlery/Jewellery/ALittleDreamcatcher1155.jpg
mv ~/Desktop/images/00101234/1203.jpg ~/Desktop/images/Jewlery/Jewellery/ALittleLuckyElephant1203.jpg

If that prints what you want, then we're ready to go. Remove the echo (that just means "print this", so removing it will cause the loop to execute the mv command instead of just printing it).

However, and this is important, your csv is probably a bit different. I am assuming you created it in Windows, which means it will have different line endings. So, to be on the safe side, you want to run this:

tr -d '\r' < yourCsv.csv | while IFS=, read -r old new; do
    mv "~/Desktop/images${old}" "~/Desktop/images/Jewlery${new}"
done < yourCsv.csv

Of course, I strongly recommend that you first make a backup of all of these files just in case something goes wrong.

Using Perl's rename (usable in any OS):

rename -n 's/TEST/PROD/g' ./*TEST*.XML

Remove -n switch, aka dry-run when your attempts are satisfactory to rename for real.

If you don't have rename (it's a really short Perl script) or your rename is the more simplistic util-linux version or you simply want to know how to make your command work: you just need to send it to the shell for execution:

find spec -name "*_test.rb" -exec sh -c 'echo mv "$1" "$(echo "$1" | sed s/test.rb\$/spec.rb/)"' _ {} \;

If you happen to have a file that looks like this:

old_name1, new_name1
old_name2, new_name2
old_name3, new_name3

You can do a dirty little trick:

sed 's/^/mv -vi "/;s/, /" "/;s/$/";/' < names.csv | bash -

The sed comamnds (delimited by semicolons) does this (s is for substitute, / is used as a delimiter, any other character would do, @ is often used as well):

• s/^/mv -vi "/ - adds mv -vi " at the beginning of each line (^ is beginning of line);
• s/, /" "/ - replaces comma followed by a space with " ";
• s/$/";/ - appends double quotes to all lines ($ means end of line)

and hence the output of sed will be this:

mv -vi "old_name1" "new_name1"
mv -vi "old_name2" "new_name2"
mv -vi "old_name3" "new_name3"

which will be fed to bash to execute. The quotes around filenames are not mandatory, they just guard any possible spaces in the filenames (however they will defintely not help against spaces followed by a comma, since that is used as delimiter). the -v instructs mv to display what it is doing (in case something goes wrong, you'll know what happened), -i will cause it to ask if it were to overwrite already existing file.

You can use the rename command to do the renaming

rename Centos1 Centos2 *

or if you have the perl rename

rename 's/Centos1/Centos2' *

Your find command should change all occurences of Centos1 to Centos2 so you could wrap them in a simple script to make it a single command.

#!/bin/bash
rename Centos1 Centos2 *

find . -type f -exec sed -i 's/Centos1/Centos2/g' {} +

The command sed 's/^.*NA -//' * would not rename files, it would attempt to replace the pattern in the files' contents, streaming the result to the terminal (with potentially weird results, especially if the expansion of * includes any binary files).

The command perl -pi -e 's/^.*NA -//' * would do the same, except modifying the contents in place, possibly corrupting your files.

To use sed (or perl itself) for file renaming, you'd need to do something like

for f in *; do mv -n -- "$f" "$(sed 's/pattern/replacement' <<<"$f")"

or

for f in *; do mv -n -- "$f" "$(printf '%s\n' "$f" | sed 's/pattern/replacement')"

i.e. passing the name of each file to sed via standard input. However your pattern could just as easily be written as a shell substitution, eliminating the need for sed altogether:

for f in *; do mv -n -- "$f" "${f##* - NA - }"; done

(I'm assuming you want to remove the leading space as well). The ##* matches the longest leading character sequence, equivalent to basic regular expression ^.*

To use perl under the hood, but modifying file names rather than contents, you'd want the rename command, from package rename. (There are other rename commands, such as the one from package util-linux that work differently.) For example:

rename -n 's/^.*? - NA - //' *.aiff

(I limited the scope to .aiff files, and made the .* match non-greedy - a feature that sed does not provide - so that it only matches up to the first - NA - in case there are multiple instances.) Remove the -n once you are satisfied with the proposed re-namings.

rename 's/ACDC/AC-DC/' *.xxx

from man rename

DESCRIPTION
       "rename" renames the filenames supplied according to the rule specified as the 
first argument.  The perlexpr argument is a Perl expression which is expected to modify the 
$_ string in Perl for at least some of the filenames specified.  If a given filename is not 
modified by the expression, it will not be renamed.  If no filenames are given on
           the command line, filenames will be read via standard input.

For example, to rename all files matching "*.bak" to strip the extension, you might say

rename 's/\.bak$//' *.bak

To translate uppercase names to lower, you'd use

rename 'y/A-Z/a-z/' *