Python学习笔记-列表元组字典

一、列表

1. 列表表示

列表类似与其他语言中的数组，但是比数组更强大，同一列表中可以存放任意数据类型

list1=[1,'a',False,(4,5),[4,5]]
print(list1)                #[1, 'a', False, (4, 5), [4, 5]]

2. 列表下标

与字符串一致，可以通过下标访问列表，正下标从0开始，负下标从-1开始

list1=[1,2,3,4,5]
print(list1[0])    #1
print(list1[-1])   #5

与字符串不同的是，列表是可变对象，可以通过下标访问改变列表中元素的值

list1=[1,2,3,4,5]
list[0]=10
print(list1[0])    #10

3. 列表方法

不是以列表名.方法名()形式的方法都不是列表专有的

1）添加元素

• append()

将元素插入到列表最后一位

list1=[1,2,3,4,5]
list1.append(6)
print(list1)    #[1, 2, 3, 4, 5, 6]

• insert() 

insert(插入位置，待插入元素)    将元素插入到指定位置，注意不是在插入位置后插入

list1=[1,2,3,4,5]
list1.insert(2,222)
print(list1)        #[1, 2, 222, 3, 4, 5]

• extend()

插入一个列表

list1=[1,2,3,4,5]
list1.extend([6,7,8])
print(list1)             #[1, 2, 3, 4, 5, 6, 7, 8]

2) 删除元素

• pop()

不带参数时，删除列表最后一个元素

list1=[1,2,3,4,5]
popped_item=list1.pop()
print(list1)    #[1, 2, 3, 4]
print(popped_item)   #5

带参数时，删除指定位置的元素

list1=[1,2,3,4,5]
list1.pop(0)
print(list1)    #[2, 3, 4, 5]

• remove()

remove(指定元素)，根据指定元素值删除，效率低，需要按顺序找到元素

list1=[1,2,3,4,5]
list1.remove(2)
print(list1)      #[1, 3, 4, 5]

 给元素命名，删除

list1=[1,2,3,4,5]
int2=2
list1.remove(int2)
print(list1)      #[1, 3, 4, 5]

如果有多个相同元素，只会删除第一个

list1=[1,2,2,3,4,5]
list1.remove(2)
print(list1)      #[1, 2, 3, 4, 5]

• del

del 列表名[下标]  删除单个元素

list1=[1,2,3,4,5]
del list1[0]
print(list1)      #[2, 3, 4, 5]

del 列表名   删除整个列表

list1=[1,2,3,4,5]
del list1
print(list1)       #NameError: name 'list1' is not defined

3)列表排序

sort()

永久排序，改变列表本身

list1=[1,3,5,2,4]
list1.sort()
print(list1)      #[1, 2, 3, 4, 5]


cars=['bmw','audi','ford','toyota']
cars.sort()
print(cars)     #['audi', 'bmw', 'ford', 'toyota']

反向排序:  reverse=True

list1=[1,3,5,2,4]
list1.sort(reverse=True)
print(list1)      #[5, 4, 3, 2, 1]

 sorted()

临时排序，不会改变原列表

list1=[1,3,5,2,4]
list1_new=sorted(list1)
print(list1)         #[1, 3, 5, 2, 4]
print(list1_new)     #[1, 2, 3, 4, 5]

4) 翻转列表

reverse()

list1=[1,2,3,4,5]
list1.reverse()
print(list1)       #[5, 4, 3, 2, 1]

 5) 列表长度

len()

list1=[1,2,3,4,5]
print(len(list1))   #5

6) 数字列表统计计算

min() 最小值   max() 最大值    sum() 总和

 list1=[1,2,3,4,5]
print(min(list1))    #1
print(max(list1))    #5
print(sum(list1))    #15

7) 强制转换成列表

list()

str1='abc'
list1=list(str1)
print(list1)    #['a', 'b', 'c']

对于字典来说，默认将字典的键转换成列表

dict1={'a':'apple','b':'banana'}
list1=list(dict1)
print(list1)             #['a', 'b']
list2=list(dict1.items())
print(list2)             #[('a', 'apple'), ('b', 'banana')]

4. 列表切片

[起始下标:终止下标:步长]  包含起始下标，不包含终止下标

list1=[1,2,3,4,5]
list1_new1=list1[1:4]
print(list1_new1)      #[2, 3, 4]
list1_new2=list1[::-1]
print(list1_new2)       #翻转列表 [5, 4, 3, 2, 1]

5. 浅拷贝与深拷贝

1. 普通赋值，相当于创建了一个快捷方式，原列表和新列表是同一个列表

list1=[1,2,3,4,[5,6]]
list2=list1
list1[0]=10  
list1[4][0]=50
print(list1,id(list1))     #[10, 2, 3, 4, [50, 6]] 139694848202048
print(list2,id(list2))     #[10, 2, 3, 4, [50, 6]] 139694848202048

 2. 浅拷贝，生成新列表，普通元素的变化不会相互影响，但列表中的子列表还是只有一份，会同步变化

import copy
list1=[1,2,3,4,[5,6]]
list2=copy.copy(list1)
list1[0]=10  
list1[4][0]=50
print(list1,id(list1))     #[10, 2, 3, 4, [50, 6]] 140277851055104
print(list2,id(list2))     #[1, 2, 3, 4, [50, 6]] 140277851055040

浅拷贝和切片是一致的

