Bespoke, 304 bytes

for the challenge,make code print,in totality,Grecian alphabet
o,but if any of inputted arguments appeared,print with a smaller measure of size
code has to start alphabet with offset
we do loop,and do a formula skipping sigma,ignoring a terminal form
printing letters in loop;end it at letter twentyfo-ur

The fact that the 17th entry - the final form of sigma - has to be skipped is a bit of a tricky detail. But it's interesting to know that subtracting 32 to get from lowercase to uppercase letters is a thing both with Latin letters and Greek letters.

Swift 6, 92 86 bytes

print({CommandLine.argc>1 ?$0:$0.uppercased()}(""+(945...969).map{.init(.init($0)!)}))

AWK, 47 bytes

{for(;i++<25;)printf"%c",i~18?X:NF?944+i:912+i}

Attempt This Online!

ATO is printing what's supposed to be a non-printing char. To try at home:

awk '{for(;i++<25;)printf"%c",i~18?X:NF?944+i:912+i}' <<< ""
awk '{for(;i++<25;)printf"%c",i~18?X:NF?944+i:912+i}' <<< "X"

C (gcc), 68 67 bytes

j;main(i){for(setlocale(6,"");j<24;)putwchar(945-1/i*32+j+j++/17);}

Try it online!

Zsh, ⁴⁵ 42 bytes

A=({Α..Ω})
((#))&&A=$A:l
tr -d \ -z<<<$A

Try it online!

-3 bytes with help from roblogic

Tcl, 73 chars, 121 bytes

puts [expr $argc>0?"αβγδεζηθικλμνξοπρστυφχψω":"ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ"]

Try it online!

Japt, 21 19 18 bytes

;Ckzir)c+816+32*NÊ

Test it (no input)
Test it (empty string input)

;Ckzir)c+816+32*NÊ     :Implicit input (or not)
;C                     :Lowercase alphabet.
  k                    :Remove
   zir                 :  "z" prepended with "r"
      )                :End remove
       c+              :Map charcodes and add
         816+32*       :  816 plus 32 multiplied by
                N      :   Array of all inputs
                 Ê     :   Length (0 if no input, 1 if a single input)

Scala, 171 bytes

Modified from @Value Ink's Ruby solution.

Golfed version. Try it online!

object Main{def main(args:Array[String])=println((if(args.nonEmpty)('α'to'ω').toSet.diff(Set('ς')).toList else('Α'to'Ρ').toList++('Σ'to 'Ω').toList).mkString(" "))}

Ungolfed version. Try it online!

object Main {
  def main(args: Array[String]): Unit = {
    val result = if (args.nonEmpty) ('α' to 'ω').toSet.diff(Set('ς')).toList
                 else ('Α' to 'Ρ').toList ++ ('Σ' to 'Ω').toList
    println(result.mkString(" "))
  }
}

Japt -P, 17 bytes

25od913+H*NÊ fÏÉ7

Test it

Explanation

25o                 map each n in range [0, 25):
   d                  convert the following codepoint to a character:
    913                 n + 913
       +H*NÊ            + (number of inputs * 32)
             fÏ     keep elements where the following is truthy:
               É7     subtract 17 from the index 
                      (if index is 17, this will be 0 = falsy)
-P                  P flag joins the array to a string

The cool part of this is fÏÉ7: É7 transforms to -17 by using the shortcut for -1 (i.e. decrement). The regular way of doing this would be something like f϶17 which is one byte longer.

Thunno 2 J, 17 16 15 14 bytes

24Ė17Ɗ913+C¤?L

-1 thanks to @TheThonnu :), saved 1 extra by using different method.

Explanation:

24Ė              # range [0, 24]
   17Ɗ           # remove index 17
      913+       # add 913 to each
          C      # convert to character array
           ¤?    # if there is input:
             L   #   convert to lowercase (vectorizes)
                 # J flag joins character array

Thunno 2 isn't on ATO yet, but I have confirmed that this works on my machine for both the input and no input versions.

Raku, 53 bytes

{say @*ARGS??.lc!!$_}([~] flat 'Α'..'Ρ','Σ'..'Ω')

Try it online!

• [~] flat 'Α'..'Ρ','Σ'..'Ω' constructs the uppercase Greek alphabet.
• { say @*ARGS ?? .lc !! $_ } is an anonymous function which receives the uppercase alphabet as an argument. If there are any command-line arguments, the alphabet is lowercased and printed, otherwise it is printed as-is.

