1.range()是一個函數(shù)

for i in range () 就是給i賦值：

比如 for i in range （1，3）：

就是把1,2依次賦值給i

range () 函數(shù)的使用是這樣的:

range(start, stop[, step])，分別是起始、終止和步長

舉例：

range（3）即：從0到3，不包含3，即0,1,2

>>> for i in range(3):
	print(i)
 
0
1
2

range（1,3,2）即：從1到3，每次增加2，因為1+2=3，所以輸出只有1

第三個數(shù)字2是代表步長。如果不設(shè)置，就是默認步長為1

>>> for i in range(1,3,2):
	print(i)
 
1

2.Python數(shù)字函數(shù)

3.Python隨機函數(shù)

隨機數(shù)可以用于數(shù)字，游戲，安全等領(lǐng)域中，還經(jīng)常被嵌入到算法中，用以提高算法效率，并提高程序的安全性；

Python包含以下常用隨機函數(shù)：

4.Python的字符串內(nèi)建函數(shù)

字符串方法是從python1.6到2.0慢慢加進來的——它們也被加到了Python中；

這些實現(xiàn)了string模塊的大部分方法，如下表所示除了目前字符串內(nèi)建支持的方法，都包含了對Unicode的支持，有一些甚至是專門用于Unicode的。

5.文件操作函數(shù)

1.open函數(shù)

語法：

file object = open(file_name [, access_mode][, buffering])
//完整版
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

各個參數(shù)的細節(jié)如下：

• file_name：file_name變量是一個包含了你要訪問的文件名稱的字符串值。
• access_mode：access_mode決定了打開文件的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數(shù)是非強制的，默認文件訪問模式為只讀®。
• buffering:如果buffering的值被設(shè)為0，就不會有寄存。如果buffering的值取1，訪問文件時會寄存行。如果將buffering的值設(shè)為大于1的整數(shù)，表明了這就是的寄存區(qū)的緩沖大小。如果取負值，寄存區(qū)的緩沖大小則為系統(tǒng)默認。
• encoding: 一般使用utf8
• errors: 報錯級別
• newline: 區(qū)分換行符
• closefd: 傳入的file參數(shù)類型
• opener: 設(shè)置自定義開啟器，開啟器的返回值必須是一個打開的文件描述符。

1.close函數(shù)

File 對象的 close（）方法刷新緩沖區(qū)里任何還沒寫入的信息，并關(guān)閉該文件，這之后便不能再進行寫入。

當一個文件對象的引用被重新指定給另一個文件時，Python 會關(guān)閉之前的文件。用 close（）方法關(guān)閉文件是一個很好的習慣。

語法：

fileObject.close()

1.seek函數(shù)

seek（offset [,from]）

方法改變當前文件的位置。Offset變量表示要移動的字節(jié)數(shù)。

From變量指定開始移動字節(jié)的參考位置。

• 如果from被設(shè)為0，這意味著將文件的開頭作為移動字節(jié)的參考位置。
• 如果設(shè)為1，則使用當前的位置作為參考位置。
• 如果它被設(shè)為2，那么該文件的末尾將作為參考位置。

1.tell函數(shù)

tell()方法告訴你文件內(nèi)的當前位置, 換句話說，下一次的讀寫會發(fā)生在文件開頭這么多字節(jié)之后。

2.write函數(shù)

write()方法可將任何字符串寫入一個打開的文件。

需要重點注意的是，Python字符串可以是二進制數(shù)據(jù)，而不是僅僅是文字。

write()方法不會在字符串的結(jié)尾添加換行符(‘\n’)：

1.read函數(shù)

read（）方法從一個打開的文件中讀取一個字符串。

需要重點注意的是，Python字符串可以是二進制數(shù)據(jù)，而不是僅僅是文字。

語法：

fileObject.read([count])

在這里，被傳遞的參數(shù)是要從已打開文件中讀取的字節(jié)計數(shù)。

