Python3.5學習之旅——day3

本節內容：

一、字符串操做

二、字典操做

三、集合

四、文件操做

五、字符編碼與轉碼

六、函數與函數式編程

 

 

 

1、字符串操做

name='kobe'
name.capitalize()  首字母大寫
name.casefold()   大寫所有變小寫
name.center(50,"-")  輸出 '---------------------kobe----------------------'
name.count('be') 統計be出現次數
name.encode()  將字符串編碼成bytes格式
name.endswith("Li")  判斷字符串是否以 Li結尾
name.find('A')  查找A,找到返回其索引， 找不到返回-1 

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


msg.index('a')  返回a所在字符串的索引
'9aA'.isalnum()   判斷是否阿拉伯數字或字母，是則返回true

'9'.isdigit() 是否整數
name.isnumeric    是否數字
name.isprintable     是否可打印
name.isspace   是不是空格
name.istitle  是否首字母大寫
name.isupper  是否大寫
 "+".join(['alex','jack','rain'])
'alex+jack+rain'


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.swapcase 大小寫互換

msg.zfill(40)   打印40個字符，不夠則前面補0




n4.ljust(40,"-")   保證打印夠40個字符，不夠後面用-補齊
‘Hello 2orld-----------------------------'
n4.rjust(40,"-")   保證打印夠40個字符，不夠前面用-補齊

'-----------------------------Hello 2orld' >>> b="ddefdsdff_哈哈" 
b.isidentifier() #檢測一段字符串能否被看成標誌符，便是否符合變量命名規則 True

 2、字典操做

字典是一種key-value（即鍵-值）的數據類型，使用時就像字典，經過筆畫、字母來查詢對應頁的內容。

一、一級字典

下面舉一個一級字典的簡單例子：

__author__ = 'Sunny Han'
info={
    'stu1101':'han',
    'stu1102':'duan',
    'stu1103':'wang',
}
print(info)

代碼執行結果以下：

能夠看出字典打印出來是無序的，也就不能用下標索引。

字典也有許多其餘操做，舉例以下：

info={
    'stu1101':'han',
    'stu1102':'duan',
    'stu1103':'wang',
}
b={'stu1101':'mao',
   'stu1104':'li',
   'stu1105':'zhao',}

info.update(b)   #將字典info更新爲b，即原有的key值相同的換成字典b的value值，之 
                          前字典info不存在而字典b存在的key值內容則直接添加進去
print(info)
print(info['stu1101'])  #打印key值爲1101所對應的value值
print(info.get('stu1108'))   #查詢是否存在key值爲1108的相應內容，若存在則直接打 
                                          印出來對應的value值，不存在則返回None
print('stu1101' in info)   #判斷是否存在key值爲1101的內容，存在則返回True，不存 
                                      在返回False
print(info.keys())  #打印字典中全部的key值
print(info.values())  ##打印字典中全部的value值
print(info.items())  #把字典打印爲一個列表
for i in info:            #循環打印字典內容
    print(i,info[i])
for k,v in info.items():   #循環打印字典內容
    print(k,v)

代碼執行結果以下：

二、多級字典嵌套及操做

player_catalog={
    'west':{'kobe':'GOAT',
            'CP3':'GREAT DRRIBLER',
            'MELO':'OLD GUY'
    },
    'EAST':{'LBJ':'ATHLETIC',
            'ANSWER':['FASTEST','SHOOTER']}
}
player_catalog['EAST']['ANSWER'][0]='NO PASS'
print(player_catalog['EAST'].get('LBJ'))
print(player_catalog.keys())
print(player_catalog.values())

player_catalog.setdefault('china',{'YI':['strong','smart']})   #建立一個新的字典內容
print('-->',player_catalog.values())
print('-->',player_catalog.keys())

代碼執行結果以下：

三、三級菜單

經過上面的學習咱們能夠嘗試着寫一個三級菜單，並能實現

1. 打印三級菜單
2. 可返回上一級
3. 可隨時退出程序

 以上三個功能，代碼示例以下：

