Python学习笔记-序列

目录

一、序列

1.索引（indexing）

 2.切片（Sliceing）

 3. 序列相加

 4.乘法（Multiplying）

 5.检查某个元素是否是序列中的成员

6.序列的长度、最大值、最小值

二、列表（List）

1.列表的创建和删除

 2.列表的基本操作

2.1 索引、切片、加法、乘法、

2.2 修改和删除

2.3 追加、插入、扩展

 2.4 多维列表

2.5 迭代器 

2.6 其他操作

三、元组（Tuple）

1.元组的创建

2.元组的基本操作

2.1 索引、切片、加法、乘法

2.2 修改

2.3 删除

2.4 迭代器、多维元组

2.5 其他操作

3.元组的优势

四、字典（dict）

1.字典的创建

2.基本操作

2.1 获取字典元素

2.2 修改

2.3 删除

2.4 字典的嵌套

2.4 其他操作

五、集合（set）

1.集合的创建

2.集合的数学运算

3.基本操作

4.不可变集合

六、列表、元组、字典和集合的区别

---

用于记述python中对于序列的应用，包括列表、元组、字典、集合、字符串等。

一、序列

序列是一块用于存放多个值的连续内存，并且按一定顺序排列，可通过索引取值。

序列主要操作如下：

• 索引：序列中元素的编号；
• 切换：
• 序列相加
• 乘法
• 检查某个元素是否是序列的成员
• 计算序列的长度、最大值、最小值

1.索引（indexing）

索引就是序列中元素的编号，索引是从0开始的，因为计算机是二进制的只识别0和1。

假如把一个酒店作为一个序号，那各个房间的房间号就是索引值，可以通过房间号获取到各个房间。

• 索引是按顺序的：0、1、2...n
• 索引可以是负的：-n、-n-1、-n-2...-1
• 负数索引是从-1开始的，并不是从0开始

示例：

# _*_ coding:utf-8 _*_
 
l = ["元素1","元素2","元素3","元素4","元素5"]
 
print("索引是正的")
print("元素0的值为：",l[0])
print("元素1的值为：",l[1])
print("元素2的值为：",l[2])
print("元素3的值为：",l[3])
print("元素4的值为：",l[4])
 
print("")
print("索引是负的")
print("元素-1的值为：",l[-1])
print("元素-2的值为：",l[-2])
print("元素-3的值为：",l[-3])
print("元素-4的值为：",l[-4])
print("元素-5的值为：",l[-5])

结果：

遍历序列：

#方法1，直接遍历
for item in 序列:
    # 输出item
 
 
#使用enumerate(),同时获得index
for index,item in enumerate(序列名)
    # 输出index 和 item

示例：

# _*_ coding:utf-8 _*_
 
list_Name = ["小明","小张","小李","小亮","小钱"]
 
print("列表如下：")
for index,item in enumerate(list_Name):
    print("序号：{0},名字：{1}".format(index+1,item))

结果：

 2.切片（Sliceing）

切片就是从序列中截取一部分元素作为新的序列。

格式如下：

sname[start : end : step]

• start：切片的起始索引，起始位置，取得的值包括起始值；
• end：切片的终点索引，结束值，取得的新序列不包括结束值；
• step：切片的步长（间隔）；
• start、end、step参数是可以省略的，不过需要保留 “:” ，省略step参数时可以不保留 “:”;

示例如下：

# _*_ coding:utf-8 _*_
 
l = ["元素1","元素2","元素3","元素4","元素5"]
 
print("原始列表 : ",l)
 
print("[1:3]值为：",l[1:3])        #从索引1到索引3（不包括）的值列表
print("[1:5:2]值为：",l[1:5:2])    #从索引1到索引5（不包括），间隔为2个元素的值
print("[1:]值为：",l[1:])          #从索引1到结束
print("[:3]值为：",l[:3])          #从第一个元素到索引为3（不包括）的值
print("[::2]值为：",l[::2])        #从第一个元素到最后一个元素，间隔为2的值
print("[:]值为：",l[:])            #从开始到结束的所有元素
print("[::]值为：",l[::])          #从开始到结束的所有元素

结果：

 3. 序列相加

使用“+”将两个序列相加，相加时不会去除重复的数据。

示例：

# _*_ coding:utf-8 _*_
 
l = ["元素1","元素2","元素3","元素4","元素5"]
m = ["元素5","元素6","元素7"]
 
