python语言两大数据类型
前言:
前期分享了基本数据类型的概念你学废了吗?任何一种语言的学习都要多敲多练,掌握基本知识很重要,基础不牢地动山摇!加油吧学习人!!
下面进入正题
组合数据类型:
1、序列类型:字符串类型、元组类型、列表类型
2、集合类型
3、字典类型
序列类型:
前期基本数据类型的文章分享了字符串的基本使用方法,今天主要分享元组和列表的使用,列表尤其重要!!
序列类型既然包含字符串类型、元组类型、列表类型,那么前期介绍的字符串的操作符和函数元组和列表能否试用呢?
**序列类型的**通用操作符和函数**:(s,x,y各表示一个序列)**
x+y表示连接序列x,y;
x*n表示将x复制n次;
x in s判断x是否在s内,正确返回True,错误返回False
x not in s判断x是否不在s内,正确返回True,错误返回False
s[i]表示索引,返回第i个元素;
s[N:M]表示切片,返回索引第N到第M个元素,不包含M
s[N:M:K]步骤切片,以K为步长进行切片
len(s)返回序列s的长度(元素个数)
min(s)返回s中最小元素
max(s)返回s中最大元素
s.count(a)返回s中元素a出现的次数
s.index(a)返回s中元素a第一次出现的位置(可设置范围)
>>> s="python学习" #字符串
>>> x="python","学习","123456"#元组
>>> y=["python","学习","123456"]#列表
>>> "学习" in s
True
>>> "学习" in x
True
>>> "学习" in y
True
>>> s[0] #序列类型正向序号是从0-->开始;反向是从-1-->开始
'p'
>>> x[0]
'python'
>>> y[0]
'python'
>>> s[0:3]#等效于s[:3],未定义初始位置时默认从序号0开始
'pyt'
>>> x[0:2]
('python', '学习')
>>> y[0:3]
['python', '学习', '123456']
>>> len(s)
8
>>> len(x)
3
>>> len(y)
3
>>> min(s)
'h'
>>> min(x)
'123456'
>>> min(y)
'123456'
>>>
学废了吗?要不要动手试试?
1、元组类型:
**特点:**
1.使用()或tuple()进行创建,元素之间用逗号分割
2.一旦创建就不能被修改
3.可嵌套使用
4.可以使用或不使用小括号
**#创建**
>>> c = "dog","cat","tiger","pen","hours" #不使用小括号创建
>>> c
('dog', 'cat', 'tiger', 'pen', 'hours')
>>> c =("dog","cat","tiger","pen","hours") #使用小括号创建
>>> c
('dog', 'cat', 'tiger', 'pen', 'hours')
**#嵌套使用及索引**
>>> c = "dog","'pig','123'"
>>> c
('dog', "'pig','123'")
>>> c[1][0]
"'"
>>> c[1]
"'pig','123'"
>>> c[1][2]
'i'
2、列表类型:
**特点:**
1.使用[]或list()创建,内部逗号分割。很显然前者创建方式简单
2.列表内各元素类型可以不同,无长度限制
3.创建后可以随意更改---因为有操作函数
4.可嵌套使用
**列表类型的操作符和函数:(ls,lt定义为列表类型)**
作为强大的类型仅仅上面那些通用操作符远不能支撑它的地位。。。
ls[i]=x 替换列表中第i个元素为x
ls[i:j]=lt 将列表lt从序号i开始插入到ls中
del ls[i] 删除ls中第i个元素
del ls[i:j] 删除ls中从序号i-->j且不包含第j个的元素
del ls[i:j:k] 删除ls中从序号i-->j且不包含第j个的元素,步长为k
ls += lt 将lt元素加大ls中(等效于ls.extend(lt))
ls.append(x) 将元素x加到ls尾部
ls.sort() 将列表内元素升序排列(或ls.sorted())
ls.reverse() 将列表元素反转 (等效于ls[::-1])
ls.clear() 清空列表
ls.remove(x) 从列表ls中去除第一次出现元素x
ls.insert(i,x) 将元素x插入到ls中第i个位置
ls.pop(i) 将ls中第i个元素取出并删除该元素
>>> ls=list(range(6)) #创建范围为6的列表ls
>>> ls
[0, 1, 2, 3, 4, 5]
>>> lt=[1,4,7,2,5,8] #创建列表lt
>>> ls[2]=9 #将列表ls中的序号为2个元素替换为数字9,序列类型正向序号是从0-->开始;反向是从-1-->开始
>>> ls
[0, 1, 9, 3, 4, 5] #数字2被替换为9
>>> ls[5:] = lt #从序号为5的位置开始插入lt的元素
>>> ls
[0, 1, 9, 3, 4, 1, 4, 7, 2, 5, 8]
>>> del ls[1] #删除序号为1的元素
>>> ls
[0, 9, 3, 4, 1, 4, 7, 2, 5, 8] #原列表ls中的数字1被删除
>>> del ls[4:] #从序号4开始删除
>>> ls
[0, 9, 3, 4]
>>> ls += lt #将列表lt中的元素插入ls中
>>> ls
[0, 9, 3, 4, 1, 4, 7, 2, 5, 8]
>>> ls.append('a') #向ls尾部插入元素‘a'
>>> ls
[0, 9, 3, 4, 1, 4, 7, 2, 5, 8, 'a']
>>> ls.sort() #错误异常,原因列表ls中有字符类型a
Traceback (most recent call last):
File "<pyshell#49>", line 1, in <module>
ls.sort()
TypeError: '<' not supported between instances of 'str' and 'int'
>>> l=[7,5,8,9,1,2,3] #为验证sort()函数,创建一个新列表
>>> l.sort() #排序
>>> l
[1, 2, 3, 5, 7, 8, 9]
>>> ls.reverse() #继续以列表ls为列操作,也可用其他列表实验反转函数
>>> ls
['a', 9, 8, 7, 5, 4, 4, 3, 2, 1, 0]
>>> ls.remove(9) #去元素9
>>> ls
['a', 8, 7, 5, 4, 4, 3, 2, 1, 0]
>>> ls.insert(0,'b') #在0位置插入元素b
>>> ls
['b', 'a', 8, 7, 5, 4, 4, 3, 2, 1, 0]
>>> ls.pop(2) #从ls中取出序号为2的元素
8
>>> ls #取出的元素8被原列表删除
['b', 'a', 7, 5, 4, 4, 3, 2, 1, 0]
>>>
**列表的嵌套:二维列表为例**
>>> list=[[1,2,3],['a','b','c'],['@!#','$%&']]
>>> list[0] #列表中序号为0的元素
[1, 2, 3]
>>> list[0][0] #列表中序号为0的元素中的第0个元素
1
>>> list[2][-1][0] #列表中序号为2的元素中的第-1个元素中的第0个元素
'$'
集合类型:
特点:
1.互异性、唯一性、无序性
2.内部元素不能是可变数据类型
3.使用{}创建,创建空集合时尽量使用set()创建避免与字典创建相同
4、满足高中数学中的集合运算(交集'&'、差集'-'、补集'^'、并集'|')
集合类型操作符和函数:(s=set() 创建空集合s)
s.add(x) 如果元素x不在集合s中,则加入其中
s.clesr() 清空集合s
s.pop() 从集合s中随机取出一个并从原集合中删除,集合为空时报错
s.copy() 返回集合s副本
s.remove(x) 从集合s中去除元素x ,x不在集合s中不报错
s.discard(x) 等效于s.remove,x不在集合s中报错
x in s 判断元素x是否在集合s,在返回True 不在返回False
x not in s 判断元素x是否在集合s,不在返回True 在返回False
len(s) 返回集合s的元素个数
>>> s=set()#空集合创建方式
>>> type(s)
<class 'set'>
>>> s={1,2,3,'a','$'} #非空集合创建
>>> s.add('b')
>>> s
{1, 2, 'a', 3, '$', 'b'}
>>> s.pop() #与列表中的pop()函数不一样,集合时随机返回一个,列表则是给定序号再返回值
1
>>> s
{2, 'a', 3, '$', 'b'}
>>> s.remove(2) #与列表remove()函数区别:集合时给出指定的元素,列表时=是给出指定的元素序号
>>> s
{'a', 3, '$', 'b'}
>>> 'a' in s
True
>>> 1 not in s
True
>>> len(s) #返回元素的数量
4
**集合运算:**(s,t各为一个集合)
s - t 求集合s和集合t差集
s & t 求集合s和集合t的交集
s | t 求集合s和集合t的并集
s ^ t 求集合s和集合t的并集并去除公有元素
s <= t 判断集合s是否是集合t的子集 是则返回True 不是则返回False
s >= t 判断集合t是否是集合s的子集 是则返回True 不是则返回False
>>> s
{'a', 3, '$', 'b'}
>>> t={1,2,3,'a'}
>>> s-t
{'$', 'b'}
>>> s&t
{3, 'a'}
>>> s|t
{1, 2, 3, 'a', '$', 'b'}
>>> s^t
{1, 2, '$', 'b'}
>>> s <= t
False
>>> s >= t
False
字典类型
映射:
分享字典类型前先聊一下我眼中的**映射**(在某一方面像极了高中数学函数)那什么是映射?映射体现在**键值对**上,就是每个键有与之相对应的值,类似于高中数学函数中对给定的自变量,函数都有唯一对应的值,这里的**键**可理解为**自变量**,**值**对应函数表达式,只是写出来方式不一样罢了
比如函数表示F(x)=3x+1;则x就是**键** 对应的**表达式**就是**值**,
键值对表达方式:x : 3x+1 中间用冒号分割;
字典就是有一个个键值对构成的集合!
**特点:**
1.一个键对应一个信息,这个信息可以是序列类型也可以是集合类型
2.空字典用{}创建,键值对与键值对之间用逗号分割
3.无序性
**字典类型的操作**(以k为字典)
k["a"]=1 创建新的键值对'a' : 1,如果字典已存在键'a'则对该键重新赋值
k.keys() 返回所有的键信息
k.values() 返回所有的值信息
k.items() 返回所有的键值对
k.get(key,value) 如果字典k中存在该键值对则返回值信息,不存在返回默认值
k.pop(key,value) 如果字典k中存在该键值对则返回值信息,不存在返回默认值
k.popitem() 随机返回一个键值对信息,以元组形式返回(key,value)
del k[key] 从字典中删除该键值对信息
<key> in k 判断键是否在字典k中,在就返回True,不在返回False
**一个键对应一个信息,这个信息可以是序列类型也可以是集合类型**
>>> k[2]=(1,2,3)
>>> k
{'china': '中国', '1': '123', 1: 123, 2: (1, 2, 3)}
>>> k[3]=[1,2,'a']
>>> k
{'china': '中国', '1': '123', 1: 123, 2: (1, 2, 3), 3: [1, 2, 'a']}
>>> k[1]='123456'
>>> k
{'china': '中国', '1': '123', 1: '123456', 2: (1, 2, 3), 3: [1, 2, 'a']}
**字典类型的操作方法**
>>>
>>> k={'china':'中国','Eng':'英语'}
>>> type(k) #查看k类型
<class 'dict'>
>>> k['吃']='饭' #添加新键值对
>>> k
{'china': '中国', 'Eng': '英语', '吃': '饭'}
>>> k.keys() #返回所有键信息
dict_keys(['china', 'Eng', '吃'])
>>> k.values() #返回所有值信息
dict_values(['中国', '英语', '饭'])
>>> k.items() #返回所有键值对
dict_items([('china', '中国'), ('Eng', '英语'), ('吃', '饭')])
>>> k.get('吃','饭')
'饭'
>>> k.get('吃','fan') #'fan' 不是键'吃'对应的值,所以返回默认值
'饭'
>>> k.pop('Eng','英语') #取出该键值对的值,并从字典中删除该键值对
'英语'
>>> k
{'china': '中国', '吃': '饭'}
>>> k.pop('1','2') #键值对1:2,并不是字典内的,但也会返回相应的值
'2'
>>> k
{'china': '中国', '吃': '饭'}
>>> 'china' in k
True
>>> 'Eng' not in k
True
>>> del k['吃']
>>> k
{'china': '中国'}
>>> len(k) #返回键值对个数
1
你学废了吗??