Python, 81 Bytes

lambda*x,b="αβγδεζηθικλμνξοπρστυφχψω":(b.upper(),b)[x>()]

-6 from TheThonnu for using *.
-2 from TheThonnu for telling me that the brackets are unneeded.
-28 from mousetail for using an uppercasing function.
-7 from TheThonnu for assigning the greek letters to a variable.

Julia 1.0, 42 bytes

print.(['Α':'Ρ';'Σ':'Ω'].+32(ARGS>[]))

Try it online!

-1 byte thanks to MarcMush: use ARGS>[] instead of ARGS==[]

APL, 27 bytes

{⎕UCS(912+32×0∊⍴⍵)+18~⍨⍳25}

The program switched to uppercase, when empty array or empty string is received. Unfortunately, it is technically impossible to distinguish them.

Rust, 134 bytes

fn main(){let mut s:String=('α'..'ϊ').collect();s.remove(34);print!("{}",if std::env::args().nth(1)==None{s.to_uppercase()}else{s})}

Try it on the Rust Playground!

ungolfed:

fn main() {                                    //full program
    let mut s: String = ('α'..'ϊ').collect();  //create a range of chars from 'α'(inclusive) to 'ϊ' (exclusive) and collect into string
    s.remove(34);                              //remove 'ς'
    print!(                                    //print
        "{}",                                  //with default formatting
        if std::env::args().nth(1) == None {   //if the 2nd arg doesn't exist (first is filename)
            s.to_uppercase()                   // uppercase string then return
        } else {                               // else
            s                                  // return unmodified string
        }
    )
}

This doesn't work on tio for some reason so this is on the playground, where you can't add input- turn the == to a != to test lowercase version.

Excel, 48 bytes

=CONCAT(UNICHAR(ROW(1:24)*19/18+944-(A1="")*32))

Alternatively, you could put the upper case alphabet in B2 and use the formula below for a combined 47 bytes (or more depending on how you account for multiple cells)

=IF(A1="",B2,LOWER(B2))

PowerShell, 94 bytes

param($n)$k=((0..16)+(18..24)|%{[char]($_+913)})-join'';if($n){$k.tolower()}else{$k.toupper()}

Try it online!

R, ^{96 53 ₅₁} 58 bytes

cat(intToUtf8((913:937)[-18]+32*!!length(commandArgs(T))))

Try it online!

I tried to make an R answer with command line args, but it's a bit longer(now a lot, lot shorter) than the loop based approach by plannapus. I used some of the tricks in their answer.

A crazy -43 bytes from Dominic Van Essen.

-2 more bytes from Dominic Van Essen.

+7 bytes after removing ς

Python 3, 74 bytes

This an improvement to @HackerBoss es' answer (I don't have enough reputation to comment).

import sys;a=len(sys.argv)-1<<5;print(*map(chr,range(a+913,a+938)),sep='')

Subtraction has higher precedence than bit shift, so no need for parentheses, we save 2 bytes. Also instead of using ''.join() we unpack the map() and set print()'s default seperator to an empty string to omit the spaces, that saves 1 byte.

Python 3, 73 bytes

import sys
x=25
while x:print(end=chr(906-x+32*len(sys.argv))[:x^8]);x-=1

Try it online!

This still may not be as low as it can go!

MATLAB, 35 bytes

@(x)disp(char((913:937)+32*nargin))

Pretty self-explainatory, I think.

CJam, 16 bytes

25,H-ea'α'Α?f+

Try it online!

25,H-         e# 0 to 24 excluding 17.
ea'α'Α?       e# If the argument list is truthy (non-empty), alpha, otherwise Alpha.
f+            e# Return characters with each number added to the character code.

Python 3, 88 bytes

import sys
s=945 if sys.argv[1:] else 913
for i in range(s,s+25):
  print(chr(i),end='')

Python 3, 78 bytes

import sys;a=(len(sys.argv)-1)<<5;print(''.join(map(chr,range(a+913,a+938))))

Explanation

a is an offset, 32 when an argument is given to use the lowercase range. 913 to 937 is the range of unicode values for the uppercase greek alphabet.

PowerShell, 81 bytes

'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ'|%('*wer','*per')[!$args.Count]

Try it online!

