`base` tried to do one too many things &amp;ndash; automatically handling loading modules but also allowing establishing inheritance from classes already loaded (possibly from a file whose name wasn&#39;t based on the module name).  To sort of make it work, there was some hackery that caused surprising results in some cases.  Rather than break backwards compatibility, a new, replacement pragma `parent` was introduced with cleaner semantics.

`parent` will be a core module as of 5.10.1.

**Update:** forgot that `base` handles `fields` (if you are using the `fields` pragma), which `parent` doesn&#39;t do.

Armed with the extra bit of information from ysth, I was able to see the differences in the docs:

The [`base`][1] pragma does the following things:

 - adds the named package to `@ISA`
 - loads the module with the same name as the named package using [`require`][2] (unless it detects that the package has already been loaded)
 - won&#39;t fail if a module with the same name as the package doesn&#39;t exist
 - dies if there are no symbols in the named package
 - if `$VERSION` does not exist in named package, base sets it to `&quot;-1, set by base.pm&quot;`
 - initializes the [`fields`][3] of the named package if they exist
 - does not call the import function of the named package

The [`parent`][4] pragma does the following things:

 - adds the named package to `@ISA`
 - loads the module with the same name as the named package using `require`
 - accepts an option that tells it not to die if a module with the same name as the package doesn&#39;t exist

  [1]: http://perldoc.perl.org/base.html
  [2]: http://perldoc.perl.org/functions/require.html
  [3]: http://perldoc.perl.org/fields.html
  [4]: http://search.cpan.org/dist/parent/lib/parent.pm

I&#39;m trying to convert some date/times to UTC, which I thought would be dead simple in Python - batteries included, right? Well, it would be simple except that Python (2.6) doesn&#39;t include any tzinfo classes. No problem, a quick search turns up [python-dateutil][1] which should do exactly what I need.

The problem is that I need to install it on Windows. I was able to upack the .tar.gz2 distribution using 7-zip, but now I&#39;m left with a collection of files and no guidance on how to proceed. When I try to run setup.py I get the error &quot;No module named setuptools&quot;.


  [1]: http://pypi.python.org/pypi/python-dateutil

How to install python-dateutil on Windows?

I know that one can define an **&#39;expected&#39;** exception in JUnit, doing:

    @Test(expect=MyException.class)
    public void someMethod() { ... }

But what if there is always same exception thrown, but with different &#39;nested&#39;
**causes**.

Any suggestions?

JUnit: Possible to &#39;expect&#39; a wrapped exception?

There appears to be a new pragma named [`parent`][1] that does roughly the same thing as [`base`][2].  What does `parent` do that warrants a new (non-core) module?  I am missing something?


  [1]: http://search.cpan.org/dist/parent/lib/parent.pm
  [2]: http://perldoc.perl.org/base.html

What is the difference between parent and base in Perl 5?

<p>There appears to be a new pragma named <a href="http://search.cpan.org/dist/parent/lib/parent.pm" target="_blank" rel="noopener noreferrer"><code>parent</code></a> that does roughly the same thing as <a href="http://perldoc.perl.org/base.html" target="_blank" rel="noopener noreferrer"><code>base</code></a>.  What does <code>parent</code> do that warrants a new (non-core) module?  I am missing something?</p>


I&#39;m maintaining a script that can get its input from various sources, and works on it per line. Depending on the actual source used, linebreaks might be Unix-style, Windows-style or even, for some aggregated input, mixed(!).

When reading from a file it goes something like this:

    @lines = &lt;IN&gt;;
    process(\@lines);

    ...

    sub process {
        @lines = shift;
        foreach my $line (@{$lines}) {
            chomp $line;
            #Handle line by line
        }
    }


So, what I need to do is replace the chomp with something that removes either Unix-style or Windows-style linebreaks.
I&#39;m coming up with way too many ways of solving this, one of the usual drawbacks of Perl :)

What&#39;s your opinion on the neatest way to chomp off generic linebreaks? What would be the most efficient?

Edit: A small clarification - the method &#39;process&#39; gets a list of lines from somewhere, _not nessecarily read from a file_. Each line might have

- No trailing linebreaks
- Unix-style linebreaks
- Windows-style linebreaks
- Just Carriage-Return (when original data has Windows-style linebreaks and is read with $/ = &#39;\n&#39;)
- An aggregated set where lines have different styles


Neatest way to remove linebreaks in Perl

Long version...

A co-worker asserted today after seeing my use of `while (1)` in a Perl script that `for (;;)` is faster.  I argued that they should be the same hoping that the interpreter would optimize out any differences. I set up a script that would run 1,000,000,000 for loop iterations and the same number of while loops and record the time between. I could find no appreciable difference. My co-worker said that a professor had told him that the `while (1)` was doing a comparison `1 == 1` and the `for (;;)` was not.  We repeated the same test with the 100x the number of iterations with C++ and the difference was negligible. It was however a graphic example of how much faster compiled code can be vs. a scripting language.

Short version...

Is there any reason to prefer a `while (1)` over a `for (;;)` if you need an infinite loop to break out of?

**Note:** If it&#39;s not clear from the question.  This was purely a fun academic discussion between a couple of friends.  I am aware this is not a super important concept that all programmers should agonize over.  Thanks for all the great answers I (and I&#39;m sure others) have learned a few things from this discussion.

**Update:** The aforementioned co-worker weighed in with a response below.

Quoted here in case it gets buried.

&gt; It came from an AMD assembly programmer. He stated that C programmers
&gt; (the poeple) don&#39;t realize that their code has inefficiencies. He said
&gt; today though, gcc compilers are very good, and put people like him out
&gt; of business. He said for example, and told me about the `while 1` vs
&gt; `for(;;)`. I use it now out of habit but gcc and especially interpreters
&gt; will do the same operation (a processor jump) for both these days,
&gt; since they are optimized.

while (1) Vs. for (;;) Is there a speed difference?

Having read a number of questions/answers over the past few weeks, I have seen the use of `\d` in perl regular expressions commented on as incorrect. As in the later versions of perl `\d` is not the same as `[0-9]`, as `\d` will represent any Unicode character that has the digit attribute, and that `[0-9]` represents the characters &#39;0&#39;, &#39;1&#39;, &#39;2&#39;, ..., &#39;9&#39;.

I appreciate that in some contexts `[0-9]` will be the correct thing to use, and in others `\d` will be. I was wondering which people feel is the correct default to use?

Personally I find the `\d` notation very succinct and expressive, whereas in comparison `[0-9]` is somewhat cumbersome. But I have little experience of doing multi-language code, or rather code for languages that do not fit into the ASCII character range, and therefore may be being naive.

I notice

    $find /System/Library/Perl/5.8.8/ -name \*pm | xargs grep &#39;\\d&#39; | wc -l
      298
    $find /System/Library/Perl/5.8.8/ -name \*pm | xargs grep &#39;\[0-9\]&#39; | wc -l
      26

Should I use \d or [0-9] to match digits in a Perl regex?

How do I sleep for shorter than a second in Perl?

How do I sleep for a millisecond in Perl?

How do I tell CPAN to install all dependencies?

I tried setting these in `cpan`:

    cpan&gt; o conf prerequisites_policy follow
    cpan&gt; o conf commit

I still had to answer &quot;y&quot; a couple of times (but fewer than before it feels like).

Is there a way to get it to always go ahead and install? I want to make it unattended. 

It would seem that I want a flag to always trust CPAN to do the right thing, and if it suggests an answer I would like to follow it (always hit &lt;kbd&gt;Enter&lt;/kbd&gt; when it asks something).


How do I tell CPAN to install all dependencies?

I have a class that is provided to me by an external library. I have created a subclass of this class. I also have an instance of the original class.

I now want to turn this instance into an instance of my subclass without changing any properties that the instance already has (except for those that my subclass overrides anyway).

The following solution seems to work.

    # This class comes from an external library. I don&#39;t (want) to control
    # it, and I want to be open to changes that get made to the class
    # by the library provider.
    class Programmer(object):
        def __init__(self,name):
            self._name = name
            
        def greet(self):
            print &quot;Hi, my name is %s.&quot; % self._name
            
        def hard_work(self):
            print &quot;The garbage collector will take care of everything.&quot;
            
    # This is my subclass.
    class C_Programmer(Programmer):
        def __init__(self, *args, **kwargs):
            super(C_Programmer,self).__init__(*args, **kwargs)
            self.learn_C()
            
        def learn_C(self):
            self._knowledge = [&quot;malloc&quot;,&quot;free&quot;,&quot;pointer arithmetic&quot;,&quot;curly braces&quot;]
            
        def hard_work(self):
            print &quot;I&#39;ll have to remember &quot; + &quot; and &quot;.join(self._knowledge) + &quot;.&quot;
    
        # The questionable thing: Reclassing a programmer.
        @classmethod
        def teach_C(cls, programmer):
            programmer.__class__ = cls # &lt;-- do I really want to do this?
            programmer.learn_C()
    
    
    joel = C_Programmer(&quot;Joel&quot;)
    joel.greet()
    joel.hard_work()
    #&gt;Hi, my name is Joel.
    #&gt;I&#39;ll have to remember malloc and free and pointer arithmetic and curly braces.
    
    jeff = Programmer(&quot;Jeff&quot;)
    
    # We (or someone else) makes changes to the instance. The reclassing shouldn&#39;t
    # overwrite these.
    jeff._name = &quot;Jeff A&quot; 
    
    jeff.greet()
    jeff.hard_work()
    #&gt;Hi, my name is Jeff A.
    #&gt;The garbage collector will take care of everything.
    
    # Let magic happen.
    C_Programmer.teach_C(jeff)
    
    jeff.greet()
    jeff.hard_work()
    #&gt;Hi, my name is Jeff A.
    #&gt;I&#39;ll have to remember malloc and free and pointer arithmetic and curly braces.

However, I&#39;m not convinced that this solution doesn&#39;t contain any caveats I haven&#39;t thought of (sorry for the triple negation), especially because reassigning the magical `__class__` just doesn&#39;t feel right. Even if this works, I can&#39;t help the feeling there should be a more pythonic way of doing this.

Is there?

----------

Edit: Thanks everyone for your answers. Here is what I get from them:

* Although the idea of reclassing an instance by assigning to `__class__` is not a widely used idiom, most answers (4 out of 6 at the time of writing) consider it a valid approach. One anwswer (by ojrac) says that it&#39;s &quot;pretty weird at first glance,&quot; with which I agree (it was the reason for asking the question). Only one answer (by Jason Baker; with two positive comments &amp; votes) actively discouraged me from doing this, however doing so based on the example use case moreso than on the technique in general.

* None of the answers, whether positive or not, finds an actual technical problem in this method. A small exception is jls who mentions to beware of old-style classes, which is likely true, and C extensions. I suppose that new-style-class-aware C extensions should be as fine with this method as Python itself (presuming the latter is true), although if you disagree, keep the answers coming.

As to the question of how pythonic this is, there were a few positive answers, but no real reasons given. Looking at the Zen (`import this`), I guess the most important rule in this case is &quot;Explicit is better than implicit.&quot; I&#39;m not sure, though, whether that rule speaks for or against reclassing this way.

* Using `{has,get,set}attr` seems more explicit, as we are explicitly making our changes to the object instead of using magic.

* Using `__class__ = newclass` seems more explicit because we explicitly say &quot;This is now an object of class &#39;newclass,&#39; expect a different behaviour&quot; instead of silently changing attributes but leaving users of the object believing they are dealing with a regular object of the old class.

Summing up: From a technical standpoint, the method seems okay; the pythonicity question remains unanswered with a bias towards &quot;yes.&quot; 

I have accepted Martin Geisler&#39;s answer, because the Mercurial plugin example is a quite strong one (and also because it answered a question I even hadn&#39;t asked myself yet). However, if there are any arguments on the pythonicity question, I&#39;d still like to hear them. Thanks all so far.

P.S. The actual use case is a UI data control object that needs to grow additional functionality *at runtime*. However, the question is meant to be very general.


Reclassing an instance in Python

The following code works:

    class Foo(tuple):
    
        def __init__(self, b):
            super(Foo, self).__init__(tuple(b))
    
    if __name__ == &#39;__main__&#39;:
        print Foo([3, 4])
    
    $ python play.py 

Result:

&lt;!-- language: lang-none --&gt;

    play.py:4: DeprecationWarning: object.__init__() takes no parameters
      super(Foo, self).__init__(tuple(b))
    (3, 4)

But not the following:

    class Foo(tuple):
    
        def __init__(self, a, b):
            super(Foo, self).__init__(tuple(b))
    
    if __name__ == &#39;__main__&#39;:
        print Foo(None, [3, 4])
    
    $ python play.py 

Result:

&lt;!-- language: lang-none --&gt;

    Traceback (most recent call last):
      File &quot;play.py&quot;, line 7, in &lt;module&gt;
        print Foo(None, [3, 4])
    TypeError: tuple() takes at most 1 argument (2 given)

Why?




Subclassing tuple with multiple __init__ arguments

In the [Python data model reference section on slots][1] there is a list of notes on using `__slots__`.  I am thoroughly confused by the 1st and 6th items, because they seem to be contradicting each other. 

**First item:**

 - When inheriting from a class without
   `__slots__`, the `__dict__` attribute
   of that class will always be
   accessible, so a `__slots__`
   definition in the subclass is
   meaningless.

**Sixth item:**

 - The action of a `__slots__`
   declaration is limited to the class
   where it is defined. As a result,
   subclasses will have a `__dict__`
   unless they also define `__slots__`
   (which must only contain names of any
   additional slots).

It seems to me these items could be better worded or shown through code, but I have been trying to wrap my head around this and am still coming up confused. I do understand how `__slots__` are [supposed to be used][2], and I am trying to get a better grasp on how they work.

**The Question:**

Can someone please explain to me in plain language what the conditions are for inheritance of slots when subclassing? 

(Simple code examples would be helpful but not necessary.)

  [1]: http://docs.python.org/reference/datamodel.html#slots
  [2]: https://stackoverflow.com/questions/472000/python-slots/472024#472024

How does inheritance of __slots__ in subclasses actually work?

I am building a class which subclasses &lt;code&gt;dict&lt;/code&gt;, and overrides &lt;code&gt;\__setitem__&lt;/code&gt;. I would like to be certain that my method will be called in all instances where dictionary items could possibly be set.

I have discovered three situations where Python (in this case, 2.6.4) does not call my overridden &lt;code&gt;\__setitem__&lt;/code&gt; method when setting values, and instead calls &lt;code&gt;PyDict_SetItem&lt;/code&gt; directly

1. In the constructor
1. In the &lt;code&gt;setdefault&lt;/code&gt; method
1. In the &lt;code&gt;update&lt;/code&gt; method

As a very simple test:

    class MyDict(dict):
        def __setitem__(self, key, value):
            print &quot;Here&quot;
            super(MyDict, self).__setitem__(key, str(value).upper())

    &gt;&gt;&gt; a = MyDict(abc=123)
    &gt;&gt;&gt; a[&#39;def&#39;] = 234
    Here
    &gt;&gt;&gt; a.update({&#39;ghi&#39;: 345})
    &gt;&gt;&gt; a.setdefault(&#39;jkl&#39;, 456)
    456
    &gt;&gt;&gt; print a
    {&#39;jkl&#39;: 456, &#39;abc&#39;: 123, &#39;ghi&#39;: 345, &#39;def&#39;: &#39;234&#39;}

You can see that the overridden method is only called when setting the items explicitly. To get Python to always call my &lt;code&gt;\__setitem__&lt;/code&gt; method, I have had to reimplement those three methods, like this:

    class MyUpdateDict(dict):
        def __init__(self, *args, **kwargs):
            self.update(*args, **kwargs)

        def __setitem__(self, key, value):
            print &quot;Here&quot;
            super(MyUpdateDict, self).__setitem__(key, value)

        def update(self, *args, **kwargs):
            if args:
                if len(args) &gt; 1:
                    raise TypeError(&quot;update expected at most 1 arguments, got %d&quot; % len(args))
                other = dict(args[0])
                for key in other:
                    self[key] = other[key]
            for key in kwargs:
                self[key] = kwargs[key]

        def setdefault(self, key, value=None):
            if key not in self:
                self[key] = value
            return self[key]

Are there any other methods which I need to override, in order to know that Python will *always* call my &lt;code&gt;\__setitem__&lt;/code&gt; method?

**UPDATE**

Per gs&#39;s suggestion, I&#39;ve tried subclassing UserDict (actually, IterableUserDict, since I want to iterate over the keys) like this:

    from UserDict import *;
    class MyUserDict(IterableUserDict):
        def __init__(self, *args, **kwargs):
            UserDict.__init__(self,*args,**kwargs)

        def __setitem__(self, key, value):
            print &quot;Here&quot;
            UserDict.__setitem__(self,key, value)

This class seems to correctly call my &lt;code&gt;\__setitem__&lt;/code&gt; on &lt;code&gt;setdefault&lt;/code&gt;, but it doesn&#39;t call it on &lt;code&gt;update&lt;/code&gt;, or when initial data is provided to the constructor.

**UPDATE 2**

Peter Hansen&#39;s suggestion got me to look more carefully at dictobject.c, and I realised that the update method could be simplified a bit, since the built-in dictionary constructor simply calls the built-in update method anyway. It now looks like this:

    def update(self, *args, **kwargs):
        if len(args) &gt; 1:
            raise TypeError(&quot;update expected at most 1 arguments, got %d&quot; % len(args))
        other = dict(*args, **kwargs)
        for key in other:
            self[key] = other[key]


Subclassing Python dictionary to override __setitem__

I would like to add some rounded corners to all of the UIImageViews in my project. I have already got the code working, but am having to apply it to every image; should I subclass UIImageView to add this? If so, can someone give me some pointers as to how to do this?

Here is the code

    - (void)viewDidLoad {
        [super viewDidLoad];
    	NSString *mainpath = [[NSBundle mainBundle] bundlePath];
    	welcomeImageView.image = [UIImage imageWithContentsOfFile:[mainpath stringByAppendingString:@&quot;/test.png&quot;]];
    	welcomeImageView.layer.cornerRadius = 9.0;
    	welcomeImageView.layer.masksToBounds = YES;
    	welcomeImageView.layer.borderColor = [UIColor blackColor].CGColor;
    	welcomeImageView.layer.borderWidth = 3.0;
    	CGRect frame = welcomeImageView.frame;
    	frame.size.width = 100;
    	frame.size.height = 100;
    	welcomeImageView.frame = frame;
    }



Add rounded corners to all UIImageViews

What&#39;s the closest GCC equivalent to this [MSVC][1] preprocessor code?

    #pragma warning( push )                    // Save the current warning state.
    #pragma warning( disable : 4723 )          // C4723: potential divide by 0
    // Code which would generate warning 4723.
    #pragma warning( pop )                     // Restore warnings to previous state.

We have code in commonly included headers which we do not want to generate a specific warning for. However, we want files which include those headers to continue to generate that warning (if the project has that warning enabled).

  [1]: https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B





Selectively disable GCC warnings for only part of a translation unit

I am currently working on a big project and maintaining all those include guards makes me crazy! Writing it by hand is frustrating waste of time. Although many editors can generate include guards this doesn&#39;t help much:

1. Editor generates guard symbol based on a filename. The problem occurs when you have headers with the same filename in different directories. Both of them will get the same include guard. Including directory structure into the guard symbol would require some fancy approach from the editor, since slashes and backslashes in the macro are not the best thing.

2. When I have to rename a file I should rename all the include guards as well (in the ifndef, define and ideally endif&#39;s comment). Annoying.

3. Preprocessor is flooded with tons of symbols without a clue what they mean.

4. Nevertheless definition is included once, compiler still opens header every time it meets header inclusion.

5. Include guards don&#39;t fit into namespaces nor templates. In fact they are subverting namespaces!

6. You have a chance that your guard symbol won&#39;t be unique.

Maybe they were acceptable solution in times when programs contained less than 1000 headers in single directory. But nowadays? It is ancient, it has nothing to do with modern coding habits. What bothers me the most is that this issues could be almost compeletly solved by #pragma once directive. Why is it not a standard?

Why isn&#39;t C/C++&#39;s &quot;#pragma once&quot; an ISO standard?

What does the HTTP header Pragma: Public mean?

Is there some way to embed pragma statement in macro with other statements?

I am trying to achieve something like:

    #define DEFINE_DELETE_OBJECT(type)                      \
        void delete_ ## type_(int handle);                  \
        void delete_ ## type(int handle);                                                \
        #pragma weak delete_ ## type_ = delete_ ## type

I am okay with boost solutions (save for wave) if one exists.

Pragma in define macro

In Visual C++, it&#39;s possible to use [`#pragma warning (disable: ...)`][1]. Also I found that in GCC you can [override per file compiler flags][2]. How can I do this for &quot;next line&quot;, or with push/pop semantics around areas of code using GCC?


  [1]: https://msdn.microsoft.com/en-us/library/2c8f766e.aspx
  [2]: http://gcc.gnu.org/onlinedocs/gcc-4.3.3/gcc/Diagnostic-Pragmas.html#Diagnostic-Pragmas

Content Type	Original Author	Original Content on Stackoverflow
Question	Chas. Owens	View Question on Stackoverflow
Solution 1 - Perl	ysth	View Answer on Stackoverflow
Solution 2 - Perl	Chas. Owens	View Answer on Stackoverflow

What is the difference between parent and base in Perl 5?

Perl Problem Overview

Perl Solutions

Solution 1 - Perl

Solution 2 - Perl

JUnit: Possible to 'expect' a wrapped exception?

How to install python-dateutil on Windows?

Attributions