Python基础学习

---

Python简介

---

Python集成开发环境

PyCharm	功能强大，有着丰富的第三方库
Spyder	一款为了数据科学工作流做了优化的开源Python集成开发环境。它是附在Anaconda软件包管理器发行版中的
Thonny	针对新手的一款集成开发环境
Sublime Text	Sublime Text 支持Python代码编译同时兼容所有平台
Atom	兼容所有平台的Atom被称为“21世纪可破解的文本编译器“
VS Code	轻量级，功能强大
Kite	一款是基于AI技术开发的程序辅助软件，不仅仅是代码补全
Vim	–
Eclipse with PyDev	–
GNU Emacs	是可扩展，自定义的文本编译器，甚至是更多的功能。Emacs的核心是Emacs Lisp解析器，但是支持文本编辑
VS	支持各种平台的开发，并且附带了自己的扩展插件市场

Python语言的特点

（1）与之前的编程语言相比，Python完成任务的效率较高。
（2）相对于Java、C++等编程语言，更加容易上手，入门快，简单易懂
（2）免费且开源
（3）具有丰富的库

Python语言涉及领域

（1）Web开发。利用Python Web做出前端界面。
（2）网络爬虫。从网络上获取有用的数据或信息，可以节省大量人工时间
（3）计算与数据分析。不仅支持各种数学运算，还可以绘制高质量的2D和3D图像。和科学计算领域最流行的商业软件Matlab相比，Python比Matlab所采用的脚本语言的应用范围更广泛，可以处理更多类型的文件和数据。
（4）人工智能。Python在人工智能大范畴领域内的机器学习、神经网络、深度学习等方面都是主流的编程语言，得到广泛的支持和应用
（5）自动化运维。Python编写的系统管理脚本在可读性、性能、代码重用度、扩展性几方面都优于普通的shell脚本。
（6）云计算。Python的最强大之处在于模块化和灵活性，而构建云计算的平台的IasS服务的OpenStack就是采用Python的，云计算的其他服务也都是在IasS服务之上的。
（7）网络编程。Python提供了丰富的模块支持sockets编程，能方便快速地开发分布式应用程序。
（8）游戏开发。很多游戏使用C++编写图形显示等高性能模块，而使用Python或者Lua编写游戏的逻辑、服务器。相较于Python，Lua的功能更简单、体积更小，然而Python则支持更多的特性和数据类型。
（9）桌面软件。Python在图形界面开发上很强大，可以用tkinter/PyQT框架开发各种桌面软件！
（10）金融分析。

初步

（1）Python语言不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量，但是python属于强类型语言，python编译器会根据赋值或运算来自动推断变量类型。

（2）Python同时也是一种动态类型语言，变量的类型也是可以随时变化的。

print("Hello World\n 你好 Python！")

x="hello world"
print(type(x)) #查看x的对应类型

name=input("请输入姓名：")
print(name)


isinstance(3,int) #测试对象是否为某个类型的实例

x=3
print(x**2) #输出为9  x的平方

x=4
y=3
print("x=%d,y=%d" %(y,x))

a=1+2j
b=complex(4,5) #表示复数4+5j
print(a+b)  

t=True  # bool变量首字母要大写
bool(0) # False

a=1
id(a) #获得a的内存地址

逻辑运算符：
not（逻辑非） and（逻辑与）  or（逻辑或）

#用单引号、双引号、三引号括起来的符号系列成为字符串

False+3       #False当0处理

"a"*10        # aaaaaaaaaa

3/3 5//3     # /表示除法 //表示整除

3 in [1,2,3]       		#True
{
     1,2,3}|{
     4,5,6} 		#并集
{
     1,1,4}&{
     4,5,6} 		#交集 
{
     1,4,5}^{
     1,4,5}   		#对称差

@  #矩阵相乘运算符

#双分支结构
a=5
print(6) if a>3 else print(5)

#获取当前时间
import time
start=time.time()

举例

输入三条边的长度，判断是否能构成三角形

a=float(input('输入三角形边长1：'))
b=float(input('输入三角形边长2：'))
c=float(input('输入三角形边长3：'))
if a+b<c and a+c <b and b+c<a:
    print("三条边不能构成三角形")
