1、元祖

元祖的特性结合了字符串和列表

元祖是用圆括号括起来的，其中的元素之间用逗号(英文半角)隔开。元祖中的元素是任意类型的python对象(包括以后自定义的对象)

元祖中的元素不可更改，所以修改列表的方法，在元祖中都会失效。

    使用场景:

元祖比列表操作速度快。如果定义了一个值，并且唯一要用他做的是不断的遍历他，那么请使用元祖代替列表。

如果对不需要修改的数据进行"写保护"，即该数据是常量，那么此时也要使用元祖。如果必须要改变这些值，则可以转换为列表修改。

元祖可以在字典(又一种对象类型，后面要讲述)中被用作key，但是列表不可以。字典的key必须是不可变的。元祖本身就是不可改变的，而列表是可变的。

   

1.1定义元祖:

  1. tu1 = tuple()
  2. tu2 = (1,)
  3. tu3 = (1,23,3,'python')

>>> a = (3)
>>> type(3)
<class 'int'>  #定义时要注意的

1.2索引和切片，与列表相同

  1. >>> t = (1,'',[123,'abc'],('python','learn'))
  2. >>> t[2]
  3. [123, 'abc']
  4. >>> t[1:]
  5. ('', [123, 'abc'], ('python', 'learn'))
  6. >>> t[2][0]
  7. 123
  8. >>> t[3][1]
  9. 'learn'

1.3转换列表

  1. >>> t = (1,'',[123,'abc'],('python','learn'))
  2. >>> tls = list(t)                            #转换列表
  3. >>> tls
  4. [1, '', [123, 'abc'], ('python', 'learn')]
  5. >>> t_tuple = tuple(tls)                #转换元祖
  6. >>> t_tuple
  7. (1, '', [123, 'abc'], ('python', 'learn'))

1.4方法

  1. dir(tuple)
  2. ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

2、字典(dictionary)

字典中的"键"必须是不可变的数据类型:"值"可以是任意数据类型

2.1创建字典

  1. >>> mydict1 = {}
  2. >>> mydict1
  3. {}
  4. >>> mydict2 = {'name':'zhang','site':'bokeyuan','language':'python'}
  5. >>> mydict2
  6. {'name': 'zhang', 'site': 'bokeyuan', 'language': 'python'}   #"键/值对" 前面的叫做(key),后面的叫做值(value)

2.2增加键值对

  1. >>> mydict2['name2'] = "taj"   #追加键值对，内存位置不变，它是可变的
  2. >>> mydict2
  3. {'name': 'zhang', 'site': 'bokeyuan', 'language': 'python', 'name2': 'taj'}  
  4.  
  5. #方法2
    >>> name = (["first","Google"],["second","Yahoo"])

  >>> type(name)
  <class 'tuple'>
  >>> website = dict(name)

#或
  >>> ad = dict(name = 'tajzhang',ahe = 22)  
  >>> ad
  {'name': 'tajzhang', 'ahe': 22}

#方法3

>>> website = {}.fromkeys(("third","forth"),"facebook")
  >>> website
  {'third': 'facebook', 'forth': 'facebook'}

2.3访问字典的值

  1. >>> mydict2 = {'name':'zhang','site':'bokeyuan','language':'python'}
  2. >>> mydict2["name"]
  3. 'zhang'

2.4基本操作

len(d),返回字典(d)中的键值对的数量

d[key],返回字典(d)中的键(key)的值

d[key]=value,将值(value)赋给字典(d)中的键(key).

del d[key],删除字典(d)的键(key)项(将该键值对删除).

key in d,检查字典(d)中是否含有键为key的项

2.5字符串格式化输出

  1. >>> city_code = {"suzhou":"","ttangshan":"","huangzhaou":""}
  2. >>> "Suzhou is a beautiful city, its area code is {suzhou}".format(**city_code)
  1. >>> temp = "<html><head><title>{lang}<title><body><p>My name is {name}.<p><body></head><html>"
  2. >>> my = {"name":"qiwsir","lang":"python"}
  3. >>> temp.format(**my)
  4. '<html><head><title>python<title><body><p>My name is qiwsir.<p><body></head><html>'
  5. #实际应用场景

2.6字典的方法

python重要概念:对象有类型，变量无类型