data={
    '北京':{
        '昌平':{
            '沙河':{'oldboy','test'},
            '天通苑':{'鏈家地產','我愛我家'}
        },
        '朝陽':{'望京':['奔馳','陌陌'],
              '國貿':{'CICC','HP'},
              '東直門':{'advent','飛信'}
              },
        '海淀':{},
    },
    '山東':{'德州':{},
            '青島':{},
            '濟南':{},
          },
    '廣東':{
        '東莞':{},
        '常熟':{},
        '佛山':{}
    },
}
exit_flag=False
while not exit_flag:
    for i in data:
        print(i)
    choice=input('選擇進入>>:')
    if choice in data:
        while not exit_flag:
            for i2 in data[choice]:
                print('\t',i2)
            choice2=input('請選擇進入2>>:')
            if choice2 in data[choice]:
                while not exit_flag:
                    for i3 in data[choice][choice2]:
                        print('\t\t',i3)
                    choice3=input('請選擇進入3>>:')
                    if choice3 in data[choice][choice2]:
                        while not exit_flag:
                           for i4 in data[choice][choice2][choice3]:
                               print('\t\t',i4)
                           choice4=input('最後一層，按b返回')
                           if choice4=='b':
                               pass
                           elif choice4=='q':
                               exit_flag=True
                    if choice3=='b':
                     break
                    elif choice3=='q':
                        exit_flag=True
            if choice2=='b':
                  break
            elif choice2=='q':
                        exit_flag=True

代碼也可以實現相應的功能，有興趣的能夠自行練習一下。

 3、集合

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

• 去重，把一個列表變成集合，就自動去重了
• 關係測試，測試兩組數據以前的交集、差集、並集等關係

下面舉一個簡單的例子：

list_1=[1,4,5,6,8,6,5,9]     #首先建立一個列表list_1
list_1=set(list_1)    #將列表轉化爲集合，這時打印出來的重複項內容及（5,6）就只出現一次了
list_1.add(999)  #添加一項
list_1.update([88,55])  #添加多項
list_1.remove(88)   #刪除指定的元素

list_2=set([2,6,5,9,7,32])  #建立集合list_2
list_3=set([1,4,5])    #建立集合list_3

print('一',list_1.discard(66))  #刪除元素，若所刪除的元素不存在，返回None
print('二',list_1,type(list_1),len(list_1))  #打印list_1的內容、類型及長度
print('三',77 in list_1)  #判斷集合list_1是否包含77，不包含則返回False
print('四',list_1.pop())  #隨意刪除一個集合元素

print('五',list_1,list_2)  #打印list_1,list_2兩個集合
print('六',list_2.intersection(list_1))   #打印list_1,list_2兩個集合的交集
print('七',list_1&list_2)    #打印list_1,list_2兩個集合的交集

print('八',list_1.union(list_2))   #打印list_1,list_2兩個集合的並集
print('九',list_1|list_2)          #打印list_1,list_2兩個集合的並集

print('十',list_1.difference(list_2))    #打印list_1,list_2兩個集合的差集（list_1中有而list_2中沒有）
print('十一',list_1-list_2)              #打印list_1,list_2兩個集合的差集（list_1中有而list_2中沒有）

print('十二',list_2.difference(list_1))   #打印list_2,list_1兩個集合的差集（list_2中有而list_1中沒有）
print('十三',list_3.issubset(list_1))   #判斷集合list_3是否list_1的子集
print('十四',list_2.issubset(list_1))   #判斷集合list_2是否list_1的子集
print('十五',list_1.symmetric_difference(list_2))   #打印list_1,list_2兩個集合的對稱差集（list_1中和list_2中沒有互相沒有的）
print('十六',list_1^list_2)   #打印list_1,list_2兩個集合的對稱差集（list_1中和list_2中沒有互相沒有的）

代碼執行結果以下：

4、文件操做

一、文件操做流程：

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

下面進行詳細介紹：

首先創建一個文本文件‘yesterday’以下：

yesterday

接下來咱們對此文件進行一些基本的操做以下：

f = open('yesterday',encoding='utf-8') #打開文件
data = f.readline()
print('first line:',data) #讀一行
print('我是分隔線'.center(50,'-'))
data2 = f.read()# 讀取剩下的全部內容,文件大時不要用;這裏要注意的是，當上面讀完第一行以後，光標就會自動放在第一行末尾，故打印的是除第一行外的剩餘部分
print(data2) #打印文件

f.close() #關閉文件

打開文件的模式有：

• r，只讀模式（默認）。
• w，只寫模式。【不可讀；不存在則建立；存在則刪除內容；】
• a，追加模式。【可讀；   不存在則建立；存在則只追加內容；】

上述例子默認是隻讀模式‘r’，接下來介紹只寫模式和追加模式：

f = open('yesterday3','w',encoding='utf-8') #建立一個新文件'yesterday3'
f.write('我愛北京天安門\n')
f.write('天安門上太陽升')

只寫模式

f = open('yesterday','a',encoding='utf-8') #對原文件'yesterday'進行追加
f.write('\n我愛你中國\n親愛的母親')   #寫追加內容

追加模式

二、其它語法

若咱們想對文件內容進行修改，咱們能夠作以下操做：

f=open('yesterday','r',encoding='utf-8')
f_new=open('yesterday_bak','w',encoding='utf-8')
for line in f:
    if '就如夜晚的微風' in line:
        line=line.replace('就如夜晚的微風','就好像夜晚的微風')
    f_new.write(line)

