python基础知识

python有三大 序列类型  lsit列表， tuple元组，range范围

list用[] , tuple用()进行创建。 

tuple元组不能修改

在python中不存在i++或者i--，若要使i实现自递增或者递减可以使用(递减同理）

i = i + 1

1. list[]  的切片 [start: end:step] 

list的下标是从0开始。而且当start与end均有数值时，区间为 [start, end)，前包后不包， 切片个数 = fabs(end - start)。 step=1可以省略

切片就是通过索引得到值的过程；c++中叫取值。

dx=[1,2,3,4,6,4,8,5,9]

取单个元素：

dx[0]

取出部分元素：

取出最后3个元素时，dx[6:]

取出全部元素

(1)方法一： dx[:]    一个冒号，从左到右    [1, 2, 3, 4, 6, 4, 8, 5, 9]

(2)方法二：dx[::]   两个冒号，从左到右    [1, 2, 3, 4, 6, 4, 8, 5, 9]

(3)方法三： dx[::-1]               从右到左      [9, 5, 8, 4, 6, 4, 3, 2, 1]

dx[:-1]   输出为： [1, 2, 3, 4, 6, 4, 8, 5]

结论： 

根据step判断是从左到右还是从右到左，然后根据start 到 end的顺序进行输出即可。

start 到 end的方向必须与step一致，如果不一致返回的就是空[] 。 

对于缺省start或者end的情况，缺少的终点对应的索引数据是要获取的。

例子： dy = [1, 2, 3, 4,5, 6, 7, 8, 9]

值	1	2	3	4	5	6	7	8	9
正索引	0	1	2	3	4	5	6	7	8
负索引	-9	-8	-7	-6	-5	-4	-3	-2	-1

dy[2:8] = [3, 4, 5, 6, 7, 8]

dy[2:8:-1] # step = -1. 从右到左，而起始的索引为2→8 ，补偿为+1，与前面step=-1相反 输出为空

dy[8:2]#输出也为空，原因同上

dy[:8] #输出： [1, 2, 3, 4, 5, 6, 7, 8]   缺少起点，及步长，认为step=1，左右到右，所以缺少的就是左侧终点，索引0的数据，所以是

dy[:6:-1] #step=-1 从右到左，end=6，根据缺少的是起点，所以是索引8为起点，得到结果为[9,8]

dy[8:]  #输出 [9]         注意与下面的区别

dy[8:8]#输出为空[]

dy[:8:-1]#输出为空，从右到左，从最右侧的索引8到索引8，输出为空了

dy[8::-1]#输出为[9, 8, 7, 6, 5, 4, 3, 2, 1]     步长为-1，从右到左，缺省为终点，为左侧的索引0，所以是

索引为负的情况时：

dy[-2:-8] # 输出为空，方向与实际方向相反，

dy[-2:-8:-1] # 输出 [8, 7, 6, 5, 4, 3]

dy[-8::-1] # 输出 [2,  1]  缺省的要到终点

dy[-1:] #输出[9]

索引正负混合时：

dy[2:-2] #   step=1 从左到右，输出结果为 [3, 4, 5, 6, 7]

dy[2:-2:-1] # step=-1从右到左，但start:end = 2：-2 方向是从左到右，输出为空

dy[-1:6:-1] #  [9, 8]

多重引用时：

dy[:8][2:5][-1:] #输出为[5]   

# 等价于

y1 = dy[:8] # 输出y1= [1, 2, 3, 4,5, 6, 7, 8, 9]

y2 = y1[2:5] #输出y2= [3, 4,5]

y3 = y2[-1:]# y3=[5]

dy[2+1:3*2:7%3] = dy[3:6:1]=[4,5,6]

python切片操作_I松风水月的博客-CSDN博客_python切片操作方法https://blog.csdn.net/qq_38683460/article/details/127082478

2.range 范围 range(start, stop [,step])   生成一个以step为步长的[开始，结束)的范围, 前包后不包

list(range(11))[10:0:-2]  的取值是多少

该题是2022.11月份的软件设计考试题，

知识点: range(start, stop ,step)

中start起始位置，默认为0

， stop是结束位置，

step是步长，默认为1不可为0；

生成一个以step为步长的[开始，结束)的范围, 前包后不包

例子：range(5)   = range(0,5,1)生成的范围为[0,1,2,3,4]

range(3,6) = range(3,6,1) #范围为[3,4,5]

range(-8,-2,2) #范围[-8,-6,-4]

range(0, -9,-1)的范围 [0, -1, -2, -3, -4, -5, -6, -7, -8]

range(0, -9,-2)的范围 [0,  -2,  -4,  -6,  -8]

解题：range(11)  = range(0, 11, 1)  前包后不包，生成的范围为[0,1,2,3,4,5,6,7,8,9,10]

然后把这个范围x = range(11) #得到x的类型为 type(x)为  <class 'range'>

然后将range类型转换为 list类型，得到list类型 (C++中数组类型)。

y = list(x);#yweilist类型

然后y[10:0:-2] #步长=-2，从右到左，由于start:end都有数据，数据范围为[10, 0)，不到0，

所以结果为[10,8,6,4,2]

range 是可迭代对象而不是迭代器；range 对象是不可变的等差序列。

例子： 100以内能被3整除的数

range(3, 100, 3)

d 

3.tuple元组,用()

元组中的元素不可改变，元素可以是任何类型。

输入：  t = 1,"a", 2  

使用 type(t)检查发现   t的类型为元组 <class 'tuple'>

print(t)时，输出结果为： (1, 'a', 2)   

注意： 上面是带括号的

tt = (3), 使用type(tt)时，输出为 <class 'int'>

ty = (3, )，使用type(ty)时，输出为 <class 'tuple'>， print(ty）时，输出 (3, ) 

元组的话，必须要加逗号, 否则定义是其他类型

3.1创建元组的方式

(1) 使用()

对于有多个元素时，使用 xx = ('a', 'b')

单个元素时， 使用 xy = ('a', )

(2)强制类型转换 tuple

st = tuple( (1, 3, 5))

s = ('a', 'b', ['A', 'B'])

对于访问B时  s[2][1]

访问a时  s[0]

访问b时  s[1]

访问A时  s[2][0]

访问B时  s[2][1]

访问B时  s[2][1]

3.2元组使用场合

1)元组操作比列表list 快，

2)对于不需要修改的用元组，需要修改的用把元组强制转换为list；

