基础 day07

day07笔记:

  今天内容

    元组 tuple

    字典 dict

 

元组 tuple

  元组的定义:

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

  元组的表示方法:

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

  创建空元组的字面值

    t = ()  # t绑定空元组

  创建非空元组

    t = 200,

    t = (20,)

    t = (1, 2, 3)

    t = 100, 200, 300

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

 

元组的错误示例:

  t = (20)  # t 绑定定整数，不是元组

  x, y, z = 100, 200, 300  # 序列赋值等同于如下

  x, y, z = (100, 200, 300)  # 序列赋值

  x, y, z = [100, 200, 300]  # 序列赋值

  x, y, z = "ABC"            # 序列赋值

 

元组的构造(创建)函数 tuple

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

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

  示例:

    t = tuple()

    t = tuple([2,3,5,7])

    t = tuple(range(10))

 

元组的运算:

   +  加号用于元组的拼接操作

   *  乘号 用于用原元组生成重复的元组

   +=

   *=

  示例:

    t = (1, 2, 3) + (4, 5, 6)  #t=(1,2,3,4,5,6)

    t = (1, 2) * 3  # t=(1,2,1,2,1,2)

 

    t = (1, 2, 3)

    t += (4, 5, 6)  # 等同于字符串规则

    t *= 2  

  

元组的比较运算:

  > >= < <= == !=

    规则与列表的比较规则完全相同

  示例

    (1, 2, 3) < (1, 3, 2)  # True

    (1, 2, 3) != (1, 3, 2)  # True

    ....

    (1, '二') < ('二', 1)

 

in / not in 运算符:

   与列表的in / not in 规则完全相同

 

   2 in (1, 2, 3, 4) # True

   '2' not in (1, 2, 3, 4)  # True

 

索引和切片

  索引:

    元组[整数]

  切片:

    元组[整数:整数]

    元组[整数:整数:整数]

  规则同字符串的切片规则

  元组不支持索引赋值和切片赋值

 

练习:

  生成一个 1~9的平方的元组，元组如下:

    (1, 4, 9, 16, ...., 81)

 

 

 

元组的方法：

  T.index(v[, begin[, end]])  返回对应元素的索引下标，begin为开始索引，end为结束索引，v不存在时触发ValueErorr错误

  T.count(x)  返回元组中对应元素的个数

 

序列的种类:

  字符串str, 列表list, 元组tuple,

  字节串bytes, 字节数组bytearray(后面再讲)

 

能用于序列的函数总结：

  len(x), max(x), min(x), sum(x), any(x),all(x)

  str(obj)  将对象转为字符串

  list(iterable) 将可迭代对象转为列表

  tuple(iterable) .........转为元组

  reversed(seq)  返回反向顺序的可迭代对象

  sorted(iteralbe, reverse=False)

 

 

 

字典 dict

  什么是字典

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

    2. 字典中的每个数据都是用"键"(key) 进行索引，而不象序列可以用下标来进行索引

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

    4. 字典中的数据以键(key)-值(value)对形式进行映射存储

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

 

  字典的字面值表示方式:

    {} 括起来，以冒号(:) 分隔键-值对, 各键-值对用逗号分隔开

  创建空字典:

    d = {}  # 空字典

  创建非空字典:

    d = {'name':'tarena', 'age': 15}

    d = {1:'星期一', 2:"星期二"}

    # 以下写法会出现问题（因为键不能重复)

    d = {'a': 1, 'b': 2, 'a': '一'}  

 

  字典的构造(创建)函数 dict

    dict()    # 创建空字典，等同于 {}

    dict(iterable)  用可迭代对象初始化一个字典

    dict(**kwargs)  关键字传参形式生成一个字典

  示例:

    d = dict()

    d = dict([('name', 'tarena'), ('age', 15)])

    d = dict(name='tarena', age=15)

 

 

