Python関数の使い方まとめ

空の関数

何も行わない空の関数を定義したい場合は、pass ステートメントを使用できます: pass语句：

def nop():    pass

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

pass还可以用在其他语句里，比如if

小结

定义函数时，需要确定函数名和参数个数；

如果有必要，可以先对参数的数据类型做检查；

函数体内部可以用return随时返回函数结果；

函数执行完毕也没有return语句时，自动return None。

函数可以同时返回多个值，但其实就是一个tuple。

 

可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

当然，上面复杂的调用可以用简化的写法：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

 

命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。

仍以person()函数为例，我们希望检查是否有city和job参数

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, *, city, job):    print(name, age, city, job)

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

调用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):    print(name, age, args, city, job)

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>TypeError: person() takes 2 positional arguments but 4 were given

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

比如定义一个函数，包含上述若干种参数：

def f1(a, b, c=0, *args, **kw):    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)def f2(a, b, c=0, *, d, **kw):    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

最神奇的是通过一个tuple和dict，你也可以调用上述函数：

>>> args = (1, 2, 3, 4)>>> kw = {'d': 99, 'x': '#'}>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}>>> args = (1, 2, 3)>>> kw = {'d': 88, 'x': '#'}>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

所以，对于任意函数，都可以通过类似func(*args, **kw)

class file(object)    def close(self): # real signature unknown; restored from __doc__        关闭文件        """
        close() -> None or (perhaps) an integer.  Close the file.
         
        Sets data attribute .closed to True.  A closed file cannot be used for
        further I/O operations.  close() may be called more than once without
        error.  Some kinds of file objects (for example, opened by popen())
        may return an exit status upon closing.        """
 
    def fileno(self): # real signature unknown; restored from __doc__        文件描述符  
         """
        fileno() -> integer "file descriptor".
         
        This is needed for lower-level file interfaces, such os.read().        """
        return 0    
 
    def flush(self): # real signature unknown; restored from __doc__        刷新文件内部缓冲区        """ flush() -> None.  Flush the internal I/O buffer. """
        pass
 
 
    def isatty(self): # real signature unknown; restored from __doc__        判断文件是否是同意tty设备        """ isatty() -> true or false.  True if the file is connected to a tty device. """
        return False 
 
    def next(self): # real signature unknown; restored from __doc__        获取下一行数据，不存在，则报错        """ x.next() -> the next value, or raise StopIteration """
        pass
 
    def read(self, size=None): # real signature unknown; restored from __doc__        读取指定字节数据        """
        read([size]) -> read at most size bytes, returned as a string.
         
        If the size argument is negative or omitted, read until EOF is reached.
        Notice that when in non-blocking mode, less data than what was requested
        may be returned, even if no size parameter was given.        """
        pass
 
    def readinto(self): # real signature unknown; restored from __doc__        读取到缓冲区，不要用，将被遗弃        """ readinto() -> Undocumented.  Don't use this; it may go away. """
        pass
 
    def readline(self, size=None): # real signature unknown; restored from __doc__        仅读取一行数据        """
        readline([size]) -> next line from the file, as a string.
         
        Retain newline.  A non-negative size argument limits the maximum
        number of bytes to return (an incomplete line may be returned then).
        Return an empty string at EOF.        """
        pass
 
    def readlines(self, size=None): # real signature unknown; restored from __doc__        读取所有数据，并根据换行保存值列表        """
        readlines([size]) -> list of strings, each a line from the file.
         
        Call readline() repeatedly and return a list of the lines so read.
        The optional size argument, if given, is an approximate bound on the
        total number of bytes in the lines returned.        """
        return [] 
    def seek(self, offset, whence=None): # real signature unknown; restored from __doc__        指定文件中指针位置        """
        seek(offset[, whence]) -> None.  Move to new file position.
         
        Argument offset is a byte count.  Optional argument whence defaults to
