Day03基礎（三）

Python 基礎（三）

簡介：

　　本章，咱們詳細瞭解下，set集合使用、Python的函數相關功能及使用、open函數功能使用及其餘（with，內置函數）功能使用；

一. Python的set 集合

1. 首先建立一個集合，而後再說說集合的特性，最後作個小結

建立集合有兩種方式：

1） 直接建立

se = {"jihe",22,"long",18} 或是 se = {"jihe",22,"long",18,18,22}  # print(se) 執行結果： {18, 'jihe', 'long', 22}

2）使用set建立

li = ["jihe",22,"long",18,22,"jihe"]    

li = set(li)   或是  li = set(["jihe",22,"long",18,22,"jihe"])              # print(li) 執行結果：{18, 'long', 'jihe', 22} 

驚奇的發現，結果居然相同（雖然位置不一樣），這是爲何呢？

接下來，聊聊集合的特性，一切將迎刃而解。

經過執行結果，咱們能夠看到兩種現象：

　　　　　　　　　　1） 執行的結果是無序的，不是按照咱們賦值的順序排列的；

　　　　　　　　　　2） 是不重複的序列， 重複的值，只記錄一次；

小結：

　　1. 集合是{}中包含（不可變類型元素）字符串或數字類型的一個序列；  若是{}有列表、字典，就會報錯；元組不會報錯，由於它是不可變類型；

　　2. 集合能夠用set（）建立，內容包含可迭代的對象；如列表、字符串、元組等，若是是字典，只使用Keys； 數字不能夠，由於數字是不可迭代的；

　　3. 集合是無序的（這點和字典同樣），元素不重複，每個元素都是惟一的；

2. 集合的主要功能使用

python的set和其餘語言相似, 是一個無序不重複元素集, 基本功能包括關係測試和消除重複元素.

集合對象還支持union(聯合), intersection(交), difference(差)和sysmmetric difference(對稱差集)等數學運算. 

下面使用例子介紹說明：

s = set([3,5,9,10])      #建立一個數值集合    
t = set("Hello")         #建立一個惟一字符的集合  
 
與列表和元組不一樣，集合是無序的，也沒法經過數字進行索引。此外，集合中的元素不能重複。例如，若是檢查前面代碼中t集合的值，結果會是：  
>>> t    
set(['H', 'e', 'l', 'o'])  

注意只出現了一個'l'。  
  
集合支持一系列標準操做，包括並集、交集、差集和對稱差集，例如：  
a = t | s          # t 和 s的並集  
  
b = t & s          # t 和 s的交集  
  
c = t – s          # 求差集（項在t中，但不在s中）  
  
d = t ^ s          # 對稱差集（項在t或s中，但不會同時出如今兩者中）  
 
基本操做：  
  
t.add('x')            # 添加一項  
  
s.update([10,37,42])  # 在s中添加多項  
  
使用remove()能夠刪除一項：  
  
t.remove('H')  
  
len(s)  
set 的長度  
  
x in s  
測試 x 是不是 s 的成員  
  
x not in s  
測試 x 是否不是 s 的成員  
  
s.issubset(t)  
s <= t  
測試是否 s 中的每個元素都在 t 中  
  
s.issuperset(t)  
s >= t  
測試是否 t 中的每個元素都在 s 中  
  
s.union(t)  
s | t  
返回一個新的 set 包含 s 和 t 中的每個元素  
  
s.intersection(t)  
s & t  
返回一個新的 set 包含 s 和 t 中的公共元素  
  
s.difference(t)  
s - t  
返回一個新的 set 包含 s 中有可是 t 中沒有的元素  
  
s.symmetric_difference(t)  
s ^ t  
返回一個新的 set 包含 s 和 t 中不重複的元素  
  
s.copy()  
返回 set 「s」的一個淺複製  
  