1)copy,复制，表层id()不同，如果有多层序列类型，则调用相同id

d1 = d.copy()

2)d("key").remove("value")

3)d.clean()  清空字典为空字典

4)del d  删除字典

5)get 通过键取值

  1. >>> d = {'lang':'python'}
  2. >>> d.get('lang')
  3. 'python'
  4. >>> d.get('name')   #不会报错，较为宽容

6)setdefault

  1. >>> d
  2. {'lang': 'python'}
  3. >>> d.setdefault("lang")    #与get类似返回值
  4. 'python'
  5. >>> d.setdefault("name","tajzhang")  #也可以直接添加键值
  6. 'tajzhang'
  7. >>> d
  8. {'lang': 'python', 'name': 'tajzhang'}
  9. >>> d.setdefault("name","zhang2")     #修改值不生效
  10. 'tajzhang'
  11. >>> d
  12. {'lang': 'python', 'name': 'tajzhang'}
  13. >>> d.setdefault('web')                      #可添加一个空的键
  14. >>> d
  15. {'lang': 'python', 'name': 'tajzhang', 'web': None}

7)items,keys,values 三种字典扩展类型

  1. >>> dd = {'name':'tajzhang','lang':'python','web':'www.google.com'}
  2. >>> dd_kv = dd.items()
  3. >>> dd_kv
  4. dict_items([('name', 'tajzhang'), ('lang', 'python'), ('web', 'www.google.com')])
  5. >>> type(dd_kv)
  6. <class 'dict_items'>
  7. >>> dd.keys()
  8. dict_keys(['name', 'lang', 'web'])
  9. >>> dd.values()
  10. dict_values(['tajzhang', 'python', 'www.google.com'])

8)pop,popitems

  1. >>> dd
  2. {'name': 'tajzhang', 'lang': 'python', 'web': 'www.google.com'}
  3. >>> dd.pop('name')     #指定删除
  4. 'tajzhang'
  5. >>> dd.pop('name')     #不存在则删除报错
  6. Traceback (most recent call last):
  7.   File "<stdin>", line 1, in <module>
  8. KeyError: 'name'
  1. >>> dd
  2. {'lang': 'python', 'web': 'www.google.com', 'name': 'zhang2'}
  3. >>> dd.popitem()    #与listpop方法类似，不指定值随机删除(因为字典是无序的)，当字典为空时会报错
  4. ('name', 'zhang2')  #返回一个元祖

9)update更新字典内容

  1. >>> d1 = {"lang":'python'}
  2. >>> d2 = {'song':'I dreamed a dream'}
  3. >>> d1.update(d2)    #把d2内容更新到d1中，d2不变
  4. >>> d1
  5. {'lang': 'python', 'song': 'I dreamed a dream'}
  6. >>> d2
  7. {'song': 'I dreamed a dream'}
  1. >>> d2
  2. {'song': 'I dreamed a dream'}
  3. >>> d2.update([("name","qiwsir"),("web","itdiffer.com")])   #方法2
  4. >>> d2
  5. {'song': 'I dreamed a dream', 'name': 'qiwsir', 'web': 'itdiffer.com'}

2.7引入深度copy,不管数据多少层都是真复制 不同id()内存地址

  1. >>> x = {'lang':['python','java'],'name':'qiwsir'}
  2. >>> import copy
  3. >>> z = copy.deepcopy(x)
  4. >>> z
  5. {'lang': ['python', 'java'], 'name': 'qiwsir'}
  6. >>> id(x["lang"])
  7. 4339599752
  8. >>> id(z["lang"])
  9. 4339599880

3、集合

集合特点:有的可变 有的不可变;元素无次序，不可重复。

  1. >>> s1 = set("tajzhang")    #创建集合
  2. >>> s1
  3. {'h', 'j', 'a', 'g', 'z', 't', 'n'}
  4. >>> s2 = set([123,"google","face","book","facebook","book"])  #指定创建
  5. >>> s2
  6. {'google', 'facebook', 123, 'book', 'face'}
  7. >>> type(s2)
  8. <class 'set'>
    >>> s3 = {"facebook",123}  #直接创建
    >>> s3
    {123, 'facebook'}
    >>> type(s3)
    <class 'set'>

3.1 set常用方法

