列表

list.append()
del list[3]
列表嵌套
a=[[1,2],3]

遍历多个序列（zip())函数

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.

列表的一些函数
| 函数 | 功能 | 示例 |
|:——————————————————-:| —————————————————————————— | —- |
| list.append() | 在列表末尾添加新的元素 | |
| list.extend() | 在列表末尾一次性追加另一个序列中的多个值，可以添加列表、元组、集合 | |
| list.count() | 统计某个元素在列表中出现的次数 | |
| list.index(x[, start[, end]]) | 用于从列表中找出某个值第一个匹配项的索引位置 | |
| list.insert(index, obj) | 用于将指定对象插入列表的指定位置 | |
| list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 | |
| list.remove(obj) | 移除列表中某个值的第一个匹配项 | |
| list.reverse() | 会对列表的元素进行反向排序,该方法没有返回值 | |
| list.sort( key=None, reverse=False) | 用于对原列表进行排序，reverse = True 降序， reverse = False 升序（默认） | |
| list.clear() | 清空列表 | |
| list.copy() | 用于复制列表，类似于 a[:]。返回复制后的新列表。 | |
| len(list) | 返回列表元素个数 | |
| max(list) | 返回列表元素最大值 | |
| min(list) | 返回列表元素最小值 | |
| list(seq) | 将元组转换为列表 | |

Operator模块

operator.lt(a, b)  #  <
operator.le(a, b)  #  <=
operator.eq(a, b)  #  =
operator.ne(a, b)  #  !=
operator.ge(a, b)  #  >=
operator.gt(a, b)  #  >

元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改,但是可以重新赋值
1
2
3
4
5
tup1=(1,2)
print(tup1)

tup1 = (3,4,5)
print(tup1) #输出(3,4,5
元组使用小括号( )，列表使用方括号[ ]。
元组中只包含一个元素时，需要在元素后面添加逗号 , 否则括号会被当作运算符使用，如tup1 = (50)表示的是一个int类型的数据，tup1 = (50,)是一个长度为1的元组。
元组可以使用下标索引来访问元组中的值，如tup1[0]
可以对元组进行连接组合，如下实例:
1
2
3
4
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print (tup3)
输出:

(12, 34.56, 'abc', 'xyz')

类似，也可以用+=、 in、*、进行处理。
删除元组：

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组：

tup1=(1,2)
print(tup1) 
del tup1    # 删除整个元组
print(tup1) #会报错

元组的括号

元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号，不过括号通常是必须的（如果元组是更大的表达式的一部分）。
1
2
3
4
5
6
7
8
9
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
内置函数

| 方法 | 功能 | |
|:————————-:| —————— | ———————————————————————————————- |
| len(tuple) | 计算元组元素个数。 | |
| max(tuple) | 返回元组中元素最大值。 | |
| min(tuple) | 返回元组中元素最小值。 | |
| tuple(iterable) | 将可迭代系列转换为元组。 | list1='Google','Taobao','Runoob','Baidu'] tuple1=tuple(list1) |

字典
字典是另一种可变容器模型，且可存储任意类型对象。

理解字典的最佳方式是把它看做无序的键=>值对集合

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }
```
  **键必须是唯一的，但值则不必。**

  值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

  `tinydict1 = { 'abc': 456 }`

  `tinydict2 = { 'abc': 123, 98.6: 37 }`
```

从键值对元组列表构建字典：

构造函数 dict() 直接从键值对元组列表中构建字典

1 2	>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) {'sape': 4139, 'jack': 4098, 'guido': 4127}

创建空字典
- 使用大括号{}
  
  emptyDict={}
- 使用内置函数dict
  
  emptyDict=dict()

访问值

把相应的键放入到方括号中

#!/usr/bin/python3

tinydict = {'key_1': 'A', 'key_2': B, 'key_3': 'C'}

print ("tinydict['key_1']: ", tinydict['key_1'])
print ("tinydict['key_2']: ", tinydict['key_2'])

删除字典
事先定义:tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
- 删除单一的元素
  del tinydict['Name'] # 删除键 'Name'
- 删除整个字典
  del tinydict
- 清空字典
  tinydict.clear() # 清空字典

键的特性

键不允许重复

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print(tinydict)
# 输出{'Name': '小菜鸟', 'Age': 7}

print("tinydict['Name']: ", tinydict['Name'])
# 输出:tinydict['Name']:  小菜鸟

键必须是不可变的
可以用数字，字符串或元组充当，而用列表就不行

~~tinydict={[1,2]:3,'sd':5}~~

会报错

关于字典的函数/方法:
- dict.fromkeys(seq[, value])
  用于创建一个新字典，以序列 seq 中元素做字典的键，value （某人为none)为字典所有键对应的初始值。