請注意：union(), intersection(), difference() 和 symmetric_difference() 的非運算符（non-operator，就是形如 s.union()這樣的）版本將會接受任何 iterable 做爲參數。相反，它們的運算符版本（operator based counterparts）要求參數必須是 sets。這樣能夠避免潛在的錯誤，如：爲了更可讀而使用 set('abc') & 'cbs' 來替代 set('abc').intersection('cbs')。從 2.3.1 版本中作的更改：之前全部參數都必須是 sets。  
  
另外，Set 和 ImmutableSet 二者都支持 set 與 set 之間的比較。兩個 sets 在也只有在這種狀況下是相等的：每個 set 中的元素都是另外一箇中的元素（兩者互爲subset）。一個 set 比另外一個 set 小，只有在第一個 set 是第二個 set 的 subset 時（是一個 subset，可是並不相等）。一個 set 比另外一個 set 打，只有在第一個 set 是第二個 set 的 superset 時（是一個 superset，可是並不相等）。  
  
子 set 和相等比較並不產生完整的排序功能。例如：任意兩個 sets 都不相等也不互爲子 set，所以如下的運算都會返回 False：a<b, a==b, 或者a>b。所以，sets 不提供 __cmp__ 方法。  
  
由於 sets 只定義了部分排序功能（subset 關係），list.sort() 方法的輸出對於 sets 的列表沒有定義。  
  
運算符  
   運算結果  
  
hash(s)  
   返回 s 的 hash 值  
下面這個表列出了對於 Set 可用二對於 ImmutableSet 不可用的運算：  
  
運算符（voperator）  
等價於  
運算結果  
  
s.update(t)  
s |= t  
返回增長了 set 「t」中元素後的 set 「s」  
  
s.intersection_update(t)  
s &= t  
返回只保留含有 set 「t」中元素的 set 「s」  
  
s.difference_update(t)  
s -= t  
返回刪除了 set 「t」中含有的元素後的 set 「s」  
  
s.symmetric_difference_update(t)  
s ^= t  
返回含有 set 「t」或者 set 「s」中有而不是二者都有的元素的 set 「s」  
  
s.add(x)   
向 set 「s」中增長元素 x  
  
s.remove(x)   
從 set 「s」中刪除元素 x, 若是不存在則引起 KeyError  
  
s.discard(x)  
若是在 set 「s」中存在元素 x, 則刪除  
  
s.pop()   
刪除而且返回 set 「s」中的一個不肯定的元素, 若是爲空則引起 KeyError  
  
s.clear()   
刪除 set 「s」中的全部元素  
  
請注意：非運算符版本的 update(), intersection_update(), difference_update()和symmetric_difference_update()將會接受任意 iterable 做爲參數。從 2.3.1 版本作的更改：之前全部參數都必須是 sets。  
  
還請注意：這個模塊還包含一個 union_update() 方法，它是 update() 方法的一個別名。包含這個方法是爲了向後兼容。程序員們應該多使用 update() 方法，由於這個方法也被內置的 set() 和 frozenset() 類型支持。

上面例子的內容比較多，着重記如下幾個重要功能，知道是幹什麼就好了，遇到這種判斷時，能想到set有這個功能能夠實現；

1）difference()  差集　例子：

f0 = set(["seie",22,44,'alex','eric'])
f1 = set(["seie",33,22,55,"eric","peiqi"])
f2 = f0.difference(f1)
print(f0)
print(f1)
print(f2)

執行結果：
{'alex', 'seie', 44, 22, 'eric'}
{33, 'seie', 'peiqi', 55, 22, 'eric'}
{'alex', 44}
# 將f0 中和 f1 裏不一樣的元素取出，差集計算；

2） intersection() 交集，例子：

f0 = set(["seie",22,44,'alex','eric'])
f1 = set(["seie",33,22,55,"eric","peiqi"])
f2 = f0.difference(f1)
print(f0)
print(f1)
f3 = f0.intersection(f1)
print(f3)

執行結果：
{'eric', 44, 'seie', 22, 'alex'}
{33, 'seie', 'peiqi', 22, 55, 'eric'}
{'eric', 'seie', 22}
# 將f0 中和 f1 裏相同的元素取出，交集計算；