1)add和update

  1. >>> set1 = set()
  2. >>> set1 = {'a','i'}
  3. >>> type(set)
  4. <class 'type'>
  5. >>> set1.add('tajzhang')
  6. >>> set1
  7. {'tajzhang', 'a', 'i'}        #插入数据随机位置可见是无序的
  8. set2 = set("python")
  9. >>> set2.add('[1,2,3]')     #无法插入列表 转换成字符串格式就可以了？
  10. >>> set2
  11. {'h', '[1,2,3]', 'n', 'tajzhang', 'y', 'o', 'p', 't'}
  1. >>> s1 = set(['a','b'])
  2. >>> s1
  3. {'b', 'a'}
  4. >>> s2 = set(['github','tajzhang'])
  5. >>> s1.update(s2)         #追加
  6. >>> s1
  7. {'github', 'tajzhang', 'b', 'a'}
  8. >>> s2
  9. {'github', 'tajzhang'}
  10.  
  11. >>> s2 = set(['github','tajzhang'])
  12. >>> s1.update(s2)
  13. >>> s1
  14. {'github', 'tajzhang', 'b', 'a'}
  15. >>> s2
  16. {'github', 'tajzhang'}
  17. >>> s2
  18. {'github', 'tajzhang'}
  19. >>> s2.update('goo')  #文档描述，这个方法的作用原有的集合自身和其他的东西构成的新集合来更新原来的集合。可以理解为:others指的是作为参数的不可变对象，将它和原来的集合组成新的集合，用这个心集合代替原来的集合
  20. >>> s2
  21. {'o', 'github', 'tajzhang', 'g'}
  22. >>> s2.update((2,3))
  23. >>> s2
  24. {2, 3, 'tajzhang', 'o', 'g', 'github'}

2)pop,remove,discard,clear

  1. >>> b_set
  2. {'h', '[1,2,3]', 'n', 'tajzhang', 'y', 'o', 'p', 't'}
  3. >>> b_set.pop()
  4. 'h'
  5. >>> b_set.pop()
  6. '[1,2,3]'
  7. >>> b_set.pop()                #随机删除一个元素
  8. 'n'
  9. >>> b_set
  10. {'tajzhang', 'y', 'o', 'p', 't'}
  11. >>> b_set.pop('y')              #指定删除会报错
  12. Traceback (most recent call last):
  13.   File "<pyshell#45>", line 1, in <module>
  14.     b_set.pop('y')
  15. TypeError: pop() takes no arguments (1 given)
  1. >>> a_set = {"a","tajzhang",'i'}
  2. >>> a_set.remove('i')           #删除集合内元素，不在集合内就报错
  3. >>> a_set
  4. {'tajzhang', 'a'}
  5. >>> a_set.remove('w')
  6. Traceback (most recent call last):
  7.   File "<pyshell#49>", line 1, in <module>
  8.     a_set.remove('w')
  9. KeyError: 'w'
  10. >>> a_set.discard('a')        #在集合中就删除，否则不进行任何操作
  11. >>> a_set
  12. {'tajzhang'}
  13. >>> a_set.discard('b')
  14.  
  15. >>> a_set
  16. {'tajzhang'}
  17. >>> a_set.clear()  #终极操作清空
  18. >>> a_set
  19. set()
  20. >>> a_set.clear()
  21. >>> bool(a_set)
  22. False

3.2不可变集合

用set()来创建的集合都是可修改，可变的，即unhashable的集合。还有一种集合不能原地修改，这种集合的创建方法是用frozenset(),这种集合就是一个冻结的集合是不能修改的，hashable类型

  1. >>> f_set = frozenset("tajzhang")
  2. >>> f_set
  3. frozenset({'h', 'n', 'z', 'a', 'j', 'g', 't'})
  4. >>> f_set.add("python")
  5. Traceback (most recent call last):
  6.   File "<pyshell#61>", line 1, in <module>
  7.     f_set.add("python")
  8. AttributeError: 'frozenset' object has no attribute 'add'
  9. >>> dir(f_set)
  10. ['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']

3.3集合运算

1)元素与集合的关系

元素与集合只有一种关系，元素要么属于某个集合，要么不属于.

  1. >>> a_set = set("python")
  2. >>> a_set
  3. {'h', 'n', 'y', 'o', 'p', 't'}
  4. >>> "a" in a_set
  5. False
  6. >>> "h" in a_set
  7. True

