<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[小胖子吃辣肉面的专栏]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/rommi</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; rommi]]></copyright><item><title><![CDATA[5 个很好的 Python 面试题]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51991238</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51991238</guid><author>rommi</author><pubDate>Fri, 22 Jul 2016 08:22:28 +0800</pubDate><description><![CDATA[问题一：以下的代码的输出将是什么? 说出你的答案并解释。
class Parent(object):
    x = 1

class Child1(Parent):
    pass

class Child2(Parent):
    pass

print Parent.x, Child1.x, Child2.x
Child1.x = 2
print Parent.x, Child1.x,]]></description><category></category></item><item><title><![CDATA[Python 函数默认参数不能使用可变对象，如List,dict]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51979556</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51979556</guid><author>rommi</author><pubDate>Thu, 21 Jul 2016 09:34:35 +0800</pubDate><description><![CDATA[许多使用很长时间Python的人也被下面的问题困扰:
def foo(a=[]):
    a.append(5)
    return a

Python新手估计可能会想这个函数返回一个只有元素[5]的列表.但是结果却出人意料:
>>> foo()
[5]
>>> foo()
[5, 5]
>>> foo()
[5, 5, 5]
>>> foo()
[5, 5, 5, 5]
>>> foo]]></description><category></category></item><item><title><![CDATA[python 类成员变量]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51967855</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51967855</guid><author>rommi</author><pubDate>Wed, 20 Jul 2016 14:20:19 +0800</pubDate><description><![CDATA[class A(object):
    x = 0   # static variable
    def __init__(self):
        self.x = 1 # instance variable

print (A.x) # display 0
a = A()
print (a.x) # display 1]]></description><category></category></item><item><title><![CDATA[Python With]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51597960</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51597960</guid><author>rommi</author><pubDate>Mon, 06 Jun 2016 20:15:49 +0800</pubDate><description><![CDATA[上下文管理器（Context Manager）：支持上下文管理协议的对象，这种对象实现了

__enter__() 和 __exit__() 方法。上下文管理器定义执行 with 语句时要建立的运行时上下文，

负责执行 with 语句块上下文中的进入与退出操作。通常使用 with 语句调用上下文管理器，

也可以通过直接调用其方法来使用。

运行时上下文（runtime cont]]></description><category></category></item><item><title><![CDATA[Python import 和 from import区别]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51484000</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51484000</guid><author>rommi</author><pubDate>Mon, 23 May 2016 19:08:29 +0800</pubDate><description><![CDATA[导入mode，import与from...import的不同之处在于，简单说：
如果你想要直接输入argv变量到你的程序中而每次使用它时又不想打sys，
则可使用：from sys import argv
一般说来，应该避免使用from..import而使用import语句，
因为这样可以使你的程序更加易读，也可以避免名称的冲突


from ... import 可能会导致命名冲突]]></description><category></category></item><item><title><![CDATA[Python  __init__.py 用法]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51446590</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51446590</guid><author>rommi</author><pubDate>Wed, 18 May 2016 19:25:05 +0800</pubDate><description><![CDATA[python的每个模块的包中，都有一个__init__.py文件，有了这个文件，我们才能导入这个目录下的module。
那么，__init__.py还有什么别的功能呢？
其实，__init__.py里面还是可以有内容的，我们在导入一个包时，实际上导入了它的__init__.py文件。
我们可以再__init__.py文件中再导入其他的包，或者模块。
[python]
import rea]]></description><category></category></item><item><title><![CDATA[Python is和==区别]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51438869</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51438869</guid><author>rommi</author><pubDate>Tue, 17 May 2016 19:56:43 +0800</pubDate><description><![CDATA[1. is 是比较对象id是否相等，是否是同一对象，是否内存地址相同
2. ==是比较内容是否相等


a1 = "Hi"
b1 = "Hi"

a is b  True
a== b True


a2 = "long sentence"
b2 = "long sentence"

a is b  False
a== b True


python有string interning机制，]]></description><category></category></item><item><title><![CDATA[Python Enumerate]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51438761</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51438761</guid><author>rommi</author><pubDate>Tue, 17 May 2016 19:40:13 +0800</pubDate><description><![CDATA[def enumerate(collection): 
    'Generates an indexed series:  (0,coll[0]), (1,coll[1]) ...'      
     i = 0 
     it = iter(collection) 
     while 1: 
     yield (i, it.next()) 
     i += 1
enumer]]></description><category></category></item><item><title><![CDATA[Python With]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51427384</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51427384</guid><author>rommi</author><pubDate>Mon, 16 May 2016 19:16:20 +0800</pubDate><description><![CDATA[with如何工作?
紧跟with后面的语句被求值后，返回对象的 __enter__() 方法被调用，这个方法的返回值将被赋值给as后面的变量。
当with后面的代码块全部被执行完之后，将调用前面返回对象的 __exit__()方法。


#!/usr/bin/env python
# with_example01.py
class Sample:
    def __enter__(se]]></description><category></category></item><item><title><![CDATA[Python 生成器 generator]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51365828</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51365828</guid><author>rommi</author><pubDate>Tue, 10 May 2016 19:23:08 +0800</pubDate><description><![CDATA[1. 生成器：带有yield的函数，不能有return 
2. 生成器表达式：类似与一个yield值的匿名函数。表达式本身看起来像列表推到,
 但不是用方括号而是用圆括号包围起来


生成器（Generator）是创建迭代器的简单而强大的工具。它们写起来就像是正规的函数，只是在需要返回数据的时候使用yield语句。每次next()被调用时，生成器会返回它脱离的位置（它记忆语句最后一次执行]]></description><category></category></item><item><title><![CDATA[Python 迭代器]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51355728</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51355728</guid><author>rommi</author><pubDate>Mon, 09 May 2016 20:09:29 +0800</pubDate><description><![CDATA[迭代器是访问集合内元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素都被访问一遍后结束。

迭代器不能回退，只能往前进行迭代。这并不是什么很大的缺点，因为人们几乎不需要在迭代途中进行回退操作。

迭代器也不是线程安全的，在多线程环境中对可变集合使用迭代器是一个危险的操作。但如果小心谨慎，或者干脆贯彻函数式思想坚持使用不可变的集合，那这也不是什么大问题。

对于原生支持]]></description><category></category></item><item><title><![CDATA[Python3 nonlocal]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51277200</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51277200</guid><author>rommi</author><pubDate>Thu, 28 Apr 2016 20:04:58 +0800</pubDate><description><![CDATA[在Python 2.x中，闭包只能读外部函数的变量，而不能改写它。
举例来说，这样是合法的：

def a():
  x = 0
  def b():
    print locals()
    y = x + 1
    print locals()
    print x, y
  return b

a()()而这样是非法的：
def a():
  x = 0
  def b():]]></description><category></category></item><item><title><![CDATA[Python 闭包]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51277155</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51277155</guid><author>rommi</author><pubDate>Thu, 28 Apr 2016 19:57:00 +0800</pubDate><description><![CDATA[首先还得从基本概念说起，什么是闭包呢？来看下维基上的解释:


有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。
....
上面提到了两个关键的地方：
自由变量 和 函数,
 这两个关键稍后再说。还是得在赘述下“闭包”的意思，望文知意，可以形象的把它理解为一个封闭的包裹，这个包裹就是一个函数，当然还有函数内部对应的逻辑，包裹里面的东西就是自由变量，自由变量可以在随着包裹]]></description><category></category></item><item><title><![CDATA[Python 没有多态]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51253337</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51253337</guid><author>rommi</author><pubDate>Tue, 26 Apr 2016 19:43:01 +0800</pubDate><description><![CDATA[C++的多态表示： 基类指针指向派生类对象。 Python变量无类型，自然也就不存在多态。
python是一种动态语言，参数在传入之前是无法确定参数类型的

class A:  
    def prt(self):  
        print "A"  
  
class B(A):  
    def prt(self):  
        print "B"  
        ]]></description><category></category></item><item><title><![CDATA[为什么 Python 不支持函数重载？]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51253270</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51253270</guid><author>rommi</author><pubDate>Tue, 26 Apr 2016 19:31:52 +0800</pubDate><description><![CDATA[这个问题，最近在 cpyug 上面讨论得很火热。我简要概括一下。

为了考虑为什么 python 不提供函数重载，首先我们要研究为什么需要提供函数重载。

函数重载主要是为了解决两个问题。
1。可变参数类型。
2。可变参数个数。

另外，一个基本的设计原则是，仅仅当两个函数除了参数类型和参数个数不同以外，其功能是完全相同的，此时才使用函数重载，如果两个函数的功能其实不同，那么不应当]]></description><category></category></item><item><title><![CDATA[Python @classmethod和@staticmethod区别]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51203632</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51203632</guid><author>rommi</author><pubDate>Wed, 20 Apr 2016 20:04:27 +0800</pubDate><description><![CDATA[一般来说，要使用某个类的方法，需要先实例化一个对象再调用方法。

而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。

这有利于组织代码，把某些应该属于某个类的函数给放到那个类里去，同时有利于命名空间的整洁。




既然@staticmethod和@classmethod都可以直接类名.方法名()来调用，那他们有什么区别]]></description><category></category></item><item><title><![CDATA[Python 类成员函数第一个参数self]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51203509</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51203509</guid><author>rommi</author><pubDate>Wed, 20 Apr 2016 19:44:58 +0800</pubDate><description><![CDATA[类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。
你一定很奇怪Python如何给self赋值以及为何你不需要给它赋值。举一个例子会使此变得清晰。假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObj]]></description><category></category></item><item><title><![CDATA[Python Decorator 3: 嵌套]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51182173</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51182173</guid><author>rommi</author><pubDate>Mon, 18 Apr 2016 19:44:32 +0800</pubDate><description><![CDATA[@decorator_one
@decorator_two
def func():
    pass
等价于
func = decorator_one(decorator_two(func))


@decorator(arg1, arg2)
def func():
    pass
等价于
func = decorator(arg1,arg2)(func)



带参数及多]]></description><category></category></item><item><title><![CDATA[Python decorator 2:  类]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51154054</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51154054</guid><author>rommi</author><pubDate>Thu, 14 Apr 2016 19:13:08 +0800</pubDate><description><![CDATA[class myDecorator(object):
 
    def __init__(self, fn):
        print "inside myDecorator.__init__()"
        self.fn = fn
 
    def __call__(self):
        self.fn()
        print "inside myDecorato]]></description><category></category></item><item><title><![CDATA[Python decorator 1: 函数]]></title><link>https://blog.youkuaiyun.com/rommi/article/details/51146068</link><guid>https://blog.youkuaiyun.com/rommi/article/details/51146068</guid><author>rommi</author><pubDate>Wed, 13 Apr 2016 19:51:04 +0800</pubDate><description><![CDATA[A.把要装饰的方法作为输入参数，
B.在函数体内可以进行任意的操作(可以想象其中蕴含的威力强大，会有很多应用场景)，
C.只要确保最后返回一个可执行的函数即可（可以是原来的输入参数函数， 或者是一个新函数）


如果只需要在被包装函数执行前插入代码，decorator可以加上插入代码后返回原函数 (例1，3)
如果需要在包装函数执行之前和之后都插入代码，decorator需要另加一个函]]></description><category></category></item></channel></rss>