static IEnumerable<string> Lines(Stream stream)
        {
            using (StreamReader reader = new StreamReader(stream))
                for (string line; (line = reader.ReadLine()) != null; )
                    yield return line;
        }

FR>arr = open("test.txt").readlines()
FR>arr.sort()

            List<string> lines;
            using (Stream file = File.OpenRead("text.txt"))
                lines = new List<string>(Lines(file));
            lines.Sort();

FR>out = open("out.txt", "w")
FR>for line in arr:
FR>    print >> out, line,

            using (TextWriter file = File.CreateText("out.txt"))
                foreach (string line in lines)
                    file.WriteLine(file);

        delegate T Operator<T>(T l, T r);
        interface IMathOperators<T>
        {
            Operator<T> Add { get; }
            Operator<T> Sub { get; }
            Operator<T> Mul { get; }
            Operator<T> Div { get; }
        }
        class MathOperatorsInt : IMathOperators<int>
        {
            public Operator<int> Add { get { return delegate(int l, int r) { return l + r; }; } }
            public Operator<int> Sub { get { return delegate(int l, int r) { return l - r; }; } }
            public Operator<int> Mul { get { return delegate(int l, int r) { return l * r; }; } }
            public Operator<int> Div { get { return delegate(int l, int r) { return l / r; }; } }
        }
        static Dictionary<Type, object> MathOperatorsMap = new Dictionary<Type, object>();
        static IMathOperators<T> MathOperators<T>()
        {
            return (IMathOperators<T>)MathOperatorsMap[typeof(T)];
        }
        static Program()
        {
            MathOperatorsMap.Add(typeof(int), new MathOperatorsInt());
        }

        delegate T Parse<T>(string s);
        static IEnumerable<T> Map<T>(Stream stream)
        {
            Parse<T> parse = (Parse<T>)Delegate.CreateDelegate(typeof(Parse<T>),
                typeof(T), "Parse");
            foreach (string line in Lines(stream))
                yield return parse(line);
        }
        static T Sum<T>(IEnumerable<T> numbers)
        {
            Operator<T> add = MathOperators<T>().Add;
            T val = default(T);
            foreach (T number in numbers)
                val = add(val, number);
            return val;
        }

FR>import sys, itertools
FR>print sum(itertools.imap(int, open("in.txt")))
FR>

    using (Stream file = File.OpenRead("text.txt"))
        Console.WriteLine(Sum(Map<int>(file)));

FR>Другой пример я уже приводил Владу, простейший калькулятор(он из темы где вы с Владом спорили и ты делал этот же калькулятор на плюсах ссылки к сожалению не помню)

Т>"out.txt" 0: t[<t: 0: "text.txt"]
Т>

bash$ sort text.txt > out.txt

FR>arr = open("test.txt").readlines()
FR>arr.sort()

FR>out = open("out.txt", "w")
FR>for line in arr:
FR>    print >> out, line,
FR>

file("out.txt", "w").writelines(sorted(file("test.txt")))

WH>>>А я вот не знаю просвети не разумного.

FR>>знаешь

arr = open("test.txt").readlines()
arr.sort()

out = open("out.txt", "w")
for line in arr:
    print >> out, line,

import sys, itertools
print sum(itertools.imap(int, open("in.txt")))

# -*- coding: cp1251 -*-
import psyco, time

from math import sin
from math import cos

formula =r"-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234\
-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234\
-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234\
-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234\
-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234"

ParseCount = 1
CalcCount  = 10000

#компилируем
t1 = time.clock()
for i in xrange(ParseCount):
    f = eval(compile("lambda asd, qwe : " + formula, "<string>", "eval"))
    psyco.bind(f)
t2 = time.clock()
print "Парсинг %d проходов. Выполнено за %f сек." % (ParseCount, t2 - t1)

#используем
def run():
    t1 = time.clock()
    for i in xrange(1, CalcCount + 1):
        f(i, i)
    t2 = time.clock()
    print "Подсчет %d проходов. Выполнено за %f сек."  % (CalcCount, t2 - t1)

psyco.bind(run)

run()
run()

print "f(1, 1,) =", f(1, 1)
print "f(-1, 333) =", f(-1, 333)

sort < out.txt > out2.txt

class Test
    def test_method(self):
       ...
...
tst=some_external_function()
tst.test_method()

FR>Конечно напишешь Но суть в том что создатели java и C# выкинув процедурный стиль просто принуждают из простейших вещей делать криптокод.

