Python基础知识问答

柔情只为你懂 2021-09-29 15:20 699阅读 0赞

**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中的//，%和 \*\* 运算符

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符<br></th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">//</td> 
   <td>取整除</td> 
   <td>返回商的整数部分, 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0</td> 
  </tr> 
  <tr> 
   <td align="center">%</td> 
   <td>取余（取模）</td> 
   <td>返回除法的余数</td> 
  </tr> 
  <tr> 
   <td align="center">**</td> 
   <td>幂</td> 
   <td>返回x的y次幂</td> 
  </tr> 
 </tbody> 
</table>

**12.在Python中有多少种运算符？解释一下算数运算符。**

python中主要有7种运算符:算术运算符,赋值运算符,关系运算符,逻辑运算符,位运算符,成员运算符,身份运算符等等

<table> 
 <thead> 
  <tr> 
   <th>运算符<br></th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>加</td> 
   <td>1+2=3</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减</td> 
   <td>3-1=2</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘</td> 
   <td>3*2=6</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除</td> 
   <td>6/3=2</td> 
  </tr> 
  <tr> 
   <td>//</td> 
   <td>取整除</td> 
   <td>9.0//2.0=4.0</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取余</td> 
   <td>9.0%2.0=1.0</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>幂</td> 
   <td>返回x的y次幂,2**3=8</td> 
  </tr> 
 </tbody> 
</table>

身份运算符

<table> 
 <thead> 
  <tr> 
   <th align="left">运算符<br></th> 
   <th align="left">描述</th> 
   <th align="left">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">is</td> 
   <td align="left">is 是判断两个标识符是不是引用自一个对象</td> 
   <td align="left"><strong>x is y</strong>, 类似 <strong>id(x) == id(y)</strong> , 如果引用的是同一个对象则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td align="left">is not</td> 
   <td align="left">is not 是判断两个标识符是不是引用自不同对象</td> 
   <td align="left"><strong>x is not y</strong> ， 类似 <strong>id(a) != id(b)</strong>。如果引用的不是同一个对象则返回结果 True，否则返回 False。</td> 
  </tr> 
 </tbody> 
</table>

**13.解释一下Python中的关系运算符**

<table> 
 <thead> 
  <tr> 
   <th>运算符<br></th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>检查两个操作数的值是否相等，如果是则条件变为真。</td> 
   <td>如a=3,b=3则（a == b) 为 true.</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>检查两个操作数的值是否相等，如果值不相等，则条件变为真。</td> 
   <td>如a=1,b=3则(a != b) 为 true.</td> 
  </tr> 
  <tr> 
   <td>&lt;&gt;</td> 
   <td>检查两个操作数的值是否相等，如果值不相等，则条件变为真。</td> 
   <td>如a=1,b=3则(a &lt;&gt; b) 为 true。这个类似于 != 运算符</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>检查左操作数的值是否大于右操作数的值，如果是，则条件成立。</td> 
   <td>如a=7,b=3则(a &gt; b) 为 true.</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>检查左操作数的值是否小于右操作数的值，如果是，则条件成立。</td> 
   <td>如a=7,b=3则(a &lt; b) 为 false.</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。</td> 
   <td>如a=3,b=3则(a &gt;= b) 为 true.</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。</td> 
   <td>如a=3,b=3则(a &lt;= b) 为 true.</td> 
  </tr> 
 </tbody> 
</table>

**14.解释一下Python中的赋值运算符**

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+=</td> 
   <td>加法赋值运算符</td> 
   <td>c += a 等效于 c = c + a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法赋值运算符</td> 
   <td>c -= a 等效于 c = c - a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘法赋值运算符</td> 
   <td>c *= a 等效于 c = c * a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法赋值运算符</td> 
   <td>c /= a 等效于 c = c / a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取模赋值运算符</td> 
   <td>c %= a 等效于 c = c % a</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂赋值运算符</td> 
   <td>c <strong>= a 等效于 c = c</strong> a</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>取整除赋值运算符</td> 
   <td>c //= a 等效于 c = c // a</td> 
  </tr> 
  <tr> 
   <td>=</td> 
   <td>赋值运算符</td> 
   <td>把=号右边的结果给左边的变量 num=1+2*3 结果num的值为7</td> 
  </tr> 
 </tbody> 
</table>

**15.解释一下Python中的逻辑运算符**

<table> 
 <thead> 
  <tr> 
   <th>运算符<br></th> 
   <th>逻辑表达式<br></th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>x and y</td> 
   <td>布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。</td> 
   <td>(a and b) 返回 20。</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>x or y</td> 
   <td>布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。</td> 
   <td>(a or b) 返回 10。</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>not x</td> 
   <td>布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。</td> 
   <td>not(a and b) 返回 False</td> 
  </tr> 
 </tbody> 
</table>

**16.解释一下Python中的成员运算符**

<table> 
 <thead> 
  <tr> 
   <th align="left">运算符</th> 
   <th align="left">描述</th> 
   <th align="left">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">in</td> 
   <td align="left">如果在指定的序列中找到值返回 True，否则返回 False。</td> 
   <td align="left">x 在 y 序列中 , 如果 x 在 y 序列中返回 True。</td> 
  </tr> 
  <tr> 
   <td align="left">not in</td> 
   <td align="left">如果在指定的序列中没有找到值返回 True，否则返回 False。</td> 
   <td align="left">x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。</td> 
  </tr> 
 </tbody> 
</table>

**17 。讲讲Python中的位运算符**

运算符

<table> 
 <thead> 
  <tr> 
   <th align="left">运算符<br></th> 
   <th align="left">描述</th> 
   <th align="left">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">&amp;</td> 
   <td align="left">按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0</td> 
   <td align="left">(a &amp; b) 输出结果 12 ，二进制解释： 0000 1100</td> 
  </tr> 
  <tr> 
   <td align="left">|</td> 
   <td align="left">按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。</td> 
   <td align="left">(a | b) 输出结果 61 ，二进制解释： 0011 1101</td> 
  </tr> 
  <tr> 
   <td align="left">^</td> 
   <td align="left">按位异或运算符：当两对应的二进位相异时，结果为1</td> 
   <td align="left">(a ^ b) 输出结果 49 ，二进制解释： 0011 0001</td> 
  </tr> 
  <tr> 
   <td align="left">~</td> 
   <td align="left">按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。<strong>~x</strong> 类似于 <strong>-x-1</strong></td> 
   <td align="left">(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。</td> 
  </tr> 
  <tr> 
   <td align="left">&lt;&lt;</td> 
   <td align="left">左移动运算符：运算数的各二进位全部左移若干位，由 <strong>&lt;&lt;</strong> 右边的数字指定了移动的位数，高位丢弃，低位补0。</td> 
   <td align="left">a &lt;&lt; 2 输出结果 240 ，二进制解释： 1111 0000</td> 
  </tr> 
  <tr> 
   <td align="left">&gt;&gt;</td> 
   <td align="left">右移动运算符：把"&gt;&gt;"左边的运算数的各二进位全部右移若干位，<strong>&gt;&gt;</strong> 右边的数字指定了移动的位数</td> 
   <td align="left">a &gt;&gt; 2 输出结果 15 ，二进制解释： 0000 1111</td> 
  </tr> 
 </tbody> 
</table>

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