該方法從文件的開頭開始讀入，如果沒有傳入count，它會嘗試盡可能多地讀取更多的內(nèi)容，很可能是直到文件的末尾。

舉例：

fo = open("test.txt",'r+')
print("fo->name:%s,fo->mode:%s"%(fo.name,fo.mode))
fo.write("this is my test.")
 
str = fo.read(5)
print("first read:%s"%str)
#查找當前位置
print("當前位置:",fo.tell())
fo.seek(0,0)
print("當前位置：",fo.tell())
print("str:",fo.read(20))
fo.close()

open函數(shù)中mode 參數(shù)有：

6.zip函數(shù)

對于我們的兩個list，a和b，list(zip(a, b))生成了一個列表。在這個列表中，每個元素是一個tuple；對于第i個元組，它其中的內(nèi)容是(a[i-1], b[i-1])。

這樣的操作，與壓縮軟件的“壓縮”十分接近。如果我們繼續(xù)在zip()中加入更多的參數(shù)，比如zip(a, b, c, d)，那么在將它轉(zhuǎn)換成list之后，結(jié)果當然就是[(a[0], b[0], c[0], d[0]), (a[1], b[1], c[1], d[1]), …, (a[n-1], b[n-1], c[n-1], d[n-1])]。

事實上，在 Python 3 中，為了節(jié)省空間，zip()返回的是一個tuple的迭代器，這也是我們?yōu)槭裁匆{(diào)用list()將它強制轉(zhuǎn)換成list的原因。不過，Python 2中，它直接返回的就是一個列表了。

如果我們傳入zip()中的幾個參數(shù)不等長，會有什么結(jié)果呢？zip()很靈活，如果幾個參數(shù)不等長，那么它會取最短的那個參數(shù)的長度，然后再進行處理。至于那些超出最短長度的成員，就只好被舍棄掉了。

origin = zip(result) #前面加號，事實上*號也是一個特殊的運算符，叫解包運算符

例子：

numbers = [ 1, 2, 3]
string = [ 'one','two','three']
result = zip(numbers,string)
lresult = list(result)
print(set(result))
 
print(lresult)
c,v = zip(*lresult)
print('num:', c)
print("str:", v)

結(jié)果：

[(1, 'one'), (2, 'two'), (3, 'three')]
num: (1, 2, 3)
str: ('one', 'two', 'three')

7.python內(nèi)置函數(shù)set

• set函數(shù)返回值：一個 set object （集合對象，即 一個 “無序不重復(fù)元素集”，特點 ：無序，不重復(fù)）
• 參數(shù)：空 或者 一個可迭代對象。

特性一：不重復(fù)?？梢允址奖愕膶崿F(xiàn)一個去重的目的。當然，我們也可以將set對象轉(zhuǎn)化為其它的可迭代對象。

特性二：無序。對于無序的可迭代對象，不能通過索引的方式取值。

set對象內(nèi)置方法：

• 1.add 即：添加一個元素進入集合，當此元素存在時， 無影響（啥也不做）。
• 2.clear 即：將集合中所有元素移除（變?yōu)榭占希?/li>
• 3.copy 即：返回一個集合的淺拷貝
• 4.difference 即：將兩個和或多個集合進行比較，返回一個新集合，這個集合中的元素存在于**第一個集合（或調(diào)用這個方法的集合）中，但不存在于其它集合中。
   
• 5.difference_update 即：從第一個集合(或調(diào)用這個方法的集合)中移除所有屬于其它集合但不屬于第一個集合(或調(diào)用這個方法的集合)**的所有元素。需要特別注意的是，這個方法返回值并不是一個新集合。
• 6.remove() 即：清除一個元素可以用 remove 或者 discard, 而清除全部可以用 clear.
• 7.difference() 即：進行一些篩選操作, 比如對比另一個東西, 看看原來的 set 里有沒有和他不同的 (difference).

編寫一個函數(shù)來查找字符串數(shù)組中的最長公共前綴

