Python 列表-元组-字典

列表和元组

用一个变量来表示多个数据,类似于其他语言的数组.

• 大部分相等,区别是

​ 列表是可变的:创建好之后随时能改,(散装的)

​ 元组是不可变的:改不了(包装好的),只能换一个新的

列表

#创建列表
a=[]
print(type(a))
a=list()
print(type(a))

#设定初始值,用,分割
b=[1,2,3,4]
print(b)

    #可以放不同类型的数据
c=[1,'hello',True,[4,5,6]]
print(c)

#通过下标访问的方式,获取列表中的元素,从0开始数,到长度-1
print(b[1])
print(c[3])
print(c[3][2])

#获取列表长度len
l=len(b)
print(l)

    #下标为负数,就是反向获取,-1就相当于len(b)-1
print(b[-1])

#还可以通过下标修改值
b[1]=666
print(b)

切片

只是取出原有列表中的一部分,并不涉及到数据的拷贝,即使列表很大,切片的效率都很高效/

#切片
a=[1,2,3,4]
print(a[1:3])#切片操作,[1,3),下标左闭右开的范围

#可以省略边界
print(a[1:])
print(a[:2])
print(a[:])
#下标为负数也可
print(a[:-1])
#指定步长
a=[1,2,3,4,54,65,7,87,9]
print(a[::2])
print(a[1:-1:2])
#步长为负数,就是从后往前打印
print(a[-1:1:-1])
print(a[::-1])
#不是有效范围下标的时候不会出现异常,而是尽可能把符合要求的元素拿到
print(a[1:100])

遍历

a=[1,2,3,4,5,6]
#in 后面是可迭代对象就行

#将列表中的每个元素对elem 赋值,不会对原列表造成影响
for elem in a:
    # print(elem)
    elem+=1
print(a)    #[1, 2, 3, 4, 5, 6]
print(elem) #7

#下标的方式遍历取到了列表元素,可以修改
for elem in range(0,len(a)):
    a[elem]+=10
print(a)    #[11, 12, 13, 14, 15, 16]

i=0
while i<len(a):
    a[i]+=1
    i+=1
print(a)

列表新增元素

# append 搭配列表对象a来一起使用,也叫作方法
# 不是独立的函数(type,print,input,len)
a = [1, 2, 3, 4, 5]
a.append('hello')
print(a)    #[1, 2, 3, 4, 5, 'hello']

#insert()任意位置插入
b=[1,2,3,4,56,6]
b.insert(1,'hello')
print(b)    #[1, 'hello', 2, 3, 4, 56, 6]
b.insert(100,'xiaoawei')
print(b)    #[1, 'hello', 2, 3, 4, 56, 6, 'xiaoawei']

查找和删除

# +拼接两个列表,生成一个新的列表
a=[1,2,3,4,5,6]
b=[7,8,9,0]
print(a+b)  #[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

#extend进行拼接,把后一个列表直接拼接到前一个的列表
a.extend(b)
print(a)    #[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(b)    #[7, 8, 9, 0]
#extend没有返回值,那一个变量None接收返回值
c=a.extend(b)
print(c)    #None

#+=实现
a+=b    #a=a+b,先产生一个新的列表,再有一个重新赋值的操作,然后把旧值释放
print(a)    #[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(b)    #[7, 8, 9, 0]

元组

# 创建元组
a=()
b=tuple()

a=(1,2,3,4,5)
b=(1,2,3,"hello",[1,2,3])

#下标访问
print(a[1])
print(a[-1])
# print(a[100])   #IndexError: tuple index out of range

#切片
print(a[1:3])

for elem in a:
    print(elem)

print(3 in a)
print(a.index(3))

print(a+b)

#修改不可取TypeError: 'tuple' object does not support item assignment
# for i in range(0,len(a)):
#     a[i]+=1
# print(a)
# a[0]=100
# a.append(5)
# a.pop()
# a.insert(1,5)
# a.extend(b)

#当进行多元赋值的时候,本质就是按照元组的方式进行工作的
def getPoint():
    x=10
    y=20
    return x,y
        #构建一个元组,然后赋值
x,y=getPoint()
print(type(getPoint())) #<class 'tuple'>

• B调用A实现的函数接口,传参的时候避免A函数将我的参数内容进行修改,所以使用元组的方式作为参数,避免这样的纠结.

• 元组是不能修改的->不可变对象是可以哈希的

字典

键值对Key-Value,映射关系.字典中可以同时包含很多的键值对,同时要求这些键不能够重复.

对于字典来说,使用in或者[]来获取value都是比较高效的,本质是字典的背后使用了哈希表.

对于列表来说in就比较低效,使用[]比较高效,类似顺序表取下标.

#创建字典
a={}
b=dict()
#key类型有约束,value类型随便
#最后键值对的,可写可不写
a={
    'id':1,
   'name':'张三',
    100:'xiabio'
}
print(a)

#查找
    # in or not in (只是判定key的存在)
print('id' in a)
print('classid' not in a)
    #[]直接获取value
print(a['id'])
print(a[100])
# print(a['classid']) #KeyError: 'classid'读操作,没有怎么读到显示器

增删

#使用[]进行新增
a={
    'id':1,
    'name':'张三'
}
#不存在,往里面写入
a['score']=90
print(a)
#已存在的值,叫修改
a['score']=100
print(a)

#删除,,根据key
a.pop('name')
print(a)

遍历

遍历值的就是把一个可迭代对象,元素依次取出来,并进行操作.字典被设计出来的初衷是为了增删改查,不是为了实现遍历.哈希表能够以常数级时间复杂度,完成增删改查.无论字典中有多少个元素,增删改查都是固定时间,不会因为元素多了就变慢了.字典中的key值是不能重复的.

C++中的键值对存储的是无序的,但是python中的字典做过特殊处理,保证存储顺序是按照插入顺序的.

a={
    'id':1,
    'name':'张三',
    'score':90
}
for key in a:
    print(key,a[key])
# keys values items
print(a.keys()) #dict_keys(['id', 'name', 'score'])
print(a.values())
print(a.items())   #dict_items([('id', 1), ('name', '张三'), ('score', 90)])

for key,value in a.items():
    print(key,value)

合法key类型-可哈希hash()

hash()计算变量哈希值,不可变的对象基本都可哈希

print(hash('xiaoawei')) #字符串
print(hash((1,2,3)))    #元组
print(hash(True))
print(hash(1))

print(hash([1,2,3]))    #TypeError: unhashable type: 'list'
print(hash({ }))    #TypeError: unhashable type: 'dict'