元组与字典的相关知识

元组 tuple

  元组是不可改变的序列，同list一样，元组可以存放任意类型的元素

表示方法：

  用小括号()括起来，单个元素括起来后加逗号(,)区分单个对象还是元组

创建空元组的字面值

  t=()

创建非空元组的字面值

  t=200,

  t=(20,)

  t=(1,2,3)

  t=100,200,300

type(x) 函数  用来返回x的类型

元组的错误示例：

t=(20)

x,y,z=1,2,3 # 序列赋值，并非创建元组

x,y,z=(1,2,3) # 序列赋值

x,y,z=[1,2,3] # 序列赋值

x,y,z=”abc” # 序列赋值

 

元组的构建函数tuple

  tuple()     生成一个空元组，等同于()

  tuple(iterable)     用可迭代对象生成一个元组

元组的运算：

  元组的所有运算同列表运算

  算术运算：
  + += * *=

  比较运算

>  >=  <  <=  ==  !=

In / not in 运算

索引和切片

元组的索引和切片等同于列表、

  元组的切片返回一个元组

**：元组不能索引赋值和切片赋值

字典 dict

  什么是字典：

    字典是一种可变的容器，可以存储任意类型的数据

    字典中的每个数据都用’键’进行索引，而不像序列可以用下标（index）索引

    字典中的数据没有先后顺序的关系，字典的存储是无序的

    字典中的数据以键（key）值（value）对的形式进行映身存储

    字典的键不能重复，只能用’不可变类型’作为字典的键

 

字典的字面值表示方式：

  字典的表示方式以{} 括起来，以冒号（：）分割 键-值对，各 键值对 之间用逗号(,)隔开

  创建空字典：

  D = {} # D绑定空字典

  创建非空字典：
    d = {‘name’ : ’tarena’ , ’age’ : 16}

  D = {‘year’:2018,’month’:4,’day’:1}

 

字典的构造函数：

  Dict()       生成一个空字典{}，等同于{}

  Dict(itrable)  用可迭代对象初始化一个字典

  Dict(**kwargs)  用命名关键字传参形式生成一个字典

  

示例：
    d = dict{}

  D = Dict( [ (‘name’ : ’tarena’) ,( ’age’ : 16) ] )

  D = dict(name=’tarena’,age=15)

  Dict(((1,2) , (3,4)))>>>{1:2,3:4} #三层括号 (类型(元组(序列)))

 

字典的键为不可变类型：基础数据类型不可变
    boo,  int, flaot, complex, str, tuple, frozenset(固定集合)，bytes(字节串) 包括：None

可变的类型：

  List, dict, set(集合)，bytearray(字节数组)

 

字典的基本操作：

  键索引：

    语法：

      字典[键]

示例：d = {‘name’ : ’tarena’ , ’age’ : 16}

      >>>d[‘name’]

      >>>’tarena’

 

添加/修改字典：

字典[键] = 值对象

  示例：

  d = {}

  d[‘birthday’] = (2002, 1, 1)  # 添加键值对

  d[‘age’] = 16 # 添加键值对

  d[‘age’] = 17 # 修改‘age’对应的值

 

删除字典元素 del 语句

  语法：

    Del 字典[键]

  示例：

    d = {‘name’ : ’tarena’ , ’age’ : 16}

    del d[‘age’]  #  删除’age’这个键

字典的成员资格判断 in / not in 运算符

  用 in 运算符可以判断一个键是否存在于字典中，如果存在则返回True，否则返回False

  Not in 返回值与 in 相反

 

示例：
d = {1:”” , 2:””}

1 in d     True

2 in d     True

2 not in d  False

8 not in d  True

8 in d     False

“” in d    False  # 只能判断键，不能判断值

 

列表的 in 运算符和字典的 in 运算符比较：

1. 列表的in运算符计算时间会因列中元素各数的增加而增加

2. 字典的in运算符计算时间不会因列中元素各数的增加而增加

 

字典的迭代访问：

  容器是可迭代对象，字典只能对键进行迭代访问

  D = {‘name’：’小明’ , ‘birthday’ , : (2008,8,8)}

  For k in d:

      Print(k)>>>小明 2008,8,8

      Print(‘键：’ ,k, ’值：’ ,(2008,8,8))

 

字典推导式

  作用：

    用可迭代对象生成字典

  语法：

    {键表达式：值表达式 for 变量 in 可迭代对象 [if 真值表达式] }

 

示例：

  生成一个字典，键为10以内的数字，值为键的平方

  D = {x:x**2 for x in range(10)}

>>> D

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

 

例题：

   1.有字符串列表如下：

     L = [‘tarena’ , “小鸟” , “hello”]

   用推导式生成如下字典：

     D = {‘tarena’:6 , “小鸟”:9 , “hello”:5 }

   注：字典的值为键的长度

    D = {x:len(x) for x in L}

2、有两个列表：

No = [1001, 1002, 1003, 1004]

Name = [‘tom’ , ‘jery’ , ‘spike’ , ‘alin’]

用no中的编码作为键，以name中的字符串作为值，生成字典。

D = {no[i]:name[i] for i in range(len(no))} # 用no 长度索引出键的位置

 

字典 VS 列表

1. 都是可变对象

2. 索引方式不同

3. 字典的查找方式快于列表

4. 列表的存储有序，字典无序