python 学习笔记（3）数据类型2 （元组（tuple），集合，字典）

 

声明：本文系本人学习python3总结，如有侵权等，请及时告知；

                       欢迎转载：请保留 http://blog.csdn.net/kevinx_xu/article/details/8889772

 

1、元组

         元组有点类似C中的枚举型，但是又别于枚举行，在C中的枚举型都是整形，在python中元组，可以是任何类型，但是元组一旦创建，不能增加，不能删除，不能修改，元组 是不可变的列表。

 

         1） 元组的定义方式和列表相同，除了整个元素的集合都用圆括号，而不是方括号闭合。  

         tuple= （1，2，3，“test”,"hello"）

         2） 和列表一样，元组的元素都有确定的顺序。元组的索引也是以零为基点的，和列表一样，因此非空元组的第一个元素总是 tuple[0] 。  

         3）负的索引从元组的尾部开始计数，这和列表也是一样的。  

         4） 和列表一样，元组也可以进行切片操作。对列表切片可以得到新的列表；对元组切片可以得到新的元组。

 

         5)元组和列表的主要区别

    元组不能进行修改。用技术术语来说，元组是 不可变更 的。从实践的角度来说，没有可用于修改元组的方法。列表有像 append()、 extend()、 insert()、remove() 和 pop() 这样的方法。这些方法，元组都没有。可以对元组进行切片操作（因为该方法创建一个新的元组），可以检查元组是否包含了特定的值（因为该操作不修改元组）

 

         6)元组的特点及使用

         （1） 无法向元组添加元素。元组没有 append() 或 extend() 方法。  

         （2）不能从元组中删除元素。元组没有 remove() 或 pop() 方法。  

         （3）可以 在元组中查找元素，由于该操作不改变元组。  

         （4）还可以使用 in 运算符检查某元素是否存在于元组中。 

         7）元组优点 

         • 元组的速度比列表更快。如果定义了一系列常量值，而所需做的仅是对它进行遍历，那么请使用元组替代列表。  

         • 对不需要改变的数据进行“写保护”将使得代码更加安全。使用元组替代列表就像是有一条隐含的 assert 语句显示该数据是常量，特别的想法（及特别的功能）必须重写。

         • 一些元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。列表永远不能当做字典键使用，因为列表不是不可变的。 

         8）元组与列表之间的转换

                   list(tuple)将元组转换为列表

                   tuple（list）将列表转换为元组

 

         9)注意：

         (1)在布尔类型上下文环境中，空元组为假值。  

         (2)  任何至少包含一个上元素的元组为真值。  

         (3)  任何至少包含一个上元素的元组为真值。元素的值无关紧要。不过此处的逗号起什么作用呢？  

         (4)  为创建单元素元组，需要在值之后加上一个逗号。没有逗号，Python 会假定这只是一对额外的圆括号，虽然没有害处，但并不创建元组。 

2、同事赋多个元素值

         a_val=｛｝/()/[]

         ｛｝/()/[]=a_val同时赋多值可发生在多种类型之间，但是在使用的时候，需要谨慎。

        range() 函数是一个迭代器

         range(10),返回0~10 的一堆值

         range（20，100）返回20~100的一堆数值

        使用for i in range(0,n):

                  就是C 中的for(i=0; i<n; i++)

        在python中的for语句比C的更加灵活

         fori in [1,2,3]:

                   printi;

         fori in (1,2,3,54):

                   printi

