Python에서 일반적으로 사용되는 PEP8 사양 및 Python 트릭

이 기사의 내용은 Python에서 일반적으로 사용되는 PEP8 사양과 Python 트릭입니다. 이제 모든 사람과 공유합니다. 도움이 필요한 친구들은 이 기사의 내용을 살펴볼 수 있습니다.

Foreword

이동 + 요약 이 표준은 Python의 몇 가지 트릭을 결합하여 더 많은 Pythonic 코드를 작성합니다~

PEP8 코딩 사양

영어 원본을 보려면 여기를 클릭하세요

다음은 다음과 같습니다. @bobo 편집본, 원문 PEP8 Python 코딩 표준 정리 코드 배열

1. 들여쓰기를 참조하세요. 4칸 들여쓰기(모든 편집자가 이 기능을 완료할 수 있음), Tap을 사용하지 않으며 Tap과 공백을 혼합할 수 없습니다.

2. 한 줄의 최대 길이는 79자입니다. 줄 바꿈에는 백슬래시를 사용할 수 있으며 괄호를 사용하는 것이 가장 좋습니다. 줄 바꿈 지점은 연산자 뒤에 적중되어야 합니다.

3. 클래스와 최상위 함수 정의 사이에 두 개의 빈 줄, 클래스의 메서드 정의 사이에 하나의 빈 줄, 함수 내에서 논리적으로 관련 없는 단락 사이에 하나의 빈 줄이 없도록 하세요.

문서 배열

1. 모듈 내용의 순서: 모듈 설명 및 독스트링 - 가져오기 - 전역 및 상수 - 기타 정의. 가져오기 부분은 표준, 타사, 자체 작성 순으로 배열되어 있으며 사이에 빈 줄이 있습니다

2. import os, sys와 같이 한 문장으로 여러 라이브러리를 가져오지 마십시오

3. from XX import XX 라이브러리를 인용할 때 'module.'을 생략할 수 있으나, 이 경우 import XX

공백 사용

1. 을 사용해야 합니다. 다양한 닫는 괄호 앞에 공백을 추가하세요.

2. 쉼표, 콜론, 세미콜론 앞에 공백을 추가하지 마세요.

3. 함수의 왼쪽 괄호 앞에 공백을 추가하지 마세요. 예를 들어 Func(1)

4. 시퀀스의 왼쪽 대괄호 앞에 공백을 추가하지 마세요. 예를 들어 list[2]

5. 연산자의 왼쪽과 오른쪽에 공백을 추가합니다. 정렬을 위해 공백을 추가하지 마세요.

6. 함수의 기본 매개변수에서 사용하는 할당 연산자 주위에 공백을 생략하세요.

7. 한 줄에 여러 문장을 쓰지 마세요.

8. if/for/while 문에서는 ';' 사용이 허용되지만, 실행 문이 한 문장이라도 주석으로 달아야 합니다. 새 줄

일반 원칙, 잘못된 댓글은 댓글이 없는 것보다 나쁩니다. 따라서 코드가 변경되면 가장 먼저 해야 할 일은 주석을 수정하는 것입니다! 주석은 영어로 작성해야 하며 첫 글자는 대문자로 작성해야 합니다. 문장 뒤에는 종결자가 있어야 하며 다음 문장을 시작하려면 공백이 두 개 와야 합니다. 구문인 경우 종결자를 생략할 수 있습니다.

1. 댓글, 코드 앞에 추가된 댓글을 차단합니다. '#' 뒤에 공백을 추가하세요. 단락은 '#' 줄로만 구분하세요. 예:

# Description : Module config.# # Input : None## Output : None

1. 줄 주석, 코드 줄 뒤에 주석을 추가합니다. 예: x = x + 1 # Increment x하지만 이 방법은 가능한 한 적게 사용하세요.

2. 쓸데없는 댓글은 자제해주세요.

문서 설명

1. 모든 공개 모듈, 함수, 클래스 및 메서드에 대한 독스트링을 작성하세요. 비공개 항목은 필요하지 않지만 주석을 작성할 수 있습니다(def의 다음 줄에).

2. 한 줄 주석은 다음 방법을 참고하세요

def kos_root():
    """Return the pathname of the KOS root directory."""
    global _kos_root    if _kos_root: return _kos_root
    ...

네이밍 규칙