3)元组可以用在字典中；

4)元组可以用于字符串的格式化中

Python 元组(Tuple)操作详解 - Smah - 博客园 (cnblogs.com)

4. 字典 dict{}

字典 可以在原内存地址上进行修改。

4.1创建字典

4.1.1创建空字典

mydi = {}   #创建的空字典

4.1.2 使用键值对 创建   

"键" : "值 "      #  ： 前是键，不可重复,，不可改变的对象，不能改变键的内容； ：后是值，具体内容

mydx = {"name":"wang", "addre":"shandong"}

mydx["tel"] = "123445567"    #增加键值对 

mydx["tel"] = "0058"    #修改键值对 

4.1.3 使用元组构建

方法1：

tw=(["first", "0988"] , ["second", "346"] ) #元组

ndict = dict(tw) # 元组强制转换为字典

方法2：

ad = dict(name="qiwsir", age="42")  #

 方法3：

websit={}.fromkeys(("third","fourth"), "facebook")

的

4.1.4 键不可改变

d = {(1,2) : 1}  #输出 字典类型   为  {(1, 2): 1}   键为元组类型(1,2) 不可改变的项

如果改为 dd = {[1,2] : 1}  #输出错误，键不能为 可改变的项 

则输出错误：Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

4.2 字典的基础操作

len(ad) #返回键值对的数量

del ad("name") #删除键值对

ad.clear() #清空键值对，字典还在

ad = { } #将 字典赋值为空，python自动回收这样的垃圾

del ad #删除这个字典，内存中没有了

ad["name"] = "sldfj" #增加键值对

 type(ad["age"]) #查看某个键值的内容类型 

4.3字符串格式化输出

5. 集合set

元素没有序列，元素不可重复，

5.1 定义

s1 = set("qiwisir") #输出为 ： {'r', 'q', 'i', 's', 'w'}     #数据类型  <class 'set'>

s22 = {"a", "b"} #定义的就是集合了

不提倡使用{}进行定义，这样有时候分不出是 集合还是字典。用set创建的集合是可变集合。

dir(set) #查看set中的函数 

s2 = {}  #这种创建的空 默认为字典，如果对s2进行集合的操作是会出错的。

的

5.2基本用法

s1 = set(["a", "b"])