3、集合

         注：集合是无序的

                  要创建空集合，可不带参数调用 set() 。

                  将列表转化为集合set = set(list);

         集合set 是装有独特值的无序“袋子”。一个简单的集合可以包含任何数据类型的值。如果有两个集合，则可以执行像联合、交集以及集合求差等标准集合运算。  

         1）要创建只包含一个值的集合，仅需将该值放置于花括号之间。（{}）。  

         2）实际上，集合以 类 的形式实现，但目前还无须考虑这一点。  

         3）要创建多值集合，请将值用逗号分开，并用花括号将所有值包裹起来。 

         eg：s = {1,2}

         4)集合操作

                  增加成员

                            set.add()增加一个元素到集合中

                            试图添加一个集合中已有的值，将不会发生任何事情。将不会引发一个错误；只是一条空操作。 

                            set.update()将传入的无论何种类型的集合/列表/元组等并如集合中；

           删除成员：

                            set.discard(member)               

                            set.remove()

                            set.pop()

                   从集合中删除存在的一个成员；

                  1. discard() 接受一个单值作为参数，并从集合中删除该值。  

                  2. 如果针对一个集合中不存在的值调用 discard() 方法，它不进行任何操作。不产生错误；只是一条空指令。  

                  3. remove() 方法也接受一个单值作为参数，也从集合中将其删除。  

                  4. 区别在这里：如果该值不在集合中，remove() 方法引发一个 KeyError 例外。 

                   5.set.pop()会联想到list.pop（）对于set个元素没有顺序，因此调用pop的时候删除的是随机的一个成员，对于list则是从最后一个开始删除；

                  集合的运算

                   a_set= {1,2,3}

                   b_set=(1,2,3,4,5,6)

                  并集：    

                           a_set| b_set    

                            a_set.union(b_set)

                            union() 方法返回一个新集合，其中装着 在两个 集合中出现的元素。  

                   交集：

                            a_set& b_set

                            a.set.intersection(b_set)

                            intersection() 方法返回一个新集合，其中装着 同时 在两个集合中出现的所有元素。  

                   补集：

                            a_set - b_set

                            a_set.difference(b_set)

                   difference() 方法返回的新集合中，装着所有在 a_set 出现但未在 b_set 中的元素。  

                   互补集：

                            存放两个集合中互不相同的一些元素；

                           c_set= (a-b)

                            c_set.update(b-a);

                            a_set.symmetric_difference(b_set)

                           symmetric_difference() 方法返回一个新集合，其中装着所有 只在其中一个 集合中出现的元素。 

 

         1.  a_set 与 b_set 的对称差分 看起来 和b_set 与 a_set 的对称差分不同，但请记住：集合是无序的。任何两个包含所有同样值（无一遗漏）的集合可认为是相等的。  

         2.  而这正是这里发生的事情。不要被 Python Shell 对这些集合的输出形式所愚弄了。它们包含相同的值，因此是相等的。  

         3.  对两个集合的 Union［并集］操作也是对称的。  

         4.  对两个集合的 Intersection［交集］操作也是对称的。  

         5.  对两个集合的 Difference［求差］操作不是对称的。这是有意义的；它类似于从一个数中减去另一个数。操作数的顺序会导致结果不同。 

        

         子集：

                            如果a_set - b_set =None

                   则a_set为b_set的子集；

                      b_set 为a_set的超集；

         bool对结合真假的判断；

                  1. 在布尔类型上下文环境中，空集合为假值。  

                  2. 任何至少包含一个上元素的集合为真值。  

                  3. 任何至少包含一个上元素的集合为真值。元素的值无关紧要。 

        

4、字典

                   字典 是键值对的无序集合。向字典添加一个键的同时，必须为该键增添一个值。

         1）创建字典

                   dic= {'a':1, 'b':2}

         字典由两部分组成,  键值：内容   键值和内容可以为任何类型；

 

         2）可以通过键获取值，但不能通过值获取键；

         3）字典没有预定义的大小限制。可以随时向字典中添加新的键值对，或者修改现有键所关联的值

                   (1)    修改字典内容

                            根据关键字去修改

                            dic['a']= 2;

                   (2)增加字典成员

                            dic['c']= 3

                   注意：

                   (1) 在字典中不允许有重复的键。对现有的键赋值将会覆盖旧值。  

                  (2) 可随时添加新的键值对。该语法与修改现有值相同。  

                  (3) 字典项按顺序出现是个巧合；现在它们不按顺序出现同样也是个巧合。  

                   (4)  对既有字典键进行赋值只会用新值替代旧值。  

                  (5) 字典键是区分大小写的，因此该语句创建了一组新的键值对，而不是覆盖既有的字典项。对你来说它们可能是一样的，但对于 Python 而言它们是完全不同的。 

         4）字典的数据类型

                   字典并非只能用于字符串。字典的值可以是任何数据类型，包括整数、布尔值、任何对象，甚至是其它的字典。而且就算在同一字典中，所有的值也无须是同一类型，您可根据需要混合匹配。字典的键要严格得多，可以是字符串、整数和其它一些类型。在同一字典中也可混合、匹配使用不同数据类型的键。

 

         5）bool上下文字典真假

         （1） 在布尔类型上下文环境中，空字典为假值。  

         （2） 至少包含一个键值对的字典为真值。 

        

         6）删除字典成员dic.pop()

                                               deldic['key']

         7)字典排序

                   dic= sorted（dic）

 

5、None 类型

         类似C语言的NULL

         None 是 Python 的一个特殊常量。它是一个 空 值

         None 是唯一的空值。它有着自己的数据类型（NoneType）。可将 None 赋值给任何变量，但不能创建其它 NoneType 对象。所有值为 None 变量是相等的。

 在 布尔类型上下文环境中， None 为假值，而 not None 为真值。 

 

         not相当于C中的！

 

 

 

数据类型总结

         对于数据类型中bool,None的话，很容易理解，就是对真假的判断，及对变量赋值

         对于列表，元组，字典，集合这几个都相似，操作方法也不尽相同，具体使用结合

dir() 和help()进行查看使用，那么多的方法，记住也不太现实；