當前位置：首頁 > 编程资源 > 综合教程 >内容正文

综合教程

Python 常用的PEP8规范及Python小把戏

發布時間：2023/12/19 综合教程 33 生活家

生活随笔收集整理的這篇文章主要介紹了 Python 常用的PEP8规范及Python小把戏小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

本篇文章的內容是Python 常用PEP8規范及Python小把戲，現在分享給大家，有需要的朋友可以看一下這篇文章的內容

前言

從很多地方搬運+總結，以后根據這個標準再將python的一些奇技淫巧結合起來，寫出更pythonic的代碼~

PEP8 編碼規范

英文原版請點擊這里

以下是@bobo的整理，原文請見PEP8 Python 編碼規范整理代碼編排

縮進。4個空格的縮進（編輯器都可以完成此功能），不使用Tap，更不能混合使用Tap和空格。
每行最大長度79，換行可以使用反斜杠，最好使用圓括號。換行點要在操作符的后邊敲回車。
類和top-level函數定義之間空兩行；類中的方法定義之間空一行；函數內邏輯無關段落之間空一行；其他地方盡量不要再空行。

文檔編排

模塊內容的順序：模塊說明和docstring—import—globals&constants—其他定義。其中import部分，又按標準、三方和自己編寫順序依次排放，之間空一行
不要在一句import中多個庫，比如import os, sys不推薦
如果采用from XX import XX引用庫，可以省略‘module.’，都是可能出現命名沖突，這時就要采用import XX

空格的使用

各種右括號前不要加空格。
逗號、冒號、分號前不要加空格。
函數的左括號前不要加空格。如Func(1)
序列的左括號前不要加空格。如list[2]
操作符左右各加一個空格，不要為了對齊增加空格
函數默認參數使用的賦值符左右省略空格
不要將多句語句寫在同一行，盡管使用‘；’允許
if/for/while語句中，即使執行語句只有一句，也必須另起一行

注釋

總體原則，錯誤的注釋不如沒有注釋。所以當一段代碼發生變化時，第一件事就是要修改注釋！注釋必須使用英文，最好是完整的句子，首字母大寫，句后要有結束符，結束符后跟兩個空格，開始下一句。如果是短語，可以省略結束符。

塊注釋，在一段代碼前增加的注釋。在‘#’后加一空格。段落之間以只有‘#’的行間隔。比如：


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

登錄后復制

行注釋，在一句代碼后加注釋。比如：x = x + 1 # Increment x但是這種方式盡量少使用。
避免無謂的注釋。

文檔描述

為所有的共有模塊、函數、類、方法寫docstrings；非共有的沒有必要，但是可以寫注釋（在def的下一行）。
單行注釋請參考如下方式


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

登錄后復制

命名規則

* 總體原則，新編代碼必須按下面命名風格進行，現有庫的編碼盡量保持風格。絕不要單獨使用例如大寫的’i’和大寫的’o’*

模塊命名盡量短小，使用全部小寫的方式，可以使用下劃線。
包命名盡量短小，使用全部小寫的方式，不可以使用下劃線。
類的命名使用CapWords的方式，模塊內部使用的類采用_CapWords的方式。
異常命名使用CapWords+Error后綴的方式。
全局變量盡量只在模塊內有效，類似C語言中的static。實現方法有兩種，一是all機制;二是前綴一個下劃線。
函數命名使用全部小寫的方式，可以使用下劃線。
常量命名使用全部大寫的方式，可以使用下劃線。
類的屬性（方法和變量）命名使用全部小寫的方式，可以使用下劃線。
類的屬性有3種作用域public、non-public和subclass API，可以理解成C++中的public、private、protected，non-public屬性前，前綴一條下劃線。
類的屬性若與關鍵字名字沖突，后綴一下劃線，盡量不要使用縮略等其他方式。
為避免與子類屬性命名沖突，在類的一些屬性前，前綴兩條下劃線。比如：類Foo中聲明__a,訪問時，只能通過Foo._Foo__a，避免歧義。如果子類也叫Foo，那就無能為力了。
類的方法第一個參數必須是self，而靜態方法第一個參數必須是cls。

編程建議

編碼中考慮到其他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

登錄后復制

異常中try的代碼盡可能少。
使用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'

登錄后復制

使用isinstance()比較對象的類型。比如:


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

登錄后復制

判斷序列空或不空，有如下規則：


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

登錄后復制

二進制數據判斷使用 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 'list'>, {'brown': [2], 'lazy': [7], 'over': [5], 'fox': [3],
# 'dog': [8], 'quick': [1], 'the': [0, 6], 'jumps': [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]>>> ['>3' if i>3 else '<3' for i in foo]
['<3', '>3', '>3', '>3', '>3', '>3', '>3', '>3', '>3']>>> t=map(lambda x:'<3' if x<3 else '>3',foo)>>> t
['<3', '>3', '>3', '>3', '>3', '>3', '>3', '>3', '>3']
>>>

登錄后復制

可參考：最簡單的理解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 'str'> {"55": "66", "1": 2, "3": 4}print type(json.loads(json_str)) 
# <type 'dict'> {u'55': u'66', u'1': 2, u'3': 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 'here'...>>> 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 常用的PEP8规范及Python小把戏的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：楚留香绛亭春怎么获得
下一篇： simantaneous AJAX ca