Python入门基础（四）变量类型分类、序列详解

变量类型分类

在Python底层中，每个变量存储的并不是值，而是指向这个值的地址，根据操作变量是否对地址产生影响，将变量归为两类：可变类型和不可变类型。

不可变类型

不可变类型是指当你对变量的值进行操作时，变量存储的地址会从原地址改为一个新地址，而不能直接改变原地址指向的值。

a=1
print("a的值：{},a的地址：{}".format(a,id(a)))#a的值:1,a的地址:1910370036016
b=1
print("b的值：{},b的地址：{}".format(b,id(b)))#b的值:1,a的地址:1910370036016
a=2
print("a的值：{},a的地址：{}".format(a,id(a)))#a的值:2,a的地址:1910370036048

优点

不可变类型的优点是：内存中不管有多少引用，值相同的对象都是使用同一块内存地址。

缺点

不可变类型的缺点是：当每次需要对变量的值进行操作时，就要开辟另一块内存空间，创建另一个对象。

归类

Python中的不可变类型有：数字，布尔，字符串，元组

可变类型

Python中的可变类型是指，当对变量的值进行操作时，可直接改变变量指向的内存地址指向的值，而不需要再开辟另一块内存空间。

a=[1,2]
print("a的值：{},a的地址：{}".format(a,id(a)))#a的值：[1, 2],a的地址：2301791031232
b=[1,2]
print("b的值：{},b的地址：{}".format(b,id(b)))#b的值：[1, 2],b的地址：2301791031451
a.append(3)
print("a的值：{},a的地址：{}".format(a,id(a)))#a的值：[1, 2, 3],a的地址：2301791031232

优点

可变类型的优点：需要修改变量值时，可直接修改内存地址指向的值，而不需要再开辟新的内存空间。

缺点

可变类型的缺点：当变量值相同时，每个变量的地址是不同的，即相同的值不能共用一块地址。

归类

Python中的可变类型有：列表、集合、字典

序列

Python中的序列是指一块可以存放多个值的连续内存空间，这些值按照一定的顺序排列，可通过索引访问他们。

序列索引访问
Python的序列中，每个元素都有自己的编号（索引），从起始元素开始，索引由0递增，如图：

从末尾元素开始，索引由-1递减，如图：

序列切片
Python中，只要获取一部分的序列时，就需要使用到序列切片，它可以获取一部分的序列并生成新的序列，语法格式如下：
news=sname[start : end : sep]
参数讲解：
sname为操作的序列名
start为范围开始的索引，可不指定，默认为0
end为范围结束的索引（不包括end），可不指定，默认为序列长度
sep为每个元素之间的间隔值，可不指定，默认为1，不指定时可去掉最后一个冒号

a=[1,2,3,4,5,6,7,8,9]
print(a[1])#单独获取：2
print(a[5])#单独获取：6
print(a[1:5])#切片操作，取索引1~4：[2,3,4,5]
print(a[:5])#切片操作，省略start，默认从0开始：[1,2,3,4,5]
print(a[1:])#切片操作，省略end，默认序列长度：[2,3,4,5,6,7,8,9]
print(a[1:5:2])#切片操作，取索引1~4，间隔2：[2,4]
print(a[::-1])#切片操作，序列倒序：[9,8,7,6,5,4,3,2,1]
print(a[:])#切片操作，省略start和end，范围默认整个序列：[1,2,3,4,5,6,7,8,9]

序列相加

Python中可通过“+”实现两个序列拼接的操作，但序列拼接不会去除重复元素：

a=[1,2,3]
b=[4,5,6]
print(a+b)#[1,2,3,4,5,6]

序列相乘
Python中可通过“*”实现将序列内容复制n次的操作：

a=[1,2,3]
print(a*3)#[1,2,3,1,2,3,1,2,3]

Python中的序列有：字符串、列表、元组、集合、字典，集合与字典不支持切片操作

列表

Python中的列表类似与其他语言中的数组，但数组仅可以存放相同类型数据，而列表可以存放任意类型的数据。

