三、python数据类型2组合数据类型

目录

一、集合类型

1.定义

2.集合类型初始化

3.集合操作符

（1）基本操作符：

（2）增强操作符：

3.集合的处理方法

4.集合类型应用场景

二、序列类型

1.序列类型定义

2.序列处理函数及方法

3.元组类型及操作

4.列表类型及操作

（1）列表类型定义：

（2）函数或方法：

5.序列类型的应用场景

6. 相关操作

（1）排序

三、字典类型

1.字典类型定义

2.字典处理函数及方法

 

---

python数据类型1:https://blog.csdn.net/sandalphon4869/article/details/88546235 

---

功能	集合	元组	列表	字典
添加	s.add()	不可更改	l.append()	d1.update(d2)或者d[新增键]=新值
元素个数	len(s)	len(t)	len(l)	len(d)

 

一、集合类型

1.定义

集合类型：

（1）集合是多个元素的无序组合

（2）集合类型与数学中的集合概念一致

（3）集合元素之间无序，每个元素唯一，不存在相同元素

（4）集合元素不可更改，不能是可变数据类型（万一可变，就可能相同）

 

非可变数据类型：整数，浮点数，复数，字符串，元组类型

可变数据类型：列表

 

2.集合类型初始化

表示：

（1）集合用大括号{}表示，元素间用逗号分隔

（2）建立集合类型用{}或set()

（3）建立空集合类型，必须用set()

#{}表示
a={"123",13,True}
print(a)
#{'123', 13, True}

#set()表示
s=set("123")
print(s)
#{'1', '2', '3'}

#set()试错

#一个元素用单引号
a=set('1')
print(a)
#{'1'}

#多个元素用单引号
b=set('123')
print(b)
#{'2', '3', '1'}

#多个元素间用逗号间隔
set('1','2','3')
#error

#多个元素
ls=["py123",123,True]
c=set(ls)
print(c)
#{'py123', 123, True}

"""
总结：set()中传入的参数是一个其他类型的变量，'1'和'123'都是字一个符串类型的量，'1','2','3'错是因为它是多个元素，
要传入特定的多个元素，就要像ls一样将它们包装到另一种类型中成为一个变量。
"""

3.集合操作符

（1）基本操作符：

S|T ： 并，返回一个新集合，S和T中的所元素

S-T ： 差，返回一个新集合，在S但不在T中的元素

S&T ： 交，返回一个新集合，S和T都有的元素

S^T ： 补，返回一个新集合，S和T中的非相同元素

S<=T或S<T ：返回True/False，判断S和T的子集关系

S>=T或S>T ：返回True/False，判断S和T的包含关系

A={"p","y",123}         #{'y', 123, 'p'}
B=set("pypy123")        #{'1', 'y', '2', '3', 'p'}

print(A-B)
#{123}
print(B-A)
#{'3','1','2'}
print(A&B)
#{'p','y'}
print(A|B)
#{'1','p','2','y','3',123}
print(A^B)
#{'2','1','3',123}

 

（2）增强操作符：

S|=T ：更新集合S，包括在集合S和T中的所有元素

S-=T ：更新集合S，包括在集合S但不在T中的元素

S&=T ：更新集合S，包括同时在集合S和T中的元素

S^=T ：更新集合S，包括集合S和T中的非相同元素

3.集合的处理方法

S.add(x) ：    如果x不在集合S中，将x增加到S

S.discard(x) ：移除S中元素x，如果x不在集合S中，不报错

S.remove(x) ： 移除S中元素x，如果x不在集合S中，产生KeyError异常

S.clear() ：   移除S中所有元素

S.pop() ：     随机返回S的一个元素，同时在集合中移除这个元素并更新S，若S为空产生KeyError异常

S.copy() ：    返回集合S的一个副本

len(S) ：      返回集合S的元素个数

x in S ：      判断S中元素x，x在集合S中，返回True，否则返回False

x not in S ：  判断S中元素x，x不在集合S中，返回False，否则返回True（和上面一样，都是在则True）

set(x) ：      将其他类型变量x转变为集合类型

4.集合类型应用场景

#数据去重：集合类型所有元素无重复
ls=["p","p","y","y",123]
s=set(ls)               #利用集合无重复元素的特点
print(s)
#{'p','y',123}

for x in s:             #将集合转换为列表
    lt.append(x)
print(lt)
#['p','y',123]


#lt=list(s)#直接转换会TypeError报错

