第十二~十三天：python進階深入
1.生成器：創建生成器最簡單的方法就是用圓括號()代替方括號 []
把列表生成式的 [ ] 變成（）
生成器只能調用一次，不占用資源。用完就釋放出來。

            
              for i in g:
   print(i)

            
          

也可以調用Next函數直到計算出最后一個元素位置,但是這種方法很明顯不適用，并且最后會拋出StopIteration的錯誤。

斐波那契數列：除第一個和第二個數外，任意一個數都可由前兩個數相加得到：
1, 1, 2, 3, 5, 8, 13, 21, 34, …
return返回的是具體的數值
yield返回的是一個生成器
遞歸的思路代碼：

            
              def fib(n_position):
    if n_position == 1 or n_position ==2:
        return 1
    return fib(n_position - 1 ) + fib(n_position -2)

            
          

2.迭代器：
可用于for循環的對象統稱為可迭代對象：Iterable。包括之前學的list,tuple等數據結構以及生成器。 但是生成器不僅可以被for循環調用， 還可以使用next函數獲取元素，可以被next()函數調用并不斷返回下一個值的對象稱為迭代器：Iterator。
生成器都是Iterator對象，但list、dict、str雖然是Iterable，卻不是Iterator

isinstance（g,Iterator） 判斷g 是不是后面類似返回True or False

3.函數式編程
高階函數：
函數名也是變量，
既然變量可以指向函數，函數可以接受變量，那么一個函數就可以接受另一個函數作為傳入參數,拿來使用

            
              def add(x,y,z):
    return z(x) + z(y)
add([1,2,3,4],[4,3,1,5,6],len)

            
          

4.map/reduce
map接受兩個參數，一個是函數，一個是Iterable，函數作用在序列的每一個元素上，并把結果作為Iterable返回

            
              x=[1,2,3,4,5,6,7,8,9,10]
map(lambda s:s*s，x)
list（map(lambda s:s*s，x)）

            
          

reduce也是把函數作用與序列上，但是這個函數必須接受兩個參數，reduce把計算結果繼續與下一個元素做累積計算

            
              from functools import reduce
reduce(lambda a,b:a*b,x)

            
          

5.filter函數：
filter也是把函數作用在序列元素上，但是該函數返回的結果必須是布爾型，filter根據true或者false進行元素的保留和刪除

            
              x = [1,3,6,7,2,19,20,33,29,10,49]
list(filter(lambda s : s%2 ==0,x))

            
          

6.匿名函數 Lambda

            
              f=lambda s:s*2
x=[1,2,3,4]
map(f,x)

            
          

            
              f=lambda a,b:(a+b)*2 
x=[1,2,3]
y=[2,3,4]
list(map(f,x,y))

            
          

7.面向對象
類里面一般包含屬性和方法，你可以簡單理解為屬性為靜態，方法是動態的。比如人(PERSON)這個類，嘴、手、腿就是類的屬性，跑步、吃飯等就是累的方法。

我們可以把在創建實例時我們認為必須綁定的屬性強制填寫進去，這里通過 init 方法完成。 init 方法的第一個參數永遠是self,代表了實例本身。有了該方法之后，在創建的實例的時候必須強制指定屬性值，否則會報錯。該方法也可以理解為初始化的一個動作，在創建實例的時候初始化該實例的一些屬性！
前后都是兩個下劃線
下面的S是的大寫，如果是多個單詞組合，每個單詞第一個字母大寫（編寫規范）

            
              class Student:
     def __init__(self,student_id,address,score):
           self.staudent_id = staudent_id 
           self.address = address
           self.score = score
           self.name = student_name
           self.gender = "female"
    def getId(self):
          print(self.student_id)
   #創建實例
  student = Student(1020202,"北京",98,"xiaoming")  
  必須把（）里面參數填滿  

            
          

            
              class Student:
    
    kind = "Chinese" # Shared by all instances
    
    def __init__(self,id,address,score):
        self.id = id 
        self.address = address
        self.score = score
    
    def getId(self):
        print(self.id)
        print(self.kind)
        
    def judge_age(self,age):
        if age < 18:
            return "未成年"
        elif age < 30:
            print("Student: {0}".format(self.id))
            return "年輕人"
        elif age < 60:
            return "中年人"
        else:
            return "老年人"
        
S1 = Student(12324,"上海市",100)
S2 =  Student(3245,"上海市",90)
# print(S1.kind)
# S1.judge_age(22)

上述程序中，kind是被所有的實例共享，只要是實例擁有的都要用self一下。

            
          

調用屬性和方法都是通過 .

繼承和多態：
面向對象編程語言連都會有繼承的概念，我們可以定義一個class類，然后再定義它的子類,這個子類繼承了上面的類，被繼承的類稱作父類

            
              class HighSchool(Student):
    pass

            
          

Highschool類集成了Student類，student類就是父類。
繼承的好處就是子類可以享用父類的全部方法和屬性。雖然HighSchool什么也沒定義，但是可以直接使用Student的方法

子類也可以由自己的初始化方法，一定要用 super().init(name, id) 去初始化父類
函數super()將返回當前類繼承的父類，即 Student ，然后調用init()方法

            
              class Student():
    
    def __init__(self,name,id):
        self.name = name
        self.id = id
    
    def student(self):
        print("Student score!")
        
    def get_name_id(self):
        print(self.name +":" +self.id)