3）symmetric_difference()  兩個集合的並集減交集，例子：

f0 = set(["seie",22,44,'alex','eric'])
f1 = set(["seie",33,22,55,"eric","peiqi"])

print(f0)
print(f1)
f4 = f0.symmetric_difference(f1)
print(f4)
執行結果：
{'alex', 44, 'eric', 22, 'seie'}
{33, 'seie', 22, 55, 'peiqi', 'eric'}
{33, 'alex', 55, 'peiqi', 44}
# 將f0裏有的f1裏不存在的取出 和 將f1裏有的f0裏不存在的取出，放在一個集合裏；

4）以上幾項還有個update功能，下面簡介一下：

f0 = set(["seie",22,44,'alex','eric'])
f1 = set(["seie",33,22,55,"eric","peiqi"])
f4 = f0.symmetric_difference(f1)
f0.symmetric_difference_update(f1)

print(f4)
print(f0)

執行結果：
{33, 'peiqi', 44, 55, 'alex'}
{33, 55, 'alex', 'peiqi', 44}
# 將執行結果賦值給f0，update更新了源值；

5）　difference_update() 和  intersection_update() 同上，將比較集合獲得的值，賦值給比較集合，被比較集合值不變；

set 就介紹到這裏，想了解更多，看源碼是最正確的選擇。

二. python 函數

 一. 函數的定義

1. 函數定義的基本形式   

　　在某些編程語言當中，函數聲明和函數定義是區分開的（在這些編程語言當中函數聲明和函數定義能夠出如今不一樣的文件中，好比C語言），可是在Python中，函數聲明和函數定義是視爲一體的。在Python中，函數定義的基本形式以下：

def function(params):
    block
    return expression/value

返回值不是必須的，若是沒有return語句，則Python默認返回值None。建立函數時括號內的參數是形式參數，當調用時，使用的參數是實際參數。

• 函數名的命名規則： 

　　1) 函數名必須如下劃線或字母開頭，能夠包含任意字母、數字或下劃線的組合。不能使用任何的標點符號；

　　2) 函數名是區分大小寫的。 

　　3) 函數名不能是保留字。 

•   函數分爲幾個部分：

　　1）def 關鍵字，用來建立函數；

　　2）一個函數名function(): ，括號裏能夠放形式參數；

　　3）函數體（函數的內容），要記得給函數加註釋，時間久了，可能會忘記函數是幹什麼的了；

　　4）返回值；

• 函數的做用域

　　Python使用名稱空間的概念存儲對象，這個名稱空間就是對象做用的區域， 不一樣對象存在於不一樣的做用域。下面是不一樣對象的做用域規則：

　　1) 每一個模塊都有自已的全局做用域。

　　2) 函數定義的對象屬局部做用域，只在函數內有效，不會影響全局做用域中的對象。

　　3) 賦值對象屬局部做用域，除非使用global關鍵字進行聲明。

• LGB（名稱查找規則）規則是Python查找名字的規則，下面是LGB規則：

　　1） 大多數名字引用在三個做用域中查找：先局部(Local)，次之全局(Global)，再次以內置(Build-in)。

　　2） 如想在局部做用域中改變全局做用域的對象，必須使用global關鍵字。

　　3） 'global'聲明把賦值的名字映射到一個包含它的模塊的做用域中。

　　　　函數的參數是函數與外部溝通的橋樑，它可接收外部傳遞過來的值。

　　4） 在一個函數中對參數名賦值不影響調用者。

　　5） 在一個函數中改變一個可變的對象參數會影響調用者。

　　　　參數是對象指針，無需定義傳遞的對象類型。

• 函數中的參數接收傳遞的值，參數可分默認參數、指定參數等如：

　　默認參數給參數賦值：

　　def function(args=VALUE)

　　元組（Tuples）參數：

　　def function(*args)

　　字典（dictionary）參數：

　　def function(**kwargs)

