文件操做，函數初始到起步，推倒式，迭代器，生成器

文件操做

只讀

使用open()來打開一個文件,獲取到文件句柄,而後經過文件句柄就能夠進行操做

打開方式的不一樣可以執行的操做會有相應的差別

打開文件的方式:

r,w,a r+,w+,a+ rb,wb,ab

r模式 只讀操做只能進行讀取

f=open('文件名稱',mode='操做方式',encoding='編碼類型')
f.read()  讀取
f.close() 關閉文件
f.readline()讀行
f.redlines()逐行讀取

open中第一個參數放入的是要打開的文件名字,第二個參數是要對這個文件進行什麼樣的操做,第三參數使用誰讓你買編碼方式打開文件彙總的內容.

f能夠寫成任意變量,被稱爲文件句柄,文件操做符,或者文件操做對象等,open是python調用的操做系統的功能,windows的默認編碼方式爲gbk,Linux默認編碼爲utf-8,因此文件用什麼編碼保存的,就用什麼方法打開,mode爲打開方式,常見的有r,w,a,r+,a+,w+,rb,wb,ab等 默認不寫是r,流程就是打開文件,產生一個文件句柄,對文件句柄進行相應操做,關閉文件.

rb模式:只讀字節

f=open('文件名字',mode='rb) #注意在rb,wb,ab,模式不能寫encoding

s=f.read()

print(s)

獲得的是字節bytes類型

rb做用:在讀取分文本的文件的時候,好比讀取圖像,MP3視頻等,就會須要用到rb,由於這種數據是沒有辦法直接寫出來的

用於本身的傳輸和儲存.

相對路徑和絕對路徑

相對路徑:就是在同一級裏找,同一個文件夾下,直接寫文件名就能夠

絕對路徑:在電腦磁盤進行查找文件的路徑,至關於不知道在哪而後去別的地方找,一直找到文件名

轉義

有時候你輸入路徑的時候

C:\user\ner   #這個\n會成爲換行符,防止被轉義就須要
    #兩種方法能夠防止轉義
    1.C:\\user\\ner  #雙斜槓
    2.r'C:\user\ner  #前面加r

覆蓋寫 w

寫文件的時候要養成好習慣 寫完就刷新 flush()

f=open("文件",mode='w',encoding='utf-8')

f.write("內容")

f.flush()

f.close()

當使用w模式的時候,打開文件就會把文件先清空,而後再寫入.注意在覆蓋寫的時候,在打開文件的時候就會把文件清空,

w操做不能夠進行進行讀取

wb模式,不能夠打開文件的編輯,可是寫文件的時候必須將字符串轉換成utf-8的bytes數據

f=open("文件",mode='wb') 注意必定要不能寫encoding

msg='你好'.encode(utf-8)

f.write(msg)

f.flush() #刷新

f.close()

追加a,ab,a+

都是在文件末尾添加,追加,不論光標位置

a,w模式若是文件不存在,都會建立一個新的文件

f=open('內容',mode='a',encoding='utf-8')

msg=f.write("這糖化了之後")

讀寫模式 r+

讀寫顧名思義,必定是先讀後寫,由於光標默認是在前面,當讀完了之後,光標讀到最後,再進行寫

r+模式

f=open("文件名稱",mode='r+',encoding='utf-8')
s=f.read()
f.write("針棒")
f.flush()
f.close()
print(s)
#正常的讀取,寫在結尾

r+模式的坑

在進行讀寫操做後,若是讀取了內容不管多少,光標顯示的是多少,再寫入或者操做文件的時候都是在結尾進行操做的.

寫讀模式 W+

f=open("文件名",mode='w+',encoding='utf-8')

先把內容清空,而後寫入,而後再讀取,可是讀取內容是空的,不經常使用

f=open("文件名",mode='w+',encoding='utf-8')
f.write("xiaogui")
s=f.read()
f.flush()
f.close()
print(s)
讀取不到內容,和覆蓋寫同樣,都會清空再寫內容

追加讀 a+

f=open("文件名",mode='a+',encoding='utf-8')
f.write('內容')
f.flush()
s=f.read()
f.close()
print(s)
a+模式下,不管是先讀仍是後讀都是讀不到數據的

其餘操做

seek()是移動光標的位置,移動單位是byte字節,全部若是是utf-8的中文部分要是三的倍數

一般用seek都是移動到開頭揮着結尾

移動到開頭 seek(0,0)

移動到結尾seek(0,2)

移動到當前位置 seek(0,1)

移動一個字:seek(3) 移動光標是按照字節進行移動的

f = open("小娃娃", mode="r+", encoding="utf-8")
f.seek(0,0)將光標移動到開頭
s=f.read()  讀取內容,此時光標讀取完之後移動到結尾
print(s)
f.seek(0)  再次移動到開頭
f.seek(0,2)  移動光標到結尾
s1=f.read()   由於光標移動到結尾 因此什麼也沒讀取到
print(s1)
f.seek(0)  將光標移動到開頭 
f.write("戰鼓啊")寫入信息,如今光標在9  由於中文的utf-8編碼一箇中文三字節,3*3=9
f.flush()
f.close()
f.tell()   查看光標位置

tell 查看光標位置:

f = open("小娃娃", mode="r+", encoding="utf-8")
f.seek(0)移動光標到開頭
s=f.read()  讀取內容,光標移動到結尾 
print(s)
f.seek(0)    開頭
f.write("美滋滋")  三個字 9個字節 
f.tell()  查看光標位置 9

修改文件

文件修改,只能將文件中的內容讀取到內存中,將信息修改完畢後刪除源文件,將新文件的名字改爲舊文件的名字

1. 弊端操做,一次將全部內容就行讀取,內存溢出

import os
with open("../path1/小娃娃", mode="r", encoding="utf-8") as f1,\    #讀
open("../path1/小娃娃_new", mode="w", encoding="UTF-8") as f2:      #寫
    s=f1.read()
    new_s=s.replace("冰糖葫蘆","大白梨")
    f2.write(new_s)
os.remove('文件路徑') #刪除原文件
os.remove("新文件筆記","舊文件名") #重命名新文件

1. 解決方案:一行一行讀取和操做

import os
with open("../path1/小娃娃", mode="r", encoding="utf-8") as f1,\   #舊 讀
open("../path1/小娃娃_new", mode="w", encoding="UTF-8") as f2:     #新 改
    for line in f1:
        new_line=line.replace("大白梨","冰糖葫蘆")
        f2.write(new_line)
os.remove("小娃娃")  #刪除源文件
os.remove("新文件","源文件")  #重命名新文件

1. 讀行 f.readline() 讀一行 自動換行
2. print(f.readline() .strip()) 讀多行 去除換行符
3. print(f.readslines()) 一行一行的讀取,存放在列表中
4. 利用for 循環進行一行一行的獲取

函數初始

函數

用函數來實現len
s=[1,2,3,4,5]
count=0
for i in s:
    count+=1
print(count)

一、函數的定義：將可重複使用的，實現某種功能的代碼段組織在一塊兒
二、函數的語法：
def 函數名(參數)：
函數體
return
2.一、函數名是一個變量，所以命名規則需遵照變量命名規則

三、函數的調用
函數名()
四、函數的返回值
return 可空、None、單個、多個的話 以tuple返回給調用者
五、函數的參數：
函數定義時聲明的變量的叫形參
一、位置參數
二、默認參數
函數調用時傳給函數的叫實參
一、位置參數
定義多少個，調用時也必須傳多少個
二、關鍵字參數
三、混合參數

函數的調用

使用函數名加括號就能夠調用函數了當寫到函數名加括號,這個函數體就會被執行

def len():
    s=[1,2,3,4,5]
    count=0
    for i in s:
        count+=1
    print(count)
len()   #函數的調用

函數的返回值

def func():
    print("1")
func()
func()
func()   #屢次調用

這樣就能夠屢次調用函數

函數的返回值return

def func():
    print(1)
    return
func()
return 吧這個結果返回給了調用者 由於return後面沒有跟東西 因此默認返回None,而且return之後後續代碼再也不執行,函數的返回值有多個結果的時候就是返回一個元祖,調用者也能夠經過解構得到多個變量,返回給函數的調用者,沒有return也是默認返回None

總結return

1. 遇到return,此函數結束,return代碼不會執行
2. return默認是返回None,後面多個返回值是一個元組形式

位置參數需在關鍵字參數以前

1. 函數的參數

   參數是函數括號裏的內容,函數在調用的時候回指定一個具體的變量的值,就是參數
   def 函數名(參數):
    函數體
   
   def func(chat):    #形參
       print('打開+chat')
   func(chat)          #實參
   在調用的時候給chat一個值再執行函數體

   2.形參與實參

   • 形參,寫在函數聲明的位置交形參,形式上的完整,表示這個函數須要xxx
   • 實參:寫在函數的調用的時候給函數傳遞的值,加實參,實際執行的時候給函數傳遞的信息,表示給函數xxx
   • 傳參:從調用函數的時候講值傳遞到定義函數的過程叫作傳參

   3.參數的分類

   def func(a,b,c=1):   #形參 a,b是關鍵字參數,c是默認參數  排序就是位置>關鍵字>默認
       prin(a)
       print(b)  
       print(c)     #形參就是變量名 實參就是指 傳參就是把值賦值給形參
       func(a=2,b=3)   #實參

   def func(a,b):
    print(a+b)
   s=func(1,2)
   print(s)

   1. 總結參數:位置參數,關鍵字參數,混合參數 位置參數必須在關鍵字參數前面
      • 位置參數,按照位置來賦值
      • 關鍵字參數,經過關鍵字來查找參數
      • 默認值參數:有默認值參數一般用默認的值,下面的實參若是給默認值參數賦值,那就會改變成實參賦予的值

用while循環實現for的本質;

s=[1,2,3,4,5]
n=s.__iter__()  #迭代器
while True:
    try:
        print(n.__next__())
    except StopIteration:
        break

動態參數,名稱空間,函數嵌套

函數的動態參數

1. *args是萬能的位置函數,接收任意多個 args能夠變,程序猿統一用args 定義函數時"*"叫聚合,在參數位置用*表示接受任意參數,默認值參數放在動態位置參數後面,這樣不會覆蓋默認參數的值
2. 順序就是
   • 位置順序 : 位置參數>動態位置參數>
   • def song(*args) 這個裏面的*\叫作聚合,聚合得到的結果是個元組
   • print(a,b,*args)這個裏面的叫作打打散,打散能夠得到各個元素.
   • 動態接收參數的時候注意:動態參數必須在位置參數後面
   • 形參的順序:位置參數>動態參數>默認參數

3.**kwargs 得到的是一個dict字典,接受的關鍵字參數 *kwargs這個星是能夠取這個字典的鍵 **kwargs萬能傳參(動態關鍵字參數)

參數的優先級:位置參數>動態位置參數args>默認參數>kwargs動態關鍵字參數

1. 萬能傳參:動態位置參數,動態關鍵字參數
2. def song(*args,**kwargs):
3. 位置參數>動態位置參數

函數的註釋

def func(a,b):
    '''
    邏輯判斷...
    :param a:str
    :param b:int
    return:bool
    '''
    print(a,b)
   
def func(user,password):
    '''
    密碼加密
    :param user:用戶名 str
    :param password:密碼 str
    :return:加密的密碼 MDS
    '''
    print(user,password)
 
print(func.__doc__)
print(func2.__doc__)
print(func.__name__)

名稱空間

print(b)
a=10
def func():
    b=20
    print(b)
   
內置空間:print input len  這是python自帶的內置空間
全局空間:當前py文件須要開闢的孔家存放在全局空間
局部空間:函數中開闢的空間都是局部空間
  
加載順序:
    內置空間>全局空間>局部空間
取值順序:
    局部空間>全局空間>內置空間(還找不到就會犯錯)
    
做用域:
    全局做用域:內置空間+全局空間
    局部做用域:局部空間

函數的嵌套

def song():
    print(1)
    def fan():
        print(2)
    return fan()
song()
1,2
____________________
def song():
    a=1
    def jia():
        b=2
        print(b)
        print(a)
        def fan():
            pring(b)
        return fan()
    return jia
song()
2 1 2
____________
def func():
    a=1
    foo()
    pring(a)
def foo():
    b=2
    print(b)
func()
    def a():
        a=1
        c=()
        print(c)
def b():
    b=2
    print(b)
def c():
    c=3
    print(a)
def run():
    a()
    
run()
____________________

def func():
    a=1
    def b():
        print(a)
def foo():
    b=1
    def z():
        print(func)
        print(b)
    ret=z()
    func()
    return ret
def run():
    foo()
print(run())
func 的內存地址 1 還有None
________________________
def func(a):
    foo(a)
def foo(e):
    b(e)
def b(c):
    print(c)
func(15)
15 
______________________
a=10
def func():
    a=10+1
    print(a)
func()
11 別被迷惑
________________
def f1():
    a=10
    print(a)
    def f2():
        a=15
        print(a)
        def f3():
            global a 
            a += 1
            print(a)
        print(a)
        f3()
    print(a)
    f2()
    print(a)
f1()
10 15 11 15 10 10 
__________________
a=10
def f1():
    a=10
    def f2():
        a=15
        def f3():
            global a
            a += 1
            print(a)
        print(a)
        f3()
    print(a)
    f2()
print(a)
f1()
10 10 15 11 
—————————————————————
a=100
def func():
    global a
    a=28
print(a)
func()
print(a)
100 28 
____________
a=10 
def func1():
    a=20
    def func2():
        nonlocal a
        a=30
        print(a)
     func2()
     print(a)
func1()
30 30
___________________
a=1
def fun_1():
    a=2
    def fun_2():
        nonlocal a
        a=3
        def fun_3():
            a=4
            print(a)
        print(a)
        fun_3
        print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)