创建列表

方法1、使用方括号将数据括起来，各个数据元素之间使用逗号分隔：

l1=[1,2,3]
print(l1,type(l1))#[1,2,3] <class 'list'>

方法2、使用list()方法可创建一个空列表，也可以通过给函数传递其他类型变量获得列表：

s="123"
l1=list(s)
print(l1,type(l1))#[1,2,3] <class 'list'>

方法3、列表推导式创建列表：

l1=[i for i in range(10)]#for循环创建,将for循环得出的i填充到列表中
print("l1:",l1)#[1,2,3,4,5,6,7,8,9]

l2=[i for i in range(10) if i%2==0]#for-if创建,for循环得出i后进行判断,满足if条件就填充到列表中
print("l2:",l2)#[0,2,4,6,8]

l3=[i+20 if i%2==0 else i+10 for i in range(10)] #if-else-for创建,for循环得出i后，进行判断,满足if语句执行if前面的操作，否则执行else后面操作
print("l3:",l3)#[20,11,22,13,24,15,26,17,28,19]

操作列表

增
可通过append(data)、insert(index,data)、extend(lname)等函数实现向列表中添加元素的操作：

a=[1,2,3]
b=[4,5,6]
a.append(b)#作用：向a列表末尾追加一个b列表
print(a)#[1,2,3,[4,5,6]]

a=[1,2,3]
b=[4,5,6]
a.insert(1,b)#作用：向a列表的索引1位置插入一个b列表
print(a)#[1,[4,5,6],2,3]

a=[1,2,3]
b=[4,5,6]
a.extend(b)#作用：向a列表末尾追加b列表的元素
print(a)#[1,2,3,4,5,6]

删
可通过remove(data)、pop([index])、del lname[index]等函数实现给列表删除元素的操作：

l1=[1,2,3,4,5]
l1.remove(2)#作用：当有1个元素时删除1个元素，当有多个重复元素时只删除第1个重复元素
print(l1)#[1,3,4,5]

l1=[1,2,3,4,5]
l1.pop()#作用：当指定索引时，删除指定位置元素，未指定时，删除末尾元素
print(l1)#[1,2,3,4]

l1=[1,2,3,4,5]
del l1[3]#作用：当指定索引时，删除指定位置元素，当只有序列名时，删除序列
print(l1)#[1,2,3,5]

查
可通过序列切片或循环遍历实现查看列表元素的操作：

l1=[1,2,3,4,5]
print(l1[2])#3
print(l1[1:4])#[2,3]
for i in l1:
    print(i,end=' ')#1 2 3 4 5

改
可通过列表元素重新赋值实现更新列表元素操作：

l1=[1,2,3,4,5]
l1[2]=20
print(l1)#[1,2,20,4,5]

排序
通过sort()、sorted()、reverse()等函数，sort()和sorted()有两个关键参数：reverse指定升降序，True降序，False升序，key指定排序依据，通过这些函数来实现对列表元素进行排序的操作：

l1=[2,4,3,1,5]
l1.sort()#作用：将列表元素从小到大排序
print(l1)#[1,2,3,4,5]

l1=[2,4,3,1,5]
print(sorted(l1))#[1,2,3,4,5] 作用：将列表元素从小到大排序，并返回排序后结果

l1=[1,2,3,4,5]
l1.reverse()#作用：将列表倒序
print(l1)#[5,4,3,2,1]

常见函数