print("原始列表l : ",l)
print("原始列表m : ",m)
 
print("l+m值为：",l+m)       

结果：

注意：

只能同类型的序列才能相加，即元组和元组，列表和列表，字符串和字符串等，并不是不同数据类型的同类型序列不能相加。

示例1，将列表和元组相加：

# _*_ coding:utf-8 _*_
 
l = ["元素1","元素2","元素3","元素4","元素5"]
m = ("元素5","元素6","元素7")
 
print("原始列表l : ",l)
print("原始列表m : ",m)
 
print("l+m值为：",l+m)      

相加时会报错：

 示例2，将字符串列表和数字列表相加：

# _*_ coding:utf-8 _*_
 
l = ["元素1","元素2","元素3","元素4","元素5"]
m = [5,6,7]
 
print("原始列表l : ",l)
print("原始列表m : ",m)
 
print("l+m值为：",l+m)       

结果如下：

 4.乘法（Multiplying）

序列的乘法就是使用“*”，一个序列乘以一个数字获得一个新的序列，新的序列是原来的序列重复n次。

格式如下：

序列 * n

示例：

# _*_ coding:utf-8 _*_
 
l = ["元素1","元素2","元素3"]
 
print("序列乘以3 : ", l*3)

结果：

注意：

        是将元素重复n次，而不是将元素内的值乘以n。

乘法可以用来生命指定长度的新列表，或者输出指定长度的空格或者*号等。

示例：

# _*_ coding:utf-8 _*_
 
 
print("长度为5的空列表: ", [None]*5)
print("5个*号: ", "*"*5)

结果：

 5.检查某个元素是否是序列中的成员

格式：

值 in 序列

示例：

# _*_ coding:utf-8 _*_
 
list_Name = ["小明","小张","小李","小亮","小钱"]
 
if "小明" in list_Name:
    print("小明在名字列表中。")
    
print("小明" in list_Name)
print("小哥" in list_Name)

结果：

6.序列的长度、最大值、最小值

通过len(),max(),min()函数获取序列的长度、最大值、最小值。

格式：

序列长度：             len(序列)

最大值：                   max(序列)

最小值：                   min(序列)

示例：

# _*_ coding:utf-8 _*_
 
list_Name = ["小明","小张","小李","小亮","小钱"]
 
print("序列长度为    ：",len(list_Name))
print("序列的最大值为：",max(list_Name))
print("序列的最小值为：",min(list_Name))

结果：

二、列表（List）

1.列表的创建和删除

列表可以直接创建，使用“[]”包括的元素就是列表

创建格式：

变量名 = [元素1,元素2,...,元素n] 

列表推导式：

变量名 = [ 表达式 for var in range ]

删除格式：

del 列表

列表在python中会自动回收，可以不用删除，不过用完后删除列表是比较规范的写法。

 列表删除后再次调用会报错。

示例：

# _*_ coding:utf-8 _*_
 
list_Name = ["小明","小张","小李","小亮","小钱"]
 
print("列表    ：",list_Name)
print("[i*2 for i in range(0,10)] ：",[i*2 for i in range(0,10)])
print("[i*2 for i in [0,1,2,4,6]  ：",[i*2 for i in [0,1,2,4,6]])

结果：

 2.列表的基本操作

2.1 索引、切片、加法、乘法、

同序列的操作。

2.2 修改和删除

通过索引获取匀速，然后进行修改或删除；

使用del删除部分元素，删除整个列表后，列表不可再次被引用。

修改格式：

list[index] = obj

删除格式：

del list[index]

删除示例：

# _*_ coding:utf-8 _*_
 
listA = [1,2,3,4,5]
print("Creat list  : ",listA)
listA[0] = 5
print("Modify listA[0] to 5  : ",listA)
del listA[0]
print("Delete listA[0]",listA)
del listA[2:]
print("Delete listA from index 2 to end : ",listA)
del listA[0:]
print("Delete all data : ",listA)
 

结果：

2.3 追加、插入、扩展

• append(obj) ：在列表对象尾部添加元素
• insert(index,obj)    ：在列表对象的指定索引位置插入元素，该索引位置元素后移一位
• extend(seq)  ：在当前列表尾部添加另一个序列的值。

示例：

# _*_ coding:utf-8 _*_
 
listA = [1,2,3,4,5]
print("ListA  : ",listA)
listA.append(6)
print("Append 6  : ",listA)
 
listA.insert(0,"0")
print("Insert(0,\"0\")  : ",listA)
 
