IronPython – jak zacząć?, cz. 2/2

Autor: Bartosz Kierun

Opublikowano: 2010-11-29

Początek, czyli Hello, Python!

Gdyby niniejszy artykuł miał dotyczyć wstępu do programowania w języku C#, zaczęlibyśmy prawdopodobnie od opisu założenia nowego projektu w środowisku Visual Studio oraz wyjaśnialibyśmy pojęcia takie jak kompilacja czy podzespół (assembly). Jednakże w przypadku języków takich jak Python czy Ruby możemy rozpocząć programowanie w bardzo łatwy sposób przy użyciu tzw. interaktywnej konsoli (IronPython Console). Aby ją uruchomić, przejdź do katalogu, w którym zainstalowany został IronPython, a następnie uruchom program o nazwie ipy.exe.

Teraz spróbujemy rozpoznać nieco możliwości języka Python na podstawie kilku prostych przykładów z wykorzystaniem tejże konsoli.

**Rys. 2. Interaktywna konsola w akcji.

Po uruchomieniu konsoli każdy początkujący programista powinien zacząć od wpisania polecenia:

import this

co spowoduje wyświetlenie manifestu „Zen of Python”, którego przesłanie można stosować z powodzeniem podczas pisania kodu praktycznie w każdym języku programowania, a to, jakie zawiera on paradygmaty, pozostawiam do odkrycia Czytelnikowi.

W pierwszych potyczkach z językiem Python z pewnością pomogą nam różne samouczki dostępne w Internecie oraz fora i grupy dyskusyjne poświęcone Pythonowi. Bardzo dobry podręcznik dystrybuowany jest również z IronPythonem, a znajduje się on w pliku IronPython.chm.

Rozpocznijmy zatem szybki przegląd możliwości IronPythona, analizując kilka poniższych przykładów.

1. IronPython jako kalkulator

Choć wykonywanie mniej lub bardziej skomplikowanych obliczeń matematycznych nie nastręcza zbyt wielu trudności w większości języków programowania, to dobrze jest wiedzieć, że przy użyciu języka Python oraz interaktywnej konsoli możemy przeprowadzać nawet zaawansowane obliczenia natychmiast po uruchomieniu jednego narzędzia działającego w konsoli.

Dobrze też wiedzieć, że wykorzystywane w przykładach narzędzie ipy.exe ma wiele dodatkowych opcji i parametrów uruchomieniowych. W naszych przykładach będzie użyty sposób uruchomienia interpetera, jaki zaoferuje nam takie podstawowe elementy, jak kolorowanie tekstu oraz automatyczne dopełnianie pozycji tabulacji:

ipy.exe -D -X:TabCompletion -X:ColorfulConsole

Warto również pamiętać, że programy w języku Python możemy zapisać do jednego lub wielu plików (najczęściej stosowane rozszerzenie plików z programami w Pythonie to *.py) i uruchamiać je w następujący sposób:

ipy.exe program.py

Stwórzmy zatem nasz pierwszy kawałek kodu.

C:\Program Files (x86)\IronPython 2.7>ipy64.exe -D -X:TabCompletion -X:ColorfulConsole

IronPython 2.7 Beta 1 (2.7.0.10) on .NET 4.0.30319.1

Type "help", "copyright", "credits" or "license" for more information.

>>> 2+2

4

>>> # to jest komentarz

>>> 1.2 * (64 / 2.4) + 36 + 2 ** 5 # a teraz cos bardziej zaawansowanego

100.0

>>> # Python bez problemu radzi sobie z liczbami zespolonymi

>>> 1j * complex(0,1)

(-1+0j)

>>> 3+1j*3

(3+3j)

>>> (3+1j)*3

(9+3j)

>>> # nie są mu obce również funkcje matematyczne

>>> abs(-0.5) + round(3.123456)

3.5

>>> # te bardziej zaawansowane dostępnesą po zaimportowaniu biblioteki matematycznej

>>> import math

>>> math.cos(math.pi / 4.0) + math.log(1024, 2)

10.707106781186548

>>> # bez zbędnego wysiłku możemyrównież operować na naprawdę dużych liczbach oraz zmiennych

>>> duza_liczba1 = 27362736273627362763

>>> duza_liczba2 = 8989898987873223222345

>>> wynik = duza_liczba1 + duza_liczba2

>>> print wynik

9017261724146850585108