1 2 3 3 3 1
#注意看這個沒有被調用的函數
_______________________

global nonlocal

global:修改全局空間的變量對應的值

nonlocal:在外層的函數中修改局部空間變量值,徹底不涉及全局空間,只修改上一級離他最近的一層,最近的上一層沒有繼續往上走,知道找到最外層函數

三元運算符

三元運算符:變量條件成立的結果 條件的判斷 條件不成立的結果

return a if a>b else b 
a = 10
b = 20
c = a if a> b else b
變量名 = 條件成立的結果 條件 條件不成立的結果

enumerate 枚舉

自動排序

enumerate：枚舉，對於一個可迭代的（iterable）/可遍歷的對象（如列表、字符串），enumerate將其組成一個索引序列，利用它能夠同時得到索引和值。

enumerate(可迭代對象,1) 1決定從幾開始計數

li = ['alex','銀角','女神','egon','太白']
for i in enumerate(li):
    print(i)
    (1, 'alex')
    (2, '引腳')
    (3, '女神')
    (4, '太白')
for index,name in enumerate(li,1):
    print(index,name)
    1 alex
    2 引腳
    3 女神
    4 太白
for index, name in enumerate(li, 100):  # 起始位置默認是0，可更改
    print(index, name)　
    100 alex
    101 引腳
    102 女神
    103 太白