listA.extend([7,8,9])
print("Extend([7,8,9])  : ",listA)

结果：

 2.4 多维列表

列表中的元素还是列表，就是多为列表。

示例：

# _*_ coding:utf-8 _*_
 
listA = [["1_1","1_2","1_3"],["2_1","2_2","3_3"],["3_1","3_2","3_3"]]
print("多维列表：",listA)
 
print("元素1 listA[1] ：",listA[1])
print("元素1的元素2 listA[1][2] ：",listA[1][2])

结果：

2.5 迭代器 

通过迭代器函数获取列表的迭代器对象，然后通过迭代器对象的__next__()函数可以边离列表中的元素。

示例：

# _*_ coding:utf-8 _*_
 
listA = [1,2,3,4,5]
iter_obj = iter(listA)
print(next(iter_obj))
print(next(iter_obj))
print(next(iter_obj))
print(next(iter_obj))
print(next(iter_obj))
print(next(iter_obj))

结果：

 注意：

当元素遍历一遍之后再次获取，会报错。

2.6 其他操作

其他常用操作如下：

• list(seq)：将序列转换为列表
• list.count(obj)：统计某个元素在列表中出现的次数
• list.index(obj)：从列表中找到某个元素第一次出现的索引位置
• list.pop(obj = list[-1])：删除对象的某一个元素，默认是最后一个元素，并返回该元素。
• list.remove(obj)：一处列表中某个值的第一个匹配项
• list.reverse()：反向列表中元素
• list.sort([func]) ：对原列表进行排序
• list.clear()：清空列表
• list.copy()：复制列表

示例：

# _*_ coding:utf-8 _*_
 
tupleA = (1,2,3,4,5)
print("元组：",tupleA)
print("元组转换为列表：",list(tupleA))
string = '这是个字符串'
print("字符串：",string)
print("字符串转换为列表：",list(string))
listA = [1,2,3,4,5]
print("列表：",listA)
print("listA.count(1) :",listA.count(1))
 
print("listA.index(1) :",listA.index(1))
listA = [1,2,3,4,5]
print("列表：",listA)
listA.pop()
print("listA.pop() :",listA)
pop = listA.pop(-2)
print("listA.pop(-2) data:",pop)
print("listA.pop(-2) :",listA)
listA = [1,2,3,4,5]
print("列表：",listA)
listA.remove(2)
print("listA.remove(2) :",listA)
listA.reverse()
print("listA.reverse() :",listA)
listA.sort()
print("listA.sort() :",listA)
copy1 = listA.copy()
print("listA.copy() :",copy1)
listA.clear()
print("listA.clear() :",listA)
 
print("listA.count() :",listA.count())

结果：

 注意：

        count()需要有元素，没有参数时会报错。

三、元组（Tuple）

1.元组的创建

格式：       

变量名 = (元素1,元素2,...,元素n)

元组推导式：

变量名 = ( 表达式 for var in range )

注意：

当元组只有一个元素时，需要在元素后面添加逗号，否则小括号会被当做运算符。

2.元组的基本操作

2.1 索引、切片、加法、乘法

同序列的索引。

2.2 修改

元组的元素不允许修改；

不过可以对元组进行相加生成新的元组；

2.3 删除

元组中的元素不能进行删除，但是可以使用del语句删除整个元组。

元组删除后不允许再次访问。

2.4 迭代器、多维元组

用法同列表。

2.5 其他操作

• tuple(seq)：将序列转换为元组
• tuple.count(obj)：统计某个元素在列表中出现的次数
• tuple.index(obj,[start,[stop]]])：从列表中找到某个元素第一次出现的索引位置，可通过start和stop设置搜索范围。

3.元组的优势

• 可以使函数返回多个值
• 可以使程序运行性能提升
• 一般来说，创建元组类型tuple的变量比列表类型list要快，而且占用更小的存储空间。
• 使用元组是线程安全的
• 元组类型变量的元素不可更改性，可保证多线程读写时的安全问题。

四、字典（dict）

1.字典的创建

格式：

变量名={key1:value1, key2:value2,…, keyn:valuen}

字典推导式：

变量名 = { key表达式:值表达式 for var in range }

• 字典的元素是可变的，可以是列表、元组、字典等任意数据类型；
• 键（key）值必须使用不可变的类型。
• 在一个字典中，key值必须是唯一的。

2.基本操作

2.1 获取字典元素