else:
    L=(a+b+c)/2
    S=(L*(L-a)*(L-b)*(L-c))**0.5
    print('三角形的面积为 %0.2f' %S);

求某人年龄的大小

x=int(input("请输入一个人的出生年份:"))
y=2020-x
print(y)

比较a和b的大小

a=int(input("请输入a的值:"))
b=int(input("请输入b的值："))
if (a>b):
 print("a的值比b大,为%d" %a);
elif (a==b):
 print("a的值和b的一样大");
else:
 print("b的值比a大,为%d" %b);    
      

输入一个年份判断是不是闰年

year=int(input("请输入年份："))
if (year%400==0 or(year%4==0 and year%100 !=0)):
     print("你输入的%d为闰年"% year)
else:
     print("你输入的%d为平年"% year)

输入三个数，从大到小排列

a=int(input("请输入a的值："))
b=int(input("请输入b的值："))
c=int(input("请输入c的值："))
if a<b:
    (a,b)=(b,a)
if a<c:
     (a,c)=(c,a)
if b<c:
     (b,c)=(c,b)
print(a,b,c)     
     

输入分数，判断是否会挂科

score=float(input("请输入学生成绩："))
if score>=90 and score<=100:
     print("优")
elif score>=80 and score <90:
     print("良")
elif score>=70 and score <80:
     print("中")
elif score>=60 and score<70:
    print("及格")
else:
     print("不及格")

求出1-100内的奇数之和和偶数之和

sum_all=0
sum_double=0
sum_odd=0
for i in range(1,101):
   sum_all+=i;
   if(i%2==0):
       sum_double+=i
   sum_odd=sum_all-sum_double
print("奇数之和为%d,偶数之和为%d"%(sum_odd,sum_double)) 

多次输入学生成绩，按Q或q结束，统计学生的个数和平均成绩

num=0
mark=0
average=0
while True:
      grade=input("请输入学生的成绩：")
      if grade=='Q' or grade=='q':
          break;
      if float(grade)<0 or float(grade)>100:
          print("请重新输入：")
          continue
      num+=1
      mark+=float(grade)
      average=mark/num
print("输入学生的人数为：%d,平均成绩为%0.2f"%(num,average))       
       

输入圆的半径r，计算并输出圆的周长和面积

import math
r=float(input("请输入圆的半径r："))
c=2*math.pi*r
s=math.pi*r*r
print("圆的周长为%.2f,圆的面积为%.2f" %(c,s))

创建两个变量，一个指向你的姓，一个指向你的名，然后使用字符串变量替换（站位）的方法输出一个带有你姓名的句子（如：“你好，张英！”）。

surname=(input("请输入你的姓:"))
name=(input("请输入你的名字:"))
pn=surname+name
print("你好,%s" %pn)

str1="张"
str2="英"
print('''"你好，%s%s!"'''%(str1,str2))
print(f'"你好，{str1}{str2}!"')

编写程序实现打印9*9乘法表

for a in range(1,10):
    b = 1
    while b <= a:
        print('%d*%d=%d' % (b, a, a * b), end="\t")
        b += 1
    print()

猜数游戏： 1、随机出一个数（1-10之间） 2、用户输入一个数 3、猜对则提示WON 猜错继续，最猜三次

import random
num=random.randint(1,10)
count=0
while(count<3):
    a=int(input("请输入一个数："))
    print(num)
    if(a==num):
        print("You win ！")
        break;
    else:
        count+=1
        continue

计算100内最大素数

for n in range(100,1,-1):
 for i in range(2,n):
     if n%i==0:
         break
 else:
    print(n)
    break

列表中使用“+”和append()函数的区别？速度如何？写出测试代码。

+：只能在两个列表之间操作，将两个list相加，会返回到一个新的list对象，不能添加非列表对象，性能问题要考虑。

append():append()的参数被视为对象 函数用于在列表末尾添加新的对象，该方法无返回值，但是会修改原来的列表。

append的速度比”+”的速度快
测试代码：

import time

sum=[]
start=time.time()
for i in range(10000):
   sum=sum+[i]
print(len(sum),',“+”执行消耗时间：',time.time()-start)

sum=[]
start=time.time()
for i in range(10000):
   sum.append(i)
print(len(sum),',“append”执行消耗时间：',time.time()-start)

#或者

from timeit import Timer