strs = ['hello','helool','heool']
lst = list(strs)
def longestCommonPrefix(strs):
    result = ""
    print(set(zip(*strs)))
    for temp in zip(*strs):
        print("tmp:",temp)
        if len(set(temp)) == 1:
            result += temp[0]
        else:
            break
    return result
 
print( longestCommonPrefix(lst))

結(jié)果：

{('e', 'e', 'e'), ('o', 'o', 'l'), ('h', 'h', 'h'), ('l', 'o', 'o'), ('l', 'l', 'o')}
tmp: ('h', 'h', 'h')
tmp: ('e', 'e', 'e')
tmp: ('l', 'l', 'o')
he

8.python中的round()函數(shù)

round()是python自帶的一個函數(shù)，用于數(shù)字的四舍五入。 

round(number,digits)

參數(shù)：

• digits>0，四舍五入到指定的小數(shù)位
• digits=0, 四舍五入到最接近的整數(shù)
• digits<0 ，在小數(shù)點左側(cè)進行四舍五入
• 如果round()函數(shù)只有number這個參數(shù)，等同于digits=0

四舍五入規(guī)則：

• 要求保留位數(shù)的后一位<=4，則進位，如round(5.214,2)保留小數(shù)點后兩位，結(jié)果是 5.21
• 要求保留位數(shù)的后一位“=5”，且該位數(shù)后面沒有數(shù)字，則不進位，如round(5.215,2)，結(jié)果為5.21
• 要求保留位數(shù)的后一位“=5”，且該位數(shù)后面有數(shù)字，則進位，如round(5.2151,2)，結(jié)果為5.22
• 要求保留位數(shù)的后一位“>=6”，則進位。如round(5.216,2)，結(jié)果為5.22

9.字典中setdefault函數(shù)

在setdefault函數(shù)使用時，如果不指定value，默認的value就是None（None在Python中也是一個對象，記住Python中一切都是對象，Python支持動態(tài)類型變換）。

setdefault函數(shù)的設(shè)計思想，設(shè)置key對應(yīng)的默認值，如果key存在，key對應(yīng)的value不會被改變，而且函數(shù)總是返回key的默認值。

在setdefault之后，dict類型的對象就有了index（key），然后就可以直接通過index來修改對應(yīng)的value。

或者直接通過index（key），可以增加dict對象中的key-value pairs。

字典常用函數(shù)/操作：

10.python中items函數(shù)

items:函數(shù)以列表返回可遍歷的(鍵, 值) 元組數(shù)組常與for循環(huán)搭配

//例如
a={'a':1,'b':2,'c':3}
print(a.items())
for key,value in a.items():
    print("key:",key)
    print('value；',value)
//輸出
dict_items([('a', 1), ('b', 2), ('c', 3)])
key: a
value； 1
key: b
value； 2
key: c
value； 3

11.python中的strip()函數(shù)

返回刪除前導(dǎo)和尾隨空格的字符串副本。如果給定了chars而不是None，則刪除chars中的字符。（該方法只能刪除開頭或是結(jié)尾的字符，不能刪除中間部分的字符。）

第一種：strip()當函數(shù)體內(nèi)不存在任何的字符的時候則返回的是刪除字符串前導(dǎo)和尾隨空格的字符串副本(一般用來去除前后的空格)

第二種：strip()當函數(shù)體內(nèi)存在字符的時候則得到的是刪除字符串頭尾相應(yīng)字符的字符串副本

a = “abcdef123456cba”
print(a.strip(“abc”))
>>> def123456

12.python中數(shù)字與字符的轉(zhuǎn)換