class HighSchool(Student):
    
    def __init__(self,name,id,score):
        super().__init__(name,id)
        self.score=score
    pass

            
          

如果在父類和子類的方法重復了，會首先使用我子類自己的方法

8.Collections類
8.1 deque：
deque 和list的用法比較類似，它是隊列與棧的實現，可以對序列數據進行兩端的操作。deque支持在O(1)的時間復雜度上對序列進行兩端的append或者pop。list也可以實現同樣的操作，但是它的復雜度是O(N)
O（N）復雜度

            
              # 類似于列表實現
from collections import deque
a = deque(['a','b','c','d'])

a.append("e")
# a
a.pop()

            
          

            
              # 兩端操作
#a.popleft()
a.appendleft("a")
#反轉
a.rotate()

對首端進行操作的話，用deque_a.appendleft("a")

            
          

8.2 counter

            
              from collections import Counter
a = list('absgctsgabfxtdrafabstxrsg')
c = Counter(a)

            
          

            
              # 查看TOPN的元素
c.most_common(5)

            
          

關于OrderedDict
本身不是對key或者value的大小進行排序，而是對存儲的時候，人為定義好的插入的順序進行保存。

            
              from collections import OrderedDict
# regular unsorted dictionary
d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

# dictionary sorted by key
OrderedDict(sorted(d.items(), key=lambda t: t[0]))


# # dictionary sorted by value
OrderedDict(sorted(d.items(), key=lambda t: t[1]))


# # dictionary sorted by length of the key string
OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))

            
          

            
              od = OrderedDict(sorted(d.items(), key=lambda t: t[0]))

t[0]:key
t[1]:value

od.popitem(last = False)
False 去掉左端第一個，是True的話就是末尾

            
          

9.字符串處理
s.strip() 去掉首位兩端的空格 延伸：.lstrip(),.rstrip()
s.find() s.find(“e”)返回e的索引位置，如果沒有就會返回-1
s.find(“H”,1) 后面的1是啟始位置，其實只要找的到了，是不影響索引位置。
s.startwith(“H”,1) 判斷后面的索引位置開始的首字母是否是"H"，返回True or False
s.endwith()
s.lower()
s.upper()

s.split(",") 切割，返回的一個列表。

            
              map(lambda t : t.strip()   ,  s.strip().upper().split(","))

            
          

10.格式化

            
              for i in range(100):
    t = str(i)      
    print("這是我打印的第 %s 個數字"%t)

            
          

下面這個看起來更簡潔

            
              a = "shanghai"
b = 39

print("今天 {0} 的氣溫是 {1}".format(a,b))     根據索引的位置選

            
          

11.datetime

            
              from datetime import datetime
print(datetime.now())

            
          

strptime(,)

            
              # 字符串與時間的轉換
s = '20170901'
s1 = datetime.strptime(s,'%Y%m%d')

s = "2019/05/03"
s2 = datetime.strptime(s,'%Y/%m/%d')

            
          

返回結果：

timedelta
** timedelta **

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

            
              from datetime import datetime.timedelta
s2 - s1

            
          

返回結果是609天，datetime用作減可以直接減

加的話是

            
              s2+timedelta(3)

            
          

減可以是

            
              s2-timedelta(3)  或 s2+timedelta(-3)

            
          

            
              s2  + timedelta(hours = 10) + timedelta(weeks = 1)

            
          

s1.date() 只獲取到日的節點

            
              from datetime import datetime
s="2019-5-9"
s_test=datetime.strptime(s,"%Y-%m-%d")
s_test.day

            
          

12 I/O
讀文件需要使用 open()函數，其參數為文件名與標識符：

            
              f = open("file",'r')
data = f.read()
f.close()

            
          

讀了文件一定要關閉文件。
可以使用with關鍵詞進行整合：

            
              with open("helloWorld.py",'r') as handle:
    data = handle.readlines()

            
          

read(）所有數據讀取進來
readlines(）一行一行讀出來，

            
              list(map(lambda s : s.strip(),data))

            
          

編碼問題：添加encoding=

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

            
          

數據寫入：
寫文件和讀文件幾乎一致，唯一的區別是標識符需要改為"w"。
第一個實參也是要打開的文件的名稱； 第二個實參（‘w’）告訴Python，我們要以寫入模式打開這個文件。打開文件時，可指定 讀取模 式（‘r’） 、 寫入模式（‘w’） 、 **附加模式（‘a’）**或讓你能夠讀取和寫入文件的模式（‘r+’）。如果 你省略了模式實參， Python將以默認的只讀模式打開文件

            
              with open("test2.txt",'w') as handle:
    handle.write("hello world")

            
          

如果你要寫入的文件不存在，函數open()將自動創建它。然而，以寫入（‘w’）模式打開文 件時千萬要小心，因為如果指定的文件已經存在， Python將在返回文件對象前清空該文件。

            
              with open("test.txt",'a') as handle:
    handle.write("Today is Nice!\n")
    handle.write("We are happy!!\n")

            
          

如果你要給文件添加內容，而不是覆蓋原有的內容，可以附加模式打開文件。你以附加模式 打開文件時， Python不會在返回文件對象前清空文件，而你寫入到文件的行都將添加到文件末尾。 如果指定的文件不存在， Python將為你創建一個空文件。

要寫入多行的話。需要自己添加換號符 “\n”