2)集合与集合关系

假设有两个集合A、B

(1)A是否等于B，即两个集合的元素是否完全一样。

  1. >>> a = set(['q','i','s','r','w'])
  2. >>> b = set(['a','q','i','l','o'])
  3. >>> a == b
  4. False
  5. >>> a != b
  6. True

(2)A是否是B的子集，或者反过来，B是否是A的超集，即A的元素也是B的元素，但是B的元素比A的元素数量多

判断集合A是否是集合B的子集，可以使用A<B或者A.issubset(B),返回True则是子集，否则不是.

  1. >>> a = set("tajzhang")
  2. >>> a
  3. {'h', 'n', 'z', 'a', 'j', 'g', 't'}
  4. >>> c = set("taj")
  5. >>> c
  6. {'t', 'a', 'j'}
  7. >>> c < a
  8. True
  9. >>> c.issubset(a)
  10. True
  11. >>> a.issuperset(c)
  12. True
    >>> b = set("zhang222")  #当a不是b的子集
    >>> b
    {'h', 'n', 'z', 'a', '2', 'g'}
    >>> a < b
    False
    >>> a.issubset(b)
    Fals

(3)A、B的并集，即A、B的所有元素，如下图:

可以使用符号"|" 是一个半角状态的竖线，也可使用函数A.union(B) 得到的结果就是两个集合的并集.得到的结果是新生成的一个对象，而不是讲AB扩充

  1. >>> a = set("tajzhang")
  2. >>> b = set("zhangquandan")
  3. >>> a
  4. {'h', 'n', 'z', 'a', 'j', 'g', 't'}
  5. >>> b
  6. {'h', 'd', 'n', 'z', 'a', 'g', 'q', 'u'}
  7. >>> c = a|b
  8. >>> c
  9. {'u', 'h', 'd', 'n', 'z', 'a', 'j', 'g', 'q', 't'}
  10. >>> d = a.union(b)
  11. >>> d
  12. {'u', 'h', 'd', 'n', 'z', 'a', 'j', 'g', 'q', 't'}

(4)A、B得到了一个新的结果，但原有集合没有任何改变。

  1. >>> a
  2. {'h', 'n', 'z', 'a', 'j', 'g', 't'}
  3. >>> b
  4. {'h', 'd', 'n', 'z', 'a', 'g', 'q', 'u'}
  5. >>> c = a & b
  6. >>> c
  7. {'h', 'n', 'z', 'a', 'g'}
  8. >>> d = a.intersection(b)
  9. >>> d
  10. {'h', 'n', 'z', 'a', 'g'}

or 与 and  ？？？？

(5)A相对B的差(补),即A相对B不同的部分元素，如下图所示。

  1. >>> a = set("tajzhang")
  2. >>> b = set("zhangquandan")
  3. >>> a - b
  4. {'t', 'j'}
  5. >>> a.difference(b)
  6. {'t', 'j'}
  7. >>> b.difference(a)
  8. {'u', 'd', 'q'}

(6)A、B的对称差集，如图:

  1. >>> a = set("tajzhang")
  2. >>> b = set("zhangquandan")
  3. >>> a.symmetric_difference(b)
  4. {'d', 't', 'j', 'q', 'u'}
  5. >>> b.symmetric_difference(a)
  6. {'d', 'q', 't', 'u', 'j'}