• int(x ) 將x轉(zhuǎn)換為一個整數(shù)
• long(x) 將x轉(zhuǎn)換為一個長整數(shù)
• float(x ) 將x轉(zhuǎn)換到一個浮點數(shù)
• complex(real [,imag ]) 創(chuàng)建一個復(fù)數(shù)
• str(x ) 將對象 x 轉(zhuǎn)換為字符串
• repr(x ) 將對象 x 轉(zhuǎn)換為表達式字符串
• eval(str ) 用來計算在字符串中的有效Python表達式,并返回一個對象
• tuple(s ) 將序列 s 轉(zhuǎn)換為一個元組
• list(s ) 將序列 s 轉(zhuǎn)換為一個列表
• chr(x ) 將一個整數(shù)轉(zhuǎn)換為一個字符
• unichr(x ) 將一個整數(shù)轉(zhuǎn)換為Unicode字符
• ord(x ) 將一個字符轉(zhuǎn)換為它的整數(shù)值
• hex(x ) 將一個整數(shù)轉(zhuǎn)換為一個十六進制字符串
• oct(x ) 將一個整數(shù)轉(zhuǎn)換為一個八進制字符串

13.hasattr()函數(shù)用于判斷對象是否包含對應(yīng)的屬性

hasattr(object, name)
object -- 對象。
name -- 字符串，屬性名。
return
如果對象有該屬性返回 True，否則返回 False。

14. filter() 函數(shù)

(1)、filter()函數(shù)的簡介和語法：

filter()函數(shù)用于過濾序列，過濾掉不符合條件的元素，返回符合條件的元素組成新列表。

(2)、filter()語法如下：

filter(function,iterable)

• function – 判斷函數(shù)。
• iterable – 可迭代對象

序列中的每個元素作為參數(shù)傳遞給函數(shù)進行判斷， 返回True或者False，最后將返回True的元素放到新列表中

(3)、filter()使用舉例

栗子1： 過濾掉列表當中的數(shù)字0

list_num = [1, 2, 3, 0, 8, 0, 3]
print(list(filter(lambda x: x, list_num)))

結(jié)果為：

[1, 2, 3, 8, 3]

栗子2：過濾列表中數(shù)字的大小寫(針對的是字母全都是大寫或小寫的情況)

list_word = ['a', 'B', 'c', 'd', 'E']
print(list(filter(lambda x: x.isupper(), list_word)))
print(list(filter(lambda x: x.islower(), list_word)))

結(jié)果為：

['B', 'E']
['a', 'c', 'd']

例子3：與dict構(gòu)成的列表處理例子

dict_a = [{'name': 'python', 'points': 10}, {'name': 'java', 'points': 8}]
test_filter = filter(lambda x : x['name'] == 'python', dict_a)
print(list(test_filter))
 
輸出結(jié)果：
[{'name': 'python', 'points': 10}]

例子4：去除空格字符

b = ['\n    ', '1', '  ','Tuesday, May 05, 2020','\n',None]
 
def not_empty(s):
    return s and s.strip()
c = filter(not_empty,b)
print(list(c))
結(jié)果：
[‘1', ‘Tuesday, May 05, 2020']

15.isinstance() 內(nèi)置函數(shù)

isinstance() 函數(shù)來判斷一個對象是否是一個已知的類型，類似 type()。

sinstance() 與 type() 區(qū)別：

• type() 不會認為子類是一種父類類型，不考慮繼承關(guān)系。
• isinstance() 會認為子類是一種父類類型，考慮繼承關(guān)系。

如果要判斷兩個類型是否相同推薦使用 isinstance()。

1、原型

isinstance(object, classinfo)

2、參數(shù)

object – 實例對象。 classinfo – 可以是直接或間接類名、基本類型或者由它們組成的元組。

3、返回值

如果對象的類型與參數(shù)二的類型（classinfo）相同則返回 True，否則返回 False。

實例：（獲取嵌套的數(shù)組列表）

def flatten(nest_list:list):
    out = []
    for i in nest_list:
        if isinstance(i, list):
            tmp_list = flatten(i)
            for j in tmp_list:
                out.append(j)
        else:
            out.append(i)
    return out
    
    
    
測試結(jié)果：

a = [[1,2], ['a','b', [3, 4]]]
b = flatten(a)
print(b)
# 輸出： [1, 2, 'a', 'b', 3, 4]

總結(jié)

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

最新評論