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
]
)