字典的基本操作:

  字典的键索引

    用[] 运算符可以获取和修改键所对应的值

  语法:

    字典[键]

  示例:

    d = {'name': 'tarena', 'age': 15}

    print('姓名:', d['name'], '年龄:', d['age'])

  

  添加/修改字典的元素

    字典[键] = 值

 

  示例:

    d = {}

    d['name'] = 'tarena'

 

  键索引赋值说明:

    当键不存在时，创建键并绑定键对应的值

    当键存在时，修改键绑定的对象

 

 

删除字典的元素

  del 语句 可以用来删除字典的键

  语法:

    del 字典[键]

  示例:

     d = {1:"星期一", 2:'星期二'}

     del d[2]

 

in 运算符(成员资格判断运算符)

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

  2. not in 与 in 相反

 

  示例:

    d = {1: "One", 2: "Two", "三": 'Three'}

    1 in d  # True

    '二' in d  # False

    3 not in d  # True

    'One' in d  # False

 

字典的迭代访问:

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

 

  示例:

    d = {1: "One", 2: "Two", "三": 'Three'}

    for k in d:

        print(k, '对应的值是:', d[k])

 

 

练习:

  写程序，实现以下要求:

    1. 将如下数据形成一个字典 seasons

        键     值

        1      '春季有1,2,3月'

        2      '夏季有4,5,6月'

        3      '秋季有7,8,9月'

        4      '冬季有10,11,12月'

    2. 让用户输入一个整数代表季度,打印这个季度的信息。

       如果用户输入的信息不在字典中，则提示'信息不存在'

可以用于字典的内建(built-in)函数

  len(x)  返回字典的键值对的个数

  max(x)  返回字典的键的最大值

  min(x)  返回字典的键的最小值

  sum(x)  返回字典的键的和

  any(x)  真值测试，如果字典中的一个键为真，则结果为真

  all(x)  真值测试，字典中所有键为真，则结果才为真

 

字典的方法:

  文档见:

      python_base_docs_html/dict.html

 

  示例:

    d = {1:'One', 2:'Two', 3:'Three'}

    for k, v in d.items():

        print("字典的键是:", k, '值是:', v)

 

练习:

  输入一段字符串，打印出这个字符串中出现过的字符及字符出现过的次数

 

  如:

    输入:  abcdabcaba

    输出:

      a: 4次

      b: 3次

      d: 1次

      c: 2次

    (不要求打印的顺序)

 

 

 

 

 

字典推导式

  字典推导式是用可迭代的对象依次生成字典的表达式

 

  语法:

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

    注: [] 及其中的内容代表可省略

  说明:

    1. 先从可迭代对象中取值

    2. 用变量绑定

    3. 用if 进行条件判断，如果为真值则执行下一步

    4. 执行'键表达式'和 '值表达式' 然后加入到新字典中

  示例:

    生成一个字典，键为1~9的整数,值为键的平方

    d = {x: x **2 for x in range(1, 10)}

 

练习:

  有如下字符串：

    L = ['tarena', 'china', 'beijing']

  生成如下字典:

    D = {'tarena': 6, 'china':5, 'beijing':7}

  答:

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

 

练习2:

  No = [1001, 1002, 1005, 1008]

  names = ['Tom', 'Jerry', 'Spike', 'Tyke']

  用上面No列表中的数据作为键，用names中的数据作为值，生成相应的字典:

    如:

    d = {1001: 'Tom', 1002: 'Jerry', ....}

 

  方法1:

    d = {No[i]: names[i] for i in range(len(No))}

  方法2:

    d = {n: names[No.index(n)] for n in No}

字典推导式可以嵌套，语法同列表推导式

 

 

字典 vs 列表

  1. 都是可变对象

  2. 索引方式不同,列表用整数索引，字典用键索引

  3. 字典的查找速度可能会快于列表(重要)

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

 

列表 和字典 的内部存储原理

  列表，顺序存储

  字典，映射存储