老齐python-基础4(元祖、字典、集合)的更多相关文章

  1. python-列表元祖字典集合

    列表 list = ["a", "b", "c", "d"]元祖 tup = (1, 2, 3, 4, 5 ) 1.元组 ...

  2. python 元祖字典集合

    一.元祖 1.用途:记录多个值,当多个值没有改变的需求,元祖不能修改,但元祖里的数据的数据可以修改. 2.定义方式:在()内用逗号分隔开多个任意值. 思考:如果定义一个只有一个一个值的元祖. # t ...

  3. Python学习笔记---切片 列表 元祖 字典 集合

    列表[1,2,3,2]#[] 元祖(1,2,3,2)#() 字典{1:2,3:2}#{} 集合{1,2,3,2}#{} 1,集合与列表的区别,集合里不能有重复元素 2.字典与集合的区别,都是用花括号表 ...

  4. python基础类型—元祖

    元组  被称为只读列表,即数据可以被查询,但不能被修改,所以,字符串的切片操作同样适用于元组. 例:(1,2,3)("a","b","c") ...

  5. Python基础入门-元祖

    其实,元组合列表的特性和使用几乎差不太多,今天我们重点来看下元组的一些操作和使用. 1.元祖的定义和特点 定义:元组是以小括号包围,元素以逗号分隔,不可变的序列之一. 特点: 1)元祖内的元素不可以增 ...

  6. python基础之元祖、嵌套，for循环、 enumerate、range的试用案例

    元祖又叫做只读列表,可循环查询.可切片,元祖里的直接元素不能更改,但是若里面有嵌套的列表,则可以修改列表里的元素 tu = (1,2,3,'sun',[3,4,5,'cat']) tu[4][3] = ...

  7. python基础之元祖tuple

    元祖是只读列表,不可哈希,可循环查询,可切片*儿子不能改,孙子可更改--元祖里面单个元素不能更改---元祖内列表可更改增:tu1+tu2查:tu1[index] tu1[start_index:end ...

  8. python基础--4 元祖

    #元组,元素不可被修改,不能被增加或者删除 #tuple,有序 tu=(11,22,33,44,55,33) #count 获取指定元素在元祖中出现的次数 print(tu.count(33)) #i ...

  9. 06 元祖 字典 集合set

    元组 定义: ti=() print(ti,type(ti)) 参数:for可以循环的对象(可迭代对象) t2=tuple(") # ('1', '2', '3') <class 't ...

随机推荐

  1. canvas图形的组合与裁切

    当两个或两个以上的图形存在重叠区域时,默认情况下一个图形画在前一个图像之上.通过指定图像globalCompositeOperation属性的值可以改变图形的绘制顺序或绘制方式,globalAlpha ...

  2. js Worker 线程

    在平时的运行的javascript脚本都在主线程中执行,如果当前脚本包含复杂的.耗时的代码.那么JavaScript脚本的执行将会被阻塞,甚至整个刘看齐都是提示失去响应. 例子: 假设程序需要计算.收 ...

  3. jquery 动态创建 DIV

    方法一: var creatediv= function(){    var parentdiv=$('<div></div>');        //创建一个父div    ...

  4. Unicode 和 UTF-8 有何区别？ - 引自知乎

    作者:于洋链接:http://www.zhihu.com/question/23374078/answer/69732605来源:知乎著作权归作者所有,转载请联系作者获得授权. 很久很久以前,有一群人 ...

  5. Buildroot构建指南——工具链

    Linux系统的交叉编译工具链用来将源代码变成bin文件或者库文件的一个软件.一般大家默认工具链等于gcc或者arm-linux-gcc,但是实际上,gcc只是工具链的编译器部分,不是全部,制作一个工 ...

  6. (转)Pig 重写加载函数和存储函数UDF

    pig自带的pigstorage不能指定行分隔符,所以自己重写了一个简单的UDF类,可以指定列和行的分隔符,之前研究过的简单的, http://blog.csdn.net/ruishenh/artic ...

  7. [置顶] 完美解决Android Studio 运行时出现的警告信息？

    今天群友看到他说运行的时候报下面的错,我记得我之前导入百度地图也是遇到过,运行的时候一堆警告信息,然后编译失败等的,特别郁闷,其实后来在网上查了下,原来是很多第三方里面加个混淆,然后你有找不到那些方法 ...

  8. 使用编译时注解简单实现类似 ButterKnife 的效果

    这篇文章是学习鸿洋前辈的 Android 如何编写基于编译时注解的项目 的笔记,用于记录我的学习收获. 读完本文你将了解: 什么是编译时注解 APT 编译时注解如何使用与编写 举个例子 思路 创建注解 ...

  9. 开源一款ftp软件——filezilla

    filezilla是一款高性能ftp/sftp文件工具,关于它的具体的介绍可参见其官网:https://www.filezilla.cn/.其原作者是Tim Kosse (tim.kosse@file ...

  10. Jira简单使用操作指引20150605

    1.选择项目 2.点击[问题]——>[所有问题] 3.选择状态(一般开发关注[新增.处理中],测试关注[已解决.已作废]) 4.选择[more],勾选[解决版本].[影响版本].[解决人],我们 ...