二、序列类型

1.序列类型定义

序列：

（1）序列是具有先后关系的一组元素

（2）序列是一维元素向量，元素类型可以不同

（3）序列类型是一种基类，衍生类型为：字符串类型、元组类型和列表类型

 

序列的序号：

就是那个正向递增序号和反向递减序号

2.序列处理函数及方法

6个操作符：

（1）x in s ：如果x是序列s的元素，返回True，否则返回False

（2）x not in s ：如果x是序列s的元素，返回True，否则返回False

（3）s+t ：连接两个序列s和t

（4）s*n或n*s ：将序列s复制n次

（5）s[i] ：索引，返回s中的第i个元素，i是序列的序号

（6）s[i:j]或s[i:j:k]：切片，返回序列s中第i到j以k为步长的元素子序列

 

5个函数和方法：

（1）len(s) ：返回序列s的长度

#列表
list = [123, 'xyz', 'zara']
print(len(list))
#3

#元组
t=(1,2,3)
print(len(t))
#3

（2）nin(s) ：返回序列s的最小元素，s中元素需要可比较

（3）max(s) ：返回序列s的最大元素，s中元素需要可比较

（4）s.index(x)或s.index(x,i,j)：返回序列s从i开始到j位置中第一次出现元素x的位置

（5）s.count(x)：返回序列s中出现x的总次数

 

3.元组类型及操作

元组类型：

（1）元组是序列类型的一种扩展，一旦创建就不能被修改

（2）使用小括号()或tuple()创建，元素间用逗号，分隔

（3）可以使用或不使用小括号

#例1：
def func()
    return 1,2
#这个1，2就是一种不使用小括号的元组类型

#例2：
creature="cat","dog","tiger","human"
print(creature)
('cat','dog','tiger','human')
print(creature)
('cat', 'dog', 'tiger', 'human')
#不像集合，原元组未改变，序列类型有特定的顺序
color=(0x001100,"blue",creature)
print(color)
(4352,'blue',('cat','dog','tiger','human'))

#例3：
creature="cat","dog","tiger","human"
print(creature[::-1])
#('human', 'tiger', 'dog', 'cat')
color=(0x001100,"blue",creature)
print(color[-1][2])        #[-1]是creature,[-2]是creature变量里的[2]tiger
#'tiger'

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,)

4.列表类型及操作

（1）列表类型定义：

（1）列表是序列类型的一种扩展，创建后可以随意被修改

（2）使用方括号[]或list()创建，元素间用逗号，分隔

（3）可以使用或不使用小括号

#例1：
ls=["cat","dog","tiger",1024]
print(ls)
['cat', 'dog', 'tiger', 1024]

#方括号[]真正创建一个列表，赋值仅传递引用
lt=ls			
print(lt)
#['cat', 'dog', 'tiger', 1024]
lt[0]="change"
print(lt)
#['change', 'dog', 'tiger', 1024]
print(ls)
#['change', 'dog', 'tiger', 1024]

#嵌套序列(比如由一组等长列表组成的列表)
data=[[1,2,3],[4,5,6]]
print(data)
#[[1, 2, 3], [4, 5, 6]]

（2）函数或方法：

（1）ls[i]=x： 替换列表ls第i元素为x

（2）ls[i:j:k]=lt： 用列表lt替换ls切片后所对应元素子列表

（3）del ls[i]： 删除列表ls中第i元素

（4）del ls[i:j:k]： 删除列表ls中第i到第j以k为步长的元素

（5）ls+=lt： 更新列表ls，将列表lt元素增加到列表ls中

（6）ls*=n： 更新列表ls，将元素重复n次

（7）ls.append(x)： 在列表ls最后增加一个元素x

（8）ls.clear()： 删除列表ls中所有元素

（9）ls.copy()： 生成一个新列表，赋值ls中所有元素

（10）ls.insert(i,x)： 在列表ls的第i位置增加元素x

（11）ls.pop(i)： 将列表ls中第i位置元素取出并删除该元素

（12）ls.remove(x)： 将列表ls中出现的第一个元素x删除

（13）ls.reverse()： 将列表ls中的元素反转

#例2：
ls=["cat","dog","tiger",1024]			#ls[0]='cat'
ls[1:2]=[1,2,3,4]
print(ls)
#['cat', 1, 2, 3, 4, 'tiger', 1024]

del ls[::3]
print(ls)
#[1,2,4,'tiger']

