摘要：內容列表元組操作字符串操作字典操作集合操作文件操作字符編碼與轉碼內置函數在中，最基本的數據結構是序列。序列中的每個元素被分配一個序號即元素的位置，也稱為索引。空字典不包括任何項由兩個大括號組成。

day2內容
1、列表、元組操作
2、字符串操作
3、字典操作
4、集合操作
5、文件操作
6、字符編碼與轉碼
7、內置函數

在Python中，最基本的數據結構是序列(sequence)。序列中的每個元素被分配一個序號--即元素的位置，也稱為索引。第一個索引是0，第二個是1，以此類推。Python包含6中內鍵的序列：列表、元組、字符串、Unicode字符串、buffer對象和xrange對象。
序列都可以進行的操作包括索引、切片、加、乘、檢查成員
此外，Python已經內置確定序列的長度以及確定最大和最小元素的方法。

列表是Python中最常用的數據類型之一，通過列表可以對數據實現最方便的存儲，修改等操作。

names = ["dabric","devil","Tom"]

通過下標訪問列表中的元素，下標從0開始計數

>>> names
["dabric", "devil", "Tom"]
>>> names[0]
"dabric"
>>> names[1]
"devil"
>>> names[-1]   #還可以從后往前取
"Tom"
>>> names[-2]
"devil"

為指定下標的元素賦值

>>> names
["dabric", "devil", "Tom"]
>>> names[1] = "Alice"
>>> names
["dabric", "Alice", "Tom"]

Python通過對序列進行分片，來取序列中的多個元素，分片遵循顧前不顧后的原則

>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil"]
>>> names[0:3]             #當從列表的首個元素開始切片時，可以省略不寫0；相當于names[:3]
["dabric", "Alice", "Tom"] 

>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil"]
>>> names[1:]              #要取從指定下標處開始所有列表中的元素，省略不寫后面的下標；
["Alice", "Tom", "Beth", "Cecil"]

#從列表后往前切片  
>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil"]
>>> names[-3:-1]
["Tom", "Beth"]

>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil"]
>>> names[:-1]
["dabric", "Alice", "Tom", "Beth"]
>>> names[-4:]
["Alice", "Tom", "Beth", "Cecil"]

append方法用于在列表末尾追加新的對象：

>>> names
["dabric", "Alice", "Tom"]
>>> names.append("Beth")
>>> names
["dabric", "Alice", "Tom", "Beth"]

count方法統計某個元素在列表中出現的次數：

>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil", "Cecil"]
>>> names.count("Cecil")
2

extend方法可以在列表的末尾一次性追加另一個序列中的多個值。換句話說，可以用新列表擴展原有的列表：

>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil", "Cecil"]
>>> name
["Dee-Dee", "Earl"]
>>> names.extend(name)
>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil", "Cecil", "Dee-Dee", "Earl"]

index方法用于從列表中找出某個值第一個匹配的索引位置：

>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil", "Cecil", "Dee-Dee", "Earl"]
>>> names.index("dabric")
0
>>> names.index("Tom")
2
>>> names.index("Jerry")
Traceback (most recent call last):
  File "", line 1, in 
ValueError: "Jerry" is not in list

insert方法用于將對象插入到列表中的指定位置：

>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil", "Cecil", "Dee-Dee", "Earl"]
>>> names.insert(3,"貝斯")
>>> names
["dabric", "Alice", "Tom", "貝斯", "Beth", "Cecil", "Cecil", "Dee-Dee", "Earl"]

pop方法會移除列表中的一個元素(默認為最后一個)，并且返回該元素的值：

>>> names
["dabric", "Alice", "Tom", "貝斯", "Beth", "Cecil", "Cecil", "Dee-Dee", "Earl"]
>>> names.pop()
"Earl"
>>> names
["dabric", "Alice", "Tom", "貝斯", "Beth", "Cecil", "Cecil", "Dee-Dee"]
>>> names.pop(3)         #移除指定下標的元素，并將該元素的值返回
"貝斯"
>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil", "Cecil", "Dee-Dee"]

remove方法用于移除列表中某個值的第一個匹配項(remove方法修改了列表卻沒有返回值，這與pop方法相反)：