(offset from start of file, offset should be >= 0); other values are 1
        (move relative to current position, positive or negative), and 2 (move
        relative to end of file, usually negative, although many platforms allow
        seeking beyond the end of a file).  If the file is opened in text mode,
        only offsets returned by tell() are legal.  Use of other offsets causes
        undefined behavior.
        Note that not all file objects are seekable.        """
        pass
 
    def tell(self): # real signature unknown; restored from __doc__        获取当前指针位置        """ tell() -> current file position, an integer (may be a long integer). """
        pass
 
    def truncate(self, size=None): # real signature unknown; restored from __doc__        截断数据，仅保留指定之前数据        """
        truncate([size]) -> None.  Truncate the file to at most size bytes.
         
        Size defaults to the current file position, as returned by tell().        """
        pass
 
    def write(self, p_str): # real signature unknown; restored from __doc__        写内容        """
        write(str) -> None.  Write string str to file.
         
        Note that due to buffering, flush() or close() may be needed before
        the file on disk reflects the data written.        """
        pass
 
    def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__        将一个字符串列表写入文件        """
        writelines(sequence_of_strings) -> None.  Write the strings to the file.
         
        Note that newlines are not added.  The sequence can be any iterable object
        producing strings. This is equivalent to calling write() for each string.        """
        pass
 
    def xreadlines(self): # real signature unknown; restored from __doc__        可用于逐行读取文件，非全部        """
        xreadlines() -> returns self.
         
        For backward compatibility. File objects now include the performance
        optimizations previously implemented in the xreadlines module.        """
        passPython 2.x

pass ステートメントは何も行わないので、何の役に立つのでしょうか?実際、pass はプレースホルダーとして使用できます。たとえば、関数コードの書き方がまだわかっていない場合は、最初に pass を置くことができます。コードが実行できること。

pass は、if などの他のステートメントでも使用できます

概要

関数を定義するときは、関数名とパラメーターの数を決定する必要があります。

必要に応じて、最初にパラメータのデータ型を決定します。チェックを実行します。🎜🎜関数が実行され、return を使用できます。 code>return ステートメントを実行すると、自動的に return None が返されます。 🎜🎜この関数は同時に複数の値を返すことができますが、実際にはタプルです。 🎜🎜🎜🎜変数パラメーター🎜🎜 Python 関数では、変数パラメーターを定義することもできます。名前が示すように、可変パラメーターは、渡されるパラメーターの数が可変であり、1、2、または任意の数、または 0 の可能性があることを意味します。 🎜🎜*nums は、nums リストのすべての要素を変数パラメーターとして渡すことを意味します。この書き方は非常に便利で、非常に一般的です。 🎜🎜キーワード パラメーター🎜🎜 変数パラメーターを使用すると、関数が呼び出されるときに、0 または任意の数のパラメーターを渡すことができます。キーワード パラメーターを使用すると、パラメーター名を含むパラメーターを 0 個または任意の数で渡すことができ、これらのキーワード パラメーターは関数内の dict に自動的にアセンブルされます。 🎜🎜キーワードパラメータは何に使用されますか?関数の機能を拡張できます。たとえば、person 関数では、呼び出し元が希望する場合は、2 つのパラメータ name と age を受け取ることが保証されます。さらにパラメータを受け取ることもできます。ユーザー登録機能を実行していると想像してください。ユーザー名と年齢は必須ですが、それ以外はすべてオプションです。キーワード パラメーターを使用してこの機能を定義すると、登録のニーズを満たすことができます。 🎜🎜変数パラメーターと同様に、最初に辞書を組み立ててから、その辞書をキーワード パラメーターに変換して渡すこともできます: 🎜

🎜

class TextIOWrapper(_TextIOBase):    """
    Character and line based layer over a BufferedIOBase object, buffer.
    
    encoding gives the name of the encoding that the stream will be
    decoded or encoded with. It defaults to locale.getpreferredencoding(False).
    
    errors determines the strictness of encoding and decoding (see
    help(codecs.Codec) or the documentation for codecs.register) and
    defaults to "strict".
    
    newline controls how line endings are handled. It can be None, '',
    '\n', '\r', and '\r\n'.  It works as follows:
    
    * On input, if newline is None, universal newlines mode is
      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
      these are translated into '\n' before being returned to the
      caller. If it is '', universal newline mode is enabled, but line
      endings are returned to the caller untranslated. If it has any of
      the other legal values, input lines are only terminated by the given
      string, and the line ending is returned to the caller untranslated.
    
    * On output, if newline is None, any '\n' characters written are
      translated to the system default line separator, os.linesep. If
      newline is '' or '\n', no translation takes place. If newline is any
      of the other legal values, any '\n' characters written are translated
      to the given string.
    
    If line_buffering is True, a call to flush is implied when a call to
    write contains a newline character.    """
    def close(self, *args, **kwargs): # real signature unknown        关闭文件        pass

    def fileno(self, *args, **kwargs): # real signature unknown        文件描述符  
        pass

    def flush(self, *args, **kwargs): # real signature unknown        刷新文件内部缓冲区        pass

    def isatty(self, *args, **kwargs): # real signature unknown        判断文件是否是同意tty设备        pass

    def read(self, *args, **kwargs): # real signature unknown        读取指定字节数据        pass

    def readable(self, *args, **kwargs): # real signature unknown        是否可读        pass

    def readline(self, *args, **kwargs): # real signature unknown        仅读取一行数据        pass

    def seek(self, *args, **kwargs): # real signature unknown        指定文件中指针位置        pass

    def seekable(self, *args, **kwargs): # real signature unknown        指针是否可操作        pass

    def tell(self, *args, **kwargs): # real signature unknown        获取指针位置        pass

    def truncate(self, *args, **kwargs): # real signature unknown        截断数据，仅保留指定之前数据        pass

    def writable(self, *args, **kwargs): # real signature unknown        是否可写        pass

    def write(self, *args, **kwargs): # real signature unknown        写内容        pass

    def __getstate__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __next__(self, *args, **kwargs): # real signature unknown
        """ Implement next(self). """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # defaultPython 3.x

🎜もちろん、上記は次のとおりです。複雑な呼び出しは単純化された方法で書くことができます: 🎜

🎜

with open('log','r') as f:
       
    ...

🎜**extra は、extra のすべての Key-Value を意味します dict キーワード引数を使用して関数の **kw パラメータに渡します。kw は kw によって取得された dict を取得します。 は extra のコピーです。kw への変更は関数外の extra には影響しません。 🎜🎜 🎜🎜名前付きキーワード パラメーター🎜🎜 キーワード パラメーターの場合、関数の呼び出し元は無制限のキーワード パラメーターを渡すことができます。何が渡されるかについては、関数内の kw を通じて確認する必要があります。 🎜🎜引き続き person() 関数を例として、city パラメータと job パラメータがあるかどうかを確認したいと思います🎜🎜必要に応じてキーワード パラメータの名前を制限するには、名前付きキーワード パラメータを使用できます。たとえば、キーワード パラメータとして city と job のみを受け取ります。この方法で定義された関数は次のとおりです: 🎜

🎜

with open('log1') as obj1, open('log2') as obj2:    pass

🎜 キーワード パラメータ **kw とは異なり、名前付きキーワード パラメータには特別な区切り文字が必要です* と * は、名前付きキーワード パラメータとして扱われます。 🎜🎜呼び出しメソッドは次のとおりです: 🎜

🎜

# 普通条件语句if 1 == 1:
    name = 'wupeiqi'else:
    name = 'alex'
   # 三元运算name = 'wupeiqi' if 1 == 1 else 'alex'

🎜関数定義に変数パラメーターがすでに存在する場合、次の名前付きキーワード パラメーターには特別な区切り文字*: 🎜

🎜

# ###################### 普通函数 ####################### 定义函数（普通方式）def func(arg):    return arg + 1   
# 执行函数result = func(123)   
# ###################### lambda ######################
   # 定义函数（lambda表达式）my_lambda = lambda arg : arg + 1   
# 执行函数result = my_lambda(123)

🎜名前付きキーワード パラメータは、位置パラメータとは異なり、パラメータ名で渡す必要があります。パラメータ名が渡されない場合、呼び出しはエラーを報告します: 🎜

🎜

def fact(n):    if n==1:        return 1    return n * fact(n - 1)

🎜パラメータの組み合わせ🎜🎜 Python で関数を定義します。必須パラメータ、デフォルトパラメータ、変数を使用できます。パラメータ、キーワード パラメータ、名前付きキーワード パラメータ、これら 5 つのパラメータは組み合わせて使用​​できます。ただし、パラメータ定義の順序は、必須パラメータ、デフォルト パラメータ、変数パラメータ、名前付きキーワード パラメータ、キーワード パラメータである必要があることに注意してください。 🎜🎜たとえば、上記のパラメータを含む関数を定義します。 🎜

🎜

>>> fact(1)1
>>> fact(5)120
>>> fact(100)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

===> fact(5)===> 5 * fact(4)===> 5 * (4 * fact(3))===> 5 * (4 * (3 * fact(2)))===> 5 * (4 * (3 * (2 * fact(1))))===> 5 * (4 * (3 * (2 * 1)))===> 5 * (4 * (3 * 2))===> 5 * (4 * 6)===> 5 * 24
===> 120

🎜 関数が呼び出されると、Python インタープリタはパラメータの位置とパラメータに従って、対応するパラメータを自動的に渡します。パラメータ名に入ります。 🎜

🎜

def fact(n):    return fact_iter(n, 1)def fact_iter(num, product):    if num == 1:        return product    return fact_iter(num - 1, num * product)

🎜 最も驚くべきことは、タプルと辞書を介して上記の関数を呼び出すこともできることです: 🎜

🎜

===> fact_iter(5, 1)===> fact_iter(4, 5)===> fact_iter(3, 20)===> fact_iter(2, 60)===> fact_iter(1, 120)===> 120

🎜つまり、どの関数でも、どのような方法であっても、func(*args, **kw) に似た形式で呼び出すことができます。そのパラメータは次のように定義されています。 🎜🎜🎜概要🎜🎜Python の関数には非常に柔軟なパラメータ形式があり、単純な呼び出しを実装できるだけでなく、非常に複雑なパラメータを渡すこともできます。 🎜🎜デフォルトパラメータは不変オブジェクトを使用する必要があります。変数オブジェクトの場合、プログラムの実行時にロジックエラーが発生します。 🎜🎜可変引数パラメーターとキーワード パラメーターを定義するための構文に注意してください:🎜

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

 

内置函数

注：查看详细猛击这里

 

文件操作函数

open函数，该函数用于文件处理

操作文件时，一般需要经历如下步骤：

• 打开文件

• 操作文件

一、打开文件

　　文件句柄 = open('文件路径', '模式')

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

• r，只读模式（默认）。

• w，只写模式。【不可读；不存在则创建；存在则删除内容；】

• a，追加模式。【可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

• r+，可读写文件。【可读；可写；可追加】

• w+，写读

• a+，同a

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

• rU

• r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

• rb

• wb

• ab

 

二、操作

class file(object)    def close(self): # real signature unknown; restored from __doc__        关闭文件        """
        close() -> None or (perhaps) an integer.  Close the file.
         
        Sets data attribute .closed to True.  A closed file cannot be used for
        further I/O operations.  close() may be called more than once without
        error.  Some kinds of file objects (for example, opened by popen())
        may return an exit status upon closing.        """
 
    def fileno(self): # real signature unknown; restored from __doc__        文件描述符  
         """
        fileno() -> integer "file descriptor".
         
        This is needed for lower-level file interfaces, such os.read().        """
        return 0    
 
    def flush(self): # real signature unknown; restored from __doc__        刷新文件内部缓冲区        """ flush() -> None.  Flush the internal I/O buffer. """
        pass
 
 
    def isatty(self): # real signature unknown; restored from __doc__        判断文件是否是同意tty设备        """ isatty() -> true or false.  True if the file is connected to a tty device. """
        return False 
 
    def next(self): # real signature unknown; restored from __doc__        获取下一行数据，不存在，则报错        """ x.next() -> the next value, or raise StopIteration """
        pass
 
    def read(self, size=None): # real signature unknown; restored from __doc__        读取指定字节数据        """
        read([size]) -> read at most size bytes, returned as a string.
         
        If the size argument is negative or omitted, read until EOF is reached.
        Notice that when in non-blocking mode, less data than what was requested
        may be returned, even if no size parameter was given.        """
        pass
 
    def readinto(self): # real signature unknown; restored from __doc__        读取到缓冲区，不要用，将被遗弃        """ readinto() -> Undocumented.  Don't use this; it may go away. """
        pass
 
    def readline(self, size=None): # real signature unknown; restored from __doc__        仅读取一行数据        """
        readline([size]) -> next line from the file, as a string.
         
        Retain newline.  A non-negative size argument limits the maximum
        number of bytes to return (an incomplete line may be returned then).
        Return an empty string at EOF.        """
        pass
 
    def readlines(self, size=None): # real signature unknown; restored from __doc__        读取所有数据，并根据换行保存值列表        """
        readlines([size]) -> list of strings, each a line from the file.
         
        Call readline() repeatedly and return a list of the lines so read.
        The optional size argument, if given, is an approximate bound on the
        total number of bytes in the lines returned.        """
        return [] 
    def seek(self, offset, whence=None): # real signature unknown; restored from __doc__        指定文件中指针位置        """
        seek(offset[, whence]) -> None.  Move to new file position.
         
        Argument offset is a byte count.  Optional argument whence defaults to