def list_append():
    lists=[]
    for i in range(1000):
        lists.append(i)
def list_add():
    lists = []
    for x in range(1000):
        list1 = [x]
        lists =lists+list1

add_time=Timer('list_add()','from __main__ import list_add')  
print('"+"插入列表时间：',add_time.timeit(1000))

append_time=Timer('list_append()','from __main__ import list_append')  
print('append插入列表时间：',append_time.timeit(1000))

列表的删除函数有哪些？写代码将x = [3,2,1,2,3,3,3]中的3删除

1.列表名.remove(要删除的值) 举例: lists.remove(lists[6]) 2.列表名.pop(元素的索引) 举例： lists.pop(6) 3.del(删除值) 举例： del(lists[6]) or del lists（删除列表） 4.列表名.clear() #清空列表 举例 lists.clear()

x=[3,2,1,2,3,3,3]
for i in x[::]:
    if i==3:
        x.remove(i)
print(x)        

使用列表推导式实现0、1、2任意两个元素的元组组合

list1=[(i,j) for i in range(3) for j in range(3) if i!=j] 
print(list1)  #实现0、1、2任意两个元素的元组组合
#或者
list1=[i for i in range(0,3)]
list2=[i for i in range(0,3)]
list_com=[]
list_end=[]
for i in  range(len(list1)):
   for j in range(len(list2)):
    if(i!=j):   
     list_com.append((i,j))
     list_end=tuple(list_com)
print(list_end)    

首先生成包含1000个随机字符的字符串，然后统计每个字符的出现次数。（使用字典）

import string
import random
x= string.ascii_letters + string.digits + string.punctuation
y = [random.choice(x) for i in range(1000)] 
z=''.join(y)
data = dict() 
for ch in z:
    data[ch] = data.get(ch,0) + 1   #get(ch,0) 返回ch出现的次数，若没有返回0
print(data)   

举例说明集合的交、并、差和对称差集的求法。（两种不同的方法，|、&、-、^和union()、intersection()、difference()、symmetric_difference()）

x= {
     1, 2, 3, 4,8,7,9}
y= {
     1, 4, 5,10,7,13}
while True:
    flag=input("请输入你选择的操作：")
    if(flag=="a"):
        print('交集')
        print(x & y)
        print(x.intersection(y))
    elif(flag=="b"):
        print('并集')
        print(x | y)
        print(x.union(y))
    elif(flag=="c"):
        print('差集')
        print(x - y)
        print(x.difference(y))
    elif(flag=="d"):
        print('对称差分集')
        print(x ^ y)
        print(x.symmetric_difference(y))
    else:
        print("非法操作！")
        break

使用“insert()”和extend()函数的区别？测试insert()和append（）函数速度

insert()和extend()都是在列表的尾部插入数据，区别：

insert()将要传入的参数视为一个列表元素去处理，其参数有两个，第一个参数是索引点，即插入的位置，第二个参数是插入的元素。

extend()函数会将传入的参数视为列表，只接受一个参数，插入列表元素不一定是同类型，并将该列表的每个元素一一逐个插入到原列表尾部，如果该参数不是列表，将报错。

测试代码：

import time

def Insert():
    a=[]
    for i in range(10000):
         a.insert(0,i)

def Append():
    a=[]
    for i in range(10000):
        a.append(i)

start=time.time()
for i in range(10):
    Insert()
print('Insert:',time.time()-start)

start=time.time()
for i in range(10):
    Append()
print('Append:',time.time()-start)

#或者
from timeit import Timer

def list_append():
    lists=[]
    for i in range(1000):
        lists.append(i)


def list_insert():
    lists=[]
    for i in range(1000):
        lists.insert(0,i)

append_time=Timer('list_append()','from __main__ import list_append')  
print('append插入列表时间：',append_time.timeit(1000))

insert_time=Timer('list_insert()','from __main__ import list_insert')  
print('insert插入列表时间：',insert_time.timeit(1000))   

过滤a = [-1,-4,6,7.5,-2.3,12,9,-11]，使a中的元素都>0.

a=[-1,-4,6,7.5,-2.3,12,9,-11]
b=[]
for i in a:
    if i>0:
         b.append(i)
print(b)        

编写程序，输入两个集合 setA 和 setB，分别输出它们的交集、并集和差集 setA-setB