* 새로운 코드는 다음 네이밍 스타일에 따라 컴파일하는 것을 원칙으로 하며, 기존의 코딩은 도서관은 가능한 한 스타일을 유지해야 합니다. 대문자 'i'와 대문자 'o'*를 단독으로 사용하지 마십시오. 모듈 이름은 가능한 한 짧게 유지하고 모두 소문자를 사용하며 밑줄은 허용됩니다.

1. 패키지 이름은 최대한 짧게 유지하고 모두 소문자를 사용하며 밑줄은 사용하지 마세요.

2. 클래스 이름은 CapWords 형식으로 지정되며, 모듈 내에서 사용되는 클래스 이름은 _CapWords 형식으로 지정됩니다.

3. 예외 이름 지정에는 CapWords+Error 접미사를 사용합니다.

4. 전역 변수는 C 언어의 정적 변수와 마찬가지로 가능한 한 모듈 내에서만 유효해야 합니다. 구현 방법에는 두 가지가 있습니다. 하나는

   all

   메커니즘이고, 다른 하나는 밑줄을 앞에 붙이는 것입니다.

5. 함수 이름은 모두 소문자를 사용하고, 밑줄도 가능합니다.

6. 상수 이름은 모두 대문자로 사용하고, 밑줄도 가능합니다.

7. 클래스의 속성(메소드, 변수) 이름은 모두 소문자로 표기해야 하며, 밑줄을 사용할 수 있습니다.

8. 클래스 속성에는 공개, 비공개 및 하위 클래스 API의 세 가지 범위가 있습니다. 이는 C++에서 공개, 비공개 및 보호로 이해될 수 있습니다. 비공개 속성 앞에 밑줄 접두사가 있습니다.

9. 클래스 속성이 키워드 이름과 충돌하는 경우 밑줄을 붙이고 약어나 기타 방법을 사용하지 마세요.

10. 하위 클래스 속성과 이름 지정 충돌을 방지하려면 클래스의 일부 속성 앞에 두 개의 밑줄을 붙입니다. 예를 들어, __a는 Foo 클래스에 선언되어 있으며 액세스 시 모호함을 피하기 위해 Foo._Foo__a를 통해서만 액세스할 수 있습니다. 하위 클래스가 Foo라고도 불리는 경우에는 할 수 있는 일이 없습니다.

11. 클래스 메소드의 첫 번째 매개변수는 self여야 하고, 정적 메소드의 첫 번째 매개변수는 cls여야 합니다.

12. 프로그래밍 제안

코딩 시 다른 Python 구현의 효율성과 기타 문제를 고려하세요. 예를 들어 '+' 연산자는 CPython(Python)에서는 매우 효율적이지만 Jython에서는 매우 낮습니다. 그래서 .join() 메소드를 사용해야 합니다.

尽可能使用‘is’‘is not’取代‘==’，比如if x is not None 要优于if x

使用基于类的异常，每个模块或包都有自己的异常类，此异常类继承自Exception。

常中不要使用裸露的except，except后跟具体的exceptions。例如

try:
    ...except Exception as ex:    print ex

1. 异常中try的代码尽可能少。

2. 使用startswith() and endswith()代替切片进行序列前缀或后缀的检查。

foo = 'abc000xyz'if foo.startswith('abc') and foo.endswith('xyz'):    
print 'yes'else:    print 'no'#yes#而如下的方式不提倡if foo[:3]=='abc' and foo[-3:]=='xyz':    
print 'yes'else:    print 'no'

1. 使用isinstance()比较对象的类型。比如:

foo = 'abc000xyz'# 提倡print isinstance(foo,int) # false# 不提倡print type(foo) == type('1') #true

1. 判断序列空或不空，有如下规则：

foo = 'abc000xyz'if foo:    
print "not empty"else:    
print "empty"#不提倡使用如下if len(foo):    
print "not empty"else:    print "empty"

1. 二进制数据判断使用 if boolvalue的方式。

给自己的代码打分

使用pylint进行代码检查，@permilk–Python代码分析工具：PyChecker、Pylint

# 安装pip install pylint

写一段测试代码，命名为test.py

# -*- coding:utf-8 -*-# 原理:http://blog.csdn.net/morewindows/article/details/6684558# 代码提供: http://www.cnblogs.com/yekwol/p/5778040.htmldef parttion(vec, left, right):
    key = vec[left]
    low = left
    high = right    while low < high:        while (low < high) and (vec[high] >= key):
            high -= 1
        vec[low] = vec[high]        while (low < high) and (vec[low] <= key):
            low += 1
        vec[high] = vec[low]
        vec[low] = key    return low# 采用递归的方式进行函数构建def quicksort(vec, left, right):
    if left < right:
        p = parttion(vec, left, right)
        quicksort(vec, left, p-1)  # 再同样处理分片问题
        quicksort(vec, p+1, right)  
    return vec#s = [6, 8, 1, 4, 3, 9, 5, 4, 11, 2, 2, 15, 6]before_list = [4, 6, 1, 3, 5, 9]print "before sort:", before_list