(offset from start of file, offset should be >= 0); other values are 1
        (move relative to current position, positive or negative), and 2 (move
        relative to end of file, usually negative, although many platforms allow
        seeking beyond the end of a file).  If the file is opened in text mode,
        only offsets returned by tell() are legal.  Use of other offsets causes
        undefined behavior.
        Note that not all file objects are seekable.        """
        pass
 
    def tell(self): # real signature unknown; restored from __doc__        获取当前指针位置        """ tell() -> current file position, an integer (may be a long integer). """
        pass
 
    def truncate(self, size=None): # real signature unknown; restored from __doc__        截断数据，仅保留指定之前数据        """
        truncate([size]) -> None.  Truncate the file to at most size bytes.
         
        Size defaults to the current file position, as returned by tell().        """
        pass
 
    def write(self, p_str): # real signature unknown; restored from __doc__        写内容        """
        write(str) -> None.  Write string str to file.
         
        Note that due to buffering, flush() or close() may be needed before
        the file on disk reflects the data written.        """
        pass
 
    def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__        将一个字符串列表写入文件        """
        writelines(sequence_of_strings) -> None.  Write the strings to the file.
         
        Note that newlines are not added.  The sequence can be any iterable object
        producing strings. This is equivalent to calling write() for each string.        """
        pass
 
    def xreadlines(self): # real signature unknown; restored from __doc__        可用于逐行读取文件，非全部        """
        xreadlines() -> returns self.
         
        For backward compatibility. File objects now include the performance
        optimizations previously implemented in the xreadlines module.        """
        passPython 2.x

python 2.0

class TextIOWrapper(_TextIOBase):    """
    Character and line based layer over a BufferedIOBase object, buffer.
    
    encoding gives the name of the encoding that the stream will be
    decoded or encoded with. It defaults to locale.getpreferredencoding(False).
    
    errors determines the strictness of encoding and decoding (see
    help(codecs.Codec) or the documentation for codecs.register) and
    defaults to "strict".
    
    newline controls how line endings are handled. It can be None, '',
    '\n', '\r', and '\r\n'.  It works as follows:
    
    * On input, if newline is None, universal newlines mode is
      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
      these are translated into '\n' before being returned to the
      caller. If it is '', universal newline mode is enabled, but line
      endings are returned to the caller untranslated. If it has any of
      the other legal values, input lines are only terminated by the given
      string, and the line ending is returned to the caller untranslated.
    
    * On output, if newline is None, any '\n' characters written are
      translated to the system default line separator, os.linesep. If
      newline is '' or '\n', no translation takes place. If newline is any
      of the other legal values, any '\n' characters written are translated
      to the given string.
    
    If line_buffering is True, a call to flush is implied when a call to
    write contains a newline character.    """
    def close(self, *args, **kwargs): # real signature unknown        关闭文件        pass

    def fileno(self, *args, **kwargs): # real signature unknown        文件描述符  
        pass

    def flush(self, *args, **kwargs): # real signature unknown        刷新文件内部缓冲区        pass

    def isatty(self, *args, **kwargs): # real signature unknown        判断文件是否是同意tty设备        pass

    def read(self, *args, **kwargs): # real signature unknown        读取指定字节数据        pass

    def readable(self, *args, **kwargs): # real signature unknown        是否可读        pass

    def readline(self, *args, **kwargs): # real signature unknown        仅读取一行数据        pass

    def seek(self, *args, **kwargs): # real signature unknown        指定文件中指针位置        pass

    def seekable(self, *args, **kwargs): # real signature unknown        指针是否可操作        pass

    def tell(self, *args, **kwargs): # real signature unknown        获取指针位置        pass

    def truncate(self, *args, **kwargs): # real signature unknown        截断数据，仅保留指定之前数据        pass

    def writable(self, *args, **kwargs): # real signature unknown        是否可写        pass

    def write(self, *args, **kwargs): # real signature unknown        写内容        pass

    def __getstate__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __next__(self, *args, **kwargs): # real signature unknown
        """ Implement next(self). """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # defaultPython 3.x

python3.0

三、管理上下文

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

with open('log','r') as f:
       
    ...

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：

with open('log1') as obj1, open('log2') as obj2:    pass

lambda表达式

学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：

# 普通条件语句if 1 == 1:
    name = 'wupeiqi'else:
    name = 'alex'
   # 三元运算name = 'wupeiqi' if 1 == 1 else 'alex'

对于简单的函数，也存在一种简便的表示方式，即：lambda表达式

# ###################### 普通函数 ####################### 定义函数（普通方式）def func(arg):    return arg + 1   
# 执行函数result = func(123)   
# ###################### lambda ######################
   # 定义函数（lambda表达式）my_lambda = lambda arg : arg + 1   
# 执行函数result = my_lambda(123)

lambda存在意义就是对简单函数的简洁表示!

 

递归

def fact(n):    if n==1:        return 1    return n * fact(n - 1)

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：

>>> fact(1)1
>>> fact(5)120
>>> fact(100)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

===> fact(5)===> 5 * fact(4)===> 5 * (4 * fact(3))===> 5 * (4 * (3 * fact(2)))===> 5 * (4 * (3 * (2 * fact(1))))===> 5 * (4 * (3 * (2 * 1)))===> 5 * (4 * (3 * 2))===> 5 * (4 * 6)===> 5 * 24
===> 120

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：

def fact(n):    return fact_iter(n, 1)def fact_iter(num, product):    if num == 1:        return product    return fact_iter(num - 1, num * product)

可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。

fact(5)对应的fact_iter(5, 1)的调用如下：

===> fact_iter(5, 1)===> fact_iter(4, 5)===> fact_iter(3, 20)===> fact_iter(2, 60)===> fact_iter(1, 120)===> 120

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

小结

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

汉诺塔：

#!/usr/bin/env python3# -*- coding: utf-8 -*-# 利用递归函数计算阶乘# N! = 1 * 2 * 3 * ... * Ndef fact(n):    if n == 1:        return 1    return n * fact(n-1)print('fact(1) =', fact(1))print('fact(5) =', fact(5))print('fact(10) =', fact(10))# 利用递归函数移动汉诺塔:def move(n, a, b, c):    if n == 1:        print('move', a, '-->', c)        return
    move(n-1, a, c, b)    print('move', a, '-->', c)
    move(n-1, b, a, c)

move(4, 'A', 'B', 'C')

以上がPython関数の使い方まとめの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。