| 函数 | 功能 | 说明/示例 |
| —————————————————— | ———————————————————————————————————————————— | ———————————————————— |
| len(dict) | 计算字典元素个数，即键的总数。 | |
| str(dict) | 输出字典，可以打印的字符串表示。 | str({"A":1,"B":2})会返回"{"A":1,"B":2}" |
| dict.copy() | 返回一个字典的浅复制。 | |
| dict.fromkeys(seq[, value]) | 创建一个新字典，以序列 seq 中元素做字典的键,value默认为none | |
| dict.get(key[, value]) | 返回指定键的值，如果键不在字典中返回默认值，如果不指定默认值，则返回 None。 | |
| dict.setdefault(key, default=None) | 和 dict.get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。 | |
| dict.items() | 返回一个视图对象。视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。字典改变，视图也会跟着变化。 | |
| dict.keys() | 返回一个视图对象。 | |
| dict.values() | 返回一个视图对象。 | |
| | | |
| dict.pop(key[,default]) | 删除字典 key（键）所对应的值，返回被删除的值。key 不存在时返回default | |
| dict.popitem() | 随机返回并删除字典中的最后一对键和值。 | |
| dict.update(dict2) | 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。 | |

集合

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔，或者也可以使用 set() 函数创建集合。

创建空集合
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合内置方法
| 函数 | 功能 | 说明 |
|:—————————————————————-:|:————————————————————————————:|:—————————————:|
| x.add(elmnt) | 给集合添加元素 | 如果添加的元素在集合中已存在，则不执行任何操作 |
| x.update(set) | 可以添加新的元素或集合到当前集合中 | 参数set不能是一个元素，必须是一个可迭代对象 |
| x.clear() | 移除集合中的所有元素 | 无返回值，如果打印原来的set，会输出一个set() |
| x.copy() | 用于拷贝一个集合 | |
| x.difference(y) | 返回集合的差集,元素包含在集合 x ，但不在集合 y | |
| x.difference_update(y) | 用于移除两个集合中都存在的元素 | 直接在原来的集合x中移除元素，没有返回值 |
| x.remove(item) | 移除集合中的指定元素 | 移除一个不存在的元素时会发生错误 |
| x.discard(value) | 移除指定的集合元素 | 移除一个不存在的元素时不会发生错误 |
| x.intersection(set1, set2 ... etc) | 返回两个或更多集合中都包含的元素，即交集 | set1 — 必需，其余可选。返回一个新的集合 |
| x.intersection_update(set1, set2 ... etc) | 在原始的集合上移除不重叠的元素，即返回x与set1、set2······的交集 | 在原始的集合上移除不重叠的元素 |
| x.isdisjoint(set) | 判断两个集合是否包含相同的元素,交集为空返回True，反之返回False | |
| x.issubset(y) | 判断x是否是y的子集，是的话返回True,否则返回False | |
| x.issuperset(y) | 判断y是否是x的子集，是的话返回True,否则返回False | |
| x.pop() | 移除并返回集合中的一个随机元素 | |
| x.symmetric_difference(y) | 返回两个集合的对称差，即两个集合中不重复的元素集合 | |
| x.symmetric_difference_update(y) | 将x更新为对称差(移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中) | |
| x.union(set1, set2...) | 返回多个集合的并集 | |
| len( s ) | 返回对象的长度或元素个数 | |

直接赋值、浅拷贝、深拷贝

直接赋值
其实就是对象的引用（别名）。

当原来的对象(列表等~~)被改变的时候，赋值后的对象会跟着改变。
浅拷贝(copy)
拷贝父对象，不会拷贝对象的内部的子对象。

当原来的对象(列表等~~)被改变的时候，如果子对象改变了，赋值后的对象不会跟着改变。

深拷贝

copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。不管父对象如何改变，子对象都不改变。

#!/usr/bin/python
# -*-coding:utf-8 -*-

import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象

b = a                       #赋值，传对象的引用
c = copy.copy(a)            #对象拷贝，浅拷贝
d = copy.deepcopy(a)        #对象拷贝，深拷贝

a.append(5)                 #修改对象a
a[4].append('c')            #修改对象a中的['a', 'b']数组对象

print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )

运行结果：

('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
('c = ', [1, 2, 3, 4, ['a', 'b', 'c']])
('d = ', [1, 2, 3, 4, ['a', 'b']])

Python Relearning-List/Tuple/Dict/Set

列表

list.append()

del list[3]

列表嵌套

遍历多个序列（zip())函数

列表的一些函数

Operator模块

元组

字典

创建空字典

访问值

删除字典

删除单一的元素

删除整个字典

清空字典

键的特性

键不允许重复

键必须是不可变的

关于字典的函数/方法:

`dict.fromkeys(seq[, value])`

集合

创建空集合

集合内置方法

直接赋值、浅拷贝、深拷贝

直接赋值

浅拷贝(copy)

深拷贝