after_list = quicksort(before_list, left=0, right=len(before_list)-1)print"after sort:", after_list

进行代码规范测试

# 使用pylint test.py# 输出Problem importing module variables.py: No module named functools_lru_cache
Problem importing module variables.pyc: No module named functools_lru_cache
No config file found, using default configuration
************* Module test
C: 24, 0: Trailing whitespace (trailing-whitespace)
C:  1, 0: Missing module docstring (missing-docstring)
C:  5, 0: Missing function docstring (missing-docstring)
C: 20, 0: Missing function docstring (missing-docstring)
C: 22, 8: Invalid variable name "p" (invalid-name)
C: 28, 0: Invalid constant name "before_list" (invalid-name)
C: 30, 0: Invalid constant name "after_list" (invalid-name)


Report
======23 statements analysed.

Statistics by type
------------------

+---------+-------+-----------+-----------+------------+---------+
|type     |number |old number |difference |%documented |%badname |
+=========+=======+===========+===========+============+=========+
|module   |1      |1          |=          |0.00        |0.00     |
+---------+-------+-----------+-----------+------------+---------+
|class    |0      |0          |=          |0           |0        |
+---------+-------+-----------+-----------+------------+---------+
|method   |0      |0          |=          |0           |0        |
+---------+-------+-----------+-----------+------------+---------+
|function |2      |2          |=          |0.00        |0.00     |
+---------+-------+-----------+-----------+------------+---------+Raw metrics-----------

+----------+-------+------+---------+-----------+
|type      |number |%     |previous |difference |
+==========+=======+======+=========+===========+
|code      |23     |71.88 |23       |=          |
+----------+-------+------+---------+-----------+
|docstring |0      |0.00  |0        |=          |
+----------+-------+------+---------+-----------+
|comment   |5      |15.62 |5        |=          |
+----------+-------+------+---------+-----------+
|empty     |4      |12.50 |4        |=          |
+----------+-------+------+---------+-----------+Duplication-----------

+-------------------------+------+---------+-----------+
|                         |now   |previous |difference |
+=========================+======+=========+===========+
|nb duplicated lines      |0     |0        |=          |
+-------------------------+------+---------+-----------+
|percent duplicated lines |0.000 |0.000    |=          |
+-------------------------+------+---------+-----------+Messages by category--------------------

+-----------+-------+---------+-----------+
|type       |number |previous |difference |
+===========+=======+=========+===========+
|convention |7      |7        |=          |
+-----------+-------+---------+-----------+
|refactor   |0      |0        |=          |
+-----------+-------+---------+-----------+
|warning    |0      |0        |=          |
+-----------+-------+---------+-----------+
|error      |0      |0        |=          |
+-----------+-------+---------+-----------+Messages--------

+--------------------+------------+
|message id          |occurrences |
+====================+============+
|missing-docstring   |3           |
+--------------------+------------+
|invalid-name        |3           |
+--------------------+------------+
|trailing-whitespace |1           |
+--------------------+------------+Global evaluation-----------------Your code has been rated at 6.96/10 (previous run: 6.96/10, +0.00)

• 
  

---

Python奇技淫巧

---

使用 Counter 进行计数统计

>>> from collections import Counter>>> Counter(s=3, c=2, e=1, u=1)
Counter({'s': 3, 'c': 2, 'u': 1, 'e': 1})>>> some_data=('c', '2', 2, 3, 5, 'c', 'd', 4, 5, 'd', 'd')>>> Counter(some_data).most_common(2)
[('d', 3), ('c', 2)]>>> some_data=['c', '2', 2, 3, 5, 'c', 'd', 4, 5, 'd', 'd']>>> Counter(some_data).most_common(2)
[('d', 3), ('c', 2)]>>> some_data={'c', '2', 2, 3, 5, 'c', 'd', 4, 5, 'd', 'd'}>>> Counter(some_data).most_common(2)
[('c', 1), (3, 1)]

• 
  

---

enumerate获取键值对

• 在同时需要index和value值的时候可以使用 enumerate。下列分别将字符串，数组，列表与字典遍历序列中的元素以及它们的下标