函數名的第一類使用對象,f格式化.遞歸,迭代器

函數名第一類對象及使用

第一類對象的特殊性:

能夠當作值賦值給變量

def func():
    print("呵呵")
print(func)
a=func
a()  #函數調用 func()
a=func 那麼 a+()就能夠調用這個函數,吧這個函數賦值給一個變量,

當作元素存放在容器中

def func():
    print(func)
func()
lst=[func,func,func]
print(lst)
這個列表的每個元素都是函數func裏面的內存地址

函數名能夠看成函數的參數

def func():
    print(1)
def func1(fn):
    print(2)
    fn()          #執行傳遞過來的fn
    print("666")
func1(func)        #吧函數func當成參數傳遞給func1的參數fn

能夠看成函數的返回值

def func():
    print(1)
    def fun():
        print("看我")
    return fun
fun=func()
fun()
1, 看我

f格式化

f-strings 是python3.6開始加入的格式化輸出的新寫法,這個格式化輸出比以前的%s或者format高並且更加簡化

結果F/f+str的形式,在字符換中想要替換的位置用{}佔位,與format相似,可是這個能夠直接識別

name=1
age=2
s=f'姓名:{name},性別:{age}'
print(s)
能夠加任意表達式
print(f'{2*3}')   #6   直接運算結果
name='song'
print(f'所有大寫:{name.upper()}')  SONG