setA = {
     4, 5, 6, 7}
setB = {
     4, 5, 9, 10, 6}

print(' setA 和 setB交集:')
print(setA & setB)
print(setA.intersection(setB))

print(' setA 和 setB并集:')
print(setA | setB)
print(setA.union(setB))

print(' setA 和 setB差集:')
print(setA - setB)
print(setA.difference(setB))

编写程序，输入一个大于 2 的自然数，然后输出小于该数字的所有素数组成的集合。

a=int(input("请输入一个大于2的自然数："))
lst=[]
if a<=2:
    print("请输入大于2的自然数！")
for i in  range(1,a+1,1):
   for j in range(2,i):
       if i%j==0:
           break
   else:
        lst.append(i)
print(lst)        

阿凡提与国王比赛下棋，国王说要是自己输了的话阿凡提想要什么他都可以拿得出来。阿凡提说那就要点米吧，棋盘一共64个小格子，在第一个格子里放1粒米，第二个格子里放2粒米，第三个格子里放4粒米，第四个格子里放8粒米，以此类推，后面每个格子里的米都是前一个格子里的2倍，一直把64个格子都放满。需要多少粒米呢？

print(sum([2**x for x in range(64) ]))

# 或者：
# sum=0
# for i in range(64):
#     sum+=2**i
# print(sum)
 

测试list列表中insert和append的执行速度

timeit模块
timeit模块可以用来测试一小段Python代码的执行速度

class timeit.Timer(stmt='pass',setup='pass',timer=<timerfunction>)
Timer是测量小段代码执行速度的类：其中stmt参数是要测试的代码语句（statment）；
setup参数是运行代码时需要的设置；timer参数是一个定时器函数与平台有关通常保持默认

使用方法：
timeit.Timer.timeit(number=1000000)
timeit.Timer的对象求出后，调用其timeit()方法：number参数是测试代码时的测试次数，默认为1000000次，返回一个float类型的秒数。


#coding=utf-8
from timeit import Timer

def append_list():
    li=[]
    for i in range(10000):
        li.append(i)


def insert_list():
    li=[]
    for i in range(10000):
        li.insert(0,i)

append_time=Timer('append_list()','from __main__ import append_list')  #求出timeit.Timer的对象
print('append插入列表时间：',append_time.timeit(1000))

insert_time=Timer('insert_list()','from __main__ import insert_list')  #求出timeit.Timer的对象
print('insert插入列表时间：',insert_time.timeit(1000))


结果:
append插入列表时间： 0.7346160988088778
insert插入列表时间： 18.13291039210702

python 去除列表中小于某个数的值

实现一：新申请一个数组

nums = [2,3,4,10,9,11,19,14]
newnums=[]
for i in nums:
    if i>=5:
           newnums.append(i)
newnums

实现方法二：利用列表推导式

nums = [2,3,4,10,9,11,19,14]
newnums=[i for i in nums if i>=5]
newnums

实现方法三：filter()函数

nums = [2,3,4,10,9,11,19,14]
newnums=list(filter(lambda x:x>=5, nums))
newnums

计算100以内素数之和

#找出100内所有素数
ls = [];
for i in range(100):
    if i < 2:
        continue;
 
    #难点：
    #1.range(2,2) 返回空值，直接跳过循环，未执行break,else语句会被执行
    #2.for.j循环执行完毕后，如果未找到满足i%j==0的数值，证明其是素数，break不会被执行，else会被执行；如果找到i%j==0的数值，证明其不是素数，break会被执行，else则不会被执行；
    for j in range(2, i):      
        if i%j == 0: 
            #print("{0}不是素数".format(i));
            break;
    else:
        #print("{0}是素数".format(i));
        ls.append(i);
print(ls);
 
#求和
s = 0;
for k in ls:
    s += k;
print(s);
#运行结果
#[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
#1060

用zip方法把两个列表打包成“一对儿”（元组or字典）

把[x,y,z] [1,2,3]合并成[(x,1),(y,2),(z,3)]。我们可以使用for循环的方法来实现

list1 = ['x','y','z']
list2 = [1,2,3]
list_m = []
for i in range(len(list1)):
	tuple_temp = (list1[i],list2[i])
	list_m.append(tuple_temp)
print(list_m)