字典的的元素是无序的，只能通过key值获取对应元素。

不能通过索引获取。

2.2 修改

通过key值获取字典之后可以对value进行操作修改。

2.3 删除

字典可以使用del删除某个元素或者整个字典。

2.4 字典的嵌套

字典是可以嵌套的，与多为数组类似

2.4 其他操作

• str(dict)：将字典转换成字符串；
• radiansdict.clear()：清空字典元素
• radiansdict.copy()：复制一个字典
• radiansdict.fromkeys()：创建一个字典，一序列中的元素作为键值，value为字典所有键对应的初始值
• radiansdict.get(key,default = None)：返回指定键的值，如果值不存在，则返回default值；
• key in radiansdict：判断key是否在字典中，在返回True,否则返回False
• radiansdict.items()：以列表的形式返回可遍历的(key,value)元组数组
• radiansdict.keys()：以列表形式返回字典的所有键
• radiansdict.setdefault(key,default = None)：如果键值不存在，则创建一个键，设置值为default的值
• radiansdict.update(dict2)：把字典dict2键/值对更新到原字典中
• radiansdict.values()：以列表返回字典中的所有值

示例：

# _*_ coding:utf-8 _*_
 
dict1 = {1:"元素1",2:"元素2",3:'元素3'}
print("字典:",dict1)
 
print("字典str(dict1):",str(dict1))
dict1.clear()
print("\n")
print("清空字典:",dict1)
dict1 = {1:"元素1",2:"元素2",3:'元素3'}
print("字典:",dict1)
print("dict1.copy():",dict1.copy())
print("dict1.fromkeys([1,2,3]):",dict1.fromkeys([1,2,3]))
print("dict.fromkeys([1,2,3]):",dict.fromkeys([1,2,3]))
print("dict1.get(1):",dict1.get(1))
print("dict1.get(5):",dict1.get(5))
print("dict1.get(5,None):",dict1.get(5,None))
print("dict1.get(5,True):",dict1.get(5,True))
print("1 in dict1:", 1 in dict1)
print("5 in dict1:", 5 in dict1)
print("dict1.items():",dict1.items())
print("dict1.keys():",dict1.keys())
 
print("dict1.setdefault(1)",dict1.setdefault(1))
print("dict1.get(1):",dict1.get(1))
 
print("dict1.setdefault(5)",dict1.setdefault(5))
print("dict1.get(5):",dict1.get(5))
print("dict1.setdefault(6,True):",dict1.setdefault(6,True))
print("dict1.get(6):",dict1.get(6))
 
print("dict1.update({1:'元素a',2:'元素b',3:'元素3',4:'元素4'}):",dict1.update({1:"元素a",2:"元素b",3:'元素3',4:'元素4'}))
print("updated字典:",dict1)
print("dict1.values():",dict1.values())

结果：

五、集合（set）

1.集合的创建

格式：       

变量名 = {元素1,元素2,...，元素n}

特点：

• 无序性：元素之间没有确定的顺序；
• 互异性：集合中不会出现重复的元素；
• 确定性：元素与集合只有属于和不属于的关系
• 用set()创建空集合，{}表示一个空的字典

2.集合的数学运算

3.基本操作

• add()：添加一个元素

• update()：同时添加多个元素

• remove()：删除集合中特定的元素，元素不存在时会报错

• discard()：删除集合中的特定元素，元素不存在时不会报错。

• set()：转换为集合

4.不可变集合

使用frozenset()方法创建的集合时不可变的，不能进行更改和删除。

示例：

# _*_ coding:utf-8 _*_
 
set1 = {"元素1","元素2",'元素3'}
set2 = {"元素3","元素4",'元素5'}
print("set:",set1)
print(type(set1))
 
print("set1|set2:",set1|set2)
print("set1&set2:",set1&set2)
print("set1-set2:",set1-set2)
print("set1^set2:",set1^set2)
print("set1.add('元素6'):",set1.add('元素6'))
print("set1.add('元素7','元素8'):",set1.update('元素7','元素8'))
print("set1.discard('元素1'):",set1.discard('元素1'))
print("set:",set1)
print("set1.discard('元素9'):",set1.discard('元素9'))
print("set:",set1)
print("set1.remove('元素2'):",set1.remove('元素2'))
print("set:",set1)
print("set1.remove('元素9'):",set1.remove('元素9'))
print("set:",set1)

结果：

六、列表、元组、字典和集合的区别