Braingolf, 24 bytes

l?#α:#Α|# 9->[.!@ 1+];

Try it online!

Explanation:

l?#α:#Α|# 9->[.!@ 1+];  Implicit input of args to stack
l                       Push length of stack
 ?                      If last item (length) is != 0..
  #α                    ..Push lowercase alpha
    :                   else
     #Α                 ..Push uppercase alpha
       |                endif
        #<space>        Push 32 (ordinal of a space)
          9-            Subtract 9 (23)
            >           Move last item to start of stack
             [......]   Do-While loop, will run 24 times
              .         Duplicate last item
               !@       Print without popping
                  1     Push 1
                   +    Pop last 2 items (1 and duplicate) and push sum
                     ;  Suppress implicit output

APL (Dyalog Extended), 26 bytes

The normal way to pass multiple arguments to APL programs is through a lists. So this program prompts for such a list, which may have 0 or 1 arguments.

'ς΢'~⍨⍳'Ω'×~≢⎕

Try it online!

⎕ prompt for argument list

≢ tally the number of arguments (0 or 1)

~ negate that (1 or 0)

'Ω'× "multiply" Omega by that (1 keeps uppercase, 0 folds to lowercase)

⍳ All characters from Α–Ω or α–ω respectively

'ς΢'~⍨ remove lowercase and "uppercase" final sigmas

Retina, 55 bytes

.+
αβγδεζηθικλμνξοπρστυφχψω
^$
ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ

Try it online

PHP, 84 Bytes

Online Version

<?=($argc<2?trim:mb_strtolower)("ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ");

PHP, 87 Bytes

$s="ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ";echo$argc>1?mb_strtolower($s):$s;

Pip, 21 20 bytes

C:913+32*#g+Y,24RM17

This is a memorable day. Pip has tied beaten Jelly!¹

_{¹ And lost to two other golflangs, but whatever.}

Try it online!

Explanation

             ,25      Numbers 0 through 24
                RM17  Remove 17 (ς)
            Y         Yank (to get correct order of operations)
  913                 Char code of capital alpha
      32*#g           32 times number of cmdline args (must be 0 or 1)
     +     +          Add everything up
C:                    Convert to characters (using the compute-and-assign metaoperator to
                        lower the precedence of C)

PHP, 79 bytes

for($i=944-32*!--$argc;$i++-9&31;$i+=$i%32==1)echo html_entity_decode("&#$i;");

generates unicode html entities and decodes them. Run with -r.

Haskell, 114 108 bytes

import System.Environment
q[a,b]=[a..b]
f[]=q"ΑΡ"++q"ΣΩ"
f _=q"αρ"++q"σω"
main=f<$>getArgs>>=putStr

Thanks to @xnor for saving 6 bytes

This might win in the category of longest imports if nothing else…

Perl under Windows -- console has no Unicode support -- (42 bytes, including spaces)

This is not my solution, I am just merely adapting the Perl solution of Denis Ibaev above, to Windows console Perl.

perl -E"say map{chr$_+151-!@ARGV*24}1..24"
ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
$ perl -E"say map{chr$_+151-!@ARGV*24}1..24" with one or many arguments
αβγδεζηθικλμνξοπρσςτυφχψ

The console page code must be Greek of course:

chcp 737

^{NOTE: Just a small idea. On this page I can see that some of the answers use CHARACTERS that seem to been Unicode above 255. Therefore those characters take at least 2 bytes to code (perhaps 4 if one is using a console using 32bits Unicode chars?). Would not it be better if the contest measure was the CHARACTER unit (being Unicode or ASCII or EBCDIC ou whatever) rather than just BYTES? Would not it be simpler and more unifying (wonder if this adjectif exists in English, "unificateur" in French)?}

Previous code in error: Does not print lowercase omega.

Corrected code (70 chars) :

perl -E"$i=!@ARGV+0;@a=73;pop@a if$i;say map{chr$_+151-$i*24}1..24,@a"
ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
perl -E"$i=!@ARGV+0;@a=73;pop@a if$i;say map{chr$_+151-$i*24}1..24,@a" foo
αβγδεζηθικλμνξοπρσςτυφχψω

^{I know we are not supposed to print the 'end-of-word' sigma form ('ς') but as it is a mispelling error in ancient Greek to use regular sigma ('σ') at the end of a lowercase word, I choose to print it, as the tittle of this puzzle is "Print the Greek alphabet" and that this character is part of it...}

