python数据结构系列1--list(列表)

落寞红颜玉玫瑰

已于 2023-09-14 19:38:13 修改

阅读量106

点赞数

分类专栏： python基础-数据结构文章标签： python list

于 2023-03-30 22:53:49 首次发布

本文链接：https://blog.csdn.net/weixiyaya/article/details/129868359

版权

python基础-数据结构专栏收录该内容

5 篇文章 0 订阅

订阅专栏

#coding：utf-8
#@author：shenshang/落寞红颜玉玫瑰
#userApp：Jupyter Notebook (Anaconda3)

本文中所有的命名方式为：驼峰命名法

1.1 概念与理解

概念详见：https://baike.baidu.com/item/list

理解：任何东西一旦脱离了某些条件，它将变得没有任何意义，比如 1<2 ?。下面是我的拙见。

list就是一个列表，它的存在就是为了方便我们对相关数据进行操作。正所谓无规矩不成方圆，为了我们见到这个符号就知道这个表示list，也为了方便计算机处理，更好的与我们交互，所以规定用[]来表示list。同时，我们也可以认为list就是一手数据的处理的程序化：我们拿到了某项实验或者其他的一手数据，为了进一步的研究，我们需要对数据进行处理，无外乎登记，筛查，检验，再处理这几步，而list()就是这个过程的序列化，或者说规范化。

listF=[1,2,3,9,3,"wang"],这是一个list，其中用“,”分开的每个值叫元素，元素可以为数字，字符等，并且可以重复出现；从左到右其排序为0，1，2，3...n，从右到左顺序为-1，-2，-3...,我们把这个顺序叫索引或下标。

1.2 基本操作-创建list

##创建list的几种方法

 ##1.直接赋值
list_createFirst=[]      ##这种创建方式是英文状态下的"[]"!
print(list_createFirst)

 ##通过list()创建 
list_createSecond=list() ##注意这种方式创建list后面是英文状态下的"()"!
print(list_createSecond)

1.3 基本操作-增删改查

1.3.1 增

##1.创建一个新数组
createListFirst=[1,"wang",2,3,2,"str","true",0] ##每个list元素用英文“,”隔开，字符用“""”包裹，数字可直接输入。

##输出看看list
print(createListFirst)


##2.给createListFirst添加新元素
  ##1）通过append()方法：只能把元素添加到末尾
  
createListFirst.append(2)       ##添加数字
print(createListFirst)
    
createListFirst.append("huang") ##添加字符类型，须用""包裹
print(createListFirst)

##2）通过insert(index,value)方法来添加：可插入到任何位置
createListFirst.insert(0,"hello!")

print(createListFirst)

1.3.2 删

##3.删除list中的元素
  ##1）通过remove()方法：需要输入要删除元素的值，继续以createListFirst为例
    ##删除所有值为2的元素，每次只能删除一个，重复，则单次只删除第一个
createListFirst.remove(2)
print(createListFirst)

 ##2）通过del 方法删除：语法为del list[indexStart:indexEnd:(step)]，可以连续删除多个元素
    ##删除一个元素
del createListFirst[0]
print(createListFirst)

    ##删除多个元素
del createListFirst[0:2]
print(createListFirst)

    ##删除某个区间某几个有规律（索引）的元素
del createListFirst[0:6:2]
print(createListFirst)

    ##删除整个list，谨慎使用
#del createListFirst
#print(createListFirst)

 ##3）通过pop()方法删除：随机删除一个元素，也可以传入索引，删除指定元素；且返回删除元素
    ##默认index=-1
createListFirst.pop()
print(createListFirst.pop())
print(createListFirst)

    ##传入索引
createListFirst.pop(0)
print(createListFirst.pop(0))
print(createListFirst)

1.3.3 改

##3.改变list中的值
  ##1）直接提出索引，改变对应的值
createListFirst[0]="how are you"
print(createListFirst)

 ##2）提取片段输入对应的值,片段与值要一一对应
createListFirst[0:3]="how","are","you"
print(createListFirst)

 ##3）当然也可以按步长替换，同样要求一一对应
createListFirst[0:6:2]="how","are","you"
print(createListFirst)

1.3.4 查

##4.查看list中的元素
  ##1）直接查看
print(createListFirst)
print(createListFirst[3])

  ##2）通过[:]查看
print(createListFirst[:])

 ##3）直接遍历输出
for i in createListFirst:
    print(i)
##4）找到它的索引

print(createListFirst[createListFirst.index("how")])

##5）加个序号好查找？？
for i in range(len(createListFirst)):
    print(i,"--",createListFirst[i])