字典也能夠
teacher={'song':'jiafan'}
print(d"the teacher is {teacher['name']})  #大括號裏查詢字典鍵就能夠導員元素
      
列表
lst=['song','jiafan']
      s=f'姓名:{lst[0]},年齡:{lst[1]}
      print(s)
     
也能夠插入表達式
def func(a,b):
      return a+b
a=1
b=2
print(f'和+{func(a+b)}')

多行F
      name='1'
      age=2
      sex=1
      print(f'姓名{name}\
      性別{sex}\
      年齡{age}')

其餘細節

print(f'{{{g}}}') 兩個大括號 打印出啦就是一個大括號 四個就是倆 大括號裏面不能出現標點符號 !,:{};

迭代器

可迭代對象定義:有不少私有方法,支持__iter__()方法的就是可迭代對象

迭代器:支持__iter__()方法和__next__()方法的就是迭代器

1. 查看對象內部的方法 一種是看源碼 一種是經過dir()去判斷裏面到底有哪些方法

s=123
print(dir(s))
dir會返回一個列表,這個列表含有該對象的整型的全部方法名咱們就能夠判斷是否是可迭代對象了
print('__iter__()'in dir(s))   False 不支持

可迭代對象的優勢:能夠直觀的查看裏面的數據,

缺點:佔內存,可迭代對象不能迭代取值,出去索引,key之外

for 循環也是在底層作了一個小小的轉化才能夠迭代取值,將可迭代對象轉化成一個迭代器

迭代器

1. 迭代器的定義:**在python中，內部含有__Iter__方法而且含有__next__方法的對象就是迭代器。**

2. 能夠經過判斷next方法和iter方法來判斷哪些是迭代器,哪些是可迭代對象 文件句柄就是一個迭代器剩下的list tuple dict str set 都是可迭代對象

3. 可迭代對象如何轉化成迭代器

   lst=[1,2,3,4,5]
   s=lst.__iter__()
   s=iter(lst)
   print(s)

4. 迭代器的取值:可迭代對象是不能夠一直迭代取值的(出去索引,切片以及key)可是轉化成迭代器就能夠了他是利用__next__()取值的

   lst=[1,2,3,4]
   s=lst.__iter__()
   print(s)     #內存地址
   s1=s.__next__()
   print(s1)     #迭代器取得是值
   s1=s.__next__()
   print(s1)  
   迭代器是經過next取值的一個next取對應的一個值,若是迭代器裏面的值取完了還有next那就StopIteration報錯

5. while模擬for循環內部機制

   for循環對象必定是可迭代對象,可是不意味着可迭代對象就能夠取值,由於for循環內部機制是:將可迭代對象轉換成迭代器,而後用next進行取值,最後利用異常處理處理StopIteration拋出的異常

   s=[1,2,3,4,5]
   s1=s.__iter__()    #將可迭代對象轉化成迭代器
   while True:   利用while循環,next進行取值
       try:      利用異常處理終止循環
           print(s1.__next__())
       except StopIteration:
           break

6. 迭代器優勢:省內存,迭代器在內存只能怪至關於只佔一個數據的空間,由於每次取值上一條數據會在內存釋放,加載當前的此條數據

   惰性機制:next一次,取一個值毫不過多取值

7. 迭代器的缺點:

   不能質管的查看裏面的數據

   取值是不走回頭路,只能一直向下取值

8. 可迭代對象和迭代器的對比

   可迭代對象操做靈活,私有方法比較多,好比什麼增刪改查,比較直觀,可是佔用內存,並且不能直接經過循環迭代取值的這麼一個數據集

   應用:若是你側重於對於數據能夠靈活處理,並且內存空間足夠,將數據集設置爲可迭代對象是明確的選擇

   迭代器:是一個很是節省內存的,能夠記錄取值位置,能夠直接經過for循環加next方法取值,可是不直觀,操做方法比較單一的數據集

   應用:當你的內存空間比較緊湊的時候,數據量過大的時候,將數據集設置爲迭代器是一個不錯的選擇,

遞歸:知足兩個條件

1. 自身調用自身
2. 有明確的終止條件

生成器,推導式,內置函數一

1.生成器

1. python裏面三種方式來建立生成器

   • 經過生成器函數
   • 經過生成器推導式
   • python內置函數或者模塊提供,python提供的生成器函數
2. 把return換成yield就是生成器

def func():
    print(111)
    yield "222"
g=func()          #這個時候函數不會執行,而是獲取到生成器
print(g.__next__()) #這個時候函數纔會執行
                    #而且yield會將func生產出來的數據222給了g.__next__()
    結果
    111
    222

1. return和yield都是返回

2. yield會記錄執行位置

3. return能夠寫多個,可是隻會執行一次,能夠終止函數,並給函數的調用者返回值知識

4. yield能夠寫多個會記錄執行位置,還能夠返回屢次,不會終止函數,next會把這個yield對應的內容

   def func():
       yield "hehe"
       yield "hehe"
       yield "hehe"
   g=func()
   ret=g.__next__()
   print(ret)
   ret1=g.__next__()
   print(ret1)
   ret2=g.__next__()
   print(ret2)
       #必須一一對應 要不會報錯 一個yield對應一個next

   5.yield能夠在函數內部將for while 循環進行臨時暫停

   6.next()==__next__() iter()==__iter__() python2和python3中都有next() python2只有next()方法 推薦next()

send()方法(瞭解)

send和next的區別

相同點:send和next()均可以讓生成器對應的yield向下執行一次,均可以獲取到yield生成的值

不一樣: 第一次獲取yield值只能是用next不能用send(能夠用send(None))send能夠給上一個yield值傳遞值

yield from

python3提供一種能夠直接把可迭代對象中的每個數據做爲生成器的結果進行返回

yield將可迭代對象元素逐個返回

def func():
    lst=[1,2,3,4,5]
    yield lst
g=func()
print(g)        #返回func內存地址
print(next(g))  #只是返回一個列表


def func():
    lst=[1,2,5,3,4]
    yield from lst    
g=func()
print(g)      #內存地址
print(next(g))#  返回的是一個列表的元素   多了也會報錯

def func():
    lst=[1,2,3,4,5]
    lst1=[9,8,7,6,5]
    yield from lst1    #先執行這個lst1列表的元素
    yield from lst     #挨個返回後再執行lst的元素
g=func()
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))

