1.列表和元組之間的區別是？
列表和元組都是python內置的集合類型，列表用list表示，元組用tuple表示
list是有序的動態數組，引用不可變但是可以改變元素的個數，列表元素下標從0開始，列表用[ ] 表示，列表相關操作的方法有append()，len(),extend（+）,insert(index, object)等等。
元組與列表類似，但是元組的元素不能修改，用（）表示，Python在顯示只有1個元素的tuple時，會加一個逗號,以免引起歧義，例如 t (1,) 。
2.解釋一下Python中的繼承
python支持多繼承，一個類可以繼承多個父類，父類中非私有的屬性和方法都會被繼承，如果多個父類中有同名方法，在子類調用個方法的時候，調用的是父類類名列表中第一個父類的方法。
子類可以調用mro()查看子類對象查找類的先后順序。
3.Python中的字典是什么？
dict全稱dictionary，在其他語言中也稱為map，使用鍵-值（key-value）存儲，具有極快的查找速度。字典中的key唯一,value可以重復可以為空。set集合相當于沒有值的dict
dict是一個可變類型
- 字典和列表一樣，能夠存儲多個數據
- 列表中找某個元素時，根據下標進行的
- 字典中找某個元素時，根據’名字’（就是冒號:前面的那個值，例如上面代碼中的’name’、‘id’、‘sex’）
- 字典的每個元素由2部分組成，鍵:值。例如 ‘name’:‘班長’ ,'name’為鍵，'班長’為值
若訪問不存在的鍵，則會報錯，如果不確定字典中是否存在某個鍵而又想獲取其值，可以使用get方法，還可以設置默認值：
age = info.get(‘age’, q) # 若info中不存在’age’這個鍵，就返回默認值18
4.請解釋使用*args和kwargs的含義
- 加*的args存放所有未命名的變量參數，args是元組；
- 加**的變量kwargs存放命名參數，如key=value的參數， kwargs為字典。
- *args:表示一組值的集合,普通數據
- **kwargs:表示k-v格式的數據
5.請寫一個Python邏輯，計算一個文件中的大寫字母數量
w
=
open
(
"test.txt"
,
'r'
,
True
)
sum
=
0
while
True
:
ff
=
w
.
read
(
1
)
if
not
ff
:
break
if
ff
.
isupper
(
)
:
sum
+=
1
print
(
"大寫字母個數：%d"
%
sum
)
w
.
close
(
)
6.什么是負索引？
Python中的序列索引可以是正也可以是負。如果是正索引，0是序列中的第一個索引，1是第二個索引。如果是負索引，（-1）是最后一個索引而（-2）是倒數第二個索引。
7.Python區分大小寫嗎？
python嚴格區分大小寫， Ange != ange
8.怎么移除一個字符串中的前導空格？
使用lstrip()刪除字符串中的前導空格
9.怎樣將字符串轉換為小寫？
lower() 大寫轉小寫
upper() 小寫轉大寫
10 .Python中的pass語句是什么？
pass 是空語句，不做任何事情，用做占位語句。為了保持程序結構的完整性。
如果定義一個空函數會報錯，但是是可以用 pass 填充，使程序可以正常運行。
11.解釋一下Python中的//，%和 ** 運算符
|
運算符
|
描述 | 實例 |
|---|---|---|
| // | 取整除 | 返回商的整數部分, 9//2 輸出結果 4 , 9.0//2.0 輸出結果 4.0 |
| % | 取余（取模） | 返回除法的余數 |
| ** | 冪 | 返回x的y次冪 |
12.在Python中有多少種運算符？解釋一下算數運算符。
python中主要有7種運算符:算術運算符,賦值運算符,關系運算符,邏輯運算符,位運算符,成員運算符,身份運算符等等
|
運算符
|
描述 | 實例 |
|---|---|---|
| + | 加 | 1+2=3 |
| - | 減 | 3-1=2 |
| * | 乘 | 3*2=6 |
| / | 除 | 6/3=2 |
| // | 取整除 | 9.0//2.0=4.0 |
| % | 取余 | 9.0%2.0=1.0 |
| ** | 冪 | 返回x的y次冪,2**3=8 |
身份運算符
|
運算符
|
描述 | 實例 |
|---|---|---|
| is | is 是判斷兩個標識符是不是引用自一個對象 | x is y , 類似 id(x) == id(y) , 如果引用的是同一個對象則返回 True，否則返回 False |
| is not | is not 是判斷兩個標識符是不是引用自不同對象 | x is not y ， 類似 id(a) != id(b) 。如果引用的不是同一個對象則返回結果 True，否則返回 False。 |
13.解釋一下Python中的關系運算符
|
運算符
|
描述 | 示例 |
|---|---|---|
| == | 檢查兩個操作數的值是否相等，如果是則條件變為真。 | 如a=3,b=3則（a == b) 為 true. |
| != | 檢查兩個操作數的值是否相等，如果值不相等，則條件變為真。 | 如a=1,b=3則(a != b) 為 true. |
| <> | 檢查兩個操作數的值是否相等，如果值不相等，則條件變為真。 | 如a=1,b=3則(a <> b) 為 true。這個類似于 != 運算符 |
| > | 檢查左操作數的值是否大于右操作數的值，如果是，則條件成立。 | 如a=7,b=3則(a > b) 為 true. |
| < | 檢查左操作數的值是否小于右操作數的值，如果是，則條件成立。 | 如a=7,b=3則(a < b) 為 false. |
| >= | 檢查左操作數的值是否大于或等于右操作數的值，如果是，則條件成立。 | 如a=3,b=3則(a >= b) 為 true. |
| <= | 檢查左操作數的值是否小于或等于右操作數的值，如果是，則條件成立。 | 如a=3,b=3則(a <= b) 為 true. |
14.解釋一下Python中的賦值運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| += | 加法賦值運算符 | c += a 等效于 c = c + a |
| -= | 減法賦值運算符 | c -= a 等效于 c = c - a |
| *= | 乘法賦值運算符 | c *= a 等效于 c = c * a |
| /= | 除法賦值運算符 | c /= a 等效于 c = c / a |
| %= | 取模賦值運算符 | c %= a 等效于 c = c % a |
| **= | 冪賦值運算符 | c = a 等效于 c = c a |
| //= | 取整除賦值運算符 | c //= a 等效于 c = c // a |
| = | 賦值運算符 | 把=號右邊的結果給左邊的變量 num=1+2*3 結果num的值為7 |
15.解釋一下Python中的邏輯運算符
|
運算符
|
邏輯表達式
|
描述 | 實例 |
|---|---|---|---|
| and | x and y | 布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。 | (a and b) 返回 20。 |
| or | x or y | 布爾"或" - 如果 x 是 True，它返回 True，否則它返回 y 的計算值。 | (a or b) 返回 10。 |
| not | not x | 布爾"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。 | not(a and b) 返回 False |
16.解釋一下Python中的成員運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否則返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中沒有找到值返回 True，否則返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
17 。講講Python中的位運算符
運算符
|
運算符
|
描述 | 實例 |
|---|---|---|
| & | 按位與運算符：參與運算的兩個值,如果兩個相應位都為1,則該位的結果為1,否則為0 | (a & b) 輸出結果 12 ，二進制解釋： 0000 1100 |
| | | 按位或運算符：只要對應的二個二進位有一個為1時，結果位就為1。 | (a | b) 輸出結果 61 ，二進制解釋： 0011 1101 |
| ^ | 按位異或運算符：當兩對應的二進位相異時，結果為1 | (a ^ b) 輸出結果 49 ，二進制解釋： 0011 0001 |
| ~ | 按位取反運算符：對數據的每個二進制位取反,即把1變為0,把0變為1 。 ~x 類似于 -x-1 | (~a ) 輸出結果 -61 ，二進制解釋： 1100 0011，在一個有符號二進制數的補碼形式。 |
| << | 左移動運算符：運算數的各二進位全部左移若干位，由 << 右邊的數字指定了移動的位數，高位丟棄，低位補0。 | a << 2 輸出結果 240 ，二進制解釋： 1111 0000 |
| >> | 右移動運算符：把">>"左邊的運算數的各二進位全部右移若干位， >> 右邊的數字指定了移動的位數 | a >> 2 輸出結果 15 ，二進制解釋： 0000 1111 |
18.怎樣獲取字典中所有鍵的列表？
調用字典的keys()，然后遍歷
dict
=
{
"a"
:
22
,
"b"
:
23
,
"c"
:
24
}
for
i
in
dict
.
keys
(
)
:
print
(
i
)
19.怎樣聲明多個變量并賦值？
#1.
a
=
b
=
c
=
1
#2.s
a
,
b
=
45
,
54
#3.使用元組為多個變量賦值
data
=
(
"zhangsan"
,
"China"
,
"Python"
)
name
,
country
,
language
=
data
#4.為多個列表同時賦值
list1
,
list2
=
[
"hello"
,
"world"
]
,
[
"word"
,
"count"
]
20 .為何不建議以下劃線作為標識符的開頭
Python 沒有私有變量的概念，以下劃線__為開頭來聲明一個私有變量。如果變量非私有，不能使用下劃線開頭。
21.一行代碼實現1到100的求和
print
(
sum
(
[
i
for
i
in
range
(
1
,
101
)
]
)
)
22 .詳細描述單例模式的實現
class
Singleton
(
object
)
:
__instance
=
None
__First_init
=
True
def
__init__
(
self
,
name
)
:
if
self
.
__First_init
:
self
.
__First_init
=
False
self
.
name
=
name
print
(
"init"
)
def
__new__
(
cls
,
name
)
:
print
(
"new"
)
# 如果類數字能夠__instance沒有或者沒有賦值
# 那么就創建一個對象，并且賦值為這個對象的引用，保證下次調用這個方法時
# 能夠知道之前已經創建過對象了，這樣就保證了只有1個對象
if
not
cls
.
__instance
:
cls
.
__instance
=
object
.
__new__
(
cls
)
return
cls
.
__instance
def
run
(
self
)
:
print
(
"runing"
)
a
=
Singleton
(
"zs"
)
b
=
Singleton
(
"ls"
)
print
(
id
(
a
)
)
print
(
id
(
b
)
)
print
(
a
.
name
)
print
(
b
.
name
)
日常使用的電腦上都有一個回收站，在整個操作系統中，回收站只能有一個實例，整個系統都使用這個唯一的實例，而且回收站自行提供自己的實例。因此回收站是單例模式的應用。
確保某一個類只有一個實例，而且自行實例化并向整個系統提供這個實例，這個類稱為單例類，單例模式是一種對象創建型模式。
23、詳細描述工廠模式的實現
class
Person
(
object
)
:
def
__init__
(
self
,
name
)
:
self
.
name
=
name
def
work
(
self
,
type
)
:
print
(
self
.
name
,
"開始工作"
)
axe
=
Factory
.
getAxe
(
type
)
axe
.
cut_tree
(
)
class
Axe
(
object
)
:
def
__init__
(
self
,
name
)
:
self
.
name
=
name
def
cut_tree
(
self
)
:
print
(
"使用"
,
self
.
name
,
"砍樹"
)
class
StoneAxe
(
Axe
)
:
def
__init__
(
self
)
:
pass
def
cut_tree
(
self
)
:
print
(
"使用石斧砍樹"
)
class
StreeAxe
(
Axe
)
:
def
__init__
(
self
)
:
pass
def
cut_tree
(
self
)
:
print
(
"使用鋼斧砍樹"
)
# 工廠類
class
Factory
(
object
)
:
@
staticmethod
def
getAxe
(
type
)
:
if
"storn"
==
type
:
return
StoneAxe
(
)
elif
"stell"
==
type
:
return
StreeAxe
(
)
elif
"ju"
==
type
:
return
ju
(
)
else
:
print
(
"參數有誤"
)
class
ju
(
Axe
)
:
def
__init__
(
self
)
:
pass
def
cut_tree
(
self
)
:
print
(
"電鋸砍樹"
)
p
=
Person
(
"zs"
)
p
.
work
(
"ju"
)
Simple Factory模式是Factory Method模式的一種簡單的、特殊的實現。也被稱為靜態工廠模式，通常創建者的創建方法被設計為static方便調用。
1、靜態的工廠類
2、用全局函數改寫工廠類
24、python操作數據庫的步驟
from
pymysql
import
*
conn
=
connect
(
"192.168.200.24"
,
"root"
,
"123"
,
"mydb"
,
3306
)
# 建立連接
cur
=
conn
.
cursor
(
)
# 查詢
# count = cur.execute("select * from emp") # 執行sql 返回影響的行數
# print(count)
# result = cur.fetchall()
# for i in result:
# print(i)
# 一條查詢結果
# result2 = cur.fetchone()
# print(result2)
# 指定個數的查詢結果
# result2 = cur.fetchmany(5)
# print(result2)
# 添加
# count = cur.execute("insert into emp(empno,ename) values(1111,'abcd')")
print
(
count
)
conn
.
commit
(
)
# 提交事務
conn
.
close
(
)
25 、NumPy中幾個熟悉的函數的使用
import
numpy
as
np
print
(
np
.
abs
(
-
1
)
)
# 絕對值
print
(
np
.
sqrt
(
9
)
)
# 平方根
print
(
np
.
square
(
3
)
)
# 平方np ** 2
print
(
np
.
exp
(
2
)
)
# e^x
print
(
np
.
log2
(
2
)
)
# log2^2 底數為2的對數
print
(
np
.
log10
(
10
)
)
# log10^10 底數為10的對數
print
(
np
.
log
(
np
.
e
)
)
# loge^e 自然對數
print
(
np
.
sign
(
-
165
)
,
":"
,
np
.
sign
(
321
)
,
":"
,
np
.
sign
(
0
)
)
# 返回各元素的正負號 1正 0零 -1負
print
(
np
.
ceil
(
3.65
)
)
# 大于等于該值的最小整數
print
(
np
.
ceil
(
-
3.65
)
)
print
(
np
.
floor
(
3.65
)
)
# 小于等于該值的最小整數
print
(
np
.
floor
(
-
3.65
)
)
array
=
np
.
random
.
randint
(
1
,
10
,
9
)
.
reshape
(
3
,
3
)
print
(
array
.
sum
(
)
)
# 所有元素的和 零長度的數組的sum為0
print
(
array
.
sum
(
0
)
)
# 每一列的求和
print
(
array
.
sum
(
1
)
)
# 每一行的求和
list
=
[
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
]
print
(
np
.
mean
(
list
)
)
# 算術平均數 (1+2+3+...+10)/10
# list = []
# print(np.mean(list))# NaN 零長度的數組的mean為NaN
print
(
np
.
max
(
list
)
)
print
(
np
.
min
(
list
)
)
print
(
np
.
argmax
(
list
)
)
# 數組最大值的索引
print
(
np
.
argmin
(
list
)
)
print
(
np
.
cumsum
(
list
)
)
# 所有元素的累計和
print
(
np
.
cumprod
(
list
)
)
# 所有元素的累計積
print
(
"np.modf(100.12) : "
,
np
.
modf
(
100.12
)
)
# 將數組中的小數部分和整數部分以兩個獨立數組的形式返回
print
(
"np.modf(100.72) : "
,
np
.
modf
(
100.72
)
)
print
(
"np.modf(math.pi) : "
,
np
.
modf
(
np
.
pi
)
)
list2
=
[
112
,
113.65
,
125
,
365.56
,
788.98
]
print
(
"np.modf(list2) : "
,
np
.
modf
(
list2
)
)
# np.modf(list2) : (array([0. , 0.65, 0. , 0.56, 0.98]), array([112., 113., 125., 365., 788.]))
# subtract:從第一個數組中減去第二個數組中的元素
list3
=
[
3
,
4
,
5
]
list4
=
[
1
,
1
,
1
]
print
(
np
.
subtract
(
list3
,
list4
)
)
# add:將數組中對應的元素相加
array1
=
np
.
random
.
randint
(
1
,
10
,
9
)
.
reshape
(
3
,
3
)
array2
=
np
.
random
.
randint
(
1
,
10
,
9
)
.
reshape
(
3
,
3
)
print
(
array1
)
print
(
array2
)
print
(
np
.
add
(
array1
,
array2
)
)
# multiply:數組元素相乘(對應元素相乘) 區別于矩陣乘法
print
(
np
.
multiply
(
array1
,
array2
)
)
# diag以一維數組的形式返回方陣的對角線元素
print
(
np
.
diag
(
array1
)
)
print
(
np
.
diag
(
array2
)
)
# dot矩陣乘法
print
(
np
.
dot
(
array1
,
array2
)
)
# trace計算對角線元素的和
print
(
np
.
trace
(
array1
)
)
print
(
np
.
trace
(
array2
)
)
# det 計算矩陣行列式
print
(
np
.
linalg
.
det
(
array1
)
)
print
(
np
.
linalg
.
det
(
array2
)
)
# eig 計算方陣的特征值和特征向量
a2
=
np
.
array
(
[
[
1
,
2
,
3
]
,
[
2
,
3
,
4
]
]
)
# 建立一個二維數組
b2
=
np
.
array
(
[
[
1
,
2
,
3
]
,
[
2
,
3
,
4
]
]
,
dtype
=
int
)
# 可以輸出指定數據類型
# print(np.linalg.eig(a2)) # 返回矩陣a2的特征值與特征向量
矩陣&切片
import
numpy
as
np
# 矩陣的逆
array
=
np
.
random
.
randint
(
1
,
10
,
9
)
.
reshape
(
3
,
3
)
# n*n的矩陣一定會有逆矩陣
# print(array)
# array2 = np.linalg.inv(array)# 生成矩陣的逆
# print(array2)
# 矩陣的乘法
# array3 = np.dot(array2, array)# 矩陣*逆矩陣=單位矩陣
# print(array3)# 單位矩陣:對角線元素為1
# 矩陣轉置
# print(array.T)
# 基本運算
# print(array.sum()) # 所有元素的和
# print(array.sum(0)) # 每一列的求和
# print(array.sum(1)) # 每一行的求和
# 切片
# array = np.random.randint(1, 10, 20).reshape(4, 5)
# # array2 = np.ones(20).reshape(4, 5)# 加減時 reshape中數字與array中一樣
# array2 = np.ones(20).reshape(5, 4)# 矩陣乘法a*b時,要保證a的列數等于b的行數 a:m*p b:p*n
# 切片
array
=
np
.
random
.
randint
(
1
,
10
,
16
)
.
reshape
(
4
,
4
)
print
(
array
)
print
(
"-------分割線---------"
)
# 取出第一行的所有值
print
(
array
[
0
]
)
# 相當于 array[0,:]
print
(
"-------分割線---------"
)
# 取第一列
print
(
array
[
:
,
0
]
)
print
(
"-------分割線---------"
)
# 取第一行和第三行
print
(
array
[
0
:
:
2
,
:
]
)
print
(
"-------分割線---------"
)
# 取第二列和第四列
print
(
array
[
:
:
,
1
:
:
2
]
)
print
(
"-------分割線---------"
)
# 取第一行和第三行的第二列和第四列
print
(
array
[
0
:
:
2
,
1
:
:
2
]
)
print
(
"-------分割線---------"
)
# 遍歷多維數組
for
i
in
range
(
0
,
array
.
shape
[
0
]
)
:
for
j
in
range
(
0
,
array
.
shape
[
1
]
)
:
print
(
array
[
i
]
[
j
]
,
end
=
"\t"
)
print
(
)
array
=
np
.
random
.
randint
(
1
,
10
,
9
)
.
reshape
(
3
,
3
)
print
(
array
)
print
(
np
.
where
(
array
>
5
,
array
,
0
)
)
# 將大于5的值留下來,小于5的用0代替
print
(
array
[
2
]
[
2
]
)
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
