1、執行 Python 腳本的兩種方式
答：1.>>python ../pyhton.py
2. >>python.py #必須在首行有 #!/usr/bin/env python3 指定執行語言
2、簡述位、字節的關系
答：一個字節(byte)=8位(bit) 位為最小的單位
3、簡述 ascii、unicode、utf-8、gbk 的關系
ascii:只能表示256個符號
unicode:萬國碼，各國都有 需要有2位來表示
utf-8:UTF-8，是對Unicode編碼的壓縮和優化，他不再使用最少使用2個字節，而是將所有的字符和符號進行分類
gbk:中文字符集，是對
4、請寫出 “李傑” 分別用 utf-8 和 gbk 編碼所占的位數
Python
n = "李傑"
5、Pyhton 單行注釋和多行注釋分別用什么?
答：單行注釋 #代碼
多行注釋 ''' 代碼 ''' Pycharm 快捷鍵ctrl+/
6、聲明變量注意事項有那些?
答：1.變量名只能用字母、數字或下划線的任意組合
2.變量名不能以數字為第一個字符
3.內置函數名不能用
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
8、如何查看變量在內存中的地址?
答：id(變量名)
9、執行 Python 程序時，自動生成的 .pyc 文件的作用是什么?
答：運行Python程序，PyCodeObject編譯保存文件，.pyc文件是PyCodeObject永久性保存文件
10、寫代碼 a.實現用戶輸入用戶名和密碼，當用戶名為 seven 且 密碼為 123 時，顯示登陸成功，否則登陸失敗!
Python
username = input("username:")#輸入賬號
password = input("password:")#輸入密碼
if username == "alex" and password == "123":#判斷用戶名密碼是否相等
print("登錄成功")
break#循環結束
else:#不同返回信息
print("用戶名或密碼不正確，請重新輸入！")
continue
b.實現用戶輸入用戶名和密碼，當用戶名為 seven 且 密碼為 123 時，顯示登陸成功，否則登陸失敗，失敗時允許重復輸入三次
Python
for i in range(3):#程序循環3次
username = input("username:")#輸入賬號
password = input("password:")#輸入密碼
if username == "alex" and password == "123":#判斷用戶名密碼是否相等
print("登錄成功")
break#循環結束
else:#不同返回信息
print("用戶名或密碼不正確，請重新輸入！")
continue
c.實現用戶輸入用戶名和密碼，當用戶名為 seven 或 alex 且 密碼為 123 時，顯示登陸成功，否則登陸失敗，失敗時允許重復輸入三次
Python
for i in range(3):#程序循環3次
username = input("username:")#輸入賬號
password = input("password:")#輸入密碼
if username == "alex" or username == "seven":#判斷用戶名是否相等
if password == "123":#密碼是否相同
print("登錄成功")
break#循環結束
else:#不同返回信息
print("用戶名或密碼不正確，請重新輸入！")
continue
else:#不相等返回提示並重新輸入
print("用戶名或密碼不正確，請重新輸入！")
continue
11、寫代碼 a. 使用while循環實現輸出2-3+4-5+6...+100 的和
Python
i,b = 2,0
while i <= 100:#i取2-100
if i%2 == 0:#判斷是偶數
b = b + i #結果加當前的i
else:#基數
b = b - i #結果減當前i
i += 1 #判斷完自增一
print(b)
#結果：51
b. 使用for循環和range實現輸出 1-2+3-4+5-6...+99 的和
Python
b = 0 #結果
for i in range(1,100):
if i%2 == 0:#判斷是偶數
b = b - i #結果加當前的i
else:#基數
b = b + i #結果減當前i
i += 1 #判斷完自增一
print(b)
#結果：50
c. 使用 while 循環實現輸出 1，2，3，4，5， 7，8，9， 11，12
Python
i = 1#初始值
while i < 13: #判斷小余13
if i == 6 or i == 10:#只有6和10不輸出，or是或
pass #啥也不做跳過
else:
print(i)
i += 1
d. 使用 while 循環實現輸出 1-100 內的所有奇數
Python
i = 1
while i < 101:
if i%2 == 0:#取2得余數為0為偶數
pass#啥也不做
else:
print(i)
i += 1
e. 使用 while 循環實現輸出 1-100 內的所有偶數
Python
i = 1
while i < 101:
if i%2 == 0:#取2得余數為0為偶數
print(i)
else:
pass#啥也不做
i += 1
12、分別書寫數字 5，10，32，7 的二進制表示
5：0000 0101 10：0000 1010 32：0010 0000 7：0000 0111
13、簡述 對象和 類的關系(可用比喻的手法)
答：類就是文件夾，對象就是文件夾的文件 類有列表，元組，字典等 里面的元素就是對象
14、現有如下兩個變量，請簡述 n1 和 n2 是什么關系?
n1 = 123
n2 = 123
答：n1和n2都在內存中並列存在
15、現有如下兩個變量，請簡述 n1 和 n2 是什么關系?
n1 = 123456
n2 = 123456
答：n1和n2都在內存中並列存在
16、現有如下兩個變量，請簡述 n1 和 n2 是什么關系?
n1 = 123456
n2 = n1
答：n1的值在內存存在，n2的值是指向n1的值，如下圖：
17、如有一下變量 n1 = 5，請使用 int 的提供的方法，得到該變量最少可以用多少個二進制位表示?
Python
n1 = 5
print(n1.bit_length()) #3
18、布爾值分別有什么?
答：True和False 1和0
19、閱讀代碼，請寫出執行結果
a = "alex" b = a.capitalize()
print(a) print(b)
請寫出輸出結果:alex Alex
20、寫代碼，有如下變量，請按照要求實現每個功能
name = " aleX"
a. 移除 name 變量對應的值兩邊的空格，並輸入移除有的內容
Python
name = " aleX"
print(name.strip())
b. 判斷 name 變量對應的值是否以 "al" 開頭，並輸出結果
Python
name = " aleX"
print(name.startswith("al"))
c. 判斷 name 變量對應的值是否以 "X" 結尾，並輸出結果
Python
name = " aleX"
print(name.endswith("X"))
d. 將 name 變量對應的值中的 “l” 替換為 “p”，並輸出結果
Python
#第一種
name = " aleX"
name = name[:2]+"p"+name[-2:]
print(name)
#第二種
name = " aleX"
name1 = ""
for i in name:
i = "p" if i == "l" else i #三元運算
name1 += i
print(name1)
#第三種
name = " aleX"
name1 = ""
for i in name:
if i == "l":
i = "p"
name1 += i
print(name1)
e. 將 name 變量對應的值根據 “l” 分割，並輸出結果。
Python
#第一種人工分割
name = " aleX"
name1 = name[:2]
name2 = name[-2:]
print(name1,name2)
#第二種循環分割
name = " aleX"
for i,v in enumerate(name):
if v == "l":
print(name[:i],name[i+1:])
f. 請問，上一題 e 分割之后得到值是什么類型?
答：字符串
g. 將 name 變量對應的值變大寫，並輸出結果
Python
name = " aleX"
print(name.upper())
h. 將 name 變量對應的值變小寫，並輸出結果
Python
name = " aleX"
print(name.lower())
i. 請輸出 name 變量對應的值的第 2 個字符?
Python
name = " aleX"
print(name[1:2])
j. 請輸出 name 變量對應的值的前 3 個字符?
Python
name = " aleX"
print(name[:3])
k. 請輸出 name 變量對應的值的后 2 個字符?
Python
name = " aleX"
print(name[-2:])
l. 請輸出 name 變量對應的值中 “e” 所在索引位置?
Python
name = " aleX"
for i,v in enumerate(name):
if v == "e":
print("e的索引是：%s"%i)
21、字符串是否可迭代?如可以請使用 for 循環每一個元素?
Python
name = "hairui"
for i in name:
print(i)
22、請用代碼實現:利用下划線將列表的每一個元素拼接成字符串，li = ['alex', 'eric', 'rain']
Python
#方法一
li = ['alex', 'eric', 'rain']
b = li[0]+"_"+li[1]+"_"+li[2]
print(b)
#方法二
li = ['alex', 'eric', 'rain']
c = ""
for i,name in enumerate(li,1):
if i == len(li):#判斷是否是最后一位
c = c + name
else:
c = c + name + "_"
print(c)
22、寫代碼，有如下列表，按照要求實現每一個功能
li = ['alex', 'eric', 'rain'] a. 計算列表長度並輸出
Python
li = ['alex', 'eric', 'rain']
print(len(li))
b. 列表中追加元素 “seven”，並輸出添加后的列表
Python
li = ['alex', 'eric', 'rain']
li.append("seven")
print(li)
c. 請在列表的第 1 個位置插入元素 “Tony”，並輸出添加后的列表
Python
li = ['alex', 'eric', 'rain']
li.insert(0,"seven")
print(li)
d. 請修改列表第 2 個位置的元素為 “Kelly”，並輸出修改后的列表
Python
li = ['alex', 'eric', 'rain']
li[1] = "Tony"
print(li)
e. 請刪除列表中的元素 “eric”，並輸出修改后的列表
Python
li = ['alex', 'eric', 'rain']
li.remove('eric')
print(li)
f. 請刪除列表中的第 2 個元素，並輸出刪除的元素的值和刪除元素后的列表
Python
li = ['alex', 'eric', 'rain']
print(li.pop(1))
g. 請刪除列表中的第 3 個元素，並輸出刪除元素后的列表
Python
li = ['alex', 'eric', 'rain']
li.pop(2)
print(li)
h. 請刪除列表中的第 2 至 4 個元素，並輸出刪除元素后的列表
Python
li = ['alex', 'eric', 'rain','Tony']
for i in range(3):循環3次
li.pop(1)
print(li)
i. 請將列表所有的元素反轉，並輸出反轉后的列表
Python
li = ['alex', 'eric', 'rain']
print(li.reverse())
j. 請使用 for、len、range 輸出列表的索引
Python
li = ['alex', 'eric', 'rain','Tony']
for i in range(len(li)):
print(i)
k. 請使用 enumrate 輸出列表元素和序號(序號從 100 開始)l. 請使用 for 循環輸出列表的所有元素
Python
li = ['alex', 'eric', 'rain','Tony']
for i,name in enumerate(li,100):
print(i,name)
23、寫代碼，有如下列表，請按照功能要求實現每一個功能li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 請輸出 “Kelly”
Python
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
name = str(li[2][1][1])
print(name.capitalize())
b. 請使用索引找到 'all' 元素並將其修改為 “ALL”
Python
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
name = str(li[2][2])
print(name.upper())
24、寫代碼，有如下元組，按照要求實現每一個功能tu = ('alex', 'eric', 'rain')
a. 計算元組長度並輸出
Python
tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 獲取元組的第 2 個元素，並輸出
Python
tu = ('alex', 'eric', 'rain')
print(tu[1])
c. 獲取元組的第 1-2 個元素，並輸出
Python
tu = ('alex', 'eric', 'rain')
print(tu[:2])
d. 請使用 for 輸出元組的元素
Python
tu = ('alex', 'eric', 'rain')
for i in tu:
print(i)
e. 請使用 for、len、range 輸出元組的索引
Python
tu = ('alex', 'eric', 'rain')
for i in range(len(tu)):
print(i)
f. 請使用 enumrate 輸出元祖元素和序號(序號從 10 開始)
Python
tu = ('alex', 'eric', 'rain')
for i,name in enumerate(tu,10):
print(i,name)
25、有如下變量，請實現要求的功能 tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
a. 講述元祖的特性
1.不可修改 b. 請問 tu 變量中的第一個元素 “alex” 是否可被修改?
答：不可以修改 c. 請問 tu 變量中的"k2"對應的值是什么類型?是否可以被修改?如果可以，請在其中添加一個元素 “Seven”
答：可以修改，是列表
Python
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
b = tu[1][2]["k2"] = [].append("Seven")
print(tu)
d. 請問 tu 變量中的"k3"對應的值是什么類型?是否可以被修改?如果可以，請在其中添加一個元素 “Seven”
答：元組，可以，重新給k3賦值
Python
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
b = list(tu[1][2]["k3"])#k3的value轉換list
b.append("seven")#添加值
tu[1][2]["k3"] = tuple(b)#給k3賦值
print(tu)
26、字典 dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
a. 請循環輸出所有的 key
Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
for i in dic.keys():
print(i)
b. 請循環輸出所有的 value
Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
for i in dic.values():
print(i)
c. 請循環輸出所有的 key 和 value
Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
for i in dic.keys():
print(i,dic[i])
d. 請在字典中添加一個鍵值對，"k4": "v4"，輸出添加后的字典
Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
dic.setdefault("k4","v4")
print(dic)
#結果：{'k2': 'v2', 'k3': [11, 22, 33], 'k1': 'v1', 'k4': 'v4'}
e. 請在修改字典中 “k1” 對應的值為 “alex”，輸出修改后的字典
Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
dic["k1"] = "alex"
print(dic)
f. 請在 k3 對應的值中追加一個元素 44，輸出修改后的字典
Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
b = list(dic["k3"])#讀取k3的value,轉換成list賦值給B
b.append(44)#將元素添加至列表B中
dic["k3"] = b#將列表賦值給k3的value
print(dic)
g. 請在 k3 對應的值的第 1 個位置插入個元素 18，輸出修改后的字典
Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
b = list(dic["k3"])
b.insert(0,18)
dic["k3"] = b
print(dic)
27、轉換 a. 將字符串 s = "alex" 轉換成列表
Python
s = "alex"
print(list(s))
b. 將字符串 s = "alex" 轉換成元祖
Python
s = "alex"
print(tuple(s))
b. 將列表 li = ["alex", "seven"] 轉換成元組
Python
li = ["alex", "seven"]
print(tuple(li))
c. 將元祖 tu = ('Alex', "seven") 轉換成列表
Python
tu = ('Alex', "seven")
print(list(tu))
d. 將列表 li = ["alex", "seven"] 轉換成字典且字典的 key 按照 10 開始向后遞增
Python
li = ["alex", "seven"]
dict = {}
for i,name in enumerate(li,10):
dict[i] = name
print(dict)
28、轉碼
n = "老男孩"
a. 將字符串轉換成 utf-8 編碼的字節，並輸出，然后將該字節再轉換成 utf-8 編碼字符串，再輸出
Python
n = "老男孩"
print(n.encode(encoding="utf-8"))
print(n.encode(encoding="utf-8").decode(encoding="utf-8"))
b. 將字符串轉換成 gbk 編碼的字節，並輸出，然后將該字節再轉換成 gbk 編碼字符串，再輸出
Python
n = "老男孩"
print(n.encode(encoding="gbk"))
print(n.encode(encoding="gbk").decode(encoding="gbk"))
29、求 1-100 內的所有數的和
Python
b = 0
for i in range(0,101):
b = b + i
print(b)
結果：5050
30、元素分類 有如下值集合 [11,22,33,44,55,66,77,88,99,90]，將所有大於 66 的值保存至字典的第一個 key 中，將小於 66 的值保存至第二個 key 的值中。
即: {'k1': 大於 66 的所有值, 'k2': 小於 66 的所有值}
Python
li = [11,22,33,44,55,66,77,88,99]
l1 = []
l2 = []
for i in li:
if i >66:
l1.append(i)
else:
l2.append(i)
dict = {"k1":l1,"k2":l2}
print(dict)
結果：{'k1': [77, 88, 99], 'k2': [11, 22, 33, 44, 55]}
31、購物車 功能要求:
要求用戶輸入總資產，例如:2000顯示商品列表，讓用戶根據序號選擇商品，加入購物車 購買，如果商品總額大於總資產，提示賬戶余額不足，否則，購買成功。
goods = [ {"name": "電腦", "price": 1999},
{"name": "鼠標", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998},
]
Python
goods = [
{"name": "電腦", "price": 1999},
{"name": "鼠標", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998},
]
my_money = int(input("請輸入金額："))
while True:#用於循環購買
for i,good in enumerate(goods,1):#循環商品信息
print(i,goods[i-1]["name"],goods[i-1]["price"])#打印列表
user_c = int(input("請選擇商品："))#輸入商品序號
if user_c >0 and user_c <=len(goods):#判斷輸入是否在列表中
if int(goods[user_c-1]["price"]) <= my_money:#余額大於商品金額
my_money = my_money - int(goods\
[user_c-1]["price"])#減商品金額
print("購買 %s 成功,余額為 %s"%(goods[user_c-1]["name"]\
,my_money))#打印成功信息
else:
print("余額不足!再見！")
break
else:
print("無此商品！")
continue
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
基本數據類型經典題型：
一，基礎題。
1：name= " aleX leNb" (每小題一分，共計 23 分)
1) 移除 name 變量對應的值兩邊的空格,並輸出處理結果
2) 移除 name 變量左邊的’al’並輸出處理結果
3) 移除 name 變量右面的’Nb’,並輸出處理結果
4) 移除 name 變量開頭的 a’與最后的’b’,並輸出處理結果
5) 判斷 name 變量是否以 "al" 開頭,並輸出結果
6) 判斷 name 變量是否以”Nb”結尾,並輸出結果
7) 將 name 變量對應的值中的 所有的“l” 替換為 “p”,並輸出結果
8) 將 name 變量對應的值中的第一個’l’替換成’p’,並輸出結果
9) 將 name 變量對應的值根據 所有的“l” 分割,並輸出結果。
10) 將 name 變量對應的值根據第一個’l’分割,並輸出結果。
11) 將 name 變量對應的值變大寫,並輸出結果
12) 將 name 變量對應的值變小寫,並輸出結果
13) 將 name 變量對應的值首字母’a’大寫,並輸出結果
14) 判斷 name 變量對應的值字母’l’出現幾次，並輸出結果
15) 如果判斷 name 變量對應的值前四位’l’出現幾次,並輸出結果
16) 從 name 變量對應的值中找到’N’對應的索引(如果找不到則報錯)，並輸出結果
17) 從 name 變量對應的值中找到’N’對應的索引(如果找不到則返回-1)輸出結果
18) 從 name 變量對應的值中找到’X le’對應的索引,並輸出結果
19) 請輸出 name 變量對應的值的第 2 個字符?
20) 請輸出 name 變量對應的值的前 3 個字符?
21) 請輸出 name 變量對應的值的后 2 個字符?
22) 請輸出 name 變量對應的值中 “e” 所在索引位置?
23) 獲取子序列,去掉最后一個字符。如: oldboy 則獲取 oldbo。
2，寫代碼，有如下列表，按照要求實現每一個功能（每題一分，共計 12 分）
li=[‘alex’,’wusir’,’eric’,’rain’,‘alex’] 1)計算列表的長度並輸出
2)列表中追加元素’seven’,並輸出添加后的列表
3)請在列表的第 1 個位置插入元素’Tony’,並輸出添加后的列表
4)請修改列表第 2 個位置的元素為’Kelly’,並輸出修改后的列表
5)請將列表 l2=[1,’a’,3,4,’heart’]的每一個元素添加到列表 li 中，一行代碼實現，不允許循
環添加。
6)請將字符串 s=‘qwert’的每一個元素添加到列表 li 中，一行代碼實現，不允許循環添
加。
7)請刪除列表中的元素’eric’,並輸出添加后的列表
8)請刪除列表中的第 2 個元素，並輸出刪除的元素和刪除元素后的列表
9)請刪除列表中的第 2 至 4 個元素，並輸出刪除元素后的列表
10)請將列表所有得元素反轉，並輸出反轉后的列表
11)請使用 enumrate 輸出列表元素和序號（序號從 100 開始）
12)請計算出‘alex’元素在列表 li 中出現的次數，並輸出該次數。
3，寫代碼，有如下列表，利用切片實現每一個功能（每題一分，共計 6 分） li=[1,3,2,’a’,4,’b’,5,’c’]
1)通過對 li 列表的切片形成新的列表 l1,l1=[1,3,2]
2)通過對 li 列表的切片形成新的列表 l2,l2=[’a’,4,’b’]
3)通過對 li 列表的切片形成新的列表 l3,l3=[’1,2,4,5]
4)通過對 li 列表的切片形成新的列表 l4,l4=[3,’a’,’b’]
5)通過對 li 列表的切片形成新的列表 l5,l5=[‘c’]
6)通過對 li 列表的切片形成新的列表 l6,l6=[‘b’,’a’,3]
4,寫代碼，有如下字典，按照要求實現每一個功能（每題一分，共計 9 分） dic={‘k1’:’v1’,’k2’:’v2’,’k3’:’v3’}
1)請循環遍歷出所有的 key
2)請循環遍歷出所有的 value
3)請循環遍歷出所有的 key 和 value
4)請在字典中添加一個鍵值對，’k4’:’v4’,輸出添加后的字典
5)請刪除字典中鍵值對’k1’,’v1’,並輸出刪除后的字典
6)請刪除字典中的鍵’k5’對應的鍵值對，如果字典中不存在鍵’k5’，則不報錯，並且讓其 返回 None。
7)請獲取字典中’k2’對應的值。
8)請獲取字典中’k6’對應的值，如果鍵’k6’不存在，則不報錯，並且讓其返回 None。
9)現有 dic2={‘k1’:’v111’,’a’:’b’}通過一行操作使 dic2={‘k1’:’v1’,’k2’:’v2’,’k3’:’v3’,a’:’b’}
二，組合嵌套題。
1,寫代碼，有如下列表，按照要求實現每一個功能（每題 3 分，寫出一種方法得 1 分， 寫出兩種方法的 3 分。此題共 9 分） lis=[[‘k’,[‘qwe’,20,{‘k1’:[‘tt’,3,’1’]},89],’ab’]] 1)將列表 lis 中的’tt’變成大寫（用兩種方式）。
2)將列表中的數字 3 變成字符串’100’（用兩種方式）。
3)將列表中的字符串’1’變成數字 101（用兩種方式）。
2，寫代碼，有如下字典，按照要求實現每一個功能(每道題兩分，共計 10 分) dic={‘k1’:’v1’,’k2’:[‘alex’,’sb’],(1,2,3,4,5):{‘k3’:[‘2’,100,’wer’]}}
1)將’k2’對應的值的最后面添加一個元素’23’。
2)將’k2’對應的值的第一個位置插入一個元素’a’。
3)將(1,2,3,4,5)對應的值添加一個鍵值對’k4’,’v4’。
4)將(1,2,3,4,5)對應的值添加一個鍵值對(1,2,3),’ok’。
5)將’k3’對應的值的’wer’更改為’qq’。
三，循環遍歷題（每題兩分，共計 8 分）。
1)輸出 1-100 內所有的奇數
2)使用 while 循環輸出 123568910
3)求 1-2+3-4+5...99 的所有數的和
4)編寫 for 循環，利用索引遍歷出每一個字符 msg='helloegon666'
四，綜合題（1-5 題每題 1 分，6,7,8 題每題 6 分，共計 23 分）。
1)有列表 li=[‘alex’,’wusir’,’rain’]通過操作該列表構造一個字符串 s=’alexwusirrain’
2)有列表 li=[‘alex’,’wusir’,’rain’]通過操作該列表構造一個字符串 s=’alex*wusir*rain’
3)有字符串 s=‘alexwusirlex’,通過操作該字符串構造一個列表 li=[‘a’,’exwusirlex’]
4)有字符串 s=‘alexwusir’,通過操作該字符串構造一個列表 li=[‘alex’,’wusir’]
5)有字符串 s=‘alex’通過操作該字符串構造一個字符串 s1=‘a_l_e_x’
6)列表 li=[1,’2’,’ab’,3,’as21’,4,’5b’,’6’,’568’,’10q’]將所有數字類型的元素，保存在字典第一 個 key中，將所有全部由數字組成的字符串類型的元素保存在字典的第二個 key中，剩 下的所有保存在字典的第三個 key中。 如 dic={key1:數字類型的值;key2:全部由數字組成的字符串元素;key3:剩下的其他元素}
7)列表 li=[1,2,’3’,4,’5’,6,’7’,8,9]將索引為偶數位對應的值相加(遇到字符串轉化為數字相 加)最后得到的結果插入到列表 li 第二個位置。 8)按照要求實現以下功能： 現有一個列表 li=[1,2,3,’a’,’b’,4,’c’],有一個空字典 dic={}；現在需要完成這樣的操作： 如果該字典沒有’k1’這個鍵，那就創建這個’k1’鍵和對應的值(並且該鍵對應的值是列表 類型)，並將列表 li 中的索引為奇數位的元素，添加到’k1’這個鍵對應的值中。 如果該字典中有’k1’這個鍵，那就將列表 li 中的索引為奇數位的元素，添加到’k1’這個鍵
對應的值中。
答案：
name = "aleX leNb"
#1
print(name[2:])
#2
print(name[:-2])
#3
print(name[1:-1])
#4
print(name.replace('l','p'))
#5
print(name.replace('l','p',1))
#6
print(name.split('l'))
#7
print(name.split('l',1))
#8
print(name.capitalize())
#9
print(name.count('l'))
#10
print(name.count('l',4))
#11
print(name.index('X le'))
#12
print(name.index('e'))
#13
name1=name[:-1]
print(name1)
li = ['alex','wusir','eric','rain','alex']
#1
li.insert(1,'Tony')
print(li)
#2
li[1]='Kelly'
print(li)
#3
l2 = [1,'a', 3, 4,'heart']
li+=l2
print(li)
#4
s = 'qwert'
li+=list(s)
print(li)
#5
li.remove('eric')
print(li)
#6
li.pop(1)
print(li)
#7
del li[1:4]
print(li)
#8
li.reverse()
print(li)
#9
for i in enumerate(li,100):
print(i)
#10
print(li.count('alex'))
li = [1,3,2,'a',4,'b',5,'c']
#1
print(li[3:-2])
#2
print(li[::2])
#3
print(li[1:6:2])
#4
l5=li[-1:]
print(l5)
#5
l6=li[-3::-2]
print(l6)
dic = {'k1':'v1','k2':'v2','k3':'v3'}
#1
for i in dic.keys():
print(i)
#2
for i in dic.values():
print(i)
#3
for i in dic.items():
print(i)
#4
dic['k4']='v4'
print(dic)
#5
dic.pop('k1')
print(dic)
#6
print(dic.pop('k5',None))
#7
print(dic.get('k6'))
#8
dic2 ={'k1':'v111','a':'b'}
dic2.update(dic)
print(dic)
#1
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
# lis[0][1][2]['k1'][0]='TT'
# print(lis)
lis[0][1][2]['k1'][0]=lis[0][1][2]['k1'][0].upper()
print(lis)
#2
# lis[0][1][2]['k1'][1]='100'
# print(lis)
lis[0][1][2]['k1'][1]=str(lis[0][1][2]['k1'][1]+97)
print(lis)
#3
# lis[0][1][2]['k1'][2]=101
# print(lis)
lis[0][1][2]['k1'][2]=int(lis[0][1][2]['k1'][2])+100
print(lis)
#1
dic = {'k1':'v1','k2':['alex','sb'],(1,2,3,4,5):{'k3':['2',100,'wer']}}
dic['k2'].append('23')
print(dic)
#2
dic['k2'].insert(0,'a')
print(dic)
#3
dic[(1,2,3,4,5)]['k4']='v4'
print(dic)
#4
dic[(1,2,3,4,5)][(1,2,3)]='ok'
print(dic)
#5
dic[(1,2,3,4,5)]['k3'][2]='qq'
print(dic)
#1
for i in range(101):
if i%2 ==1:
print(i)
#2
cont=1
while cont <11:
if cont!=4 and cont!=7:
print(cont)
cont+=1
#3
sum_qq=0
for i in range(101):
if i%2==0:
sum_qq+=i
else:
sum_qq-=i
print(sum_qq)
#1
li = ['alex','wusir','rain']
s=''.join(li)
print(s)
#2
s='*'.join(li)
print(s)
#3
s='alexwusirrain'
li=s.split('l',1)
print(li)
#4
s = 'alex wusir'
li_1=s.split(' ')
print(li_1)
#5
s='alex'
s1='_'.join(s)
print(s1)
#7
li_int = [1,2,'3',4,'5',6,'7',8,9]
re=sum([int(li_int[i]) for i in range(len(li_int)) if i%2==0])
li_int.insert(1,re)
print(li_int)
#8
dic_bb = {'234':[1,2,3],'12b':'alex','2':['a','b','1']}
li_s=[i for i in dic_bb.keys()]
for i in li_s:
if i.isdigit():
print(i,dic_bb[i])
else:
print(dic_bb[i])
#9
li = [1,2,3,'a','b',4,'c']
li_sb=[li[i] for i in range(len(li)) if i%2==1]
print(li_sb)
dic_sb={}
if 'k1' in dic_sb:
dic_sb['k1']+=li_sb
else:
dic_sb['k1']=li_sb
print(dic_sb)
數據類型經典題型
#! usr/bin/env python
# -*- coding: utf-8 -*-
#基本數據類型
#---------------------字符串-----------------
# l = 'wangshanglonG'
# ' wangshanglong '
# print(l.strip()) #1:strip-----------------去除前后空格lstrip(左)，strip(右)1
# print(l.startswith('W'))#2:startswith---------------判斷是否以'....',開頭
# print(l.endswith('g'))#3endswit h-------------------判斷是否以'....',結尾
# print(l.upper())#4:upper-----------------------------變大寫
# print(l.lower())#5:lower-------------------------------變小寫
# print(l.swapcase())#6:swapcase---------------------------大小寫轉換
# print(l.split('s'))#7:split--------------------------------以'....',切分。
# print(l.index('s'))#8:index-----------------求'....'的索引，若找不到就報錯。
# print(l.find('p'))#9:find---------------------求'....'的索引，找不到返回負。
# print(l.count('a'))#10:count--------------------統計'....'次數。
# print(l.replace('shang','S'))#11------------------替換
# print(len(l))#12:len()-------------------------------求長度
# print('+'.join(l))#13:join--------------------------用'....'連接。
# ' wangshanglong '
# print(l.center(20,'*'))#14:center---------------------填充空白
# print(l.format())#15:format-----------------------------取出字符串的字符
#----------------------------列表-------------------------------------------
# l = ['1',2,3,'wang','shang','long']
# l.append(123)#1:append------------追加
# print(l)
# l.insert(4,'hwuhuhuhuhwuhuuw')#1：insert--------------增加（按索引）
# print(l)
# l.extend('王,尚,long')#:extend-------------------------增加（追加多個，字符）
# print(l)
# l.remove('1')#2:remove-----------------------------------刪除（按元素刪）
# print(l)
# l.pop(4)#opo-----------------------------------------------刪除（按索引）
# print(l)
# del l[0]#---------------------------------------------------刪除（按索引）
# print(l)
# a = ["q","w","e","r","t","y"]--------------------------------切片查找
# print(a[0:3])
# print(a[0::2]) #面試
# print(a[0:5])
# print(a[0:3:2])
# print(a[-1]) #面試
# print(a[-1:])#結果是列表
# print(a[3:1:-1]) #面試(倒敘)
#---------------------------------------------------------字典--------------------------------------------------------
#例題：
# lis = ['a','gfg',['qwe',20,['tre','1',3],89]]
# 根據索引找到tre元素，並改成TRE
# lis[2][2][0] = 'TRE'
# lis[2][2][0] = lis[2][2][0].upper()
# print(lis)
#1:找到數字3通過相加的方式讓其加上97，變成100。
# lis[2][2][2] += 97
# print(lis)
#2:找到字符串'1',通過相加方式變成字符串'101'。
# lis[2][2][1]+='01'
# print(lis)
#3:找到數字20，通過數字相加和字符轉換方式使其變成'120'.
# lis = ['a','gfg',['qwe',20,['tre','1',3],89]]
# lis[2][1]=str(lis[2][1]+100)
# print(lis)
# tu = ('alex',[11,22,{'k1':'v1','k2':['name','age'],'k3':(1,2,3)},32])
# 1,tu變量第一個元素能否被修改？
#不能
# 2,k2對應的值是什么類型？能否被修改，如果可以添加一個'jx'
# tu[1][2]['k2'].append('jx')
# print(tu)
# 3,k3對應的值是什么類型？能否被修改，如果可以添加一個'jx'
# 元祖不能修改
# 字典的操作
# 字典是python中唯一的映射類型，采用鍵值對（key-value）的形式存儲數據。
# python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，
# 所以字典是無序存儲的，且key必須是可哈希的。
# 可哈希表示key必須是不可變類型，如：數字、字符串、元組。
# dic = {"name":"jin","age":18,"sex":"male"}
# dic2 = {"name":"alex","weight":75}
# for key in dic:
# print(key)
# for item in dic.items():
# print(item)
# for key,value in dic.items():
# print(key,value)
# 增
# dic[[1,2,3]] = ["a","b","c"]
# print(dic)
# setdefault 在字典中添加鍵值對，如果只有鍵那對應的值是none,但是如果原字典中存在設置的鍵值對，則他不會更改或者覆蓋。
# dic.setdefault('k','v')
# print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# dic.setdefault('k','v1') # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# print(dic)
# 刪
# dic_pop = dic.pop("a",'無key默認返回值') # pop根據key刪除鍵值對，並返回對應的值，如果沒有key則返回默認返回值
# print(dic_pop)
# del dic["name"] # 沒有返回值。
# print(dic)
# dic_pop1 = dic.popitem() # 隨機刪除字典中的某個鍵值對，將刪除的鍵值對以元祖的形式返回
# print(dic_pop1) # ('name','jin')
# dic_clear = dic.clear() # 清空字典
# print(dic,dic_clear) # {} None
# 改
# dic2.update(dic) # 將dic所有的鍵值對覆蓋添加（相同的覆蓋，沒有的添加）到dic2中
# print(dic2)
# 查
# value1 = dic["name"] # 沒有會報錯
# print(value1)
# value2 = dic.get("djffdsafg","默認返回值") # 沒有可以返回設定的返回值
# print(value2)
#例題：
dic = {'k1':'v1','k2':['name','age'],'k3':{'a':'b',"c":'d'}}
#,1找出字典中所有的key值，values值，key，values值
# print(dic.keys())
# print(dic.values())
# print(dic.items())m
#2,添加一個鍵值對，'k4':'v4"
# dic.setdefault('k4','v4')
# print(dic)
# dic.update({'k4':'v4'})
# print(dic)
#3,在k3對應的值里面增加一個鍵值對，'aa':'bb',並輸出k3對應的值的鍵值對
# dic['k3'].update({'aa':'bb'})
# print(dic['k3'])
#4,請在'k2'對應的值第一個位置加入一個'sex',並輸出該值
# dic['k2'].insert(1,'sex')
# print(dic)
#5,將k2對應的值增加多個值，這些值是這個列表[1,2,3,4,5]的每一個元素
# dic['k2'].extend([1,2,3,4,5])
# print(dic)
av_catalog = {
"歐美":{
"www.youporn.com": ["很多免費的,世界最大的","質量一般"],
"www.pornhub.com": ["很多免費的,也很大","質量比yourporn高點"],
"letmedothistoyou.com": ["多是自拍,高質量圖片很多","資源不多,更新慢"],
"x-art.com":["質量很高,真的很高","全部收費,屌比請繞過"]
},
"日韓":{
"tokyo-hot":["質量怎樣不清楚,個人已經不喜歡日韓范了","聽說是收費的"]
},
"大陸":{
"1024":["全部免費,真好,好人一生平安","服務器在國外,慢"]
}
}
#三級菜單
# def find(av_catalog):
# for key in av_catalog:
# print(key)
# k = input("請輸入:")
# if k in av_catalog:
# find(av_catalog[k])
# find(av_catalog)
#1:將"資源不多,更新慢" 變成 "還是自拍好呀"
# av_catalog["歐美"]["letmedothistoyou.com"][1]="還是自拍好呀"
# print(av_catalog)
#2:將"服務器在國外,慢"追加一句：'好多找不到了'
# av_catalog["大陸"]["1024"].append("好多找不到了")
# print(av_catalog)
#3:列表 lis = ['a','b','c'] 創建一個字典(用上lis列表)，讓其變成dic = {'a':1,'b':1,'c':1}
# w = {}
# lis = ['a','b','c']
# for i in lis:
# w.setdefault(i,1)
# print(w)
#4:列表 li = [1,2,3,4,5,6,7,8,9],將所有大於6的值保存在字典第一個key中，將所有小於6的值保存在字典第二個key中
# 如：{'k1':所有大於6的值;'k2':所有小於6的值}
# li = [1,2,3,4,5,6,7,8,9]
# # w = []
# s = []
# l = {'k1':w,'k2':s}
# for i in li:
# if i > 6:
# w.append(i)
# else:
# s.append(i)
# print(l)
# a = {'k1':[],'k2':[]}
# for i in li:
# if i >6:
# a['k1'].append(i)
# else:
# a['k2'].append(i)
# print(a)
# li = [1,2,3,4,5,6,7,8,9]將索引為偶數位對應的值相加並添加到li列表的最后面。
# li = [1,2,3,4,5,6,7,8,9]
# cont = 0
# for i in li:
# if i % 2 ==0:
# cont+=i
# li.append(cont)
# print(li)