在這裏咱們就將原文件‘yesterday’中‘就如夜晚的微風’全都依次改成‘就好像夜晚的微風’。

爲了不打開文件後忘記關閉，能夠經過使用with語句來幫助自動關閉文件，即：

with open('yesterday','r',encoding='utf-8')as f:
    for line in f:
        print(line)

5、字符編碼與轉碼

首先借網絡上比較經典的解釋字符編碼與解碼的圖來直觀歸納以下：

也就是說，全部不一樣的編碼相互轉換前首先要先轉成Unicode，utf-8是Unicode的擴展集，GBK是中文軟件。

舉例以下：

import  sys
print(sys.getdefaultencoding())  #打印默認編碼格式，爲utf-8

s='你好'
s_gbk=s.encode('gbk')   #將‘你好’編碼成‘gbk'格式
s_utf8=s.encode('utf-8')   #將‘你好’編碼成‘utf-8'格式
gbk_to_utf8=s_gbk.decode('gbk').encode('utf-8')   #解碼‘gbk’模式，再編碼成‘utf-8'格式
ss=s_gbk.decode('gbk').encode('utf-8').decode('utf-8')

print(s_gbk)
print(s_utf8)
print(gbk_to_utf8)
print(ss)

代碼執行結果以下：

 6、函數與函數式編程

一、定義

函數定義：在一個變化過程當中，對於自變量x,都有一個惟一對應的因變量y，它們間的關係能夠表述爲：y=f(x),其中f爲映射關係。

編程中的函數定義：函數是邏輯結構化和過程化的一種編程方法。

python中函數的定義方法爲：

def func1(x):
    '''the function definitions'''
    x += 1
    return x

其中，def爲定義函數的關鍵字。

           func1爲自定義的函數名，函數名後的括號內能夠寫形參，也可什麼都不寫。

           三引號內爲函數的文檔描述，即介紹此函數的功能和用途。

           x+=1,泛指代碼塊或程序處理邏輯，這裏舉例爲 x+=1。

           return定義返回值。

接下來咱們舉一個簡單的調用函數的例子，以下：

def func1():
    '''testing1'''
    print('in the func1')
    return 0                 #定義了一個函數func1
def func2():
    '''testing2'''
    print('in the func2')    #無返回值，咱們稱它爲定義了一個過程而非函數
x=func1()   #調用函數func1
y=func2()   #調用過程func2
print('from func1 return is %s'%x)  #這裏打印的是函數的返回值0     
print('from func1 return is %s'%y)  #這裏因func2無返回值故打印NULL

代碼執行結果以下：

咱們能夠從以上例子直觀的看出函數與過程的區別。

使用函數有三大優勢：一、代碼重用。

                                    二、保持一致性。

                                    三、可擴展性

 二、函數返回值

要想獲取函數的執行結果，就能夠用return語句把結果返回。

def test1():
    print('in the test1')   

def test2():
    print('in the test2')
    return 0                  #返回值爲0

def test3():
    print('in the test2')
    return 1,'kobe',['west','east'],{'name':'howard'}   #返回值類型，個數可不固定

x=test1()      #調用test1
y=test2()      #調用test2
z=test3()      #調用test3
print(x)
print(y)
print(z)

代碼運行結果以下：

咱們能夠看出返回值的類型，個數能夠是不固定的。   

在這裏咱們要注意的是：

1. 函數在執行過程當中只要遇到return語句，就會中止執行並返回結果，因此也能夠理解爲 return 語句表明着函數的結束。
2. 若是未在函數中指定return,那這個函數的返回值爲None。

在這裏咱們能夠總結一下：返回值個數=0，返回None。

                                           返回值個數=1，返回object。

                                           返回值個數>1，返回tuple(元組)。

三、參數

接下來咱們簡單介紹一下函數中參數的使用方法，舉例以下：

def test(x,y):     #括號裏的x,y稱爲形式參數，簡稱形參，自己不存在，不會佔用空間
    print(x)
    print(y)
test(2,1)       #這裏將2，1稱爲實參，是真實存在的，其中2和1按照位置的前後順序被分別賦值給x,y

代碼執行結果以下：

在這裏咱們須要瞭解的是，實參賦值給形參有兩種方法：位置參數調用和關鍵字調用，兩者能夠聯合起來同時使用。其中如上例所示按照形參與實參的一一對應的位置來賦值的方法稱爲位置參數調用。

接下來咱們介紹一下關鍵字調用，舉例以下：

def test(x,y):     #括號裏的x,y稱爲形式參數，簡稱形參，自己不存在，不會佔用空間
    print(x)
    print(y)

test(y=1,x=2)    #關鍵字調用