>>> names
["dabric", "Alice", "Tom", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom"]
>>> names.remove("Tom")
>>> names
["dabric", "Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom"]

reverse方法將列表中的元素反向存放：

>>> names
["dabric", "Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom"]
>>> names.reverse()
>>> names
["Tom", "Dee-Dee", "Cecil", "Cecil", "Beth", "Alice", "dabric"]

sort方法用于在原位置對列表盡心排序。在“原位置排序”意味著改變原來的列表，sort方法修改原來的列表，其返回結果為空：

>>> names
["Tom", "Dee-Dee", "Cecil", "Cecil", "Beth", "Alice", "dabric"]
>>> name = names.sort()
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom", "dabric"]
>>> name
>>> print(name)
None

列表的賦值有三種方式：

>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom"]
>>> name = names.copy()    #方法一(淺拷貝)
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom"]
>>> name
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom"]

>>> names.pop()    #移除names中的最后一個元素
"Tom"
>>> name
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom"]
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee"]

>>> name.clear()    #清空列表中的數據
>>> name
[]
>>> name = names[:]     #方法二，names[:]得到的是包含names所有元素的分片，這是一種很有效率的復制整個列表的方法。只是簡單的把names賦值給name是沒有用的，因為這樣做就讓names和name都指向同一個列表了。
>>> name
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", "Tom"]

>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee"]
>>> name.clear()
>>> name
[]
>>> import copy     #方法三，導入copy模塊
>>> name = copy.copy(names)      #其功能和列表的copy方法一樣，都是淺拷貝
>>> name
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee"]

#淺拷貝，只能拷貝第一層的列表，對于第二層乃至更深的一層不能實現拷貝的功能。列表的拷貝是將列表中每個索引指向的值拷貝一份，對于列表中的列表，其索引指向的是另外一個地址，而淺拷貝只是將該索引指向的地址復制一份，所以當前一個列表中值發生改變，相應復制的列表中的值也發生同樣的變化。
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee"]
>>> names.append([1,2,3])
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [1, 2, 3]]
>>> name
[]
>>> name = copy.copy(names)
>>> name
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [1, 2, 3]]
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [1, 2, 3]]
>>> names[-1][0] = 10
>>> name
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [10, 2, 3]]
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [10, 2, 3]]

#深拷貝
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [1, 2, 3]]
>>> name
[]
>>> name = copy.deepcopy(names)
>>> name
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [1, 2, 3]]
>>> names[-1][0] = 10
>>> names
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [10, 2, 3]]
>>> name
["Alice", "Beth", "Cecil", "Cecil", "Dee-Dee", [1, 2, 3]]

元組與列表一樣，也是一種序列。唯一不同的是元組不能修改。

>>> 1,2,3
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)

>>> 42,
(42,)
>>> (42)
42
>>> (42,)
(42,)

元組也可以實現切片，它只有兩個方法，一個是count，另一個是index。

程序練習

程序：購物車程序

需求:
(1) 啟動程序后，讓用戶輸入工資，然后打印商品列表
(2) 允許用戶根據商品編號購買商品
(3) 用戶選擇商品后，檢測余額是否夠，夠就直接扣款，不夠就提醒
(4) 可隨時退出，退出時，打印已購買商品和余額

所有標準的序列操作（索引、分片、乘法、判斷成員資格、求長度、取最小值和最大值）對字符串同樣適用。但是字符串是不可改變的，例如：

>>> website = "http://www.python.org"
>>> website[-3:] = "com"
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "str" object does not support item assignment

字符串格式化使用字符串格式化操作符即百分號%來實現。在%號左側放置一個字符串(格式化字符串)，而右側則放置希望被格式化的值?？梢允褂靡粋€值，如一個字符串或者數字，也可以使用多個值的元組或者字典。
格式化操作符的右操作數可以是任意類型，如果右操作數是元組的話，則其中的每一個元素都會被多帶帶格式化，每個值都需要一個對應的轉換說明符。

>>> "%s plus %s equals %s" % (1,1,2)
"1 plus 1 equals 2"

基本的轉換說明符

%字符：標記轉換說明符的開始

轉換標志(可選)：-表示左對齊；+表示在轉換值之前要加上正負號；""(空白字符)表示整十數之前保留空格；0表示轉換值若位數不夠則用0填充。

最小字段寬度(可選)：轉換后的字符串至少應該具有該值指定的寬度。如果是*，則寬度會從值元組中讀出。