• 一些函數規則：

　　默認值必須在非默認參數以後；

　　在單個函數定義中，只能使用一個tuple參數（*args）和一個字典參數（**kwargs）。

　　tuple參數必須在鏈接參數和默認參數以後。

　　字典參數必須在最後定義。

3. 借用登陸、註冊小程序，詳細講解下函數：

def login(username,password):
    '''
    用戶登陸
    :param username: 用戶輸入用戶名
    :param password: 用戶輸入密碼
    :return:
    '''
    f = open('db',"r")
    for line in f:
        line_list = line.split("|")
        if line_list[0] == username and line_list[1] == password:
            return True
    return  False


def register(username,password):
    '''
    用戶註冊
    :param username: 輸入註冊用戶名
    :param password: 輸入註冊密碼
    :return:  None
    '''
    f = open('db','a')
    temp = "\n" + username + "|" + password
    f.write(temp)
    f.close()


def main():
    t = input("Input 1.登陸，2.註冊：")
    if t == '1':
        user = input("輸入用戶名：")
        pwd  = input('輸入密碼：')
        r = login(user,pwd)
        if r:
            print('login OK')
        else:
            print("login faild")
    elif t == "2":
        user = input("輸入用戶名：")
        pwd  = input('輸入密碼：')
        register(user,pwd)

這個簡單的登陸、註冊程序，由三個函數完成；　

login()函數 ： 1. 括號裏的兩個參數，是函數體裏兩個對應的兩個參數，在括號裏它是個（形式參數）；就是說調用這個函數時，能夠輸入一個新的參數代替它們，這個新的參數，就是（實際參數）；

　　　　　　　　2. 三引號內包含的就是註釋信息，必定要寫奧；

　　　　　　　　3. return，執行結果，要有一個返回值，讓咱們知道，執行了什麼或是執行結果是否成功；

register（）函數：大概的意思和上面的差很少，只是沒寫返回值，不須要返回值的時候，就不用寫了；

main（）函數： 1. 它沒有參數，可是它是一個主函數，經過執行main（），來調用上面兩個函數；

　　　　　　　　2. login（）函數裏的（user,pwd） 就是實際參數，是真正的用戶名和密碼；register（）使用 ，同login（），很少作解釋；

備註：   剛剛這個小程序，是爲了能更好的瞭解函數而寫的簡單例子，它更清楚的體現，函數的建立和使用過程，並非個標準的註冊、登陸程序，真正的註冊、登陸程序要複雜的多；

　　　　函數裏儘可能不用print（），要使用return返回值；

4. 函數參數

咱們已經介紹過了，定義的函數參數是形式參數，只是一個引用。

函數參數的寫法有多種，不一樣寫法，不一樣調用，下面咱們詳細說說函數參數的多種寫法與調用；

1）默認參數

def send(name,age):
    print(name,age)
    print("your name is:%s ,age is: %s" % (name,age))
    return True

# 調用send（）參數
while True:
    name = input("input your name:")
    resolt = send(name,'19')
    if resolt == True:
        print("true")
    else:
        print("false")
# 利用返回值，作判斷，執行結果是否成功；

默認參數： 程序裏，send（）函數調用時，從新傳了兩個實際參數，參數能夠是變量，也能夠是字符串、數字；這種按照順序傳參的方式，就是傳入默認參數；

def send(name,age = 19):
    print(name,age)
    print("your name is:%s ,age is: %s" % (name,age))
    return True
# 調用send（）函數
while True:
    name = input("input your name:")
    resolt = send(name)
    if resolt == True:
        print("true")
    else:
        print("false")
# 執行結果：
input your name:long
long 19
your name is:long ,age is: 19
true
input your name:
# 建立函數時，參數age = 19 ，給age 賦了一個19的值，指定了參數的值，當調用的時候，只須要寫入第一個參數就能夠了；