>>> for i,j in enumerate('abcde'):...     print i,j... 0 a1 b2 c3 d4 e>>> for i,j in enumerate([1,2,3,4]):...     print i,j... 0 11 22 33 4>>> for i,j in enumerate([1,2,3,4],start=1):...     print i,j... 1 12 23 34 4

• 
  

# 通过键索引来追踪元素
from collections import defaultdict

s = "the quick brown fox jumps over the lazy dog"words = s.split()
location = defaultdict(list)for m, n in enumerate(words):
    location[n].append(m)print location

# defaultdict(<type &#39;list&#39;>, {&#39;brown&#39;: [2], &#39;lazy&#39;: [7], &#39;over&#39;: [5], &#39;fox&#39;: [3],
# &#39;dog&#39;: [8], &#39;quick&#39;: [1], &#39;the&#39;: [0, 6], &#39;jumps&#39;: [4]})

• 
  

---

os.path的使用

• os.path.join用于拼接路径，好处是可以根据系统自动选择正确的路径分隔符”/”或”\”

• os.path.split 把路径分割成dirname和basename，返回一个元组

• os.listdir 获取路径下所有文件，返回list

import os
path=os.path.abspath("ams8B.zip")print path  # /Users/didi/Desktop/testhelp/ams8B.zip  # 实际上该文件夹下没有ams8B.zipprint os.path.join("/".join(path.split("/")[:-1]),'ams8B.gz')  # /Users/didi/Desktop/testhelp/ams8B.gzprint os.path.join("home","user","test")  # home/user/test# 把路径分割成dirname和basename，返回一个元组，作用在于不用区别到底是'\'还是'/'print os.path.split(path)  # ('/Users/didi/Desktop/testhelp', 'ams8B.zip')print os.path.join(os.path.split(path)[0],'ams8B.gz')  #   /Users/didi/Desktop/testhelp/ams8B.gzprint os.getcwd()  # /Users/didi/Desktop/testhelpprint os.listdir(os.getcwd())  # ['t1.txt', 'test1.py', 'test2.py', '\xe6\x8e\xa5\xe9\xa9\xbeeta\xe5\x88\x86\xe5\xb8\x83.sh']

---

善用列表推导式

>>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]>>> print filter(lambda x: x % 3 == 0, foo)
[18, 9, 24, 12, 27]
>>>>>> print map(lambda x: x * 2 + 10, foo)
[14, 46, 28, 54, 44, 58, 26, 34, 64]
>>>>>> print reduce(lambda x, y: x + y, foo)139

使用列表推导式

>>> [x * 2 + 10 for x in foo]
[14, 46, 28, 54, 44, 58, 26, 34, 64]>>> [x for x in foo if x % 3 == 0]
[18, 9, 24, 12, 27]

对于轻量级循环，可尽量使用列表推导式,熟练使用列表推导式可以很多情况下代替map，filter等

