學習記錄day03

字符串可以直接切片，But字符串不可修改

字符串修改：生成了一個新的字符串

LIst修改，在原基礎上修改(原內存上)

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

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

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

dict\list\set.. 全用 x in ..計算,,dict.has_key等已廢

文件：

fp = open() #文件句柄，文件句柄里存的內容: 文件信息、在磁盤上的開始位置、內存等

fp.tell() 查看當前位置

fp.seek(30) 跳到30

for line in fp:

print(line) ###可以直接這樣。。

###

fp.flush() 強制刷到磁盤，默認是Buffer滿了刷

r+ 讀寫(也沒什么卵用，可讀，追加寫)，w+ 寫讀(沒卵用)，a+ 追加讀

rb 二進制格式打開。網絡傳輸

wb 二進制格式寫入。fp.write("".encode())

進度條：

for i in range(50):

sys.stdout.write("#")

sys.stdout.flush()

time.sleep(0.1)

文件：增刪改·

循環寫入一個新文件，需要修改的行替換后寫入

for line in fp:

if "helooxxx" in line:

line = line.replace()

fp2.write(line)

with語句

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

with open('log','r') as f:

...

如此方式，當with代碼塊執行完畢時，內部會自動關閉并釋放文件資源。

在Python 2.7 后，with又支持同時對多個文件的上下文進行管理，即：

with open('log1') as obj1, open('log2') as obj2:

pass

開發規范：一行最好不要超過80個字符

編碼轉換：encode decode

#-*-encoding:utf8 -*-

s= "你好"

s.decode("utf-8")：Utf8轉到unicode

s.encode("gbk") unicode 轉到 gbk

decode 轉碼成Unicode, encode:unicode編碼到其他編碼

unicode utf8可以直接打印，GBK必須轉換。

將GBK轉換為utf-8: 1、GBK-->Unicode--->UTF-8，s.decode("gbk").encode("utf-8")

========================

========================

函數：

編程方法：1、面向對象；2、面向過程；3、函數式編程

參數： 位置參數調用：與形參一一對應、關鍵字調用：與順序無關

關鍵字參數不能寫在位置參數前面

ef f(x, *args):

#tuple

print args

f(1,2,3,"h","a")

f([1,2,3])

f(*[8,3,"b"])

def f4(**kwargs):

#Dictionary: 把N個關鍵字轉換為字典方式

print(kwargs)

f4(name="Alex", age=8, sex="N")

作用域：

list tuple dictionary 可以直接在內層函數中使用，其他變量則不行。函數內的list\tuple\dictionary無法到上層使用

全局與局部變量

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

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

當全局變量與局部變量同名時：

在定義局部變量的子程序內，局部變量起作用；在其它地方全局變量起作用。

=======================

遞歸函數：自爆

函數式編程(Erlang,Haskell, )： 如：y=2x, x確定后，一定有一個與之對應的值

函數： y=f(2,4), if a>7...

當然我們還是用面向對象。

===================

高階函數：

參是一個函數的，叫高階函數

=======================

list_1 = [1,6,5,4]

list_1 = set(list_1)

list_2 = set([8,9,5,10,1])

print (list_1, list_2)

print(list_1.intersection(list_2)) #交集

print(list_1.union(list_2)) #并集

#in list_1 but not in list_2

print(list_1.difference(list_2)) #差集, list_1里有但2里沒有

list_3 = set([1,6])

print(list_1.issubset(list_3)) #子集

print(list_1.issuperset(list_3)) #父集

##對稱差集，去掉交集后

print(list_1.symmetric_difference(list_2))

print("-----")

list_4 = set([90])

print(list_1.isdisjoint(list_4)) #是否沒有交集

####集合運算2#：

print(list_1,list_2)

print(list_1 | list_2) #并集

print(list_1 & list_2) #交集

print(list_1 - list_2) #差集

print(list_1 ^ list_2) #對稱差集

list_1.add('x')

list_1.update(["a","b","c","x"])

print(list_1)

print ("a" in list_1)

裝飾器：

定義：本質是函數，（裝飾其他函數）就是為其他函數添加附加功能。

原則：1、不能修改被裝飾的函數的源代碼

2、不能修改被裝飾的函數的調用方式

Python內存自動回收機制。

到底怎么個回收法呢? 有一個定時器，會不斷的掃描這些字符串、值等，如果發現某個沒有被引用，則回收掉。如：del(var1) 刪除的是var1這個變量名，這個變量對應的值回收的兩種情況1、程序結束；2、定時掃描到值沒有任何地方引用。

嵌套函數: 在函數內再定義函數

def foo():

print('in the foo')

def bar():

print('in the bar')

高階函數 + 嵌套函數 ---> 裝飾器

@auth #index = auth(index)

def index()

生成器：

#列表生成式

b=[i*2 for i in range(1000000)] ##會生成列表，速度慢

b=(i*2 for i in range(10000000)) ##瞬間完成，并不會真的生成列表，在取值的時候才會生成

生成器：只有在調用時才會生成相應的數據。只記住當前位置。只有一個__next__()，python2.7：next()

b.__next__()

next(b)

def fib(max):

n, a, b = 0, 0 ,1

while n < max:

#print(b)#

yield b ###生成器

a, b = b, a+b

n +=1

return "--------------------done"

re

re.sub() 替換

re.match()

re.find() final

re.search()

'.' 默認匹配除\n之外的任意一個字符，若指定flag DOTALL,則匹配任意字符，包括換行

'^' 匹配字符開頭，若指定flags MULTILINE,這種也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)

'$' 匹配字符結尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以

'*' 匹配*號前的字符0次或多次，re.findall("ab*","cabb3abcbbac") 結果為['abb', 'ab', 'a']

'+' 匹配前一個字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 結果['ab', 'abb']

'?' 匹配前一個字符1次或0次

'{m}' 匹配前一個字符m次

'{n,m}' 匹配前一個字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 結果'abb', 'ab', 'abb']

'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 結果'ABC'

'(...)' 分組匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 結果 abcabca456c

'\A' 只從字符開頭匹配，re.search("\Aabc","alexabc") 是匹配不到的

'\Z' 匹配字符結尾，同$

'\d' 匹配數字0-9

'\D' 匹配非數字

'\w' 匹配[A-Za-z0-9]

'\W' 匹配非[A-Za-z0-9]

's' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 結果 '\t'

'(?P...)' 分組匹配 re.search("(?P[0-9]{4})(?P[0-9]{2})(?P[0-9]{4})","371481199306143242").groupdict("city") 結果{'province': '3714', 'city': '81', 'birthday': '1993'}

re.split(r’\\’, r’a\b\c’)

或者：

re.split(‘\\\\’, r’a\b\c’)

re.search(‘a’, r’a\A\abc’, flags=re.I). 忽略大小寫

多行：

re.search(‘2’, ‘abc\n1234’, flags=re.M)

re.search(‘2’, ‘abc\n1234’, flags=re.S)

^ 以開頭、 不包含

總結

以上是生活随笔為你收集整理的python大神的成长之路_Python大神成长之路： 第三次学习记录 集合 函数 装饰 re...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。