>>>

2. IronPython i łańcuchy znaków

Osobom piszącym skrypty lub mającym do czynienia z intensywnym przetwarzaniem plików tekstowych (np. logów) bez wątpienia przydadzą się liczne konstrukcje i funkcje ułatwiające manipulacje łańcuchami znaków. Przyjrzyjmy się kilku przykładom.

>>> 'some string'

'some string'

>>> word = 'Python' + '!'

>>> word

'Python!'

>>> '<' + word*5 + '>'

'<Python!Python!Python!Python!Python!>'

>>> len(word)

7

>>> word[-1] # zwraca ostatni znak

'!'

>>> word[:-2] # zwraca wszystkie znaki oprócz ostatnich dwóch

'Pytho'

>>> 

>>> # użycie wyrażeń regularnych jest również bardzo proste

>>> import re

>>> re.match('[0-9]', 'asd123') # dopasowanie do wzorca, od początku literału

>>> re.search('[0-9]', 'asd123') # dopasowanie do wzorca, wyszukiwanie w całym napisie

<RE_Match object at 0x000000000000002B>

>>> res = re.search('[0-9]', 'asd123')

>>> res.group(0)

'1'

>>> # proste operacje na systemie wejścia/wyjścia

>>> f = open('plik.txt') # otworzenie pliku

>>> print f

<open file 'plik.txt', mode 'r' at 0x0002CCEB>

>>> f.readline()

'to jest plik tekstowy'

>>> f.close() # zwolnienie uchwytu do pliku

>>>

3. IronPython – podstawowe instrukcje sterujące

Nie da się napisać żadnego programu bez stosowania w kodzie typowych konstrukcji, takich jak pętle czy wyrażenia warunkowe. Zobaczmy, co na tym polu oferuje język Python.

>>> x = int(raw_input('Podaj liczbe: '))

Podaj liczbe: 99

>>> if x < 0:

...     print 'Liczba jest mniejsza od zera.'

... elif x == 0:

...     print 'Liczba jest równa zeru'

... elif x > 0:

...     print 'Liczba jest większa niż zero'

... else:

...     print 'A teraz cos z zupełnie innej beczki'

...

Liczba jest większa niż zero

>>> # czas na prostą tablicę

>>> napisy = ['C', 'Visual Basic', 'Haskell']

>>> # i prosta pętla

>>> for x in napisy:

...     print x, len(x)

...

C 1

Visual Basic 12

Haskell 7

>>>

4. IronPython – kolekcje i struktury danych

Język Python posiada wiele przyjaznych w użyciu i przydatnych kolekcji oraz struktur danych. Choć na programistach języków takich jak Java, czy C# nie zrobią one większego wrażenia, to programiści tworzący skrypty w leciwym już VB Script powinni być mile zaskoczeni. Zobaczmy zatem kilka przykładów.

>>> # prosta lista

>>> lista = ['element', 'kot', 12, 34.56]

>>> lista

['element', 'kot', 12, 34.56]

>>> # dodanie elementu do listy

>>> lista.append('pies')

>>> lista

['element', 'kot', 12, 34.56, 'pies']

>>> len(lista)

5

>>> # użycie listy jak kolekcji typu 'stos'

>>> lista.pop()

'pies'

>>> lista.pop()

34.56

>>> lista

['element', 'kot', 12]

>>> # użycie listy jak kolekcji typu 'kolejka'

>>> from collections import deque

>>> # użycie standardowej listy, jako kolejki nie jest zbyt wydajne, stąd import dodatkowego modułu

>>> kolejka = deque(lista)

>>> kolejka

deque(['element', 'kot', 12])

>>> kolejka.popleft()

'element'

>>> kolejka.popleft()

'kot'

>>> kolejka

deque([12])

>>> # a teraz przydatna metoda oraz elementy programowania funkcyjnego

>>> liczby = range(10)

>>> liczby

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> def f(x): return x % 2 == 0 # definicja funkcji sprawdzającej czy podany parametr jest liczbą parzystą

...

>>> filter (f, liczby) # funkcja zwracająca liczby, dla których podana jako parametr funkcja zwróciła 'true'

[0, 2, 4, 6, 8]

>>> # bardzo wygodne w użyciu są również tzw. Tuple, czyli struktura danych mogąca przechować dowolną ilość elementów nawet o różnych typach danych