2.推導式

1. 列表推導式

向列表中添加1~10
print([i for i in range(10)])
簡潔 推導這個從0-9十個數的打印
lst=[]
for i in range(10):
    lst.append(i)
print(lst)

1. 列表推導式分爲兩種模式:

   • 循環模式:[變量(加工的變量)for 變量 in iterable ]
   • 篩選模式:[變量(加工的變量)for 變量 in iterable if條件]

   3.循環模式

   lst=[i*i for i  in range(10) ]  十之內數字的全部整數平方
   這個i*i就是加工的變量
   lst=[f'python{i}期'for i in range(10)]
   print(lst)
   從python0期到python9期
   f'python{i}期'就是加工的變量

   3.篩選模式

   篩選模式就是在上面基礎上添加一個條件判斷,而後將知足條件的添加到列表中

   把lst=[1,2,3,4,5,6,7,8]這個列表中的大於三的留下來
   lst=[1,2,3,4,5,6,7,8]
   print([i for i in lst if i>3])
   
   把列表元素長度小於三的篩選掉 把剩下的所有大寫
   l = ['wusir', 'laonanhai', 'aa', 'b', 'taibai']
   print([i.upper() for i in l if len(i)>3])

   找到嵌套列表中名字含有兩個‘e’的全部名字（有難度）
   names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
            ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
   
   print([name for lst in names for name in lst if name.count('e') >= 2])  
   # 注意遍歷順序，這是實現的關鍵

   4.生成器表達式

   生成器表達式和列表推導式的語法如出一轍,只是把[]換成()就好了

   好比八十之內的全部丨的平方放到一個生成器表達式中
   s=(i**2 for i in range(10))
   print(s)
   獲得是內存地址
   #生成器表達式也能夠進行篩選
   獲取1-100能被三整除的數
   s=(i for i in range(100) if i%3==0)
   for i in s:
       print(i)

   生成器表達式和列表推導式的區別:

   1. 列表推導式比較消耗內存,全部數據一次性加載到內存.而生成器表達式遵循迭代器協議,逐個產生元素
   2. 獲得的值不同,列表推導式獲得的是一個列表,生成器表達式獲取的是一個生成器.
   3. 列表推導式一目瞭然生成器表達式知識一個內存地址.

   生成器的惰性機制:生成器只有在訪問的時候才取值,找他要纔給你值,不要就不會執行

   字典推導式:

   lst=[1,2,3]
   lst1=["nihao","hello","hey"]
   dic={lst[i]:lst[i] for i in range(len(lst))}
   print(dic)

   集合推導式;生成一個集合,集合特色無序不重複 因此結婚推導式自然去重

   print({i for i in [-13,-13,2,2,3] })

3.內置函數一

s = """for i in range(10):    print(i)"""s1 = """def func():    print(123)func()"""print(eval(s))print(exec(s1))  # 牛逼 不能用print(hash("asdfas"))print(help(list))help(dict)def func():    passprint(callable(func))  # 查看是否可調用print(float(2))     # 浮點數print(complex(56))  # 複數print(oct(15))        # 八進制print(hex(15))        # 十六進制print(divmod(5,2))     # (2, 1) 2商 1餘print(round(5.3234,2))     # 四捨五入 -- 默認是整數,能夠指定保留小數位print(pow(2,3))            # 冪print(pow(2,3,4))          # 冪,餘s = "alex"print(bytes(s,encoding="utf-8"))print(ord("你"))    # 當前編碼print(chr(20320))s = "C:\u3000"print(repr(s))print("\u3000你好")lst = [1,2,3,False,4,5,6,7]print(all(lst))   # 判斷元素是否都爲真  類似andprint(any(lst))     # 判斷元素是否有真    類似orname = 1def func():    a = 123    # print(locals())    # print(globals())func()print(globals())   # 全局空間中的變量print(locals())   # 查看當前空間的變量

這些是不經常使用的內置函數,瞭解便可