代碼執行結果和上例相同。也就是說，關鍵字調用關鍵在於要把實參的值一一賦給形參，順序能夠顛倒。

咱們要注意的是，在同時使用關鍵字調用和位置參數調用時，關鍵字調用是不能寫在位置參數調用前的。

四、默認參數與參數組

在實際中，咱們經常須要給一些形參賦一個默認值以方便咱們使用，這就是默認參數，舉例以下：

def test(x,y=6):      #形參y的值默認爲6
    print(x)
    print(y)
test(5)                 #調用函數時可只給x賦值

代碼執行結果以下：

固然，這裏的默認值也是能夠經過實參賦值來修改的，舉例以下：

def test(x,y=6):
    print(x)
    print(y)
test(5,3)

代碼執行結果以下：

能夠看到默認參數也是能夠修改的。

 五、參數組

在咱們的實際工做中可能會遇到實參個數不肯定的狀況，那這樣的話，如何在使用函數時定義形參成爲了咱們首先須要解決的問題，這裏就須要用到參數組。

在這裏咱們舉一個簡單的例子以下：

def test(*args):
    print(args)
test(1,2,3,4)
test(*[1,5,6,4])

代碼執行結果以下：

也就是說，在實參個數不肯定時，咱們在定義形參時的格式爲*+‘變量名’。

若將位置參數調用與參數組結合起來使用，咱們能夠看到以下效果：

def test1(x,*args):
    print(x)
    print(args)
test1(1,2,3,4)

代碼執行結果以下：

以上的形參接收的爲元組的形式，一樣，形參也能夠接收字典，格式爲**+‘變量名’，舉例以下：

def test2(**kwargs):
    print(kwargs)
    print(kwargs['name'])
    print(kwargs['age'])
test2(name='kobe',age=39)

代碼執行結果以下：

若將默認參數與字典結合起來：

def test4(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)
test4('kobe',sex='m',hobby='singing',age=39)

代碼執行結果以下：

六、局部變量

在這一節咱們介紹一下局部變量與全局變量的使用。

一、在子程序中定義的變量稱爲局部變量，在程序一開始定義的變量稱爲全局變量。

二、全局變量的做用域是整個程序，局部變量的做用域是定義該變量的子程序。

三、當全局變量與局部變量同名時，在定義局部變量的子程序內，局部變量起做用，在其餘地方全局變量起做用。

接下來咱們舉個簡單的例子來講明：

def change_name(name):
    print('before change',name)
    name='KOBE'        #這裏定義的即爲局部變量，只在函數內生效
    print('after change',name)
name='kobe'            #這裏定義的則爲全局變量，在整段程序內生效
change_name(name)
print(name)     

代碼執行結果以下：

從這裏咱們就能夠看出全局變量與局部變量間的明顯差異。

但倘若咱們想在函數內也定義個全局變量應該怎麼辦呢?咱們可使用關鍵字‘global’，示例以下：

school='oldboy'
def change_name(name):
    global school
    school='mage'
    print('before change',name,school)
    name='KOBE'
    print('after change',name)
name='kobe'
change_name(name)
print(name)
print(school)

代碼執行結果以下：

咱們能夠看出，使用global在函數內部定義了全局變量以後，全局變量school的值由原來的‘oldboy’變爲以後的‘mage’。

七、遞歸

在函數內部能夠調用其餘函數，若此函數調用自身，則爲遞歸函數。

遞歸函數特性：

一、必需要有一個明確的結束條件。

二、每次進入更深一層遞歸時，問題規模相比上次遞歸應有所減小。

三、遞歸效率不高，遞歸層數過多時會致使棧溢出（在計算機中函數調用是經過棧（stack）來實現的，每當進入一個函數調用，棧就會增長一層棧幀，每當函數返回時，棧就會減一層棧幀，因爲棧的大小有限，因此，若遞歸調用的次數過多，將會致使棧溢出）。

接下來舉一個例子來講明棧溢出，以下：

def calc(n):
    print(n)
    return calc(n+1)
calc(0)

代碼執行結果以下（部分截圖）：

咱們能夠看到，該程序想要經過遞歸來實現循環加1的功能，但未設置結束條件，故代碼只能執行到997（計算機極限），以後會報錯。

接下來咱們舉一個成功利用遞歸的例子，以下：

def calc(n):
    print(n)
    if int(n/2)>0:
        return calc(int(n/2))
    print('->',n)
calc(10)

代碼執行結果以下：

八、高階函數

變量能夠指向函數，函數的參數能夠接收變量，那麼一個函數就能夠接收另外一個函數做爲參數，這種函數就叫作高階函數。

舉例以下：

def add(a,b,f):
    return f(a)+f(b)
res=add(3,-6,abs)
print(res)

代碼執行結果爲9，即abs(3)+abs(-6)=9。