>>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]>>> foo
[2, 18, 9, 22, 17, 24, 8, 12, 27]>>> [&#39;>3&#39; if i>3 else &#39;<3&#39; for i in foo]
[&#39;<3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;]>>> t=map(lambda x:&#39;<3&#39; if x<3 else &#39;>3&#39;,foo)>>> t
[&#39;<3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;, &#39;>3&#39;]
>>>

可参考：最简单的理解lambda，map，reduce，filter，列表推导式

---

sort 与 sorted

# 函数原型sorted(iterable[, cmp[, key[, reverse]]])   # 返回一个排序后的列表s.sort([cmp[, key[, reverse]]])             # 直接修改原列表，返回为None>>> persons = [{'name': 'Jon', 'age': 32}, {'name': 'Alan', 'age': 50}, {'name': 'Bob', 'age': 23}]>>> sorted(persons, key=lambda x: (x['name'], -x['age']))
[{'name': 'Alan', 'age': 50}, {'name': 'Bob', 'age': 23}, {'name': 'Jon', 'age': 32}]>>> a = (1, 2, 4, 2, 3)>>> sorted(a)
[1, 2, 2, 3, 4]>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),]  
>>> sorted(students, key=lambda student : student[2])   # sort by age  [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

所以如果实际过程中需要保留原有列表，可以使用sorted()。sort()不需要复制原有列表，消耗内存较小，效率较高。同时传入参数key比传入参数cmp效率要高，cmp传入的函数在整个排序过程中会调用多次，而key针对每个元素仅作一次处理。

关于cmp的使用，这位哥们总算踩到点python中sort()方法自定义cmp PythonTip-最大正整数

# cmp   --如果排序的元素是其他类型的，如果a逻辑小于b，函数返回负数；a逻辑等于b，函数返回0；a逻辑大于b，函数返回正数就行了，这决定着两者是否交换位置def Reverse(a,b):
    return b-a

list_ = [5,3,4,1,2]
new = sorted(list_,cmp=ps)print new  # [5, 4, 3, 2, 1]# # 这里的例子是，5，3做差值，为负，故两者不交换位置，里面的return作为条件

---

善用traceback 追踪深层错误

import tracebacktry:
    do somethingexcept Exception as ex:    print ex
    traceback.print_exc()

---

切片操作[]

相当于浅copy的作用

>>> a=[1,2,3]>>> b=a[:]>>> b.append(4)>>> b
[1, 2, 3, 4]>>> a
[1, 2, 3]>>> import copy>>> c=copy.copy(a)>>> c
[1, 2, 3]>>> c.append(4)>>> a
[1, 2, 3]>>> c
[1, 2, 3, 4]>>> d=a>>> d.append(4)>>> d
[1, 2, 3, 4]>>> a
[1, 2, 3, 4]# 这里顺便说下deepcopy# [理论部分可以参考这里](http://www.cnblogs.com/wait123/archive/2011/10/10/2206580.html)# 浅copy>>> import copy>>> a = [[1,2],3,4]>>> b = copy.copy(a)  
>>> id(a)54936008L>>> id(b)54964680L>>> a is bFalse>>> b
[[1, 2], 3, 4]>>> b[0][1]2>>> b[0][1]=2333>>> b
[[1, 2333], 3, 4]>>> a
[[1, 2333], 3, 4]# deepcopy>>> a = [[1,2],3,4]>>> c = copy.deepcopy(a)>>> id(a)55104008L>>> id(c)54974536L>>> a is cFalse>>> c
[[1, 2], 3, 4]>>> c[0][1]2>>> c[0][1]=233>>> c
[[1, 233], 3, 4]>>> a
[[1, 2], 3, 4]  # 不会随之改变# 这里测试下切片操作相当于浅copy>>> d = a[:]>>> d
[[1, 2], 3, 4]>>> d[0][1]=0>>> d
[[1, 0], 3, 4]>>> a
[[1, 0], 3, 4]  # 会随之改变

进行逆序排列

>>> b
[1, 2, 3, 4]>>> b[::-1]
[4, 3, 2, 1]

---

json.dump()/loads() 存储字典结构

# json.dumps : dict转成str # json.loads:str转成dictimport json
dict_ = {1:2, 3:4, "55":"66"}
json_str = json.dumps(dict_)print type(json_str), json_str 
# <type &#39;str&#39;> {"55": "66", "1": 2, "3": 4}print type(json.loads(json_str)) 
# <type &#39;dict&#39;> {u&#39;55&#39;: u&#39;66&#39;, u&#39;1&#39;: 2, u&#39;3&#39;: 4}

---

pprint打印结构

from pprint import pprint
data = [(1,{'a':'A','b':'B','c':'C','d':'D'}),

        (2,{'e':'E','f':'F','g':'G','h':'H',            'i':'I','j':'J','k':'K','l':'L'

            }),]print data
pprint(data)#print效果[(1, {'a': 'A', 'c': 'C', 'b': 'B', 'd': 'D'}), (2, {'e': 'E', 'g': 'G', 'f': 'F', 'i': 'I', 'h': 'H', 'k': 'K', 'j': 'J', 'l': 'L'})]# pprint效果[(1, {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D'}),
 (2,
  {'e': 'E',   'f': 'F',   'g': 'G',   'h': 'H',   'i': 'I',   'j': 'J',   'k': 'K',   'l': 'L'})]

---

zip打包元组

定义：zip([seql, …])接受一系列可迭代对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。

#!/usr/bin/python# -*- coding: utf-8 -*-name = ['mrlevo','hasky']
kind = ['human','dog']
z1 = [1,2,3]
z2 = [4,5,6]
result = zip(z1,z2) # 压缩过程uzip= zip(*result) # 解压过程，拆分为元组print "the zip:",result# the zip: [(1, 4), (2, 5), (3, 6)]print "the uzip:",uzip#the uzip: [(1, 2, 3), (4, 5, 6)]print "the uzip part of z1:%s\nthe uzip part of z2:%s"%(str(uzip[0]),str(uzip[1]))#the uzip part of z1:(1, 2, 3)#the uzip part of z2:(4, 5, 6)