直接生成方式：
这里就要用到zip（打包）函数，它是python的一个内置函数，用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果使用dict方法，还可以生成字典，这个字典的键为第一个列表中的元素，值为第二个列表中的元素。

list1 = ['x','y','z']
list2 = [1,2,3]
list_m = list(zip(list1,list2))
list_d = dict(zip(list1,list2))
print(list_m)
print(list_d)

对python中的pop函数和append函数详解

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

pop()方法语法：list.pop(obj=list[-1])

obj – 可选参数，要移除列表元素的对象。

返回值：该方法返回从列表中移除的元素对象。

实例

以下实例展示了 pop()函数的使用方法：

aList = [123, 'xyz', 'zara', 'abc'];
print "A List : ", aList.pop();
print "B List : ", aList.pop(2);

以上实例输出结果如下：

A List : abc
B List : zara

append()函数：Python列表append()方法用于将传入的对象附加(添加)到现有列表中。
语法：list.append(obj)
参数：obj - 这是要添加到列表中的对象。
返回值：此方法不返回任何值，但更新现有列表。

#!/usr/bin/python3
list1 = ['C++', 'Java', 'Python']
list1.append('C#')
print ("updated list : ", list1)

#运行结果
updated list : ['C++', 'Java', 'Python', 'C#']

python实现简单计算器

#  *_* coding:utf8 *_*
import tkinter
from functools import partial

# 按钮输入调用
def get_input(entry, argu):
    # 从entry窗口展示中获取输入的内容
    input_data = entry.get()

    # 合法运算符 : + - * / -- ** // +-
    # ------------ 输入合法性判断的优化 ------------
    # 最后一个字符不是纯数字(已经有算数符号),原窗口值不为空,且输入值为运算符
    # if not input_data[-1:].isdecimal() and (not argu.isdecimal()):
    #     if input_data[-2:] in ["--", "**", "//", "+-"]:
    #         return
    #     if (input_data[-1:] + argu) not in ["--", "**", "//", "+-"]:
    #         return
    # ------------------------------------------------

    # 出现连续+，则第二个+为无效输入，不做任何处理
    if (input_data[-1:] == '+') and (argu == '+'):
        return
    # 出现连续+--，则第三个-为无效输入，不做任何处理
    if (input_data[-2:] == '+-') and (argu == '-'):
        return
    # 窗口已经有--后面字符不能为+或-
    if (input_data[-2:] == '--') and (argu in ['-', '+']):
        return
    # 窗口已经有 ** 后面字符不能为 * 或 /
    if (input_data[-2:] == '**') and (argu in ['*', '/']):
        return

    # 输入合法将字符插入到entry窗口结尾
    entry.insert("end", argu)

# 退格(撤销输入)
def backspace(entry):
    input_len = len(entry.get())
    # 删除entry窗口中最后的字符
    entry.delete(input_len - 1)

# 清空entry内容(清空窗口)
def clear(entry):
    entry.delete(0, "end")

# 计算
def calc(entry):
    input_data = entry.get()
    # 计算前判断输入内容是否为空;首字符不能为*/;*/不能连续出现3次;
    if not input_data:
        return

    clear(entry)

    # 异常捕获，在进行数据运算时如果出现异常进行相应处理
    # noinspection PyBroadException
    try:
        # eval() 函数用来执行一个字符串表达式，并返回表达式的值；并将执行结果转换为字符串
        output_data = str(eval(input_data))
    except Exception:
        # 将提示信息输出到窗口
        entry.insert("end", "Calculation error")
    else:
        # 将计算结果显示在窗口中
        if len(output_data) > 20:
            entry.insert("end", "Value overflow")
        else:
            entry.insert("end", output_data)


