python可变序列和不可变类型的区别 python中可变序列

三、组合数据类型

1、序列

• 序列是指一种包含多项数据的数据结构。这些数据项按照顺序存储。python中常见的序列类型包括字符串、列表和元组。
• 不可变序列是指数据结构-旦建立，就不能修改其中的元素，字符串和元组属于不可变序列。
• 可变序列是可以修改序列中的元素，列表是可变序列。
• 序列中的数据项可以通过索引进行访问。索引可以正向也可以方向。.
• 正向递增序号，从0开始;反向递减序号，从-1开始
  
  2、创建列表元组
• 使用[itme1,itme2,...]创建列表
• 使用(itme1,itme2,...)创建元组
  列表和元组中的数据项类型可以不同

索引和切片
索引：找下标
slice 切片（分片）：通过索引获取序列中的某一段

• Slice语法格式: [start: end: step]
• start: 切片开始的索引(默认从0开始)
• end:切片结束的索引(不包含end) (默认序列长度)
• step :步长，默认为1.步长为负数，表示从右向左切片。

list1 = [1,2,3,4,5,6,7,8,9]
print(list1[3:7])
print(list1[2:-2:2])

利用切片判断回文：

pstr = "abcdcba"
if (pstr == pstr[::-1]):
    print("True")
else:
    print("False")

2.1、查找与计数

• list.index(x): x在列表list中第-次出现的位置，如果不存在，抛出异常
• list.count(x): x在列表list中出现的次数，如果没有返回0

2.2、最大值、最小值、长度

• python内置的全局函数max( ),min( ),len( )
  注意:列表或元组的元素类型必须相同

2.3、加法、乘法、in运算

• list1 + list2 结果是两个列表或元组所包含的元素的总和
• list*n表示对应的列表或元组重复n次
• x in list 判定列表中是否存在x元素，返回True或False

list1 = [1,3,5,7,9]
list2 = [2,4,6,8,10]
print(list1+list2)
print(list1*3)
print(1 in list1)

2.4、序列封包和序列解包

• 序列封包:把多个值赋给一个变量时， python将这些值封装成元组
• 序列解包:将序列(列表或元组)直接赋值给多个变量。序列中的元素依次赋值给每个变量

# 序列的封包
vals = 3,6,9
print(vals)
print(type(vals))
# 序列的解包
d,e,f = vals
print(e)

#也可以同时封包解包
a,b,c = 1,3,5
print(b)

3、列表的操作

3.1、创建列表

s1 = list(range(1,11,2))  #内置list方法
s2 = [2,4,6,8,10]
print(s1)
print(s2)

输入输出列表：

a = input().split()
list1 = [int(a[i]) for i in range(len(a))]
print(list1)

3.2、增加元素

• append( )在列表尾部追加一个元素。注意该方法可以接收单个值，也可以接收元组或列表，但是此时，元组或列表是作为一个整体追加的，这样形成了嵌套。
• insert( )i在列表的指定位置插入
• extend( )将个列表追加咧表的尾部

list1 = [1,2,3]
list1.append([4,5])
list1.extend([4,5])
list1.insert(1,9)
print(list1)
print(list1[4]) #一个列表作为一个元素
print(list1[5])
print(list1[6])

3.3、删除

• del( )根据索引删除列表中的一个元素或段区间中的元素
• remove( )根据元素本身删除列表中的某个元素
• clear( )清空列表中所有的元素

list1 = [1,2,9,4,5,2,4,6]
list1.remove(9)
del list1[1:3] #切片删除一半
print(list1)

3.4、置逆和排序

• reverse( )将列表中的元素置逆
• sort( )将列表中的元素排序(默认从小到大，如果从大到小，需要添加参数reverse = True)

list1 = [1,2,9,4,5,2,4,6]
list1.reverse()
print(list1)
list2 = list1
list2.sort()
print(list2)
list1.sort(reverse=True)
print(list2)  #用到的时候又实现了赋值
print(list1)

3.5、弹出元素

pop( )将列表作为栈，实现出栈操作(入栈用append方法)

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

3.6、拷贝

浅拷贝：

list.copy( )方法

copy.copy )

#列表中只有不可变列表序列数据项
list1 = [1,2,3]
list2 = list1.copy()
list2[1] = 5
print(list1)
print(list2)

#列表中有可变列表序列数据项
import copy

list1 = [1,2,3,[7,8,9]]
# list2 = list1.copy()  和copy.copy一样是浅拷贝，list2会影响list1的变化
list2 = copy.copy(list1)

list2[3][0] = 5   #修改 list2 里面的第三个元素的第一个元素
list2[1] = 6
print(list1)
print(list2)

深拷贝：

copy.deepcopy( )

import copy

list1 = [1,2,3,[7,8,9]]
list2 = copy.deepcopy(list1)
list2[3][1] = 5
print(list1)
print(list2)