C#, 174 bytes

Lazy implementation, can probably golf it a lot

class P{static void main(string[] a){System.Console.Write(a.Length>0?"αβγδεζηθικλμνξοπρστυφχψω":"ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ");}}

R, 104 99 92 bytes

g=function(x)for(i in sprintf("'\\u%04X'",913:937+32*!missing(x))[-18])cat(eval(parse(t=i)))

Golfing down on the second version I had previously. Work the same way as previous version.

Thanks to @JDL for shaving off 7 bytes!

Old versions at 104 bytes:

I have two different solutions with the same byte count:

f=function(x){a="ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ";cat(if(missing(x))a else tolower(a))}

Or:

g=function(x)for(i in sprintf("'\\u%04X'",if(missing(x))913:937 else 945:969)[-18])cat(eval(parse(t=i)))

Explanations:

#First one is trivial
f=function(x){
     a="ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ" #String to print
     #If argument missing, print uppercase else lowercase 
     cat(if(missing(x))a else tolower(a)) 
     }
#Second one more interesting:
g=function(x)
     #Create escaped unicode strings (i. e. "'\\u03B1'" etc.), loop over them...
     for(i in sprintf("'\\u%04X'",if(missing(x))913:937 else 945:969)[-18])
          #...eval the strings
          cat(eval(parse(t=i))) 

Usage:

> f()
ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
> g()
ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
> f(1)
αβγδεζηθικλμνξοπρστυφχψω
> g(1)
αβγδεζηθικλμνξοπρστυφχψω
> f("a")
αβγδεζηθικλμνξοπρστυφχψω
> g("a")
αβγδεζηθικλμνξοπρστυφχψω

For some reasons, it doesn't work on R-Fiddle (it changes " to ' by default which makes the code throw an error) but you can try it out on Ideone.

Python 3, 80 bytes

import sys;print(''.join(chr(x+881+len(sys.argv)*32)for x in range(25)if x!=17))

Groovy Script, 54 51 bytes

((913..937)-930).each{print((char)(args?it+32:it))}

Edit

Switched from 913..937 and it==930?: to (913..937)-930

PowerShell v2+, 68 bytes

(($a=-join([char[]](913..929+931..937))).toLower(),$a)[!$args.count]

ASCII-only, but outputs in UTF-16. Constructs a char-array of the appropriate characters, -joins it together into a string, stores it into $a. Then, uses !$args.count as an index into the tuple, to output either $a if no arguments are present, or $a.ToLower() if there is at least one argument.

PS C:\Tools\Scripts\golfing> .\print-the-greek-alphabet.ps1
ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ

PS C:\Tools\Scripts\golfing> .\print-the-greek-alphabet.ps1 ''
αβγδεζηθικλμνξοπρστυφχψω

Java 7, 176 bytes

class M{public static void main(String[]a){System.out.print(a.length>0?"αβγδεζηθικλμνξοπρστυφχψω":"ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ");}}

Java 8, 173 bytes

interface M{static void main(String[]a){System.out.print(a.length>0?"αβγδεζηθικλμνξοπρστυφχψω":"ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ");}}

JavaScript (ES6), 89 83 81 bytes

(...a)=>String.fromCharCode(...[...Array(24)].map((_,i)=>i*1.06+913+32*a.length))

If a character array is acceptable, then for 82 80 78 bytes:

(...a)=>[...Array(24)].map((_,i)=>String.fromCharCode(i*1.06+913+32*a.length))

Edit: Saved a bunch of bytes thanks to @ETHproductions.

Python 3, 80 77 76 bytes

import sys;a='ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ';print([a,a.lower()][-len(sys.argv)])

Old version:

import sys;a='ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ';print([a,a.lower()][len(sys.argv)-1])

Older version:

import sys;a='ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ';print(a.lower()if len(sys.argv)>1else a)

JavaScript, 95 bytes

95 bytes, but only 71 characters. Byte counter. Using @Neil s way to determine if arguments are passed.

(...a)=>'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ'[`to${a.length?'Low':'Upp'}erCase`]()

Perl, 39 + 3 (-C2 flag) = 44 42 bytes

 perl -C2 -E 'say map{chr$_+954-!@ARGV*32}-9..7,9..15'

Ruby, 56 bytes

Full program. I don't think a function/lambda answer will be shorter than this for this language.