def mercurioFight():
    npc = Find("Mercurio")
    pc = __main__.FindPlayer()
    state = pc.GetQuestState("Astrolite")
    if(state == 5):
        npc.SetModel("models/character/npc/unique/Santa_Monica/Mercurio/Mercurio.mdl")
        npc.SetDisposition("Neutral", 1)
        teleporter = Find("healthy_mercurio_spot")
        teleporter.Teleport()
        script = Find("mercurio_turn_around")
        script.StartSchedule()
        trigger = Find("mercurio_angry_talk_trigger")
        trigger.Enable()
        journal = Find("mercurio_journal")
        journal.ScriptUnhide()
        sparklies = Find("journal_sparklies")
        sparklies.ScriptUnhide()
    if(__main__.IsDead("Mercurio")):
        npc.Kill()

AVK>А вот это фик его знает. Тем более что помимо процедурного питон вподдерживает функциональный стиль. Вобщем плохому танцору задачи мешают

string ReadCharBlock(int length, istream &fin)
{
vector<char> buf(length);
fin.read(&buf[0], length);
return string(buf.begin(), buf.end());
}

void FillFromHashToDisk(string file, map<string, string> &props)
{
 string currentKey = "";
 ifstream fin(file.c_str(), ios::binary);
 while(!fin.eof())
  {
  string tag; getline(fin, tag);
  if(tag == "END") return;
  vector<string> parts;
  if(split(parts, tag, is_space()).size() > 1)
    {  
    if(parts[0] == "K")
        currentKey = ReadCharBlock(lexical_cast<int>(parts[1]), fin);
    else if(parts[0] == "V")
        props[currentKey] = ReadCharBlock(lexical_cast<int>(parts[1]), fin);
    }    
  }
}

Линух 4ever!!! Мелкософт на свалку!!

AVK>private void FillFromHashToDisk(string file, IDictionary props)
AVK>{
AVK>    string currentKey = "";
AVK>    using (StreamReader sr = new StreamReader(file))
AVK>        while (true)
AVK>        {
AVK>            string tag = sr.ReadLine();
AVK>            if (tag == "END")
AVK>                return;
AVK>            string[] parts = tag.Split(' ');
AVK>            if (parts[0] == "K")
AVK>                currentKey = ReadCharBlock(int.Parse(parts[1]), sr);
AVK>            else if (parts[0] == "V")
AVK>                props[currentKey] = ReadCharBlock(int.Parse(parts[1]), sr);
AVK>        }
AVK>}

AVK>private static string ReadCharBlock(int length, StreamReader sr)
AVK>{
AVK>    char[] buffer = new char[length];
AVK>    sr.Read(buffer, 0, length);
AVK>    return new string(buffer);
AVK>}
AVK>

def FillFromHashToDisk(fin):
    props = {}
    key = ""
    while True:
        tag = fin.readline();
        if tag[:3] == "END": break
        parts = tag.split(' ')
        if parts[0] == "K":
            key = fin.read(int(parts[1]))
        elif parts[0] == "V":
            props[key] = fin.read(int(parts[1]))
    return props        
        
print FillFromHashToDisk(file("data.txt", "rb"))

I currently work for Elemental Security -- a startup in California. We have created a large server/agent based security application that can monitor and manage the security configuration settings and network traffic of hosts on a large enterprise network. I've written a large part of the agent code in Python.

We're currently designing a new compound statement that lets you code resource acquisition and release pairs (such as acquiring and releasing a lock, or opening and closing a file) in a way that guarantees the release always happens without having to write a try-finally statement. Look at the recent python-dev summaries (http://www.python.org/dev/summary/) to find out more

arr = open("test.txt").readlines()
arr.sort()

out = open("out.txt", "w")
for line in arr:
    print >> out, line,

# -*- coding: cp1251 -*-
from math import sin
from math import cos

formula =r"-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234\
-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234\
-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234\
-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234\
-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234-(asd-qwe)*3*3*asd/(asd-sin(qwe)+5/asd)-123.234"

print "f(1, 1,) =", eval(compile("lambda asd, qwe : " + formula, "<string>", "eval"))(1, 1)

E>file("out.txt", "w").writelines(sorted(file("test.txt")))
E>

arr = open("test.txt").readlines()
arr.sort()
open("out.txt", "w").writelines(arr)

arr = open("test.txt").readlines()
arr.sort()
print >> open("out.txt", "w"), "".join(arr)

import win32api, os

class Test:
    def __del__(self):
        win32api.MessageBox(0, "test", "test")
        
tst = Test()

class Test:
    def crashIt(self):
       cyclic=self
       db_connection=connect_to_database(...)
tst=Test()

Ожидаемая стоимость — $6'995 на разработчика с 1 годичной поддержкой и апгрейдами. Пользователи версий IBM VA Smalltalk имеющие поддержку смогут обновится до Instantinations' VA Smalltalk за $1'495. Пользователи не имеющие поддержки, а так же пользователи конкурирующих диалектов смогут перейти на VAST 7 за $1'995.