點(.)后跟精度值(可選)：如果轉換的是實數，精度值就表示出現小數點后的位數。如果轉換的是字符串，那么該數字就表示最大字段寬度。如果是*，那么精度將會從元組中讀出。

轉換類型：參見下表。

基本方法

center

方法center通過在兩邊添加填充字符(默認為空格)讓字符串居中。

>>> name = "My name is Dabric"
>>> name.center(39)
"           My name is Dabric           "
>>> name.center(39,"*")
"***********My name is Dabric***********"


>>> name.ljust(40,"*")   #將字符串靠左顯示，如果字符串不夠給定長度，用給定字符進行填充
"My name is Dabric***********************"
>>> name.rjust(40,"*")   #將字符串靠右顯示，如果字符串不夠給定長度，用給定字符進行填充
"***********************My name is Dabric"

>>> name.zfill(40)       #將字符串靠右顯示，如果字符串不夠給定長度，用0進行填充
"00000000000000000000000My name is Dabric"

find

方法find在字符串中查找子串。如果找到，就返回子串的第一個字符的索引，否則返回-1.

>>> name.find("e")
6
>>> name.find("u")
-1
還可以指定搜索的起點和終點(可選)
>>> subject = "$$$ Get rich now!!! $$$"
>>> subject.find("$$$")
0
>>> subject.find("$$$", 1) # 只指定了起點
20
>>> subject.find("!!!")
16
>>> subject.find("!!!", 0, 16) # 同時指定了起點和終點(搜索范圍包含起點，但不包含終點)
-1

join

join是一個非常重要的字符串方法，其作用于split相反，用于合并序列的元素。

>>> seq = [1, 2, 3, 4, 5]
>>> sep = "+"
>>> sep.join(seq) # 嘗試合并一個數字列表
Traceback (most recent call last):
File "", line 1, in ?
TypeError: sequence item 0: expected string, int found
>>> seq = ["1", "2", "3", "4", "5"]
>>> sep.join(seq) # 合并一個字符串列表
"1+2+3+4+5"
>>> dirs = "", "usr", "bin", "env"
>>> "/".join(dirs)
"/usr/bin/env"
>>> print("C:" + "".join(dirs))
C:usrinenv

repalce

方法replace將指定子串都替換為另一個字符串，并返回替換后的結果。

>>> "dabric tian, chinese name is tianchenguang".replace("tian","TIAN",1)
     "dabric TIAN, chinese name is tianchenguang"

spilt

split是一個非常重要的字符串方法，其作用與join相反，用于將字符串拆分為序列。

>>> "1+2+3+4+5".split("+")
["1", "2", "3", "4", "5"]
>>> "/usr/bin/env".split("/")
["", "usr", "bin", "env"]
>>> "Using the default".split()
["Using", "the", "default"]
注意，如果沒有指定分隔符，將默認在單個或多個連續的空白字符（空格、制表符、換行符
等）處進行拆分。

strip

方法strip將字符串開頭和末尾的空白（但不包括中間的空白）刪除，并返回刪除后的結果。

>>> " internal whitespace is kept ".strip()
"internal whitespace is kept"

判斷字符串是否滿足特定的條件

很多字符串方法都以is打頭，如isspace、isdigit和isupper，它們判斷字符串是否具有特定
的性質（如包含的字符全為空白、數字或大寫）。如果字符串具備特定的性質，這些方法就返回
True，否則返回False。

isalnum、isalpha、isdecimal、isdigit、isidentifier、islower、isnumeric、
isprintable、isspace、istitle、isupper

其他方法

>>> name = "My name is Dabric"
>>> name
"My name is Dabric"
>>> name.capitalize()       #首字母大寫
"My name is dabric"

>>> name.casefold()         #大寫全部變成小寫
"my name is dabric"

>>> name.count("a")         #統計指定字符或字符串出現的次數
2
>>> name.count("is")
1

>>> name.encode()           #將字符串編碼成bytes格式
b"My name is Dabric"

>>> name.endswith("dabric")   #判斷字符串是否以指定的字符串結尾
False
>>> name.endswith("Dabric")
True

>>> "dabric	tian".expandtabs(10)   #將	轉換成多長的空格
"dabric    tian"
>>> "dabric	tian".expandtabs()
"dabric  tian"