默認參數之參數默認值： 在函數建立時，給某個參數賦了值（要注意一點，賦值的參數要放在最後，放在其它位置，調用函數後傳參時會報錯的），當調用時，能夠不給賦值的參數傳入新參數，若是傳新參數，將覆蓋原來的值；

2） 指定參數

 

 

說明：

1. 執行了兩個send（）函數，執行結果是同樣的，第一個是，使用默認參數，第二個使用指定參數；
2. send函數有兩個參數，當調用send（）函數時，使用關鍵字參數，指定了參數內容，這種指定參數的傳參方法，調用函數時參數位置不受限制；

3）元組類型參數

元組類型參數(參數前加*)。一個函數裏，只容許使用一個元組類型參數；形參帶*是能夠接收動態參數；

傳入實際參數時，有兩種方法：

1. 調用函數時，使用不加*的實際參數

說明：

　　1. 傳入列表，把傳入的列表做爲此元組的一個元素傳入，能夠一次傳入多個列表，每一個列表將是此元組的一個元素；

　　2. 傳入元組，把傳入的元組做爲此元組的一個元素傳入，能夠一次傳入多個元組，每一個元組將是此元組的一個元素；

　　3. 傳入字符串或是數字，獲得的結果是一個包含字符串或數字的元組；

　　4. 傳入字典，把傳入的字典做爲此元組的一個元素傳入，能夠一次傳入多個字典，每一個字典將是此元組的一個元素；

2. 調用函數時，使用加*的實際參數

說明： 

　　1. 加*的實際參數，必須是可迭代類型如：列表、元組、字符串、字典等，數字不是可迭代的，不可使用；

　　2. 不加*執行結果：會把一整個列表、元組、字符串、字典做爲一個元組元素使用；

　　3. 加*後執行結果：把列表、元組、字符串每個元素或字符，做爲列表的元素，字典把每個key，做爲元組元素使用；

　　4. 能夠傳入多個實際參數；

4）字典類型參數

字典類型參數(參數前加**)。一個函數裏，只容許使用一個字典類型參數，加*或**的都是可變長參數；

字典類型參數，兩種傳參方法：

1. 調用函數時，使用不加**的實際參數

 說明：

　　1. （**kwargs）字典類型參數，不加**傳入實際參數，必須是一個賦值形式的（像是一個變量）參數；

　　2.  能夠傳入多個參數，函數自動將傳入的參數轉成字典，每一個參數是字典裏的一個元素；

2. 調用函數時，使用加**的實際參數

說明：

　　1. 加**傳參，傳入的參數必須是一個字典，執行的結果也是一個字典內容；

 5）萬能參數（*args，**kwargs）

萬能參數，實際是能夠接收任何數值類型的傳參，而後把字典類型的提取成字典參數，把元組類型的提出成元組參數；

函數的形參定義（*args，**kwargs）:

說明：

1.  萬能參數，不是官方說的。 函數接收參數的形式是萬能的，給了這個定義；
2.  傳入的實際參數，能夠是任何數值類型，函數會將獲得的參數自行分爲兩類；
3.  分爲：元組類型的參數，字典類型的參數； 

三. open 函數功能

1.  open（）函數功能源碼註釋 py3：