#例3：
ls=["cat","dog","tiger",1024]
print(ls*2)				
#['cat', 'dog', 'tiger', 1024,'cat', 'dog', 'tiger', 1024]

#例4：
ls=["cat","dog","tiger",1024]
ls.append(1234)
print(ls)
#['cat', 'dog', 'tiger', 1024, 1234]

ls.insert(3,"human")
print(ls)
#['cat', 'dog', 'tiger', 'human', 1024, 1234]

ls.reverse()
print(ls)
#[1234, 1024, 'human', 'tiger', 'dog', 'cat']

#例5：
#定义空列表lt
lt=[]
#向lt新增5个元素
lt+=[1,2,3,4,5]
#修改lt中第2个元素
lt[2]=6
#向lt中第2个位置增加一个元素
lt.insert(2,7)
#从lt中第1个位置删除一个元素
del lt[1]
#删除lt中第1-3位置元素
del lt[1:4]
#判断lt中是否包含数字0
print(0 in lt)          #False
#向lt新增数字0
lt.append(0)
#print(lt)               #[1, 5, 0]
#返回数字0所在lt中的索引
print(lt.index(0))      #2
#lt的长度
print(len(lt))          #3
#lt中最大元素
print(max(lt))          #5
#清空lt
lt.clear()

5.序列类型的应用场景

应用场景：

（1）元组用于元素不改变的应用场景，更多用于固定搭配场景

（2）列表更加灵活，它是最常用的序列类型

（3）最主要的作用：表示一组有序数据，进而操作它们

 

数据保护：

-如果不希望数据被程序所改变，转换成元组类型

ls=["cat","dog","tiger",1024]
lt=tuple(ls)
print(lt)
#('cat', 'dog', 'tiger', 1024)

6. 相关操作

（1）排序

b=[5,3,4]
b=sorted(b)
print(b)
#[3,4,5]

三、字典类型

1.字典类型定义

理解映射：

-映射是一种键（索引）和值（数据）的对应

-序列类型有0...N整数作为数据的默认索引

字典类型：

（1）字典类型是映射的体现

（2）键值对：键是数据索引的扩展

（3）字典是键值对的集合，键值对之间无序

（4）采用大括号{}和dict()创建，键值对用冒号:表示

（5）

格式：

<字典变量>={<键1>:<值1>,<键2>:<值2>}

<值>=<字典变量>[<键>]

<字典变量>[<键>]=<值>

#[]用来向字典变量中索引或增加元素

#生成一个字典
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d)
#{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}

print(d["中国"])
#'北京'


#生成一个空的字典
de={};
print(type(de))		#type(x)返回变量x的类型
#<class 'dict'>

2.字典处理函数及方法

函数或方法；

（1）del d[k]：删除字典d中键k对应的数据值

（2）k in d：判断键k是否在字典d中，如何在返回True，否则返回False

（3）d.keys()：返回字典d中所有的键信息

（4）d.values()：返回字典d中所有的值信息

（5）d.item()：返回字典d中所有键值对信息

（6）d.get(k,<default>)：键k存在，则返回相应值，不在则返回<default>值

（7）d.pop(k,<default>)：键k存在，则取出相应值，不在则返回<default>值

（8）d.popitem()：随机从字典d中取出一个 键值对，以元组形式返回

（9）d.clear()：删除所有的键值对

（10）len(d)：返回字典d中元素的个数

（11）d1.update(d2)：添加字典2添加到字典1中

d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}

print("中国"in d)
#True

print(d.keys())
#dict_keys(['中国', '美国', '法国'])	    #可以for遍历

print(d.values())
#dict_values(['北京', '华盛顿', '巴黎'])

print(d.get("中国","伊斯兰堡"))
#'北京'

print(d.get("巴基斯坦","伊斯兰堡"))
#'伊斯兰堡'

print(d.popitem())
#('法国', '巴黎')

#增加相同元素会出现更新

d={}

#增加元素方法1：d[新增键]=新值
d["a"]=1;d["b"]=2
print(d)
#{'a': 1, 'b': 2}

#更新现象
d["b"]=3
print(d)
#{'a': 1, 'b': 3}

#增加元素方法2：d1.update(d2)
d2={'c':3}
d.update(d2)
print(d)
#{'a': 1, 'b': 3, 'c': 3}

#更新现象
d3={'c':9}
d.update(d3)
print(d)
#{'a': 1, 'b': 3, 'c': 9}