s2 = set(["github", "qiwisir"])

s1.update(s2) #合并其他集合的元素

pop() #无参数，不能带参，删除任意的元素

remove() #删除指定的元素 

clear() #删除所有元素

5.3 不可变集合frozenset

给

ss = frozenset("qiwisir") # 输出 ss为： frozenset({'r', 'q', 'i', 's', 'w'})

 ss.add("python") #此操作错误，输出 AttributeError: 'frozenset' object has no attribute 'add'

不可操作frozenset 

5.4集合运算

1) 是否相等    A == B  或  A ！= B

2) A是否是B的子集

   A < B   返回 true是子集； 还可以用 A.issubset(B) 来判断 

3) 并集合      A  | B  (结果为黑色部分)

4) 交集   A & B 或者   A.intersection(B) (结果为黑色部分)

5) A相对B的差(补)   A - B   A相对B不同的部分(结果为黑色部分)

6) AB的对称差  A.symmetric_difference(B) 

6.逻辑运算

6.1 布尔运算符   

返回True  False

and   与运算

or     或运算 

not    非运算

运算符	描述
[] [:]	下标，切片
**	指数
~ + -	按位取反, 正负号
* / % //	乘，除，模，整除
+ -	加，减
>> <<	右移，左移
&	按位与
^ |	按位异或，按位或
<= < > >=	小于等于，小于，大于，大于等于
== !=	等于，不等于
is    is not	身份运算符
in     not in	成员运算符
not(非)    or(或)    and(与)	逻辑运算符

7语句 

ctrl + / 单行注释   

多行注释用'''  或者 """成对使用

'''