4、元组

相对于列表，元组是种包括不可变序列类型，一旦创建不可修改

• 使用( item1, item2, … )创建
• 使用tuple( )创建
• 需要注意的是，如果在初始化(创建)时只有一个元素，则必须在元素后面加个逗号，否则将被视作变量

列表元组之间的准换：

• list( )将元组转换为列表
• tuple()将列表转换为元组

5、字典

• 通过{key1: value1, key2: value2, key3: valau…}键值对创建
• “键建” 可以是Python中任意不可变数据， 例如整数、实数、复数或者是字符串， 元组等类型等可哈希数据，但不能使用列表、集合、字典或其他可变类型作为字典的“转建”;
• 通过“键”根据键来计算值的位置，快速获取和他难对应的°值°
• “键”是唯的，不允许重复，而"值是可以重复的;

5.1创建
1.直接赋值
2.通过内置函数dict( )创建

dict1 = dict()  #创建空字典
dict2 = dict([("one",1),("two",2),("three",3)])
print(dict2)

3.以参数形式创建

dict1 = dict(name="lihua",age=18)
print(dict1)

5.2访问

• 通过dict[键]来访问字典中的对应该键的值
• 如果键值不存在，则会抛出KeyError异常， 为了避免这种情况，可以先使用in关键字判定键是否存在于字典中
• 注意字典是无序的，不能通过索引访问元素

dict1 = dict(name="lihua",age=18)
print(dict1['age'])

dict1 = dict(name="lihua",age=18)
if 'age' in dict1:
    print(dict1['age'])
print("---------------------->")
if 'Age' in dict1:
    print(dict1['Age'])

5.3增加修改元素

d[key] = value:将key对应的值修改为value, key不存在添加新的kv对

dict3 ={"001":["张三",90],"002":["李四",85], "003":["王五",76]}
print(dict3)
dict3["002"] = ["赵六",80]
dict3["005"] = ["田七",79]
print(dict3)

5.4删除
del dict[key]通过键来实现删除元素，如果键值不存在，同样则会抛出KeyError异常
popitem( )方法返回并删除字典中的最后对键和值
pop(key)方法key存在就移除，井返回它的value值， 如果字典已经为空，就抛出KeyError异常，

dict1 = dict(name="lihua",sex="boy",age=18)
del dict1['sex']
print(dict1)
dict1.popitem()
print(dict1)
dict2 = dict(name="lihua",sex="boy",age=18)
if 'name' in dict2:
    dict2.pop('name')
print(dict2)

5.5 fromkeys方法
dict.fromkeys(seq[value])函数用于创建一个新字典，以给定元素做字典的键，value 为字典所有键对应的初始值。
以给定内容为“键"，创建"值”为空的字典

5.6 字典长度和字典检索

• len(dict)同列表和元组相同，返回字典中键的数量
• key in dict运算符测试某个特定的键是否在字典中

6. collections容器类
6.1 deque

• deque，类似列表（list）的容器，实现了在两端快速添加（append）和弹出（pop）
• rotate，旋转,参数是多少就挪多少次，正数就把最后一个挪到前面，负数相反

from collections import deque
#deque，类似列表（list）的容器，实现了在两端快速添加（append）和弹出（pop）
d = deque("gfs")
d.append("j")   #在左边添加元素
d.appendleft("b")   #在右边进行添加元素
print(d)
print(d.pop())
print(d.popleft())
print(d)
#rotate，旋转,参数是多少就挪多少次，正数就把最后一个挪到前面，负数相反
d.rotate(2)
print(d)
d.rotate(-1)
print(d)

6.2 ChainMap

• 将多个字典或者其他映射组合在一起，创建个单独的可吧新的视图。
• 如果没有指定maps,就提供个默认的空字典， 这样一个新链至少有一个映射。

from collections import ChainMap

baseline = {'BookName':'python','Price':'39'}
adjustment = {'Price':'49','Press':'Diy Press'}
newmap = ChainMap(adjustment,baseline)
print(newmap['Price'])
print(newmap['Press'])

6.3 Counter
Counter，是一个字典的子类，用于计数可哈希对象

from collections import Counter

c = Counter('abababccddbabaqaq')    #字符串可迭代对象
d = Counter({'red':4,'blue':2,'yellow':3})  #字典映射
e = Counter(cats=4,dogs=5)
print(c)
print(d['blue'])
print(d['black'])	#没有记录的返回0
print(e['cats'])

6.4 OrdredDict
OrdredDict，是一个有序字典，key是按照插入顺序排列，不是key本身序列

from collections import OrderedDict

d = OrderedDict.fromkeys('edcba')
print(d.popitem())
print(d)
d.move_to_end('c')
print(d)
print(''.join(d.keys()))