Dangit, sigma ς. This is why we can't have nice things. And you too, (unrenderable character that serves as a placeholder for "uppercase" ς)

print *($*[0]?([*?α..?ω]-[?ς]):[*?Α..?Ρ,*?Σ..?Ω])

Mathematica, 91 bytes

Print@{#&,ToLowerCase}[[Length@$ScriptCommandLine]][""<>"Α"~CharacterRange~"Ω"~Drop~{18}]

Script. Just takes the character range from Α to Ω, removes U+03A2/ς, either converts to lowercase or doesn't, and prints.

Jelly, 21 bytes

,⁸Ea32µ24R%18T+912+µỌ

A full program

TryItOnline! - note once run with an argument a refresh will be required to run with no argument.

How?

,⁸Ea32µ24R%18T+912+µỌ - Main link
,⁸                    - pair (,) with left argument (defaults: left=0, ⁸=[])
                            no argument: [0,[]]
                               argument: [argument,argument]
  E                   - all items equal? -> no argument: 0; argument: 1
   a32                - and 32           -> no argument: 0; argument: 32
      µ               - monadic chain separation
       24R            - range(25)        -> [  1,  2,  3,..., 17, 18, 19,..., 25]
          %18         - mod 18           -> [  1,  1,  1,...,  1,  0,  1,...,  1]
             T        - truthy indices   -> [  1,  2,  3,..., 17,     19,..., 25]
              +912    - add 912          -> [913,914,915,...,929,    931,...,937]
                  +   - add the 0 or 32 (lowercase letters are 32 code points higher)
                   µ  - monadic chain separation
                    Ọ - cast to ordinals

Pyke, 55 21 20 bytes

24Fi16>913s.C)sz!hAl

Try it here!

24F          )       -   for i in range(24):
   i16>              -       i > 16
       913s          -      sum(i, ^, 913)
           .C        -     chr(^)
              s      -  sum(^) - created uppercase alphabet
                  Al - [len, lower, upper][V](^)
                 h   -  V + 1
               z!    -   not input()

Scala, 82 bytes

print((('Α'to'Ρ')++('Σ'to'Ω')).mkString.map(& =>if(args.size<1)&else&toLower))

Ungolfed:

print((('Α'to'Ρ')++('Σ'to'Ω')).mkString.map(s=>if(args.size==0)s else s.toLower))

Sadly, (('Α'to'Ρ')++('Σ'to'Ω')) is a Vector[Char], which would be printed as Vector('Α', 'Β', ..., so it has to be converted to a string with mkString.The argument to map is called & to save spaces between &else, else& and & toLower.

Python 2, 108 bytes

#coding=iso-8859-7
import sys;print'αβγδεζηθικλμνξοπρστυφχψω'if~-len(sys.argv)else'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ'

Terribly golfed, maybe :(

And no, I can't use A.lower().

Thanks to 13285 (alexwlchan) for -11 bytes.

05AB1E, 16 bytes

Uses CP-1252 encoding.

24Ý17K913+çJDl¹s

Try it online!

Explanation

24Ý               # push range [0 ... 24]
   17K            # remove 17
      913+        # add 913 to each
          ç       # convert from code point
           J      # join to string
            Dl    # push a lowercase copy
              ¹   # push the input
               s  # swap the top 2 elements of the stack
                  # implicitly display the top of the stack

Actually, 62 bytes

 "$ù"E"ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ"@ƒ.X

Try it online!

Because some of the uppercase Greek alphabet is not present in CP437, this solution is encoded in UTF-8 and scored accordingly. Here is a hexdump (reversible with xxd -r):

00000000: 2022 24c3 b922 4522 ce91 ce92 ce93 ce94   "$.."E"........
00000010: ce95 ce96 ce97 ce98 ce99 ce9a ce9b ce9c  ................
00000020: ce9d ce9e ce9f cea0 cea1 cea3 cea4 cea5  ................
00000030: cea6 cea7 cea8 cea9 2240 c692 2e58 0a    ........"@...X.

Explanation:

 "$ù"E"ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ"@ƒ.X
<space>                               push the number of items present on the stack
 `$ù`E                                select `ù` (lowercase) if the number of items is not 0, else `$` (stringify - does nothing to a string)
      "ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ"      push the uppercase Greek alphabet
                                @ƒ    call the selected function
                                  .   print
                                   X  discard