list1=[1,2,3,4,[5,6]]
list2=list1[:]
list1[0]=10  
list1[4][0]=50
print(list1,id(list1))         #[10, 2, 3, 4, [50, 6]] 139851426207040
print(list2,id(list2))         #[1, 2, 3, 4, [50, 6]] 139851426207424 

3. 深拷贝， 生成新列表，所有元素的变化都不会相互影响

import copy
list1=[1,2,3,4,[5,6]]
list2=copy.deepcopy(list1)
list1[0]=10  
list1[4][0]=50
print(list1,id(list1))     #[10, 2, 3, 4, [50, 6]] 140187224564800
print(list2,id(list2))     #[1, 2, 3, 4, [5, 6]] 140187224564736

6. 列表解析 

例：分别计算1~10的平方，并将结果存入列表

squares=[]
for value in range(1,11):
    squares.append(value**2)
print(squares)             #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表解析可以将上述代码写在一行里，即将for循环和创建新元素合并成一行，并自动附加新元素

squares=[value**2 for value in range(1,11)]
print(squares)           #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

二、元组

1. 元组表示

元组跟列表一致，可以在同一元组中存放任意数据类型

tuple1=(1,'a',False,(4,5),[4,5])
print(tuple1)              #(1, 'a', False, (4, 5), [4, 5])

如果元组中只有一个元素，需要加一个逗号，否则会python会理解成其他类型

tuple1=(1)
print(type(tuple1))   #<class 'int'>
tuple2=(1,)
print(type(tuple2))   #<class 'tuple'>

2. 元组下标

下标跟字符串一致，正下标从0开始，负下标从-1开始

tuple1=(1,2,3,4,5)
print(tuple[0])     #1
print(tuple[-1])    #5

元组属于不可变对象，不可以通过下标访问改变元组的值

tuple1=(1,2,3,4,5)
tuple[0]=10         #报错TypeError: 'tuple' object does not support item assignment

如果元组中含有列表，那么可以通过下标改变列表的值

tuple1=(1,2,3,4,[5,6])
tuple1[4][0]=10         
print(tuple1)          #(1, 2, 3, 4, [10, 6]) 

3. 元组切片

跟列表一致，可以使用切片: [起始下标:终止下标:步长]  包含起始下标，不包含终止下标

tuple1=(1,2,3,4,5)
print(tuple[0:2])      #(1, 2)
print(tuple[::-1])     #(5, 4, 3, 2, 1)

三、字典 

 1. 基本语法

存储多个键值对，键值对总是成对出现，不存在有键没值或有值没键的情况

字典名={键:值, 键:值,[键:值]}

dict1={'A':'Apple','B':'Banana'}
print(dict1)      #{'A': 'Apple', 'B': 'Banana'}

可以分行写字典中的元素

dict1={
    'A':'Apple',
    'B':'Banana'
    }
print(dict1)        #{'A': 'Apple', 'B': 'Banana'}

字典是无序的

dict1={'A':'Apple','B':'Banana'}
dict2={'B':'Banana','A':'Apple'}
print(dict1==dict2)      #True

列表是有序的

list1=[1,2]
list2=[2,1]
print(list1==list2)   #False

字典的键存放不可变对象，值存放任意对象

dict1={[0]:'0'}
print(dict1)        #TypeError: unhashable type: 'list'

字典中的键是唯一的，如果有两个相同的键，后面的键值对会覆盖前面的

dict1={'A':'Apple','A':'Award'}
print(dict1)      #{'A': 'Award'}

2. 访问字典

通过键查询值

dict1={'A':'Apple','B':'Banana'}
print(dict1['A'])      #Apple

3.对字典的一些操作

1）新增字典元素

字典是可变对象

新增字典中没有的键

dict1={'A':'Apple','B':'Banana'}
dict1['C']='Cat'
print(dict1)      #{'A':'Apple','B':'Banana','C':'Cat'}

新增字典中存在的键，之前对应的值被替换成新的值，即实际是修改字典元素

dict1={'A':'Apple','B':'Banana'}
dict1['B']='Book'
print(dict1)      #{'A':'Apple','B':'Book'}

新增多个字典元素

字典名.update(待插入的字典)

dict1={'A':'Apple','B':'Banana'}
dict1.update({'C':'Cat','D':'Dog'})
print(dict1)       #{'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}

2）清空字典

字典仍在内存中，只是没有任何元素

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
dcit1.clear()
print(dict1)     #{}

 给字典重新赋值，会给字典分配新的内存空间

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
print(id(dict1))     #2354561965568
dict1={}
print(id(dict1))     #2354578152000

3）删除字典

删除单个元素

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
del dict1['A']
print(dict1)       #{'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}

删除整个字典，删除完字典在内存中被销毁

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
del dict1
print(dict1)       #NameError: name 'dict1' is not defined

4）查询某个元素是否在字典中

因为键是唯一的，所以通过键去查询

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
print('E' in dict1)       #False
print('Apple' in dict1)   #False
print('A' in dict1)       #True

5）遍历字典

遍历字典中的键

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
for one in dict1.keys():
    print(one)
'''
A
B
C
D
'''

遍历字典中的值

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
for one in dict1.values():
    print(one)
'''
Apple
Banana
Cat
Dog
'''

遍历字典中的元素

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
for key,value in dict1.items():
    print(key,value)
'''
A Apple
B Banana
C Cat
D Dog
'''

dict1={'A': 'Apple', 'B': 'Banana', 'C': 'Cat', 'D': 'Dog'}
for one in dict1.items():
    print(one)
'''
('A', 'Apple')
('B', 'Banana')
('C', 'Cat')
('D', 'Dog')
'''