Python之路--python基礎2

時間 2019-12-09

標籤 python 之路基礎欄目 Python 简体版

原文原文鏈接

day2內容
一、列表、元組操做
二、字符串操做
三、字典操做
四、集合操做
五、文件操做
六、字符編碼與轉碼
七、內置函數python

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

1、列表(list)

列表是Python中最經常使用的數據類型之一，經過列表能夠對數據實現最方便的存儲，修改等操做。git

一、列表的基本操做

列表的定義

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

列表中元素的訪問

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

>>> names
['dabric', 'devil', 'Tom']
>>> names[0]
'dabric'
>>> names[1]
'devil'
>>> names[-1]   #還能夠從後往前取
'Tom'
>>> names[-2]
'devil'

改變列表：元素賦值

爲指定下標的元素賦值windows

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

分片(split)

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

>>> 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

append方法用於在列表末尾追加新的對象：服務器

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

count

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

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

extend

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

>>> 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

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 "<stdin>", line 1, in <module>
ValueError: 'Jerry' is not in list

insert

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

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方法用於移除列表中某個值的第一個匹配項(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

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

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

sort

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

copy

列表的賦值有三種方式：

>>> 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]]

2、元組(tuple)

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

一、元組的定義

用逗號分隔一些值，就自動建立了元組

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

包含一個值的元組的實現

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

二、元組的操做

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

程序練習

程序：購物車程序

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

3、字符串操做

一、基本的字符串操做

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

>>> website = "http://www.python.org"
>>> website[-3:] = 'com'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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 "<stdin>", 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:\usr\bin\env

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\ttian".expandtabs(10)   #將\t轉換成多長的空格
'dabric    tian'
>>> "dabric\ttian".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

4、字典操做

字典的數據結構成爲映射，字典是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 "<stdin>", line 1, in <module>
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("\t",i2)
            choice2 = input("Please choose the province2>>:")
            if choice2 in menu[choice1]:
                while flag:
                    for i3 in menu[choice1][choice2]:
                        print("\t\t",i3)
                    choice3 = input("Please choose the province3>>:")
                    if choice3 in menu[choice1][choice2]:
                        while flag:
                            for i4 in menu[choice1][choice2][choice3]:
                                print("\t\t\t",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

5、集合操做

集合是一個無序的，不重複的數據組合，它的主要做用以下：

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

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

print(list_1,type(list_1))
{1, 3, 5, 7, 9} <class 'set'>

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

一、基本操做

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

6、文件操做

對文件操做流程

一、打開文件，獲得文件句柄並賦值給一個變量
二、經過句柄對文件進行操做
三、關閉文件

一、打開文件

要打開文件，可以使用函數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)

6、字符編碼與轉碼

一、在python2默認編碼是ASCII, python3裏默認是unicode

二、unicode 分爲 utf-32(佔4個字節),utf-16(佔兩個字節)，utf-8(佔1-4個字節)， so utf-16就是如今最經常使用的unicode版本，不過在文件裏存的仍是utf-8，由於utf8省空間

三、在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)

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。