def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): # known special case of open
    """
    Open file and return a stream.  Raise IOError upon failure.
    
    file is either a text or byte string giving the name (and the path
    if the file isn't in the current working directory) of the file to
    be opened or an integer file descriptor of the file to be
    wrapped. (If a file descriptor is given, it is closed when the
    returned I/O object is closed, unless closefd is set to False.)
    
    mode is an optional string that specifies the mode in which the file
    is opened. It defaults to 'r' which means open for reading in text
    mode.  Other common values are 'w' for writing (truncating the file if
    it already exists), 'x' for creating and writing to a new file, and
    'a' for appending (which on some Unix systems, means that all writes
    append to the end of the file regardless of the current seek position).
    In text mode, if encoding is not specified the encoding used is platform
    dependent: locale.getpreferredencoding(False) is called to get the
    current locale encoding. (For reading and writing raw bytes use binary
    mode and leave encoding unspecified.) The available modes are:
    
    ========= ===============================================================
    Character Meaning
    --------- ---------------------------------------------------------------
    'r'       open for reading (default)
    'w'       open for writing, truncating the file first
    'x'       create a new file and open it for writing
    'a'       open for writing, appending to the end of the file if it exists
    'b'       binary mode
    't'       text mode (default)
    '+'       open a disk file for updating (reading and writing)
    'U'       universal newline mode (deprecated)
    ========= ===============================================================
    
    The default mode is 'rt' (open for reading text). For binary random
    access, the mode 'w+b' opens and truncates the file to 0 bytes, while
    'r+b' opens the file without truncation. The 'x' mode implies 'w' and
    raises an `FileExistsError` if the file already exists.
    
    Python distinguishes between files opened in binary and text modes,
    even when the underlying operating system doesn't. Files opened in
    binary mode (appending 'b' to the mode argument) return contents as
    bytes objects without any decoding. In text mode (the default, or when
    't' is appended to the mode argument), the contents of the file are
    returned as strings, the bytes having been first decoded using a
    platform-dependent encoding or using the specified encoding if given.
    
    'U' mode is deprecated and will raise an exception in future versions
    of Python.  It has no effect in Python 3.  Use newline to control
    universal newlines mode.
    
    buffering is an optional integer used to set the buffering policy.
    Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
    line buffering (only usable in text mode), and an integer > 1 to indicate
    the size of a fixed-size chunk buffer.  When no buffering argument is
    given, the default buffering policy works as follows:
    
    * Binary files are buffered in fixed-size chunks; the size of the buffer
      is chosen using a heuristic trying to determine the underlying device's
      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
      On many systems, the buffer will typically be 4096 or 8192 bytes long.
    
    * "Interactive" text files (files for which isatty() returns True)
      use line buffering.  Other text files use the policy described above
      for binary files.
    
    encoding is the name of the encoding used to decode or encode the
    file. This should only be used in text mode. The default encoding is
    platform dependent, but any encoding supported by Python can be
    passed.  See the codecs module for the list of supported encodings.
    
    errors is an optional string that specifies how encoding errors are to
    be handled---this argument should not be used in binary mode. Pass
    'strict' to raise a ValueError exception if there is an encoding error
    (the default of None has the same effect), or pass 'ignore' to ignore
    errors. (Note that ignoring encoding errors can lead to data loss.)
    See the documentation for codecs.register or run 'help(codecs.Codec)'
    for a list of the permitted encoding error strings.
    
    newline controls how universal newlines works (it only applies to text
    mode). 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 closefd is False, the underlying file descriptor will be kept open
    when the file is closed. This does not work when a file name is given
    and must be True in that case.
    
    A custom opener can be used by passing a callable as *opener*. The
    underlying file descriptor for the file object is then obtained by
    calling *opener* with (*file*, *flags*). *opener* must return an open
    file descriptor (passing os.open as *opener* results in functionality
    similar to passing None).
    
    open() returns a file object whose type depends on the mode, and
    through which the standard file operations such as reading and writing
    are performed. When open() is used to open a file in a text mode ('w',
    'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
    a file in a binary mode, the returned class varies: in read binary
    mode, it returns a BufferedReader; in write binary and append binary
    modes, it returns a BufferedWriter, and in read/write mode, it returns
    a BufferedRandom.
    
    It is also possible to use a string or bytearray as a file for both
    reading and writing. For strings StringIO can be used like a file
    opened in a text mode, and for bytes a BytesIO can be used like a file
    opened in a binary mode.
    """
    pass

2. open（）函數，操做文件使用，同（file）

操做文件時，通常須要經歷以下步驟：

• 打開文件
• 操做文件

2.1  打開文件

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

注：python中打開文件有兩種方式，即：open(...) 和  file(...) ，本質上前者在內部會調用後者來進行文件操做，推薦使用 open。Python3，沒有file() ;

