strs = 'I like python and java'
one = strs.find('n')
print(one)
two = strs.rfind('n')
print(two)
find是從前往後找，返回成功匹配的第一個字符的位置索引
rfind也是從前往後找，但是返回最後一次成功匹配的字符的位置索引
Python中，打開文件語法為
text = oepn(filePath, 操作方式，編碼方式）
常見操作方式：
- ‘r’:讀
- ‘w’:寫
- ‘a’:追加
常見編碼方式：- utf-8
- gbk
lists = [1, 2, 3, 4, 5, 6]
print(lists[6:])
注意區分切片，切片一般指創造新的對象，而基於原列表而創造的切片一旦其切片值超出原列表索引下標則會無法從原列表中獲取元素，因此返回一個空的下標
切片是淺拷貝，沒有索引越界
Python變量的作用域遵循LEGB原則，即
- L：Local，局部作用域，也就是我們在函數中定義的變量；
- E：Enclosing，嵌套的父級函數的局部作用域，即包含此函數的上級函數的局部作用域，但不是全局的；
- G：Globa，全局變量，就是模塊級別定義的變量；
- B：Built-in，系統內置模塊裡面的變量，比如int, bytearray等。
a = [1]
b = 2
c = 1
def fn(lis, obj):
lis.append(b)
obj = obj + 1
return lis, obj
fn(a, c)
print(fn(a, c))
fn(a,c)：調用了一次fn函數，這時候a變成了[1,2]，c還是1，因為函數雖然返回了obj，但是沒有賦值，出了函數之後c還是全局變量的那個c；print(fn(a,c))：又調用了一次fn函數，過程同上，但是打印的時候打印的是函數的返回值，也就是此時的形參lis和obj的值，而此時lis是[1,2,2]，而obj是2。
not 1 and 1的結果為在Python3中，
not表示邏輯非，and表示邏輯與，邏輯非(not)的運算優先級大於邏輯與(and)的優先級，則not 1為False，則not 1 and 1結果為False
優先級not>and>or,諧音not at allnot 1 = FalseFalse and 1 = False
str1 = "exam is a example!"
str2 = "exam"
print(str1.find(str2, 7))
在Python3中
strs.find(str, beg=0, end=len(strs))表示在strs中返回第一次出現str的位置下標，beg表示在strs中的開始索引，默認為0（此題中為7），end結束索引，默認為strs的長度。但需要注意的是，返回的索引還是默認從0開始的，並不是beg的值（beg只是告訴程序是從該字符串第幾個索引開始尋找），因此此題的結果為10
s1 = 'aabbcc'
s2 = 'abc'
count = s1.count(s2)
if count > 0 :
print('s2是s1的子串')
else:
print('s2不是s1的子串')
"""---------------------------"""
s1 = 'aabbcc'
s2 = 'abc'
index = s1.index(s2)
if index > -1:
print('s2是s1的子串')
else:
print('s2不是s1的子串')
"""---------------------------"""
s1 = 'aabbcc'
s2 = 'abc'
find = s1.find(s2)
if find != -1 :
print('s2是s1的子串')
else:
print('s2不是s1的子串')
"""---------------------------"""
s1 = 'aabbcc'
s2 = 'abc'
if s2 in s1:
print('s2是s1的子串')
else:
print('s2不是s1的子串')
正確答案為B。
count()函數沒有匹配到對象返回0index()函數沒有匹配到對象報錯value Errorfind()函數沒有匹配到對象返回-1in沒有匹配到對象返回False
print type(1/2)
- Python2 中除法默認向下取整，因此
1/2 = 0，為整型。- 而 Python3 中的除法為正常除法，會保留小數位，因此
1/2 = 0.5，為浮點型(float)。
class A(object):
pass
class B(A):
pass
b = B()
isinstance()函數來判斷一個對象是否是一個已知的類型，類似type()。issubclass()函數用於判斷參數是否是類型參數的子類。
a = [1,2,3,1,2,4,6] 進行去重後，得到列表b，在不考慮列表元素的排列順序的前提下，下列方法錯誤的是（）b = list(set(a))
"""---------------------------"""
b = {
}
b = list(b.fromkeys(a))
"""---------------------------"""
a.sort()
b = []
i = 0
while i < len(a):
if a[i] not in b:
b.append(a[i])
else:
i += 1
"""---------------------------"""
a.sort()
for i in range(len(a)-1):
if a[i] == a[i+1]:
a.remove(a[i])
else:
continue
b = a
D選項錯誤原因在於for循環的計數次數是不變的，但是隨著a重復元素不斷的移除，會導致列表出現IndexError。
n = 1000
while n > 1:
print(n)
n = n / 2
此題題意為：n 從1000開始循環，每次循環執行 n = n / 2，已知 29 = 512，210 = 1024，因此循環的次數為 10次，當循環10次後才會不滿足循環條件
sets = {
1, 2, 3, 4, 5}
print(sets[2])
程序運行結果為：
python3中，集合不能索引取值，因此會報錯：TypeError: ‘set’ object is not subscriptable
集合無序，沒有索引訪問
num = 1
def fn():
num += 1
return lambda:print(num)
x = fn()
x()
雖然在函數外部聲明num 為全局變量，但若函數體內對num變量重新賦值，其結果會使得函數內部屏蔽了外面的全局變量num，此時語句num += 1就會拋出異常，即num變量沒有先賦值就直接引用了。
dicts = {
'one': 1, 'two': 2, 'three': 3}
tmp = dicts.copy()
tmp['one'] = 'abc'
print(dicts)
print(tmp)
字典數據類型的
copy函數，當簡單的值替換的時候，原始字典和復制過來的字典之間互不影響，但是當添加，刪除等修改操作的時候，兩者之間會相互影響。
所以新字典的值的替換對原字典沒有影響
strs = '123456'
print(strs.find('9'))
find和rfind在查不到的時候-1index和rindex在查不到時都返回value error 所以編程時建議使用find
urllib.quote(line.decode("gbk").encode("utf-16"))
注意審題，問的是解碼順序不是編碼順序
def fun(a=(), b=[]):
a += (1, )
b.append(1)
return a, b
fun()
print(fun())
Python的默認參數只在函數定義時被賦值一次，而不會每次調用函數時又創建新的引用。這意味著，函數定義完成後，默認參數已經存在固定的內存地址了，如果使用一個可變的默認參數並對其進行改變，那麼以後對該函數的調用都會改變這個可變對象，而默認參數如果是不可變對象，不存在該問題，因此正確答案為A選項。
注意審題，兩次函數調用
strs = ['a', 'ab', 'abc', 'python']
y = filter(lambda s: len(s) > 2, strs)
tmp = list(map(lambda s: s.upper(), y))
print(tmp)
filter中的條件是pass的條件
filter輸出是一個filter對象，可以通過list,tuple等工廠函數轉換為對應的數據類型
Python 中的 tuple 結構為 “不可變序列”，用小括號表示。為了區別數學中表示優先級的小括號，當 tuple 中只含一個元素時，需要在元素後加上逗號。
dicts = {
'one': 1, 'two': 2, 'three': 3}
print(dicts['one'])
print(dicts['four'])
py3 訪問不存在的索引或key：
py3 切片越界(索引為自然數情況)：
'' 空字符b = 1
def fn():
nonlocal b
b = b + 1
print(b)
fn()
# ------------------------------------
tup = (('onion', 'apple'), ('tomato', 'pear'))
for _, fruit in tup:
print(fruit)
# ------------------------------------
a = [b for b in range(10) if b % 2 == 0]
print(b) #
# ------------------------------------
lis = [1, 2, 'a', [1, 2]]
set(lis)
- A選項，變量b屬於全局變量，所以應該使用global聲明而不是nonlocal；
- B選項，可以使用_作為占位符，所以B選項不會報錯；
- C選項，python3.x中，使用列表生成式，中間變量b在生成列表後被銷毀，因此再次使用變量b會報錯；
- D選項，集合元素不能是列表這類不可散列對象，因此會報錯。
- A. 函數可以沒有return
- B. 看起來return可以返回多個值，但其實並不是，多個值返回是通過tuple實現的
- C. 在Python中是沒有Null這個數據類型的，返回的應該是None
def fn():
t = []
i = 0
while i < 2:
t.append(lambda x: print(i * x, end=","))
i += 1
return t
for f in fn():
f(2)
函數
fn存在閉包現象，自由變量是i，由於python閉包采用延遲綁定，也就是當調用匿名函數時，循環早已結束，此時i的值為2，所以輸出結果都為2*2=4，正確答案為A。
a = '123'
b = '123'
a,b為字符串不可變類型，所以指向相同地址，所以a is b
+is指地址相同==內容相同===內容和格式相同
a+b=‘123123’a==123，字符和int不相同
strs = ' I like python '
one = strs.strip()
print(one)
two = strs.rstrip()
print(two)
- strip()：刪除首尾空格；
- rstrip():僅刪除右空格；
names = ["Andrea", "Aaslay", "Steven", "Joa"]
lists = []
for name in names:
if name.count('a') >= 2:
lists.append(name)
print(lists)
此題題意為：從名字的字符數組中找出名字中包含字母 ‘a’ 個數大於等於2個名字列表合集
首先對名字的字符數組進行遍歷獲取每一個名字，再通過 count() 函數判斷名字中是否包含字母 ‘a’ 個數大於等於2個，將符合要求的名字字符存放到lists數組中（需要注意 ‘a’ 是區分大小寫的），最後輸出的 lists = [‘Aaslay’]
dicts = {
}
dicts[([1, 2])] = 'abc'
print(dicts)
在Python3中，只有當元組內的所有元素都為不可變類型的時候，才能成為字典的key，因此程序運行過程中會報錯：TypeError: unhashable type: ‘list’
lis = ['apple', 'lemon', 'pear', 'peach']
def fn(x):
return x[::-1]
lis.sort(key=fn, reverse=True)
print(lis)
函數
fn的作用就是將字符反轉，比如fn("apple")得到 “elppa”。列表中元素按照fn函數規則,進行降序排列,此時的列表元素經過函數規則後:[‘elppa’,‘nomel’,‘raep’,hcaep],進行降序排列如下:[‘raep’, ‘nomel’, ‘hcaep’, ‘elppa’],但列表元素並不會改變,所以結果為D。
_foo 不能直接用於from module import *__foo解析器用_classname__foo來代替這個名字，以區別和其他類相同的命名__foo__代表python裡特殊方法專用的標識__foo 可以直接用於from module import *python中主要存在四種命名方式：
object：公用方法_object：半保護，被看作是“protect”，意思是只有類對象和子類對象自己能訪問到這些變量，在模塊或類外不可以使用，不能用from module import *導入。__object是為了避免與子類的方法名稱沖突， 對於該標識符描述的方法，父類的方法不能輕易地被子類的方法覆蓋，他們的名字實際上是_classname__methodname。__ object：全私有，全保護，私有成員“private”，意思是只有類對象自己能訪問，連子類對象也不能訪問到這個數據，不能用from module import *導入。__ object__：內建方法，用戶不要這樣定義
①環境變量中的PYTHONPATH
②內建模塊
③python安裝路徑
④當前路徑，即執行Python腳本文件所在的路徑
其中查找順序正確的一組是（）
python搜索模塊的順序為:內建模塊>當前路徑，即執行Python腳本文件所在的路徑>環境變量中的PYTHONPATH>python安裝路徑，故答案為C。
內建模塊(built-in) > 當前路徑(./) > 環境變量 > Python安裝路徑
lis = [1,3,2]
a = id(lis)
lis = sorted(lis)
b = id(lis)
print(a==b)
print("======================")
lis = [1,3,2]
a = id(lis)
lis += [4,5]
b = id(lis)
print(a==b)
print("======================")
tup = (1,3,2)
a = id(tup)
tup += (4,5)
b = id(tup)
print(a==b)
print("======================")
tup = (1,3,2)
a = id(tup)
tup = sorted(tup)
b = id(tup)
print(a==b)
使用
sorted()進行排序會生成新的序列，生成的新序列和原序列id值必然不同。對於可變對象，sorted()進行排序時原序列也發生變化，而本題A中用lis保存了生成的新序列，因此AD選項輸出結果均為False；對於+=操作，如果是可變對象，則操作前後序列的id值不變，如果是不可變對象，則操作前後序列的id值改變，故B正確。
strs = ' I like python '
one = strs.split(' ')
two = strs.strip()
print(one)
print(two)
當分割的地方有空格， 那麼分割的時候就會保留空格。
a = 1
b = 2
a,b = b,a
print("================")
a,*b,c = range(5)
print(a,b,c)
print("================")
lis = ['1','2']
a,b = list(map(int,lis))
print(a,b)
print("================")
tup = (1,(2,3))
a,b,c = tup
print(a,b,c)
ABCD四個選項的程序都是可迭代元素拆包問題。
- A選項是兩數交換的優雅寫法；
- B選項，python允許使用*來處理剩下的參數；
- C選項是關於列表的拆包，讓可迭代對象的元素一一賦值給對應的變量；
- D選項會拋出異常，這是因為對應變量不滿足元組的嵌套結構，正確的寫法應該是a,(b,c) = tup
str = "Hello,Python";
suffix = "Python";
print (str.endswith(suffix,2));
str.endswith(suffix[, start[, end]]) 用於判斷字符串是否以指定後綴結尾，如果以指定後綴結尾返回True，否則返回False。
可選參數"start"與"end"為檢索字符串的開始與結束位置。
