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
你学废了吗？？
扫一扫
1465
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