打開文件時，須要指定文件路徑和以何等方式打開文件，打開後，便可獲取該文件句柄，往後經過此文件句柄對該文件操做。

打開文件的模式有：

• 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

2.2 操做功能

    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
        0 (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.
        """

2.3 open操做文件 之 實例：

f = open("file",'r+',encoding="utf-8")

# 若是打開方式無b,默認read（）讀取所有，按照字符讀取，有b，按照字節讀取，括號裏有數值，從數值位置讀；

f.read(1)

# tell 當前指針所在的位置（字節）

print (tell())

# seek調整當前指針的位置(字節)；

f.seek(tell())

# 當前指針位置向後覆蓋寫入

f.write("hello,world !")

# 關閉文件；

f.close()

四. with 功能使用

爲了不打開文件後忘記關閉，能夠經過管理上下文，即：

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

 

如此方式，當with代碼塊執行完畢時，內部會自動關閉並釋放文件資源。

在Python 2.7 後，with又支持同時對多個文件的上下文進行管理，即：

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

 

實例，再也不須要關閉文件：

with open('db1', 'r', encoding="utf-8") as f1, open("db2", 'w',encoding="utf-8") as f2:
    for line in f1:
        new_str = line.replace("alex", 'st')
        f2.write(new_str)

五. 內置函數

內置函數，詳細信息，請點擊連接：https://docs.python.org/2/library/functions.html

abs()

取絕對值 ，如 abs（-12） 結果：12

all（iterable） 若是iterable全部的元素返回True，或是iterable是空（空列表也是空，可是結尾加了分割符，變成元素就不同了），返回True；

若是iterable的全部元素不爲0、''、（）、{}、[]、None、False或者iterable爲空，all(iterable)返回True，不然返回False；參數iterable：可迭代對象；

如： 　返回值是False的： all([None,12,])、all([0,12,])、all([12,''])等

　　    返回值是True的：  all([])、all(())、等

實例：

>>> all(([],{}))
False
>>> all(([],)) 
False
>>> all([])
True
>>> all(([])) # 這塊我不是很明白，不糾結了，知道是這樣的，不要犯錯誤就好了；我認爲這是個bug；
True
>>>all(([[]])) # 
False　
>>> all(('ak'))
True

注意： 空元組、空列表返回值爲True，可是 空元組、空列表做爲元素時返回False，這裏要特別注意,可是要加，號；

any(iterable)  返回False： if any element of the iterable is true. If the iterable is empty.

若是iterable的任何元素不爲0、''、False,all(iterable)返回True。若是iterable爲空，返回False; 參數iterable：可迭代對象；

如：　　返回值是False的：any(['',None,0,[],()])

　　　　返回值是True的：any(("",None,"Eric",12))

實例：

>>> any(([],12))
True
>>> any(([],))
False
>>> any(([])) 
False

bytes([source[, encoding[, errors]]]) 二進制數據由bytes類型表示。

 

Return a new 「bytes」 object, which is an immutable sequence of integers in the range 0 <= x < 256. bytes is an immutable version of bytearray.

1） Python 3會假定咱們的源碼 — 即.py文件 — 使用的是UTF-8編碼方式。Python 2裏，.py文件默認的編碼方式爲ASCII。可使用# -*- coding: windows-1252 -*-方式來改變文件的編碼。若是py文件中包含中文的字符串，則須要制定爲# -*- coding: gbk -*-，貌似默認的utf8不夠哦。

2） python3中默認的str爲unicode的，可使用str.encode來轉爲bytes類型。

3） python3的print函數只支持unicode的str，貌似沒有對bytes的解碼功能，因此對對不能解碼的bytes不能正確輸出。 

4） str和bytes不能鏈接和比較。 

5） codecs仍然能夠用來str和bytes間的轉化。 

6） 定義非ascii碼的bytes時，必須使用如 bytes('中國','gbk') 來轉碼。

>>> bytes(12)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> bytes('as','utf-8')
b'as'
>>> bytes('as','gbk')
b'as'