'''

或者

""" 

"""

print("hello","world")# hello world

print("hello, world")  #打印出来的  hello,world

输出带格式的 

    radius = float(input('输入半径：'))
    zhouchang = 3.1415926 * 2 * radius
    area = 3.1415926 * radius * radius
    print('banjing=%f, zho=%f' % (radius, zhouchang))
    print(f'banjing{radius:.1f}, aread{area:.1f}')

type查看变量的类型   id查看内存地址的

7.1 import #引入模板，库

import math  #引入模板，库，引入一个模块

math.pow(3, 2) #结果为  9.0

比如一个函数Fun放在A.py下，main.py调用该函数之前，首先应该 import A

然后main.py中调用 A.Fun(）

如果不想写A.Fun()只想写Fun()，可以用from 引入方法的意思，但需要注意引入的不能和当前空间重名，最好不要这种方式。

main.py开头：from Fun import A

给模块重新命名--as

 import moudleddd as m1

7.2 初始化

x,y,z = 1, "python", ["hello","world"]  #后面的分别给xyz赋值

#x = 1  y = python"  z = ["hello","world"]

交换值 ：交换a,b的值  

  a, b  = b, a  

= 后面开始 对 =等号前面定义的变量进行赋值   

= b 是对变量a 进行赋值   a = b

, a 是对变量b进行赋值    b = a

此处与c++不一致，要注意

7.3链式赋值

x = y = "tjlsd"  # xy的结果一样，内存地址(id一样

7.4 语句

Python中是没有switch-case语句的

语句 必须通过缩进的方式来表示语句块的开始与结束；

缩进用四个空格

7.4.1条件语句if--elif--else 每句带:

a = 8;
if a==8:
   print(a)

    a = 8;
    if a==8:
       print(a)
    x = 10
    y = 1
    if x < y:
        print("x < y")
    elif x == y:
        print("x = = y")
    else:
        print("x > y")

输出结果： 8   x > y

注意：raw_input()函数获得用户在界面上输入的信息， 而通过它得到的虽
然是数字， 但它是字符串类型的， 所以要转化为整数型， 才能用于后面
的比较。

7.4.2 三元操作符  A=Y if X else Z

A=Y if X else Z

如果X为真， 那么就执行A=Y。
如果X为假， 就执行A=Z。

    x = 2
    y = 8
    a = "python" if x > y  else "qisiwisr"
    print(a)
    b = "python" if x < y  else "qisiwisr"
    print(b)

输出结果为：

qisiwisr
python

7.4.3 for循环(for 行尾有:冒号)  for()...else

    ax = "python"
    for i in ax:
        print(i)

或者 下面通过索引的方式  输出都一样，

    ax = "python"
    for i in range(len(ax)):
        print(ax[i])

 输出： 

p
y
t
h
o
n

 

7.4.4 zip, 

计算a, b两个序列对应 下标的

 例子：计算 ab序列对应下标的和

    a = [1, 2, 3, 4, 5]
    b = [9, 8, 7, 6, 5]
    sume = []
    for x,y in zip(a, b):
        sume.append(x + y)
    for i in sume:
        print(i)

输出为：

10
10
10
10
10

7.4.5 enumerate

如果想要得到list表中 元素索引及对应的值

方法1：for循环

    a = [1, 2, 3, 4, 5]
    for i in range(len(a)):
        print(str(i) + "  " +  str(a[i]))

注意将 int 转换为 str类型 字符串类型 

方法2：使用enumerate

    week = ["mon", "tues", "thir"]
    for (i, day) in enumerate(week):
        print(day + " is " +  str(i))

7.4.6 list的简易用法

 

7.4.7 while      while---else

规则：

while  条件 :

    循环体

    i = 0;
    while i < 4:
        print("-----------")
        num = int(input("请您输入0-9任一个数："))  #注意 强制类型转换
        xnum = random.randint(0, 9)
        print(xnum)
        x = 3 - i
        if num == xnum:
            print("运气好")
        elif num > xnum:
            print("财大了")
        else:
            print("猜小了")
        i += 1

 7.4.8   while..else    for..else 

跳出循环

    i = 0;
    while i < 4:
        print("-----------")
        num = int(input("请您输入0-9任一个数："))
        xnum = random.randint(0, 9)
        print(xnum)
        x = 3 - i
        if num == xnum:
            print("运气好")
        elif num > xnum:
            print("财大了")
        else:
            print("猜小了")
        i += 1
    else:
        print("跳出循环了")

    for n in range(99, 1, -1):
        root = math.sqrt(n)
        if root == int(root):
            print (n)
            break
    else:
        print ("Nothing.")

7.4.9 文件

python 推荐使用with 操作文件，防止打开文件后忘记关闭文件。

紧跟with后面的语句被求值后，返回对象的 _init_ ( 方法被调用，这个方法的返回值将被赋值给as后面的变量)。
当with后面的代码块全部被执行完之后，将调用前面返回对象的 _exit_方法,相当于析构函数。
 

 with open('致橡树.txt', 'r', encoding='utf-8') as f:
       print(f.read())

就是把open('致橡树.txt', 'r', encoding='utf-8') 当作f    ； f执行完后，最后调用f的关闭文件操作

7.4.10 with关键字

with 关键字主要是解决上下文环境中产生的异常，是一种上下文管理协议, 简化 try  except  finally。whit只能操作带_enter_ 和_exit_的对象.

8. 函数

python没有函数重载的概念

8.1 函数定义：

注意：def为define的缩写，定义函数的关键词，后面必须紧跟冒号:   否则会报错的

def  函数名(形参1，形参2):

    实现体

8.2 全局变量，局部变量

作用域不同，

def fun():
    global c
    c = 10
    print(c)  # 10


if __name__ == '__main__':
    c = 100
    fun()
    print(c)  # 10

t通过global定义全局变量，如果变量没定义，则使用c=10进行赋值。

不建议使用过多的全局变量，减少代码的耦合度。 

局部变量优先级高于全局变量，如果函数内部有一个与全局变量同名的变量，且没有global标识时，这个变量就是新定义的局部变量。

8.3命名空间 Namespace

8.4参数收集：解决参数个数不确定的情况，   可变参数

8.4.1 以通过*arg，以元组的形式收集起来

def func(x, *arg):
    print(x)
    result = x
    for i in arg:
        result += i
    return result
#调用
print(func(1,2,3,4,5,6,7,8,9)) # 输出1    45

也可以定义成

def func( *arg):
    result = 0
    for i in arg:
        result += i
    return result
#调用
print(func(1,2,3,4,5,6,7,8,9)) # 输出45  与上面不同

也可以不给*arg进行传值 

def func(x,  *arg):
    result = x
    for i in arg:
        result += i
    print(arg) #输出() 空的元组
    return result
#调用
print(func(1))
#输出 ()    1   

8.4.2 以*arg形式写调用参数 

#定义函数
def add(x, y):
    return x + y

#函数调用
bar = (2, 3)
    print(add(* bar))  #输出 5

注意： bar中 元组中元素个数必须与 定义函数形参的个数一致才行；

8.4.4 递归函数

例子：python版本 斐波拉契函数， 真简单啊

def fib(n):
    memo = {0:0, 1:1} #定义字典
    if not n in memo:
        memo[n] = fib(n - 1) +  fib(n - 2)
    return memo[n]

python中尽量少用递归，不小心会一直进行下去。。。

8.4.5 lambda表达式

定义：td =  lambda   形参列表:实现体

    lm = lambda x, y: x + y
    print(lm(4, 6))
#注意，如果缩进不对时，会有提示
#IndentationError: unindent does not match any outer indentation level

 8.4.6 map

格式：  map(func, seq) 

func 函数 , seq 序列

例子：

def add(x):
    x += 3
    return x


#调用地方
    numbers = [0,1,2,3,4,5,6,7,8,9]
    xi = map(add, numbers)
    x3 = map(lambda x: x+3, numbers)

    xx = list(x3)

#xi 与 x3的输出结果是一致的

8.4.7 reduce

逐个元素进行运算

在python3中使用会报错  'reduce' is not defined， reduce 移除了内建函数中，放入了模块 functools中

    #头上 
from functools  import reduce

    num = [1, 2, 3, 4, 5]
    print(reduce(lambda x, y:x+y, num)) #输出 15  实现是累加和

也可以用for

    #注意缩进哈
    sum = 0;
    for i in num:
        sum += i
    print(sum)

8.4.8 filter过滤器

filter(过滤条件， 序列)

    num = [1, 2, 3, 4, 5]
    yy= filter(lambda x:x > 3, num)
    s = list(yy)

8.4.9 多个模块中有相同名称的函数时

A.py中

def innn()

    print('你好innn')

B.py中

def innn()

    print('你好innn')

方法1：
test.py中

import A 
import B

A.innn()
​​​​​​​B.innn()


或者---此方法是给模块重新命名

test.py中

import A  as im1
import B  as im2

im1.innn()
​​​​​​​im2.innn()

方法2：

test.py中
from A import innn
innn()
from B import innn
innn()

推荐方法1  这种方法比较好

9 类

9.1 类的格式

class  AA:

     实现体

实例化时： a = AA() #后面的()要有的

类型为：classobj 

例子：

__metaclass__ = type # 新式类，下面是一个新类

class person(object): #定义类
    name = "wangqinghua"
    def __init__(self, name): #初始化函数  python中有__new__是构造函数
        self._name =  name
    def getName(self):
        return self._name
    def color(self, color):
        print("new color")




#实例化：
    gir = person('lihua')
    print(gir.getName())

self： python类中规定，函数的第一个参数self是实例对象本身，

就像c++中 person self;一样self是一个实力对象，所以，在类的函数中，可以看到self._name是指类中定义的变量_name。

object: 继承的类，也可以不写

init： 创建类的实例对象的时候，

也就是gir = person(‘lihua’)时，会通过init函数，把变量name传递给类中定义的变量name也就是self.name，相当于init函数中，self.name = name  （也可以说是通过init函数，把形参变量与类中定义的变量进行绑定）

init中注意与函数重载的配套使用

def __init__(self, name='Lisa'):

_name是私有的，是被保护的

对于变量私有，一般是以下划线_开头的，_name就是私有的，是被保护的。

9.2 @property 装饰器

对于受保护的变量，不建议外部直接调用，而是通过setter和getter，方法来调用类中私有的变量。 将一个属性转换为方法是通过在函数定义前加一个@property

    # 访问器 - getter方法
    @property
    def name(self):
        return self._name

    # 修改器 - setter方法
    @name.setter
    def name(self, name):
        self._name = name

不能用gir._name = ‘lily’ 进行直接赋值。

9.3 __slots__

但是如果我们需要限定自定义类型的对象只能绑定某些属性，可以通过在类中定义__slots__变量来进行限定。需要注意的是__slots__的限定只对当前类的对象生效，对子类并不起任何作用。

class Person(object):

    # 限定Person对象只能绑定_name, _age和_gender属性
    __slots__ = ('_name', '_age', '_gender')

    def __init__(self, name, age):
        self._name = name
        self._age = age

    #getter方法
    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)


def main():
    person = Person('王大锤', 22)
    person.play()
    person._gender = '男'
    # AttributeError: 'Person' object has no attribute '_is_gay'
    # person._is_gay = True

9.4 静态方法@staticmethod

from math import sqrt


class Triangle(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    @staticmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

    def perimeter(self):
        return self._a + self._b + self._c

    def area(self):
        half = self.perimeter() / 2
        return sqrt(half * (half - self._a) *
                    (half - self._b) * (half - self._c))


def main():
    a, b, c = 3, 4, 5
    # 静态方法和类方法都是通过给类发消息来调用的
    if Triangle.is_valid(a, b, c):
        t = Triangle(a, b, c)
        print(t.perimeter())
        # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数
        # print(Triangle.perimeter(t))
        print(t.area())
        # print(Triangle.area(t))
    else:
        print('无法构成三角形.')


if __name__ == '__main__':
    main()

静态方法就是在构造类对象实例之前的一个判断函数。 如果判断函数符合构造类对象的条件，就可以直接构造类对象了。 t = Triangle(a, b, c) 就叫构造类对象

9.5类方法@classmethod   不太懂

和静态方法比较类似，Python还可以在类中定义类方法，，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象。

from time import time, localtime, sleep


class Clock(object):
    """数字时钟"""

    def __init__(self, hour=0, minute=0, second=0):
        self._hour = hour
        self._minute = minute
        self._second = second

    @classmethod
    def now(cls):
        ctime = localtime(time())
        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)

    def run(self):
        """走字"""
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    def show(self):
        """显示时间"""
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)


def main():
    # 通过类方法创建对象并获取系统时间
    clock = Clock.now()
    while True:
        print(clock.show())
        sleep(1)
        clock.run()


if __name__ == '__main__':
    main()

9.6类之间的关系 继承，多态

9.6.1 继承

父类 也叫超类 或 基类

 

 UML中

参考：UML参考

UML类图（继承、实现、关联、依赖、组合、聚合），你还傻傻分不清吗？ - 知乎 (zhihu.com)https://zhuanlan.zhihu.com/p/424852966
 

 9.6.2 多态

定义抽象类

from abc import ABCMeta, abstractmethod


class Pet(object, metaclass=ABCMeta):
    """宠物"""

    def __init__(self, nickname):
        self._nickname = nickname

    @abstractmethod
    def make_voice(self):
        """发出声音"""
        pass

定义子类

class Dog(Pet):
    """狗"""

    def make_voice(self):
        print('%s: 汪汪汪...' % self._nickname)


class Cat(Pet):
    """猫"""

    def make_voice(self):
        print('%s: 喵...喵...' % self._nickname)


def main():
    pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]
    for pet in pets:
        pet.make_voice()


if __name__ == '__main__':
    main()

Pet是一个抽象类，通过abc模块的ABCMeta元类和abstractmethod包装器来达到抽象类的效果，如果一个类中存在抽象方法那么这个类就不能够实例化（创建对象）

 父类，子类的继承例子参考，子类可重写父类中定义的函数

Python-100-Days/09.面向对象进阶.md at master · jackfrued/Python-100-Days · GitHub

10. 异常处理

11.numpy模块的使用

安装步骤请参考python 安装、配置、使用 xlrd模块、numpy模块_开心大爆炸的博客-CSDN博客https://blog.csdn.net/u012719076/article/details/131779252

1)数组可以通过索引读出一系列的数据

    aa = np.array([1, 2, 3, 4, 5, 6]) #数组
    b = np.array([0, 2, 4])           #索引
    zz = aa[b]
    print(zz)                         #[1 3 5]  输出的就是b索引的对应的aa数组中的内容

2）统计数组中非零的个数及对应的索引值

    aa = np.array([1, 0, 3, 0, 5, 0, 2])#数组
    num = np.count_nonzero(aa) #统计非零个数
    print(f'数组中非零个数{num}') #输出：    数组中非零个数4
    indexNozero = np.nonzero(aa)

    print(aa[indexNozero])     #输出：     [1 3 5 2]

count_nonzero(aa) #统计非零个数

np.nonzero(aa) #返回非零元素的索引值

aa[indexNozero]中 indexNozero为索引值序列，

参考：

一定要看一下

jackfrued大佬的文章

GitHub - jackfrued/Python-100-Days: Python - 100天从新手到大师https://github.com/jackfrued/Python-100-Days

https://blog.csdn.net/xxue345678/article/details/130625300https://blog.csdn.net/xxue345678/article/details/130625300