函数	描述
min(l)	返回l中的最小值
max(l）	返回l中的最大值
len(l)	返回l的元素个数
l.count(data)	返回data在l中出现的次数
l.index(data)	返回data在l中第一次出现的索引

元组

Python中的元组与列表是类似的，不过不同的是列表是通过方括号括起来，而元组则是通过小括号扩起来，元组有一个特点：不可以进行更新元素值的操作。

创建元组

方法1：使用小括号括起来，各个元素逗号分隔

a=(1,2,3)
b=(1,)#当元组只有一个元素时，末尾必须带','
print(a,type(a))#(1,2,3) <class 'tuple'>
print(b,type(b))#(1,) <class 'tuple'>

方法2：直接逗号分隔（可读性较差，不建议使用）

a=1,2,3
b=1,
print(a,type(a))#(1,2,3) <class 'tuple'>
print(b,type(b))#(1,) <class 'tuple'>

方法3：使用tuple()方法可以创建一个空元组，也可以给函数传递其他类型的参数获得元组

a="123456"
b=[1,2,3]
c=tuple()#创建空元组
print(tuple(a))#(1,2,3,4,5,6)
print(tuple(b))#(1,2,3)
print(c)#()

操作元组

删
元组中的元素值是不可以删除的，但是我们可以通过del删除整个元组，del会将元组从内存中删除，再使用原来的元组会报错。

t1=(1,2,3)
print('删除前：',t1)#删除前： (1, 2, 3)
del t1
print('删除h后：',t1)#NameError: name 't1' is not defined

查
我们可以通过切片、索引、遍历来访问元组的元素

t1=(1,2,3,4,5,6,7,8,9)
print(t1[3])#索引访问：4
print(t1[1:5])#切片访问：(2,3,4,5)
for i in t1:#遍历访问：1 2 3 4 5 6 7 8 9
    print(i,end=" ")

改
元组的元素值是不支持修改的，若要修改元素值只能对整个元组重新赋值，但我们也可以通过“+”号进行元组拼接，再重新赋值以改变元组的值。

t1=(1,2,3,4,5,6,7,8,9)
t2=(10,)
t1=t1+t2#元组拼接
print(t1)

常见函数

函数	描述
min(t)	返回t中的最小值
max(t）	返回t中的最大值
len(t)	返回t的元素个数
t.count(data)	返回data在t中出现的次数
t.index(data)	返回data在t中第一次出现的索引

集合

Python中的集合是一个无序不重复的元素序列，外层用花括号括起来，内层用逗号分隔元素，当需要创建空集合时，只能用set()，因为空花括号是创建空字典的元素，集合中不可以存储可变类型数据如列表，字典等，因为它相当于一个只有键值的字典，而键值不能是可变类型。
创建集合
方法1、花括号括起来，各个元素逗号分隔：

s1={1,2,3}
print(s1,type(s1))#{1,2,3} <class 'set'>

方法2、通过set()函数创建空集合，或给函数传递其他类型参数来获得集合：

str1="123"
l1=[4,5,6]
s1=set(str1)
s2=set(l1)
s3=set()
print(s1,type(s1))#{'2', '3', '1'} <class 'set'>
print(s2,type(s2))#{4, 5, 6} <class 'set'>
print(s3,type(s3))#set() <class 'set'>

方法3、通过集合推导式创建集合：

s1={i for i in range(10)}
s2={i for i in range(10) if i%2==0}
s3={i+20 if i%2==0 else i for i in range(10)}
print(s1,type(s1))#{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>
print(s2,type(s2))#{0, 2, 4, 6, 8} <class 'set'>
print(s3,type(s3))#{1, 3, 5, 7, 9, 20, 22, 24, 26, 28} <class 'set'>

操作集合
增
可通过add(data)、update(seq)函数来实现为集合添加元素的操作

s1=set()
s1.add(1)#添加单个元素，若已存在不执行任何操作
s1.add(2)
print(s1)#{1,2}

s1=set()
l1=[1,2,3]
str1="123"
s1.update(str1)#添加可迭代的多个元素
s1.update(l1)
print(s1)#{1,2,3,'1','2','3'}

删
可通过remove(data)、pop()、discard(data)、clear()函数来实现删除集合中元素的操作

s1 = {1, 2, 3, 4, 5}
n=s1.pop()#如果全数字删除最小元素后升序排列；如果全非数字，随机删除；如果包含数字和非数字，选中数字时删除最小元素后升序排列，选中非数字时随机删除，并返回删除的值
print("s1:",s1,"删除元素：",n)#s1: {3, 4, 5} 删除元素： 1

s2={1,2,3,4,5}
s2.discard(2)#删除指定元素，元素存在就删除，不存在不报错
print("s2-1:",s2)#s2-1: {1, 3, 4, 5}
s2.discard(6)
print("s2-2:",s2)#s2-2: {1, 3, 4, 5}

s3={1,2,3,4,5}
s3.remove(2)#删除指定元素，元素存在就删除，不存在就报错
print("s3-1:",s3)#s3-1: {1, 3, 4, 5}
s3.remove(6)
print("s3-2:",s3)#KeyError: 6

s4={1,2,3,4,5}
s4.clear()#删除集合中的所有元素
print("s4:",s4)#set{}

查
可通过遍历查看集合元素

s1 = {1, 2, 3, 4, 5}
for i in s1:
    print(i,end=" ")#1 2 3 4 5

改
由于集合是无序不重复的序列，我们无法定位到集合的某个元素，所以无法实现修改集合元素的操作，但我们可以通过，要修改集合元素只能整体重新赋值
交集
通过&可找出两个集合的共同元素，即交集：

s1 = {1, 2, 3, 4, 5}
s2={2,15,8,26,4}
print(s1&s2)#{2,4}

并集
通过|可将两个集合的元素进行合并，重复元素只保存一个，即并集：

s1 = {1, 2, 3, 4, 5}
s2={2,15,8,26,4}
print(s1|s2)#{1, 2, 3, 4, 5, 8, 15, 26}

差集
通过-可将前集合中的两个集合的共同元素删除，即差集：

s1 = {1, 2, 3, 4, 5}
s2={2,15,8,26,4}
print(s1-s2)#{1,3,5}

对等差分
通过^可将两个集合的非共同元素找出来

s1 = {1, 2, 3, 4, 5}
s2={2,15,8,26,4}
print(s1^s2)#{1, 3, 5, 8, 26, 15}

常见函数

函数	描述
min(s)	返回s中的最小值
max(s）	返回s中的最大值
len(s)	返回s的元素个数

字典

Python的字典类似于集合，它们都是以花括号作为外层，但集合是单个值保存，而字典是以键值对形式保存的，它是一种可变容器模型，可以存储任意类型的数据，字典的键不能是可变类型，值可以是任意类型。
创建字典
方法1、花括号括起来，每组元素内部使用冒号分隔键和值，每组元素间用逗号分隔：

d1={1:'a',2:'b',3:'c'}
print(d1,type(d1))#{1: 'a', 2: 'b', 3: 'c'} <class 'dict'>

方法2、通过dict()可创建空字典，也可以给函数传递其他类型参数获得字典

t1=((1,'a'),(2,'b'),(3,'c'))
d1=dict(t1)
print(d1,type(d1))#{1: 'a', 2: 'b', 3: 'c'} <class 'dict'>
d2=dict()
print(d2,type(d2))#{} <class 'dict'>

方法3、通过给dict(zip(kseq，vseq))传递keys和values参数可创建字典

l1=[1,2,3]
t1=('a','b','c')
d1=dict(zip(l1,t1))
print(d1,type(d1))#{1: 'a', 2: 'b', 3: 'c'} <class 'dict'>

方法4、通过给dict.formkeys(kseq[,data])传递keys和values可初始化创建字典

l1=['a','b','c']
d1=dict.fromkeys(l1,1)
print(d1,type(d1))#{'a': 1, 'b': 1, 'c': 1} <class 'dict'>

方法5、通过字典推导式可创建字典

d1={i:j for i in ['a','b','c'] for j in [1,2,3]}
print(d1,type(d1))#{'a': 3, 'b': 3, 'c': 3} <class 'dict'>,在字典中如果有键相同的情况，最后一个相同的键的键值对会将前面所有相同键的键值对替代掉

d2={i:j for i,j in zip( ['a','b','c'] ,[1,2,3])}
print(d2,type(d2))#{'a': 1, 'b': 2, 'c': 3} <class 'dict'>

d3={1:'a',2:'b',3:'c'}
d3_1={key:value.upper() for key,value in d3.items()}
print(d3_1,type(d3_1))#{1: 'A', 2: 'B', 3: 'C'} <class 'dict'>

d4={1:'a',2:'b',3:'c'}
d4_1={key:value.upper() for key,value in d4.items() if key%2==0}
print(d4_1,type(d4_1))#{2: 'B'} <class 'dict'>

d5={1:'a',2:'b',3:'c'}
d5_1={key:value.upper() if key%2==0 else value for key,value in d5.items()}
print(d5_1,type(d5_1))#{1: 'a', 2: 'B', 3: 'c'} <class 'dict'>

操作字典
增
可通过为不存在的key赋值或update()方法来为字典增加元素：

d1={}
d1[1]='a'
d1[2]='b'
d1[3]='c'
print(d1,type(d1))#{1: 'a', 2: 'b', 3: 'c'} <class 'dict'>

d2={}
d2.update({1:'a'})
d2.update({2:'b'})
d2.update({3:'c'})
print(d2,type(d2))#{1: 'a', 2: 'b', 3: 'c'} <class 'dict'>

d3={}
d3.update(key1='a',key2='b',key3='c')#key只能是字符串对象
print(d3,type(d3))#{'key1': 'a', 'key2': 'b', 'key3': 'c'} <class 'dict'>

d4_1={}
d4={'1':'a','2':'b','3':'c'}
d4_1.update(**d4)#字典拆包
print(d4_1,type(d4_1))#{'1': 'a', '2': 'b', '3': 'c'} <class 'dict'>

删
可通过del d[index]、pop(key)、clear()、popitem()函数来操作字典以实现删除元素的操作：

d1={1:'a',2:'b',3:'c'}
del d1[1]#删除指定key的键值对
print('d1:',d1)#d1: {2: 'b', 3: 'c'}

d2={1:'a',2:'b',3:'c'}
d2.pop(2)#删除指定key的键值对
print('d2:',d2)#d2: {1: 'a', 3: 'c'}

d3={1:'a',2:'b',3:'c'}
d3.clear()#清空字典
print('d3:',d3)#d3: {}

d4={1:'a',2:'b',3:'c',4:'d'}
n=d4.popitem()#随机删除字典最后一个键值对并以元组形式返回删除的键值对，因为字典是无序的，所以不能确定哪项为最后一项即随机删除
print('d4:',d4,'已删除：',n)#d4: {1: 'a', 2: 'b', 3: 'c'} 已删除： (4, 'd')

d5={1:'a',2:'b',3:'c',4:'d'}
del d5#从内存中删除字典
print('d4:',d5)#NameError: name 'd5' is not defined

查
可通过key值、get(key)、items()、keys()、values()函数查看字典元素：

d1={1:'a',2:'b',3:'c'}
print(d1[1])#key值访问。：a
print(d1.get(2))#get()函数访问，可传key值和找不到时的默认返回值。：b
print(d1.items())#元组形式返回键值对。：dict_items([(1, 'a'), (2, 'b'), (3, 'c')])
print(d1.keys())#元组形式返回所有key值。：dict_keys([1, 2, 3])
print(d1.values())#元组形式返回所有value值。：dict_values(['a', 'b', 'c'])
for key,value in d1.items():#常规遍历字典
    print(key,value,end=" ")#1 a 2 b 3 c 

改
修改字典元素的操作和增加元素操作类似，所以可以使用增加元素的函数方法，只不过这次的key值必须是字典中存在的，否则是添加元素操作。

d1={1:'a',2:'b',3:'c'}
d1[2]='B'
print(d1,type(d1))#{1: 'a', 2: 'B', 3: 'c'} <class 'dict'>

常见函数

函数	描述
min(d)	返回d中的最小键
max(d）	返回d中的最大键
len(d)	返回d的键值对个数
d.fromkeys(seq，val)	创建一个字典，以seq中的值为键，val的值为值，组成键值对元素
d.setdefault(key,value)	在字典中查找key，如key不存于字典则返回指定的value值，如果存在则返回key对应的值