python开发 day07

day07笔记：

今天内容

   元组   tupie  

  字典    dict

 

1、元组  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"# 序列赋值  # 序列赋值   

 

元组的构造函数(创建） 函数 tupie

   tupie （） 生成一个空的元组，等同于（）

   tupie  （iterable） 用可迭代对象生成一个元组

  示例：

   t = tupie （）

   t = tupie （[2,3,5,7]）

   t = tupie(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)  # 等同于字符串规则

 

元组的比较运算：

 > >= < <= == !=

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

示例：

  (1,2,3）<    (1,3,2)   # Ture

  (1,2,3）！= (1,3,2)   # Ture

  序列和元组的区别就是一个可变，一个不可变。

in / not in 运算符：

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

    2  not  in (1,2,3,4)  # Ture

   

    索引和切片

    索引：

      元组  [整数]

        切片：

      元组[整数：  整数 ]

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

规则同字符串的切片规则

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

      

       练习：

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

   （1,4,9,16，.....，81）

 

解：#t = ()

#for i in range(1,10):

#    v = i ** 2   

#    t += (v,)

#print(t)

 

  方法2

#l = [x ** 2 for x in range(1,10)]

#t = (l)

 

#print(t)

 

元组的方法：

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

T.count（x）  返回元组中对应元素的个数

 

    2、序列的种类：

字符串str， 列表list，元组tupie，

字符串bytes，字节数组bytearray（后面再讲）

       能用于序列的函数总结：

len（x）， max（x），min（x），sum（x），any（x），all（x）   str （obj） 将对象转为字符串

list（iterable）将可迭代对象转为列表

tuple（iterable）........................转为元组

received（seq）   返回反向顺序的可迭代对象

sorted （iterable，reverse = False）

 

 

 

 

 

  二、字典 dict

什么是字典？

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

 2.字典中的每个据都是用“key”进行索引，而不像序列可以用下标开进行索引，

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

4.字典中的数据以键（tey）-值（value）对形式进行映射存储

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

          字典的字面值表示方式：

{ } 括起来， 以冒号（：） 分隔键- 值对，各键-值对用逗号分隔开

           创建空字典：

d = { }   #空字典

           创建非空字典：

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

d = {1: '星期一'，2 ：“星期二"}

# 一下写法会出现问题，（因为键不能重复）

d = {'b' : 2 ,  'b' : 2,   'a': '_'}

 

字典构造（创建）函数dict

   dict （）   #创建空字典，等同于{}

   dict （iterable）  用于迭代对象初始化一个字典

   dict （**kwarge）  关键字传参形式生成一个字典

       示例：

  d =  dict （）

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

  d = dict （name = 'tarena' , age = 15）

 

 

      2、字典的基本操作：

   字典的键索引

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

  语法：

       字典[ 键 ]

示例：

     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  # Talse

        3 not in d #  Ture

       'One'  in  d   #False

  

字典的迭代访问:

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

示例：

  d  =  {1：“One”，2：“Two”,"三”：‘Three’}

   for k in d：

         print（k，‘对应的值是：’）

 

练习：

   写程序，实现以下要求：

   1， 将如下数据形成一个字典  aeasons

        键            值

            1              ‘春季有1，2，3月’

        2              ‘春季有4,5,6,月’

        3              ‘春季有7，8，9月’

        4             ‘春季有10,11,12月’

    2，让用户输入一个整数代表季度，打印这个季度的信息。如果用户输入的信息不在字典中，则提示“信息不存在”

#d = {1: "春季有1,2,3月",

#    2: "夏季有4,5,6月",

#    3: "秋季有7,8,9月",

#    4: "冬季有10,11,12月"}

#a =int(input('输入一个整数代表季度'))

#if a in d:

#    print(d[a])

#else:

#    print('信息不存在')

　

 

 

可以用于字典的内建（built-in）函数

len（x）      返回字典的键值对的个数

max（x）     返回字典的键值对的最大数

min（x）     返回字典的键值对的最小数

sum（x）     返回字典的键的和

    any（x）     真值测试，如果字典中的 一个键为真，则如果为真

    all（x）      真值测试，如果字典中的所有键为真，则如果为真

 

 

字典的方法：

       见python学习笔记，函数字符串

示例：

     d = {1:'one',  2:'two',  3:'three' }

     for k, v in d ,items( ):

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

 

(1, 'one')

(2,'two')

(3,'three')

 

 

练习：

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

如：

   输入： abcdabcabdc

   输出：

         a：   4次

         b ：  3次    

         d ：  1次    

         c ：  2次

（不要求打印的顺序）

    

#f方法２

#s = input('请输入字符串:')

#d = {}

#for ch in s:

#    if ch not in d:

#        d[ch] = 1

#    else:

#        d [ch] += 1

#for ch in d:

#    print(ch , ':',d[ch],'次')

 

 

   字典推导式

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

 

       语法：

{键表达式：值表达式 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}

 

    答案

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

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

#print(D)

 

 

   练习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. 列表的存储是有序的，字典的存储是无序的

 

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

  列表，顺序存储

  字典，映射存储

 

 

 

 

练习：

  1.输入一些单词和解释，将单词作为键，将解释作为值，将这些数据输入到字典中，当输入空的单词时结束输入，然后，输入查询的单词，给出单词对应的解释

 

2.（重要）！

 输入任意个学生的信息：

     学生信息 有：

            姓名（字符串str）

            年龄（整数int）

           成绩（整数int）

   当输入学生姓名为空时结束输入

           1）将每个学生的信息形成字典，存于列表中：

如：

[{ 'name': 'xiaoqi',  'age'  : 20 ,  'score':  98},

               { 'name': 'xiaoyuan',  'age'  : 20 ,  'score':  95},]

              

2)以表格的形式打印所有学生的信息，如下：

 +---------------+----------+----------+

 |   name          |         ag     |    score    |

 +---------------+----------+----------+

 |                      |                  |                |

|                       |                  |                |

|    ......              |             ...  |                 |

 +---------------+----------+----------+

 

 

 

 

答案

#1

# dictionary = {}  # 创建字典，准备保存数据

# while True:

#     word = input("请输入单词: ")

#     if not word:  # 如果单词为空，则退出

#         break

#     trans = input("请输入解释: ")

#     dictionary[word] = trans

 

# print("字典内容是：", dictionary)

 

# while True:

#     w = input("请输入要查询的单词: ")

#     if w in dictionary:

#         print("解释是: ", dictionary[w])

#     else:

#         print("末找到解释!")

 

 

 

 

 

 

             #2

while True:

#     n = input("请输入学生姓名: ")

#     if not n:  # 如果学生姓名为空则结束输入

#         break

#     a = int(input("请输入学生年龄: "))

#     s = int(input("请输入学生成绩: "))

#     # 把上述n, a, s 所表示的信息形成字典，并加入到列表

#     d = {}  # 创建一个新字典，准备存入学生信息数据

#     d['name'] = n

#     d['age'] = a

#     d['score'] = s

#     L.append(d)  # 把字典存入列表中

 

# print(L)

 

# # 第二步，显示所有学生的信息

# print("+---------------+----------+----------+")

# print("|      name     |    age   |  score   |")

# print("+---------------+----------+----------+")

# # 此处打印所有学生的信息

# for d in L:  # 把每个学生的数据取出来，用d绑定对应的字典

#     center_name = d['name'].center(15)

#     str_age = str(d['age'])  # 先将年龄转为字符串

#     center_age = str_age.center(10) # 生成居中的字符串

#     center_score = str(d['score']).center(10)

#     line = "|%s|%s|%s|" % (center_name,

#                           center_age,

#                           center_score)

#     print(line)

# print("+---------------+----------+----------+")