format :

    >>> msg = "my name is {}, and age is {}"
    >>> msg.format("dabric",22)
    "my name is dabric, and age is 22"
    >>> msg = "my name is {1}, and age is {0}"
    >>> msg.format("dabric",22)
    "my name is 22, and age is alex"
    >>> msg = "my name is {name}, and age is {age}"
    >>> msg.format(age=22,name="dabric")
    "my name is dabric, and age is 22"
format_map
    >>> msg.format_map({"name":"dabric","age":22})
    "my name is dabric, and age is 22"


msg.index("a")  返回a所在字符串的索引

maketrans
    >>> intab = "aeiou"  #This is the string having actual characters. 
    >>> outtab = "12345" #This is the string having corresponding mapping character
    >>> trantab = str.maketrans(intab, outtab)
    >>> 
    >>> str = "this is string example....wow!!!"
    >>> str.translate(trantab)
    "th3s 3s str3ng 2x1mpl2....w4w!!!"

 msg.partition("is")   輸出 ("my name ", "is", " {name}, and age is {age}") 

 msg.swapcase 大小寫互換

>>> b="ddefdsdff_哈哈" 
>>> b.isidentifier() #檢測一段字符串可否被當作標志符，即是否符合變量命名規則
True

字典的數據結構成為映射，字典是Python中唯一內建的映射類型。字典中的值并沒有特殊的順序，但是都存儲在一個熱定的鍵(Key)下。鍵可以是數字、字符串甚至是元組。

字典由多個鍵及與之對應的值構成的Key-Value對組成。每個鍵和它的值之間用冒號(:)隔開，項之間用逗號(,)隔開，而整個字典是由一對大括號括起來。空字典(不包括任何項)由兩個大括號組成({})。例如：

phonebook = {"Alice":"2341","Beth":"9102","Cecil":"3258"}

dict函數

可以使用dict函數，通過其他映射(比如其他字典)或者(鍵，值)對的序列建立字典。

>>> items  = [("name","Gumby"),("age",42)]
>>> d = dict(items)
>>> d
{"name": "Gumby", "age": 42}

dict函數也可以通過關鍵字參數來創建字典，如下所示：

>>> d = dict(name="Gumby",age=42)
>>> d
{"name": "Gumby", "age": 42}

增加