if __name__ == '__main__':

    root = tkinter.Tk()
    root.title("Calculator")

    # 框体大小可调性，分别表示x,y方向的可变性；
    root.resizable(0, 0)

    button_bg = 'orange'
    math_sign_bg = 'DarkTurquoise'
    cal_output_bg = 'YellowGreen'
    button_active_bg = 'gray'

    # justify:显示多行文本的时候, 设置不同行之间的对齐方式，可选项包括LEFT, RIGHT, CENTER
    # 文本从窗口左方开始显示，默认可以显示20个字符
    # row：entry组件在网格中的横向位置
    # column：entry组件在网格中的纵向位置
    # columnspan:正常情况下,一个插件只占一个单元;可通过columnspan来合并一行中的多个相邻单元
    entry = tkinter.Entry(root, justify="right", font=1)
    entry.grid(row=0, column=0, columnspan=4, padx=10, pady=10)

    def place_button(text, func, func_params, bg=button_bg, **place_params):
        # 偏函数partial，可以理解为定义了一个模板，后续的按钮在模板基础上进行修改或添加特性
        # activebackground：按钮按下后显示颜place_params色
        my_button = partial(tkinter.Button, root, bg=button_bg, padx=10, pady=3, activebackground=button_active_bg)
        button = my_button(text=text, bg=bg, command=lambda: func(*func_params))
        button.grid(**place_params)

    # 文本输入类按钮
    place_button('7', get_input, (entry, '7'), row=1, column=0, ipadx=5, pady=5)
    place_button('8', get_input, (entry, '8'), row=1, column=1, ipadx=5, pady=5)
    place_button('9', get_input, (entry, '9'), row=1, column=2, ipadx=5, pady=5)
    place_button('4', get_input, (entry, '4'), row=2, column=0, ipadx=5, pady=5)
    place_button('5', get_input, (entry, '5'), row=2, column=1, ipadx=5, pady=5)
    place_button('6', get_input, (entry, '6'), row=2, column=2, ipadx=5, pady=5)
    place_button('1', get_input, (entry, '1'), row=3, column=0, ipadx=5, pady=5)
    place_button('2', get_input, (entry, '2'), row=3, column=1, ipadx=5, pady=5)
    place_button('3', get_input, (entry, '3'), row=3, column=2, ipadx=5, pady=5)
    place_button('0', get_input, (entry, '0'), row=4, column=0, padx=8, pady=5,
                 columnspan=2, sticky=tkinter.E + tkinter.W + tkinter.N + tkinter.S)
    place_button('.', get_input, (entry, '.'), row=4, column=2, ipadx=7, padx=5, pady=5)

    # 运算输入类按钮(只是背景色不同)
    # 字符大小('+','-'宽度不一样,使用ipadx进行修正)
    place_button('+', get_input, (entry, '+'), bg=math_sign_bg, row=1, column=3, ipadx=5, pady=5)
    place_button('-', get_input, (entry, '-'), bg=math_sign_bg, row=2, column=3, ipadx=5, pady=5)
    place_button('*', get_input, (entry, '*'), bg=math_sign_bg, row=3, column=3, ipadx=5, pady=5)
    place_button('/', get_input, (entry, '/'), bg=math_sign_bg, row=4, column=3, ipadx=5, pady=5)

    # 功能输入类按钮(背景色、触发功能不同)
    place_button('<-', backspace, (entry,), row=5, column=0, ipadx=5, padx=5, pady=5)
    place_button('C', clear, (entry,), row=5, column=1, pady=5, ipadx=5)
    place_button('=', calc, (entry,), bg=cal_output_bg, row=5, column=2, ipadx=5, padx=5, pady=5,
                 columnspan=2, sticky=tkinter.E + tkinter.W + tkinter.N + tkinter.S)
    root.mainloop()

列表中各种方法添加数据时的效率问题

from timeit import timeit

def count_append():
lists = []
for x in range(0, 100000):
lists.append(x)

cost_time = timeit(stmt=count_append, number=1)
print("append花费的时间是", cost_time)

def count_extend():
lists = []
for x in range(0, 100000):
list1 = [x]
lists.extend(list1)

cost_time = timeit(stmt=count_extend, number=1)
print("extend花费的时间为", cost_time)

def count_insert():
lists = []
for x in range(0, 100000):
lists.insert(x, x)

cost_time = timeit(stmt=count_insert, number=1)
print("insert花费的时间为", cost_time)

def count_plus():
lists = []
for x in range(0, 100000):
list1 = [x]
lists = lists+list1

cost_time = timeit(stmt=count_plus, number=1)
print("plus花费的时间为", cost_time)

append花费的时间是 0.008006025272567989
extend花费的时间为 0.010472806737249051
insert花费的时间为 0.012643240513279762
plus花费的时间为 13.00245008582025
由此可得append是耗时最短的