>>> tuple1 = 12, 'napis', 45.12

>>> tuple1[1]

'napis'

>>> tuple1

(12, 'napis', 45.12)

>>> # wyświetlenie elementów w odwrotnej kolejności

>>> for i in reversed(tuple1):

...     print i

...

45.12

napis

12

5. IronPython jako język proceduralny i obiektowy

W języku Python można tworzyć oczywiście standardowe funkcje i procedury, ale Python jest też pełnoprawnym językiem obiektowym oferującym między innymi takie mechanizmy, jak dziedziczenie.

>>> # funkcja zwracająca ciąg liczb Fibonacciego

>>> def fib(n):

...     a, b = 0, 1

...     while a < n:

...         print a,

...         a, b = b, a + b

...

>>> # wywołajmy, zatem naszą funkcję

>>> fib(20)

0 1 1 2 3 5 8 13 >>>

>>> fib(2000)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 >>>

# Prosta klasa

>>> class Samochod:

...     def __init__ (self, marka, kolor): # konstruktor

...         self.marka = marka

...         self.kolor = kolor

...     def GetKolor(self):  # definicja prostej metody

...         print self.kolor

...

>>> s = Samochod('Mitsubishi', 'czerwony') # tworzenie obiektu klasy 'Samochód'

>>> s.marka, s.kolor, s.GetKolor() # odczytywanie właściwości obiektu oraz wywołanie metody

czerwony

('Mitsubishi', 'czerwony', None)

>>>

6. IronPython – integracja z platformą .NET

W ostatnim przykładzie zobaczymy, jak IronPython radzi sobie ze światem platformy .NET, ponieważ to właśnie ta cecha tej implementacji języka Python jest tak ciekawa z punktu widzenia programisty .NET i posiadanej już przez niego wiedzy.

>>> import clr # import modułu odpowiedzialnego za integrację z platformą .NET

>>> clr.AddReference('System.Windows.Forms') # dodawanie referencji do standardowych bibliotek

>>> clr.AddReference('System.Drawing') # znanych chyba każdemuprogramiście.NET

>>> from System.Windows.Forms import (

...     Application, Form)

>>> form = Form() # tworzenie obiektu typu Form()

>>> form.Text = 'Hello from IronPython'

>>> Application.Run(form)

A oto wynik działania naszego programu:

**Rys. 3. Prosta formatka stworzona przy użyciu IronPythona.

IronPython i Visual Studio

Choć proste programy da się z powodzeniem pisać w interaktywnej konsoli lub prostym edytorze tekstowym, to w większych aplikacjach przydaje się bardziej zaawansowane środowisko programistyczne. Do tej grupy narzędzi bez wątpienia należy Visual Studio, który od wersji 2008 może posiadać integrację z bohaterem naszego artykułu, czyli IronPythonem.

Dzięki integracji z Visual Studio programista języka Python zyskuje:

• cztery typy projektów w sekcji IronPython:
  • Console Application,
  • WinFormsApplication,
  • IronPython Silverlight Web Page,
  • WPF Application;
• możliwość wizualnego projektowania interfejsów użytkownika;
• kolorowanie składni i podpowiadanie możliwych do użycia klas, obiektów i metod wraz z autodopełnianiem;.
• pełne wsparcie dla debuggera wraz ze wszystkimi jego udogodnieniami, np.  okna Watch, Locals, Call Stack czy Immediate Window;
• możliwość wywołania w dowolnej chwili interaktywnej konsoli IronPythona dostępnej z poziomu Visual Studio.

**Rys. 4. Projekt aplikacji WPF w języku IronPython.

**Rys. 5. Debugowanie aplikacji w języku IronPython z użyciem Visual Studio.

Podsumowanie

W niniejszym artykule dowiedziałeś się o filozofii języka Python oraz jak przygotować swoje środowisko do pracy z jego implementacją pod platformę .NET. Na podstawie kilku przykładów dowiedzieliśmy się również o podstawowych możliwościach tego języka, co powinno zachęcić zainteresowane osoby do bliższego z nim zapoznania. Jeżeli nie miałeś więc do tej pory okazji, drogi Czytelniku, aby zrobić ten pierwszy krok z dynamicznymi językami programowania, to teraz nie masz już wymówek.

W kolejnym artykule zajmiemy się bardziej formalnym i szczegółowym wprowadzeniem do języka Python.

---