目录
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}