python 基础学习-08-元组

1. 元组简介

元组基本介绍

• 元组表现形式tuple
• 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
• 使用()创建元素

#创建元组
my_tuple=()#创建一个空的原组
print(my_tuple,type(my_tuple))

() <class 'tuple'>

my_tuple=(1,2,3,4,5)
print(my_tuple,type(my_tuple))

print(my_tuple[3])

(1, 2, 3, 4, 5) <class 'tuple'>
4

元组是不可变量，不能替换

my_tuple=(1,2,3,4,5)

my_tuple[3]=10 #TypeError: 'tuple' object does not support item assignment
print(my_tuple[3])

• 元组不是空元组至少有一个 逗号(,)

my_tuple=10
print(my_tuple,type(my_tuple))

10 <class 'int'>

元组不是空元组至少有一个 逗号(,)

my_tuple=10,
print(my_tuple,type(my_tuple))

(10,) <class 'tuple'>

当元组不是空元组时括号可以省略

my_tuple=10,20,30,40
print(my_tuple,type(my_tuple))

(10, 20, 30, 40) <class 'tuple'>

• 元组解包指将元组当中的每一个元素都赋值给一个变量

my_tuple=10,20,30,40
a,b,c,d =my_tuple
print("a=",a)
print("b=",b)
print("c=",b)
print("d=",b)

a= 10
b= 20
c= 20
d= 20

对一个元组进行解包时，变量的数量必须和元组中的元素要一一对应。如果出现变量和元素没有对等的情况下，我们可以在变量前面加入*，这样变量可以获取元组中剩余的元素，以列表形式返回。

my_tuple=10,20,30,40
a,b=my_tuple #ValueError: too many values to unpack (expected 2)
print("a=",a)
print("b=",b)

my_tuple=10,20,30,40
a,b,*c=my_tuple
print("a=",a)
print("b=",b)
print(*c)
print(c)

a= 10
b= 20
30 40
[30, 40]
``
也可以根据需要获取中间数值，此时只需将*放在中间变量上。

