Python-数据类型2

序列

1.python中有一些基本数据类型，它们的成员是有序排列的，并且可以通过下标访问成员，这些类型称之为序列。

2.列表属于元素可变序列；元组和字符串属于元素不可变序列：字典，集合都不属于序列。

3.序列有共同操作：

    - 成员关系运算（in,not in)
    - 连接操作（+）
    - 重复操作（*）
    - 切片操作（[::]）
    - 最值(max(),min())
    - 元素个数len()
    - 枚举enumerate（下标和元素）

一、列表

列表是一种可以同时存储多个数据的数据模型（容器），成员可修改的有序数列。

1.列表的创建

格式：列表名 = [元素一，元素二，元素三.....]

list1 = []   # 创建一个空列表 
list2 = list()  # 创建一个空列表
list3=[1,2,python,"程序员"，[1,2,],(1,2), ... ]  # 元素可包含多种数据类型

 

2.列表元素访问

访问格式：列表名[索引]  # 索引的是指下标[sub]（下标从0开始）
修改格式：列表名[索引] = 新的元素值

list1 = []   # 创建一个空列表 
list2 = list()  # 创建一个空列表
list3 = [1,2,python,"程序员"，[1,2,],(1,2), ... ]  # 元素可包含多种数据类型

3.列表增加

list.append(obj)  

 注解：在列表末尾添加新的元素，返回值为None；obj代表普通元素,列表,元组,字典等对象。

list=[1,2,3,4,5]
list2=[1,2,3]
str="python"
set=(1,2)
list.append(0)     # 添加单个普通元素
list.append(list2) # 添加列表
list.append(str)   # 添加字符串
list.append(set)   # 添加元组
print(list)
list=[1, 2, 3, 4, 5, 0, [1, 2, 3], 'python', (1, 2)]

list.extend(obj)  

 注解：在列表的末尾一次性追加另一个非数值型的元素，返回值为None；obj可以是列表，元组，集合，字典，字符串；不能是整型。

 

list=[1,2,3]
list2=[1,3]
str="python"
set=(1,2)
list.extend([0])   # 添加单个元素列表
list.extend([1,2]) # 添加列表
list.extend(list2) # 添加列表
list.extend(str)   # 添加字符串
list.extend(set)   # 添加元组
print(list)
[1, 2, 3, 0, 1, 2, 1, 3, 'p', 'y', 't', 'h', 'o', 'n', 1, 2]

 

list.insert(i,obj)

 注解：在指定下标i的位置插入一个新元素，原来的元素后移，不会覆盖，返回值为None；obj是普通元素,列表,元组,字典等对象。

list=[1,2,3]
list2=[1,3]
str="python"
set=(1,2)
list.insert(1,5)     # 添加单个元素列表
list.insert(1,list2) # 添加列表
list.insert(1,str)   # 添加字符串
list.insert(1,set)   # 添加元组
print(list)
#[1, (1, 2), 'python', [1, 3], 5, 2, 3]

3.列表删除

list.pop(i)       

注解：删除指定下标i的元素，并返回新列表i下标对应元素value; pop()默认删除最后一个元素，并返回该元素的值。

list=[1,2,3,4,5,6,7,8,9]
list.pop(0)  # 删除第一个值
list.pop()   # 删除最后一个值
list.pop(5)  # 删任意值（超出下标最值会报错）
print(list)
#[2, 3, 4, 5, 6, 8]

list.remove(x)    

 注解：删除列表中第一个值等于x的元素：x指值，返回值为None（不是下标）；要删除的元素不存在会报错。

 

list=[1,2,3,4,5,2,7,2,9]
list.remove(2)
print(list)
[1, 3, 4, 5, 2, 7, 2, 9]

del list[i]       

注解：按下标删除,无返回值 

 

list.clear()      

注解：清空列表[]，返回值为None

list=[1,2,3,9]
list.clear()       # 清空列表[]，返回值为None
print(list)
[]

4.列表查找

list.index(x,start,end)

注解：在[start，end)范围内查找第一个等于x的元素的下标，返回值为下标

list=[1,2,3,5,3,6,9]
sub=list.index(3)
print(sub)

list.count(x)          

 注解：查找列表中x出现的次数，返回次数；如果没有x返回0

list=[1,2,3,5,3,6,3,9]
num=list.count(3)
print(num)

enumerate 

注解:将列表变成一个索引序列 ,index表示下标，value表示元素值,一一对应。
for index,value in enumerate(list1):
    print(index,value)

list=[1,2,3,5,3,6,3,9]
for index,value in enumerate(list):
    print(index,value,end="/")
0 1/1 2/2 3/3 5/4 3/5 6/6 3/7 9/

5.列表排序

list.sort(key=None,reverse=None)    
注解：key参数指明用哪个函数进行排序，默认值是None，用<进行比较，可选参数。

注解：reserse：布尔值，默认值是None，从小到大排序，如果设置为True，则从大到小排序，可选参数，返回值None

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

list.reverse()            

 注解:列表元素逆序排列，返回值为None

list=[1,2,3,5,6,8,9]
list.reverse()
print(list)
#[9, 8, 6, 5, 3, 2, 1]

6.列表生成式
range(start,end,step=1)   
list(range())             

注解：参数：start为开始值，默认是0，，end是结束（不包含结束值），step是步长

list1=list(range(0,12,2))
print(list1)
#[0, 2, 4, 6, 8, 10]

7. 列表推导式

格式：[ 表达式   for循环   if条件]

基础语法格式： 循环变量   for循环
范例：list1 = [data     for data in range(5)]

数据处理语法格式：表达式     for循环
范例：list1 = [data*5    for data in range(5)]