---

*args和**kw

*args仅仅只是用在函数定义的时候用来表示位置参数应该存储在变量args里面。Python允许我们制定一些参数并且通过args捕获其他所有剩余的未被捕捉的位置。当调用一个函数的时候，一个用*标志的变量意思是变量里面的内容需要被提取出来然后当做位置参数被使用。

def add(x, y):
    return x + y
list_ = [1,2]

add(list_[0], list_[1]) # 3add(*list_) # 3

*args要么是表示调用方法大的时候额外的参数可以从一个可迭代列表中取得，要么就是定义方法的时候标志这个方法能够接受任意的位置参数。接下来提到的**，**kw代表着键值对的字典,也就是说，你不用一个个字典用key来取value了

dict_ = {'x': 1, 'y': 2, 'z':3}def bar(x, y, z):
    return x + y + z

bar(**dict_)  # 6bar(dict_['x'],dict_['y'],dict_['z'])  # 6

---

内建函数 itertools优雅的迭代器

方法很多，就先介绍笔试题碰到的permutations

permutations(p[,r]);返回p中任意取r个元素做排列的元组的迭代器
如：permutations(‘abc’, 2) # 从’abcd’中挑选两个元素，比如ab, bc, … 将所有结果排序，返回为新的循环器。

注意，上面的组合分顺序，即ab, ba都返回。

combinations(‘abc’, 2) # 从’abcd’中挑选两个元素，比如ab, bc, … 将所有结果排序，返回为新的循环器。

注意，上面的组合不分顺序，即ab, ba的话，只返回一个ab。

再来个实际点的算法的一个例子，虽然毫无算法结构可言

# 输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba# itertools，内建库的用法# 参考：http://blog.csdn.net/neweastsun/article/details/51965226import itertoolsdef Permutation(ss):
    # write code here
    if not ss:        return []    return sorted(list(set(map(lambda x:''.join(x), itertools.permutations(ss)))))

Permutation('abc')# ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']

更多可以参考：Python标准库13 循环器 (itertools)

---

使用with open() as f 来读取文件

对于文本的读取，使用f=open(‘path’)的方法来说，局限性很大，第一是内存加载问题，第二是文件流打开之后最后还需要关闭的问题，使用with..as轻松解决

with open('path') as f:    for line in f:
        do songthing# for line in f 这种用法是把文件对象f当作迭代对象，系统将自动处理IO缓存和内存管理。对于读取超大的文件，这个方法不会把内存撑爆，这个是按行读取的with open('path') as f:    for line in f.readlines():
        do something# 这个方法是将文本中的内容都放在了一个列表里，然后进行迭代，对于大量的数据而言，效果不好

---

使用yield节省内存开销

[1,2,3,4]这个是迭代器，用for来迭代它，生成器(x for x in range(4))也是迭代器的一种,但是你只能迭代它们一次.原因很简单,因为它们不是全部存在内存里,它们只在要调用的时候在内存里生成，Yield的用法和关键字return差不多,下面的函数将会返回一个生成器。迭代的时候碰到yield立刻return一个值，下一次迭代的时候，从yield的下一条语句开始执行

>>> mygenerator = (x*x for x in range(4))>>> mygenerator
<generator object <genexpr> at 0x1121b55a0>>>> mygenerator.next()0>>> mygenerator.next()1---------------------->>> def generater(n):...     for i in range(n):...         yield i...         print &#39;here&#39;...>>> g = generater(5)>>> g
<generator object generater at 0x10c801280> # 凡是带有yield的函数都变成了生成器，都可以被迭代next()使用，>>> g.next()0>>> g.next()
here1>>> g.next()
here2 # 这里说明了它的运作过程，第一次迭代的时候，运行到yield函数，进行返回，而不执行下一个动作，第二次迭代的时候，直接从上一次yield的地方的下一条语句进行执行，也就看到了如下的效果。

另一个 yield 的例子来源于文件读取。如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。通过 yield，我们不再需要编写读文件的迭代类，就可以轻松实现文件读取：

# from 廖雪峰def read_file(fpath):
    BLOCK_SIZE = 1024
    with open(fpath, 'rb') as f:        while True:
            block = f.read(BLOCK_SIZE)           
             if block:                
            yield block            
            else:                
            return

相关推荐：

Python安装流程指南

위 내용은 Python에서 일반적으로 사용되는 PEP8 사양 및 Python 트릭의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!