>>> info
{"student1": "Alice", "student2": "Beth", "student": "Cecil"}
>>> info["student4"] = "Dabric"
>>> info
{"student1": "Alice", "student2": "Beth", "student": "Cecil", "student4": "Dabri
c"}

修改

>>> info
{"student1": "Alice", "student2": "Beth", "student": "Cecil", "student4": "Dabri
c"}
>>> info["student1"] = "ALICE"
>>> info
{"student1": "ALICE", "student2": "Beth", "student": "Cecil", "student4": "Dabri
c"}

刪除

標準刪除方法

>>> info
{"student1": "ALICE", "student2": "Beth", "student": "Cecil", "student4": "Dabri
c"}
>>> info.pop("student")                #刪除指定鍵下的值，并將該值返回
"Cecil"
>>> info
{"student1": "ALICE", "student2": "Beth", "student4": "Dabric"}

通用刪除方法

>>> info
{"student1": "ALICE", "student2": "Beth", "student4": "Dabric"}
>>> del info["student1"]
>>> info
{"student2": "Beth", "student4": "Dabric"}

隨機刪除方法

>>> info
{"student2": "Beth", "student4": "Dabric", "student1": "Alice", "student3": "Cec
il"}
>>> info.popitem()     #隨機刪除字典中的項，并將對應的鍵值以元組的形式返回
("student3", "Cecil")

查找

>>> info
{"student2": "Beth", "student4": "Dabric", "student1": "Alice", "student3": "Cec
il"}
>>> "student2" in  info    #成員資格檢查，標準用戶
True

>>> info.get("student1")   #獲取指定鍵下的值，如果該指定的鍵值不存在，返回None
"Alice"
>>> info.get("student5")
>>>

>>> info["student1"]    #同上，但是當指定的鍵不存在時報錯
"Alice"
>>> info["student5"]
Traceback (most recent call last):
  File "", line 1, in 
KeyError: "student5"

多級字典嵌套及操作

av_catalog = {
    "歐美":{
        "www.youporn.com": ["很多免費的,世界最大的","質量一般"],
        "www.pornhub.com": ["很多免費的,也很大","質量比yourporn高點"],
        "letmedothistoyou.com": ["多是自拍,高質量圖片很多","資源不多,更新慢"],
        "x-art.com":["質量很高,真的很高","全部收費,屌比請繞過"]
    },
    "日韓":{
        "tokyo-hot":["質量怎樣不清楚,個人已經不喜歡日韓范了","聽說是收費的"]
    },
    "大陸":{
        "1024":["全部免費,真好,好人一生平安","服務器在國外,慢"]
    }
}

av_catalog["大陸"]["1024"][1] += ",可以用爬蟲爬下來"
print(av_catalog["大陸"]["1024"])
#ouput 
["全部免費,真好,好人一生平安", "服務器在國外,慢,可以用爬蟲爬下來"]

其他操作

#values
>>> info
{"student2": "Beth", "student4": "Dabric", "student1": "Alice", "student3": "Cec
il"}
>>> info.values()
dict_values(["Beth", "Dabric", "Alice", "Cecil"])


#keys
>>> info.keys()
dict_keys(["student2", "student4", "student1", "student3"])

#setdefault  setdefault方法在某種程度上類似于get方法，能夠獲得與給定鍵相關量的值，除此之外，setdefault還能在字典中不含有給定鍵的情況下設定相應的鍵值。
>>> info.setdefault("student5","Devil")
"Devil"
>>> info
{"student2": "Beth", "student4": "Dabric", "student1": "Alice", "student3": "Cec
il", "student5": "Devil"}
>>> info.setdefault("student2","Devil")
"Beth"

#update   update方法可以利用一個字典項更新另外一個字典
>>> info
{"student2": "Beth", "student4": "Dabric", "student1": "Alice", "student3": "Cec
il", "student5": "Devil"}
>>> b = {1:2,3:4,"student0":"ALICE"}
>>> info.update(b)
>>> info
{"student2": "Beth", "student4": "Dabric", "student1": "Alice", "student3": "Cec
il", "student5": "Devil", 1: 2, 3: 4, "student0": "ALICE"}

#items  items方法將字典所有的項返回
>>> info.items()
dict_items([("student2", "Beth"), ("student4", "Dabric"), ("student1", "Alice"),
 ("student3", "Cecil"), ("student5", "Devil"), (1, 2), (3, 4), ("student0", "ALI
CE")])

#通過一個列表生成默認dict,有個沒辦法解釋的坑，少用吧這個
>>> dict.fromkeys([1,2,3],"testd")
{1: "testd", 2: "testd", 3: "testd"}

字典的遍歷

#方法1
for key in info:
    print(key,info[key])

#方法2
for k,v in info.items(): #會先把dict轉成list,數據大時莫用
    print(k,v)

程序練習

程序: 三級菜單
要求:

打印省、市、縣三級菜單

可返回上一級

可隨時退出程序

menu = {
    "北京":{
        "海淀":{
            "五道口":{
                "soho":{},
                "網易":{},
                "google":{}
            },
            "中關村":{
                "愛奇藝":{},
                "汽車之家":{},
                "youku":{},
            },
            "上地":{
                "百度":{},
            },
        },
        "昌平":{
            "沙河":{
                "老男孩":{},
                "北航":{},
            },
            "天通苑":{},
            "回龍觀":{},
        },
        "朝陽":{},
        "東城":{},
    },
    "上海":{
        "閔行":{
            "人民廣場":{
                "炸雞店":{}
            }
        },
        "閘北":{
            "火車戰":{
                "攜程":{}
            }
        },
        "浦東":{},
    },
    "山東":{},
}

flag = True

while flag:
    for i1 in menu:
        print(i1)

    choice1 = input("Please choose the province1>>:")
    if choice1 in menu:
        while flag:
            for i2 in menu[choice1]:
                print("	",i2)
            choice2 = input("Please choose the province2>>:")
            if choice2 in menu[choice1]:
                while flag:
                    for i3 in menu[choice1][choice2]:
                        print("		",i3)
                    choice3 = input("Please choose the province3>>:")
                    if choice3 in menu[choice1][choice2]:
                        while flag:
                            for i4 in menu[choice1][choice2][choice3]:
                                print("			",i4)
                            choice4 = input("最后一層，按b返回上層，按q退出>>:")
                            if choice4 == "b":
                                break
                            elif choice4 == "q":
                                flag = False
                    if choice3 == "b":
                        break
                    elif choice3 == "q":
                        flag = False
            if choice2 == "b":
                break
            elif choice2 == "q":
                flag = False
    if choice1 == "b":
        break
    elif choice1 == "q":
        flag = False

集合是一個無序的，不重復的數據組合，它的主要作用如下：

去重，把一個列表變成集合，就自動去重了

list_1 = [1,3,5,7,9,5]
list_1 = set(list_1)

print(list_1,type(list_1))
{1, 3, 5, 7, 9} 

關系測試，測試兩組數據之間的交集、并集、差集等關系

  
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.copy()  
返回 set “s”的一個淺復制

交集

>>>list_1 = [1,3,5,7,9,5]
>>>list_1 = set(list_1)
>>>list_2 = set([6,2,4,7,8,9])
>>>print(list_1,list_2)
{1, 3, 5, 7, 9} {2, 4, 6, 7, 8, 9}
>>>list_3 = list_1.intersection(list_2)   #或者list_3 = list_1 & list_2
>>>print(list_3)
{9, 7}

并集

>>>list_3 = list_1.union(list_2)  #或者list_3 = list_1 | list_2
>>>print(list_3)
{1, 2, 3, 4, 5, 6, 7, 8, 9}

差集

>>>list_3 = list_1.difference(list_2)  #或者list_3 = list_1 - list_2
>>>print(list_3)
{1, 3, 5}

對稱差集

>>>list_3 = list_1.symmetric_difference(list_2)    #或者list_3 = list_1 ^ list_2
>>>print(list_3)
{1, 2, 3, 4, 5, 6, 8}

子集

>>>a = list_1.issubset(list_2)  #判斷一個集合是否為另外一個集合的子集(list_1是否為list_2的子集)，如果是返回值為真，否則為假
>>>print(a)
False

父集

>>>a = list_1.issuperset(list_2)   #判斷一個集合是否為另外一個集合的父集(list_1是否包含list_2)，如果是返回值為真，否則為假
>>>print(a)
False

對文件操作流程

1、打開文件，得到文件句柄并賦值給一個變量

2、通過句柄對文件進行操作

3、關閉文件

要打開文件，可使用函數open，它位于自動導入的模塊io中。函數open將文件名作為唯一必
不可少的參數，并返回一個文件對象。如果當前目錄中有一個名為somefile.txt的文本文件（可能
是使用文本編輯器創建的），則可像下面這樣打開它：

>>> f = open("somefile.txt")

文件模式：

r，只讀模式(默認)
w，只寫模式 (不可讀；文件不存在則創建；文件存在則既有內容被刪除，并從文件開頭處開始寫入)
x，獨占寫入模式(在文件已經存在時引發FileExistsError)
a，追加模式(可讀；文件不存在則創建；存在則在文件末尾追加寫入內容)

"+"表示可以同時讀寫某個文件
r+，可讀寫文件(可讀；可寫；可追加。以讀和追加模式打開文件)
w+，寫讀(沒有文件先創建一個文件，有文件的話覆蓋原文件)
a+，追加讀寫

默認模式為"rt"，這意味著將把文件視為經過編碼的Unicode文本，因此將自動執行解碼和編碼，且默認使用UTF-8編碼。默認情況下，行以"n"結尾。讀取時講自動替換其他行尾字符("r"或"rn")；寫入時講"n"替換為系統的默認行尾字符(os.linesep)；通過設置newline參數可指定只將"r"或"rn"視為合法的行尾字符，這樣，讀取時不會對行尾字符進行轉換，但寫入時將把"n"替換為系統默認的行尾字符。

"U"表示在讀取時，可以將rnrn自動轉換成n(與r或r+模式同時使用)
rU
r+U

"b"表示處理二進制文件(如：FTP發送上傳ISO鏡像文件，linux可忽略，windows處理二進制文件時需標注)
rb
wb
ab

讀取和寫入

文件寫入

每當調用f.write(string)時，提供的字符串都將寫入到文件中既有內容的后面

>>> f = open("somefile.txt", "w")
>>> f.write("Hello, ")
7
>>> f.write("World!")
6
>>> f.close()

文件讀取

>>> f = open("somefile.txt", "r")
>>> f.read(4)
"Hell"
>>> f.read()
"o, World!"
#首先，指定了要讀取多少（4）個字符。接下來，讀取了文件中余下的全部內容（不指定要讀取多少個字符）。

讀取和寫入行

讀取行

readline
默認返回一行的內容，也可以指定返回幾個字符
readlines
讀取文件中的所有行，并以列表的方式返回

寫入行

writelines
與readlines相反：接受一個字符串列表(實際上，可以是任何序列或可迭代對象)，并將這些字符串都寫入到文件(或流)中。
注意：寫入時不會添加換行符，因此必須自行添加。另外，沒有方法writeline，一次可以使用write

with語句

為了避免打開文件后忘記關閉，可以通過上下文管理器，即：

with open("somefile.txt") as somefile
    do_something(somefile)

flush

將內存中的數據同步到磁盤上

進度條的實現
import sys,time

for i in range(50):
    sys.stdout.write("#")
    sys.stdout.flush()
    time.sleep(0.1)

tell和seek
tell方法返回文件指針的位置，seek方法用來移動文件指針的位置，一般兩個方法結合使用。

encoding
打印文件的編碼

fileno
返回文件句柄的編號。操作系統會有一個專門的接口負責調度所有的文件，該編號為系統中已經打開文件的編號。

name
打印文件名

truncate
該方法如果不接任何參數，則將文件中的內容清空；如果接一個參數10，從文件指針位置開始截斷取出十個字符并保存文件指針前的內容。

一種常見的文件操作是迭代其內容，并在迭代過程中反復采取某種措施。

每次一個字符(或字節)

使用read遍歷字符

with open("yesterday",encoding="utf-8") as f:
     char = f.read(1)
     while char:
         sys.stdout.write(char)
         char = f.read(1)

with open("yesterday", encoding="utf-8") as f:
    while True:
        char = f.read(1)
        if not char: break
        sys.stdout.write(char)

這個程序之所以可行，是因為到達文件末尾時，方法read將返回一個空字符串，但在此之前，返回的字符串都只包含一個字符(對應于布爾值True)。

每次一行

with open (filename) as f:
    while True:
        line = f.readline()
        if not line: break
        print(line)

讀取文件所有內容

如果文件不太大，可以讀取整個文件，利用下面兩種方法進行讀取

with open(filename) as f:
    for char in f.read():
        sys.stdout.write(char)

with open(filename) as f:
    for line in f.readlines:
        print(line)

兩者的區別是read不提供任何參數，將整個文件讀取到一個字符串中；readlines將文件讀取到一個字符串列表中，其中每個字符串都是一行。

使用fileinput實現延遲行迭代

延遲行迭代的方法：延遲是因為它只讀取實際需要的文本部分

import fileinput
for line in fileinput.input(filename)
    print(line)

# 模塊fileinput會負責打開文件，只需要給其提供一個文件名即可。

文件迭代器(最常見的方法)

文件實際上可迭代的(sys.stdin也是可迭代的)，所以可以用下面的方法進行讀取文件的內容：

with open(filename) as f:
    for line in f:
        print(line)

1、在python2默認編碼是ASCII, python3里默認是unicode

2、unicode 分為 utf-32(占4個字節),utf-16(占兩個字節)，utf-8(占1-4個字節)， so utf-16就是現在最常用的unicode版本， 不過在文件里存的還是utf-8，因為utf8省空間

3、在py3中encode,在轉碼的同時還會把string 變成bytes類型，decode在解碼的同時還會把bytes變回string

轉碼過程如下圖：

in python2

#-*-coding:utf-8-*-

import sys
print(sys.getdefaultencoding())


msg = "我愛北京天安門"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")

print(msg)
print(msg_gb2312)
print(gb2312_to_gbk)

in python3

#-*-coding:gb2312 -*-   #這個也可以去掉

import sys
print(sys.getdefaultencoding())


msg = "我愛北京天安門"
#msg_gb2312 = msg.decode("utf-8").encode("gb2312")
msg_gb2312 = msg.encode("gb2312") #默認就是unicode,不用再decode,喜大普奔
gb2312_to_unicode = msg_gb2312.decode("gb2312")
gb2312_to_utf8 = msg_gb2312.decode("gb2312").encode("utf-8")

print(msg)
print(msg_gb2312)
print(gb2312_to_unicode)
print(gb2312_to_utf8)