```python
my_tuple=10,20,30,40
a,*b,c=my_tuple
print("a=",a)
print("c=",c)
print(*b)
print(b)

a= 10
c= 40
20 30
[20, 30]

my_tuple=10,20,30,40
*a,b,c=my_tuple
print("a=",a)
print("b=",b)
print("c=",c)

a= [10, 20]
b= 30
c= 40

对于列表和字符串也可以采用同样的方式：

*a,b,c=[1,2,3,4,5,5,6,7,8,8]
print("a=",a)
print("b=",b)
print("c=",c)

a= [1, 2, 3, 4, 5, 5, 6, 7]
b= 8
c= 8

a,*b,c="python and java"
print("a=",a)
print("b=",b)
print("c=",c)

a= p
b= ['y', 't', 'h', 'o', 'n', ' ', 'a', 'n', 'd', ' ', 'j', 'a', 'v']
c= a

2. 可变对象

Python中，数值类型（int和float）、字符串str、元组tuple都是不可变类型。而列表list、字典dict、集合set是可变类型
可变对象中都保存了三个数据

• id(标识)
• type(类型)
• value(值)

可变对象指的是可以对对象里面的value进行改变

a=[1,2,3]
a
[1, 2, 3]
a[0]=10
a
[10, 2, 3]

a=[4,5,6]
a
[4, 5, 6]

列表是一个可变对象

#列表是一个可变对象
a=[1,2,3]
a[0]=10 #（改对象）
#这个操作时通过变量去修改对象的值
#这种操作不会改变变量所指向的对象

#a=[4,5,6](改变量）
#这个操作在给变量重修赋值
#这种操作会改变变量所指向的对象

a=[1,2,3]
print("修改前",a,id(a)) #修改前 [1, 2, 3] 4320261320

#通过索引修改列表

a[0]=30
print("修改后:",a,id(a)) #修改后: [30, 2, 3] 4320261320

#通过变量给列表重新赋值
a=[4,5,6]
print("修改后：",a,id(a)) #修改后： [4, 5, 6] 4320261256

当修改对象时，如果有其他变量也指向该对象，则修改在其他变量中也体现。
改对象的值会影响所有指向该对象的变量。（如下，a和b的值都变了）

a=[1,2,3]
b=a
b[0]=10
print("a",a,id(a))
print("b",b,id(b))

a [10, 2, 3] 4388627656
b [10, 2, 3] 4388627656

为一个变量重新赋值，不会影响其他的变量。如下改b不影响a

a=[1,2,3]
b=a
b=[10,2,3]
print("a",a,id(a))
print("b",b,id(b))

a [1, 2, 3] 4320699592
b [10, 2, 3] 4320699528

3. 字典简介

3.1 字典的基本介绍

• 字典属于一种新的数据结构称为映射(mapping)
• 字典的作用和列表类似，都是用来存储对象的容器
• 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反,查询作用强。
• 在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素。（相当于书的目录章节）
• 这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
• 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
• 创建一个有数据的字典 语法 {key:value}

d={}
#{key:value,key:value....}
print(d,type(d))

{} <class 'dict'>

字典的值可以是任意对象，key可以是任意不可变的对象（int str tuple bool…)

d={"name":"葫芦娃","age":7,"gender":"男"}

print (d)

{'name': '葫芦娃', 'age': 7, 'gender': '男'}

字典的key是不能重复的，如果出现重复，后面的会替换前面的值

d={"name":"葫芦娃","age":7,"gender":"男","name":"钢铁侠"}

print (d)

{'name': '钢铁侠', 'age': 7, 'gender': '男'}

字典的书写方式，可以竖着写：

d={"name":"葫芦娃",
   "age":7,
   "gender":"男"
}
print (d)

{'name': '葫芦娃', 'age': 7, 'gender': '男'}

通过键获取值

d={"name":"葫芦娃",
   "age":7,
   "gender":"男"
}

print(d["name"],d["age"],d["gender"])

葫芦娃 7 男

3.2 字典的使用

• dict()函数来创建字典

#可以通过dict()函数创建字典,通过传递参数的方式创建字典
d=dict(name="葫芦娃",age=7,gender="男")
print(d,type(d))

{'name': '葫芦娃', 'age': 7, 'gender': '男'} <class 'dict'>

#双值子序列转化为字典
#双值序列，序列中只有两个值，（"x",1),"ab",[5,6]
#子序列 如果序列中元素也是序列，称这个元素为子序列[（4，5），（6，7）]
d=dict([("name","葫芦娃"),("age",7)])
print(d,type(d))

{'name': '葫芦娃', 'age': 7} <class 'dict'>

d=dict([("name","葫芦娃"),("age",7)])
print(len(d))

#len()函数可以获取字典中键值对的个数

2

d=dict([("name","葫芦娃"),("age",7)])
print(len(d)) #2

#in检查字典中是否包含指定的键
#not in检查字典中是否不包含指定的键
print("name"in d) #True

#获取字典中的值，根据键（key)来获取
# 语法 dict[key]
print(d["age"]) #7

d={"name":"葫芦娃","age":7,"gender":"男"}
n="name"
print(d[n]) #葫芦娃  #此时n是变量，不要加引号，如果是字符串需要加引号
print(d["n"])#KeyError: 'n'

• get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值

# get(key[,default]) 该办法可以根据字典中的key来获取值
#如果后去字典中的键不存在，就会返回None
#也可以指定一个默认值来作为第二个参数，这样获取不到值的时候会返回默认值
d={"name":"葫芦娃","age":7,"gender":"男"}
print(d.get("python","该值不存在"))

修改和添加字典

#修改字典 dict[key]=value
d={"name":"葫芦娃","age":7,"gender":"男"}
d["name"]="钢铁侠" #修改字典的key-value
d["phone"]="131234555" #向字典中添加key-value
print(d)

{'name': '钢铁侠', 'age': 7, 'gender': '男', 'phone': '131234555'}

d.setdefalut(key[,default]) #向字典中添加key-value
#如果key已经存在到字典中，则返回key的值，不会对字典做任何操作

d={"name":"葫芦娃","age":7,"gender":"男"}
d.setdefault("name","美国队长")
print(d)

{'name': '葫芦娃', 'age': 7, 'gender': '男'}

#如果key不存在，则向字典中添加这个key，并设置value

d={"name":"葫芦娃","age":7,"gender":"男"}
d.setdefault("python","美国队长")
print(d)

{'name': '葫芦娃', 'age': 7, 'gender': '男', 'python': '美国队长'}

• update() 将其他字典的key-value添加到当前的字典当中

#将其他字典中的key-value添加到当前的字典当中。
d={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6}
d.update(d2)
print(d)

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

#如果有重复的key，则后面的则会替换起那面的

d={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6,"a":9}
d.update(d2)
print(d)

{'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

• del 删除字典中的key-value

d={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6,"a":9}
d.update(d2)
#删除 del来删除k-v
del d["a"]
del d["b"]
print(d)

{'c': 3, 'd': 4, 'e': 5, 'f': 6}

• popitem() 删除字典最后的一个key-value 这个方法是有返回值的。删除之后它会将删除的key-value作为返回值返回

d={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6,"a":9}
d.update(d2)
#删除 del来删除k-v
del d["a"]
del d["b"]


#popitem() 一般都会删除最后一个
#删除后它会将key-value作为返回值返回
#返回的是一个元组，元组中有2个元素，第一个元素是key,第二个元素是value
d.popitem()
d.popitem()
print(d)

{'c': 3, 'd': 4}

d={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6}
d.update(d2)
print("删除前",d)
#删除 del来删除k-v

#popitem() 一般都会删除最后一个
d.popitem() #第一次删除
r=d.popitem()#第二次删除，查看删除的数据
print("第二次删除的是",r)
print("删除后",d)

删除前 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
第二次删除的是 ('e', 5) #删除的是元组
删除后 {'a': 1, 'b': 2, 'c': 3, 'd': 4}

#pop(key[,default]) 根据key删除自定中的value。
#pop会将删除的值返回
d={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6}
d.update(d2)
print("删除前",d)
r=d.pop("c")
print(r)
print(d)

删除前 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
3
{'a': 1, 'b': 2, 'd': 4, 'e': 5, 'f': 6}

• pop(key[,default]) 根据key删除自定中的value。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值

#pop(key[,default]) 根据key删除自定中的value。
#pop会将删除的值返回
d={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6}
d.update(d2)
print("删除前",d)
# r=d.pop("c")
r=d.pop("w","没有这个key值")#default可以加默认值
print(r)
print(d)

3.3 copy()

copy() 方法用来对字典进行潜复制

d={"a":1,"b":2,"c":3}
d2=d.copy()
print("d=",d,id(d))
print("d2=",d2,id(d2))

d= {'a': 1, 'b': 2, 'c': 3} 4537051104
d2= {'a': 1, 'b': 2, 'c': 3} 4537051176

此时id地址已不同，二者无关系，复制后的对象和原对象是独立的，修改一个不会影响另一个。

d={"a":1,"b":2,"c":3}
d2=d.copy()
d["a"]=30
print("d=",d,id(d))
print("d2=",d2,id(d2))

d= {'a': 30, 'b': 2, 'c': 3} 4432472104
d2= {'a': 1, 'b': 2, 'c': 3} 4432472032

注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进行复制的。
潜复制会简单复制对象内部的值，如果值也是个可变对象，这个可变对象不会被复制。

d={"a":{"name":"蜘蛛侠","age":18},"b":2,"c":3}
d2=d.copy()
d2["a"]["name"]="黑猫警长"
print("d=",d,id(d))
print("d2=",d2,id(d2))

d= {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 4316309544 
d2= {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 4316309904

此时d和d2都被替换

4. 遍历字典

我们可以通过3种方式对字典进行遍历
• keys() 该方法返回字典所有的key

d={"name":"葫芦娃","age":7,"gender":"男"}
#keys()  该方法返回字典所有的key
print(d.keys())

返回的是一个列表

dict_keys(['name', 'age', 'gender'])

d={"name":"葫芦娃","age":7,"gender":"男"}
for k in d.keys():
    print(d[k])

葫芦娃
7
男

• values() 该方法返回一个序列 序列中保存有字典的值

d={"name":"葫芦娃","age":7,"gender":"男"}
for v in d.values():
    print(v)

• items() 该方法会返回字典中所有的项 它返回一个序列，序列中包含有双值子序列 双值分别是 字典中的key和value

d={"name":"葫芦娃","age":7,"gender":"男"}
print(d.items())

dict_items([('name', '葫芦娃'), ('age', 7), ('gender', '男')])

d={"name":"葫芦娃","age":7,"gender":"男"}
for k,v in d.items():
    print(k,v)

name 葫芦娃
age 7
gender 男

转载：https://blog.csdn.net/weixin_41447550/article/details/105862537