도전!

int a;

double b;

>>> a = 5

>>> print type(a)

<type 'int'>

>>> a = 4.0

>>> print type(a)

<type 'float'>

>>> a = 'hello'

>>> print type(a)

<type 'str'>

>>> a = [1,2,3]

>>> print type(a)

<type 'list'>

>>> n = 1236784319*78321919693185

>>> print n

96867322110508499166015

>>> a = 3+5j

>>> b = 4-2j

>>> print a*b

(22+14j)

>>> a.real

3.0

>>> a.imag

5.0

>>> print a.conjugate()

(3-5j)

>>> my_list = [ 10, 3.14, 30, 'hello' ]

>>> print my_list

[10, 3.14, 30, 'hello']

>>> print my_list[0]

10

>>> print my_list[1]

3.14

>>> print my_list[-1]

'hello'

>>> print my_list[-2]

30

>>> L1 = [1,2,3,4]

>>> L2 = ['a','b','c']

>>> print L1+L2

[1, 2, 3, 4, 'a', 'b', 'c']

>>> print my_list

[ 10, 3.14, 30, 'hello' ]

>>> len( my_list )

4

>>> my_list.append( 'world' )

>>> print my_list

[10, 3.14, 30, 'hello', 'world']

>>> my_list[1] = 3.14159

>>> print my_list

[10, 3.14159, 30, 'hello', 'world']

>>> L = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>> print L[2:6]

['c', 'd', 'e', 'f']

>>> print L[0:7:2]

['a', 'c', 'e', 'g']

>>> print L[::-1]

['g', 'f', 'e', 'd', 'c', 'b', 'a']

>>> print L[::-2]

['g', 'e', 'c', 'a']

>>> L = L[:3] + L[3::-1]

>>> print L

['a', 'b', 'c', 'd', 'c', 'b', 'a']

import struct, random

#Function to write a bmp file.  It takes a dictionary (d) of
#header values and the pixel data (bytes) and writes them
#to a file.  This function is called at the bottom of the code.
def bmp_write(d,byte):
    mn1 = struct.pack('<B',d['mn1'])
    mn2 = struct.pack('<B',d['mn2'])
    filesize = struct.pack('<L',d['filesize'])
    undef1 = struct.pack('<H',d['undef1'])
    undef2 = struct.pack('<H',d['undef2'])
    offset = struct.pack('<L',d['offset'])
    headerlength = struct.pack('<L',d['headerlength'])
    width = struct.pack('<L',d['width'])
    height = struct.pack('<L',d['height'])
    colorplanes = struct.pack('<H',d['colorplanes'])
    colordepth = struct.pack('<H',d['colordepth'])
    compression = struct.pack('<L',d['compression'])
    imagesize = struct.pack('<L',d['imagesize'])
    res_hor = struct.pack('<L',d['res_hor'])
    res_vert = struct.pack('<L',d['res_vert'])
    palette = struct.pack('<L',d['palette'])
    importantcolors = struct.pack('<L',d['importantcolors'])
    #create the outfile
    outfile = open('bitmap_image.bmp','wb')
    #write the header + the bytes
    outfile.write(mn1+mn2+filesize+undef1+undef2+offset+headerlength+width+height+\
                  colorplanes+colordepth+compression+imagesize+res_hor+res_vert+\
                  palette+importantcolors+byte)
    outfile.close()

###################################    
def main():
    #Here is a minimal dictionary with header values.
    #Of importance is the offset, headerlength, width,
    #height and colordepth.
    #Edit the width and height to your liking.
    #These header values are described in the bmp format spec.
    #You can find it on the internet. This is for a Windows
    #Version 3 DIB header.
    width = 2048
    height = 2048
    d = {
        'mn1':66,
        'mn2':77,
        'filesize':width*height+54,
        'undef1':0,
        'undef2':0,
        'offset':54,
        'headerlength':40,
        'width':width,
        'height':height,
        'colorplanes':0,
        'colordepth':24,
        'compression':0,
        'imagesize':width*height,
        'res_hor':0,
        'res_vert':0,
        'palette':0,
        'importantcolors':0
        }
   
    #Function to generate a random number between 0 and 255
    def rand_color():
        x = random.randint(0,255)
        return x

    #Build the byte array.  This code takes the height
    #and width values from the dictionary above and
    #generates the pixels row by row.  The row_mod and padding
    #stuff is necessary to ensure that the byte count for each
    #row is divisible by 4.  This is part of the specification.
    byte = bytes()
    for row in range(d['height']-1,-1,-1):# (BMPs are L to R from the bottom L row)
        for column in range(d['width']):
            b = rand_color()
            g = rand_color()
            r = rand_color()
            pixel = struct.pack('<BBB',b,g,r)
            byte = byte + pixel
        row_mod = (d['width']*d['colordepth']/8) % 4
        if row_mod == 0:
            padding = 0
        else:
            padding = (4 - row_mod)
        padbytes = bytes()
        for i in range(padding):
            x = struct.pack('<B',0)
            padbytes = padbytes + x
        byte = byte + padbytes
      
    #call the bmp_write function with the
    #dictionary of header values and the
    #bytes created above.
    bmp_write(d,byte)

if __name__ == '__main__':
    main()

x if a>b else y

(lambda:y, lambda:x)[a>b]()

{True:x, False:y}[a>b]

(a>b) and x or y

((a>b) and [x] or [y])[0]