tuple元组详解

元组和列表（list）的不同之处在于：
列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
从形式上看，元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔，如下所示：
(ele1, ele2, … , elen)
其中 ele1~elen 表示元组中的各个元素，个数没有限制，只要是 Python 支持的数据类型就可以。并且在同一个元组中，元素的类型可以不同

创建元组

Python 提供了两种创建元组的方法

  1. 使用 ( ) 直接创建
    通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：tuplename = (element1, element2, …, elementn)
    tuplename 表示变量名，element1 ~ elementn 表示元组的元素。

    1
    2
    3
    num = (7, 14, 21, 28, 35)
    course = ("Python教程", "http://c.biancheng.net/python/")
    abc = ( "Python", 19, [1,2], ('c',2.0) )

    在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组，
    eg.

    1
    2
    course = "Python教程", "http://c.biancheng.net/python/"
    print(course)

    需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串

    1
    2
    #最后加上逗号
    a =("http://c.biancheng.net/cplus/",)

  2. 使用tuple()函数创建元组
    Python提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型。
    tuple() 的语法格式如下：tuple(data)
    其中，data 表示可以转化为元组的数据，包括字符串、元组、range 对象等。

访问元组元素

和列表一样，我们可以使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）
使用索引访问元组元素：
tuplename[i]
tuplename 表示元组名字，i 表示索引值。元组的索引可以是正数，也可以是负数。
使用切片访问元组元素：
tuplename[start : end : step]
其中，start 表示起始索引，end 表示结束索引，step 表示步长。

修改元组

前面我们已经说过，元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。
对元组变量进行重新赋值：

1
2
3
4
tup = (100, 0.5, -36, 73)
print(tup)#对元组进行重新赋值
tup = ("nihao","hello")
print(tup)

添加元素的方法可以，但是有限制只能添加在最前面或者最后面
另外，还可以通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素

删除元组

当创建的元组不再使用时，可以通过 del 关键字将其删除

dict字典详解

字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。

字典中，习惯将各元素对应的索引称为键（key），各个键对应的元素称为值（value）
字典的主要特征
通过键而不是通过索引来读取元素
字典是任意数据类型的无序集合
字典中的键必须唯一
键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型

创建字典

创建字典的方式有很多

  1. 使用 { } 创建字典

由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。

使用{ }创建字典的语法格式如下：

dictname = {‘key’:’value1’, ‘key2’:’value2’, …, ‘keyn’:valuen}
其中 dictname 表示字典变量名，keyn : valuen 表示各个元素的键值对。需要注意的是，同一字典中的各个键必须唯一，不能重复。

  1. 通过 fromkeys() 方法创建字典
    Python 中，还可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：
    dictname = dict.fromkeys(list，value=None)
    list 参数表示字典中所有键的列表（list）
    value 参数表示默认值，如果不写，则为空值 None
    1
    2
    3
    knowledge = ['语文', '数学', '英语']
    scores = dict.fromkeys(knowledge, 60)
    print(scores)
  2. 通过 dict() 映射函数创建字典
访问字典

列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。
访问字典元素的具体格式为：
dictname[key]
dictname 表示字典变量的名字
key 表示键名。注意，键必须是存在的，否则会抛出异常。

1
2
3
4
tup = (['two',26], ['one',88], ['three',100], ['four',-59])
dic = dict(tup)
print(dic['one']) #键存在
print(dic['five']) #键不存在

除了上面这种方式外，Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。
get() 方法的语法格式为：
dictname.get(key[,default])

dictname 表示字典变量的名字；
key 表示指定的键；
default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。

1
2
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one') )

注意，当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数

1
2
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('five', '该键不存在') )

运行结果：
该键不存在

删除字典

和删除列表、元组一样，手动删除字典也可以使用 del 关键字

字典添加键值对

为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：
dictname[key] = value
dictname 表示字典名称
key 表示新的键
value 表示新的值，只要是 Python 支持的数据类型都可以。

字典修改键值对

Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。
字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。

字典删除键值对

删除字典中的键值对，还是可以使用 del 语句

1
2
3
4
a = {'数学': 95, '语文': 89, '英语': 90}
del a['语文']
del a['数学']
print(a)
判断字典中是否存在指定键值对

如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的

1
2
3
a = {'数学': 95, '语文': 89, '英语': 90}
print('数学' in a) 
print('物理' in a)
dir查询

Python 字典的数据类型为 dict，我们可使用 dir(dict) 来查看该类型包含哪些方法

keys()、values() 和 items() 方法

它们用来获取字典中的特定数据：
keys() 方法用于返回字典中的所有键（key）

values() 方法用于返回字典中所有键对应的值（value）

items() 用于返回字典中所有的键值对（key-value）

1
2
3
4
scores = {'数学': 95, '语文': 89, '英语': 90}
print(scores.keys())
print(scores.values())
print(scores.items())

如果想使用这三个方法返回的数据，一般有下面两种方案：

  1. 使用 list() 函数，将它们返回的数据转换成列表
    1
    2
    3
    a = {'数学': 95, '语文': 89, '英语': 90}
    b = list(a.keys())
    print(b)
  2. 使用 for in 循环遍历它们的返回值
    1
    2
    3
    4
    5
    6
    7
    8
    9
    a = {'数学': 95, '语文': 89, '英语': 90}
    for k in a.keys():
        print(k,end=' ')
    print()
    for v in a.values():
        print(v,end=' ')
    print()
    for k,v in a.items():
        print("key:",k," value:",v)
copy() 方法

copy() 方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典

1
2
3
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
print(b)
update() 方法

update() 方法可以使用一个字典所包含的键值对来更新己有的字典。
在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

1
2
3
a = {'one': 1, 'two': 2, 'three': 3}
a.update({'one':4.5, 'four': 9.3})
print(a)
pop() 和 popitem() 方法

pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，popitem() 总是弹出底层中的最后一个 key-value
语法格式：
dictname.pop(key)
dictname.popitem()
dictname 表示字典名
key 表示键。

1
2
3
4
5
6
a = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
print(a)
a.pop('化学')
print(a)
a.popitem()
print(a)
setdefault() 方法

setdefault() 方法用来返回某个 key 对应的 value
语法格式：
dictname.setdefault(key, defaultvalue)

dictname 表示字典名称
key 表示键
defaultvalue 表示默认值（可以不写，不写的话是 None）

当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。

1
2
3
4
5
6
7
8
9
10
11
a = {'数学': 95, '语文': 89, '英语': 90}
print(a)
#key不存在，指定默认值
a.setdefault('物理', 94)
print(a)
#key不存在，不指定默认值
a.setdefault('化学')
print(a)
#key存在，指定默认值
a.setdefault('数学', 100)
print(a)