1.4 其他操作

1.4.1 扩展1

##扩展1：如果要求生成一个连续的list你会怎么做，一个个输入？那太慢了，当然可以和for配合使用，那为什么不一步到位呢
  ##我们生成x-y直接的连续自然数可以这么做,example:10-20
seriesArray=[i for i in range(10,20)]
print(seriesArray)

  ##当然，我们也可以只输出偶数，那么，我们可以
seriesEven=[i for i in range(10,20,2)]
print(seriesEven)

1.4.2 扩展2

##扩展2：清空list，保留变量名，除了list[:],我们还可以list.clear()，以seriesArray为例
print(seriesArray)

seriesArray.clear()
print(seriesArray)

1.4.3 扩展3

##扩展3：统计需求，我们需要知道原始数据里面的某项数据共有多少个，在数据摘抄无遗漏的情况下，可以这样得到（example："j" of seriesArray）
print(seriesArray.count("j"))

##我们可以通过循环来验证其正确性
for value in seriesArray:
    if "j"==value:
        print(value)

1.4.4 扩展4

##扩展4：合并数组与比较数组
   ##合并数组
listArrayF=[i for i in range(10,20,2)]
listArrayS=[i for i in range(0,20,2)]
print(listArrayF,"\n",listArrayS)
total=listArrayF+listArrayS
print(total)

1.4.5 扩展5

##扩展5:数组比较
compare=[value for value in listArrayF if value in listArrayS]
print(compare)

1.5 杨辉三角

1.5.1 背景简介

来一个好玩的print()输出图形：杨辉三角（首现于《详解九章算法》）。

在欧洲，这个表叫做帕斯卡三角形。帕斯卡（1623----1662）是在1654年发现这一规律的，比杨辉要迟393年，比贾宪迟600年。

1.5.2 递归函数求阶乘

##提示：其每一行为（a+b）**n的二项式系数,即：
##C(n,0),C(n,1),C(n,2),...,C(n,n-2),C(n,n-1),C(n,n)
#1.先求阶乘 n！
def factorial(n):
    if n==0:
        return 1
    else:
        return n*factorial(n-1)
#这个函数的时间复杂度太大了，可以优化，但目前没必要
#这个内核很容易挂掉，配置不好的电脑谨慎尝试

1.5.3 优化阶乘函数

#优化阶乘函数
def factorialQ(n):
    #start=time.time()
    s=1
    for i in range(1,n+1):
        if n==1:
            return 1
        else:
            s=s*i
    #end=time.time()
    #useTime=end-start
    return s #,useTime,

1.5.4 计时函数

#引入时间函数，来比较一下，这俩的快慢
#可以做一个函数，调用两次函数，这样最好
import time
def eventListern(n):
    '''递归时间长度计算'''
    start=time.time()
    factorial(n)
    end=time.time()
    useTime=end-start
    return useTime

def eventListernQ(n):
    '''赋值时间长度计算'''
    start=time.time()
    factorialQ(n)
    end=time.time()
    useTime=end-start
    return useTime

def timeCompare(n):
    result=eventListern(n)-eventListernQ(n)
    return result

我们知道，对于任意的C(n,m)有：C(n,m)=n!/m!(n-m)!，那么：

1.5.5 排列函数

#2.对于其中一层来说：
def listRow(num_oneline):
    numRow=[]
    if num_oneline==1:
        return [1]
    if num_oneline==2:
        return [1,1]
    else:
        num_oneline=num_oneline-1
        for i in range(num_oneline+1):
            result=factorial(num_oneline)/(factorial(i)*factorial(num_oneline-i))
            numRow.append(result)
    return numRow

#2.对于其中一层来说：
def listRow(num_oneline):
    numRow=[]
    if num_oneline==1:
        return [1]
    if num_oneline==2:
        return [1,1]
    else:
        num_oneline=num_oneline-1
        for i in range(num_oneline+1):
            result=factorial(num_oneline)/(factorial(i)*factorial(num_oneline-i))
            numRow.append(result)
    return numRow

1.5.6 打印图形

#4.输出,打印,搞个函数
#美化输出
def print_figure(listPr):   
    for values in listPr:
        space=len(listPr)-len(values)
        #print(space)
        if len(values)==1:
            print(" "*(5*space-1),end="")
            print(1,end="   ")
            print("   ",end="")
        else:
            print(" "*5*space,end="")
            if len(values)==2:  
                for i in values:
                    print(i,end="    ")
                    print("   ",end="")
            else:
                for i in values:
                    print(i,end="    ")
                    print(" ",end="")
        print("\n")