数据过滤语法格式：表达式    for循环      if判断
范例：list1 = [data     for data in range(5)    if data > 2]

 

二、序列通用操作

有序数列都通用，包括列表，字符串，元组；集合，字典不可通用。

1.列表切片

列表的截取【分片，切片】
语法：列表名[开始下标:结束下标：步长]，表示按指定步长获取从开始下标到结束下标之间的元素，
结果：为一个新的列表
注意：包头不包尾【前闭后开区间】   [开始下标,结束下标)
步长：默认是1，正数表示从左向右取，负数表示从右向左取

list1 = [10,20,30,40,50,60]
print(list1[0:3])      #[10,20,30]
print(list1[:3])       #[10,20,30]
print(list1[2:])       #[30, 40, 50, 60] 从下标为2的元素开始取到末尾
print(list1[:])        #[10,20,30,40,50,60] 从头取到尾
print(list1[::2])      #[10,30,50] 隔一个取一个
print(list1[3:0:-1])   #[40, 30, 20]  从右向左取
print(list1[-1:-3:-1]) #[60, 50] 从右向左取
print(list1[-3::-1])   #[40, 30, 20, 10] 从右向左取到第一个元素

2.列表长度

语法：len()
print(len(list1))

list1 = [10,20,30,40,50,60]
print(len(list1))  # 6

3.列表最值

语法：max()、min()

 

list1 = [10,20,30,40,50,60]
print(max(list1))  # 60
print(min(list1))  # 10

 

4.成员操作

成员运算符：in    not in

注解：运算的结果为布尔值

list= ["hello",False,361,"good"]
print361 in list)       # True
print(361 not in list)  # True

5.列表组合

+ ：相加

*：相乘

list1 = [3,5,7,9]
list2 = [11,77,99,22,66]
print(list1 + list2)  # [3, 5, 7, 9, 11, 77, 99, 22, 66] 
print(list1 * 2)      # [3, 5, 7, 9, 3, 5, 7, 9]

 三、元组　

　元组和列表相似，数据处理类似，但元组属于不可变序列。故元组，不能修改元素的值。
1.元组创建
格式：变量名=(数据1， 数据2， 数据3...)

tuplet1 = ()             # 创建一个空元组
uplet2 = tuple()         # 空元组
tuple3 = tuple(数据1，)   # 单个数据

 2.元组的组包和拆包

组包：将多个数据赋值给一个变量时，多个数据将包装成一个元组。

注解：a=1,2，...  a的数据类型是tuple        `
解包：将元组赋值给多个变量时，变量个数和元素个数一致。

注解：a,b，...=(1,2,...)

四、集合　　

集合是一种存储大量无序不重复数据的存储模型。
1.集合创建
变量名={数据1， 数据2， 数据3...} 

set1 = set()  # 空集合  
set2 = set{}  # 不能是{}，这是字典

2.集合增加

set.add(ojb)

注解：obj必须是不可变的元素，或者元组。

set = {1,2,3,4,5}
tuple=(1,2,3)
set.add(6)
print(set)
set.add(tuple)
print(set)
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, (1, 2, 3)}

set.update(obj) 

注解：obj必须是可迭代的对象：列表、元组、字符串、字典,update会把对象打碎添加到集合中。 

s1 = {1,2,3,4}
s1.update([5,6])
s1.update((7,8))
s1.update({9,0})
s1.update('hello')
s1.update({'1':10,'2':20})
print(s1)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'h', 'l', 'o', 'e', '2', '1'}

五、字典

　　字典不属于序列，元素存放无序，是通过哈希方式进行数据存取的，字典是一个可变容器，字典中保存一个个的键值对： key : value。字典中键必须是唯一的，必须是不可变类型。

1.字典创建
格式:变量名={‘键1’: 值1,‘键2’: 值2 , } 

dict1 = {}      # 空字典
dict1 = dict()  # 空字典

 2.元素访问

字典名[key]       # 假如key找不到，dict[key]会抛异常，
字典名.get(ket)   # 假如key找不到，get(key) 则返回None

 3.元素增加

　dict1["key"]=值  

 注解：当指定的键不存在的时候，则表示添加；如果键已经存在，则表示修改value

 4.元素删除

dict.pop("key")

注解：删除并返回指定键对应的值,注意：通过键，直接删除整个键值对 

  5.字典遍历

格式一：只获取键

for key in dict:
    value = dict[key]
    print(key,value)

dict = {"jack":78,"han":99,"li":60,"wang":50}
for key in dict:
    print(key,end=" ")
#jack han li wang 

 

格式二：只获取值

注解：values,得到的结果是一个列表，当做列表处理

for value in dict.values():
    print(value)   
print(dict.values())

dict = {"jack":78,"han":99,"li":60,"wang":50}
for value in dict.values():
    print(value,end=" ")
print("")
print(dict.values())
78 99 60 50 
dict_values([78, 99, 60, 50])

方式三：同时获取键和值

注解：items,得到的结果是一个列表，列表中的元素是元组

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

dict = {"jack":78,"han":99,"li":60,"wang":50}
for key,value in dict.items():
    print(key,value)
print(dict.items()) 
*****************
jack 78
han 99
li 60
wang 50
dict_items([('jack', 78), ('han', 99), ('li', 60), ('wang', 50)])

 

 六、for-in-else循环

语法：  

for 变量名 in 列表：
    语句A
else:
    语句B
说明：主要用于遍历列表【遍历：依次访问列表中的每一个元素,获取元素值】
工作原理：按照顺序获取列表中元素，赋值给变量，再执行语句A，直到列表中的元素全部获取为止，循环终止后执行else语句块。

提示： for 循环体中的break 可终止 else的执行。