Question

字符串（str）

1. 字符串是不可变的
2. 字符串连接

   'a' + 'b'  #等价于：'ab'
   'hello ' + 'world ' + str(100)   #等价于：'hello world {}'.format(100)
   

   注：比较难看，且容易出错

3. 字符串重复

   ‘a’ * 3     #等价于：'aaa'
   

4. 字符串比较

   'str' == 'stri'  #结果为False
   'str' != 'stri'  #结果为True
   

5. 利用切片得到字符串逆序的拷贝

   s1 = 'hello'
   s2 = s1[::-1]   # 'olleh'
   

6. 相邻的两个字符串常量(不可以是变量或表达式)会自动连接，例如：

   'py''thon'  #等价于'python'
   text = ('erick '
        'huang')    #等价于text = 'erick huang'
   

元组（tuple）

元组的圆括号其实是可选的，除了以下两种情况外：
1）表示一个空元组；
2）语法上有二义性的场合。例如函数调用中f((a, b, c))中是一个元组实参，而f(a,b,c)是三个参数。

特点
有序、不可变（不可增删元素，但可以包含可变类型的元素）

创建

()  或  tuple()    #空元组
a,  或  (a,)       #单元素的元组
a,b,c 或 (a,b,c)   #多元素的元组
tuple(iterable)    #注意，如果iterable是一个tuple，则直接返回引用，不会拷贝一个副本
举例：
t = 1,2,3   #等价于：t = (1,2,3)

遍历

for x in mytuple:  
    print(x)
for i,x in enumerate(mytuple):  
    print(i, x)

列表（list）

特点
有序、可变（可增删元素）

创建

[]  或  list()   #空列表
[1,2,3]          #单元素或多元素
[x for in iterable]  #列表表达式
list(iterable)   #如果iterable是一个list,则会拷贝一个副本，它等价于iterable[:]

遍历

for x in mylist:  
    print(x)
for i,x in enumerate(mylist):  
    print(i, x)

其它
可以用切片来赋值，该操作可以改变列表的大小，例如：

mylist = [0,1,2]
a = mylist[:]     #获得一个浅拷贝(shallow copy)副本
a[1:3] = [10,20]  #替换一些元素
a[1:3] = []       #移除一些元素
a[:] = []         #清空列表

字典（dict）

特点
1）无序、可变（可增删元素）；
2）关键字必须使用不可变类型，tuple可以做关键字，但它不能直接或间接包含可变类型元素；
3）关键字不允许重复；

创建

{} 或  dict()   #空字典
{'a':1, 'b':2}  #单元素或多元素
{x:x+1 for x in iterable}  #字典推导式
dict(a=1, b=2) #适合关键字都为简单字符串的情况
dict(mapping)  #mapping是字典（从一个字典创建，将会拷贝一个副本），下同
dict(mapping, a=1, b=2)
dict(iterable)  #iterable的元素也必须是一个iterable，且可遍历出2个对象:
dict(iterable, a=1, b=2)
dict.fromkeys('abc')  #从给定键值创建，值可选，默认为None
dict.fromkeys('abc', 100)

iterable举例：
dict([('a',1), ('b',2)])
dict(zip('ab', [1,2])) 
#zip函数返回一个zip object(是一个Iterator)，遍历它可得到一系列元组：('a', 1)、('b', 2)

遍历

for key in d.keys(): 
    print(key)
for value in d.values(): 
    print(value)
for (key,value) in d.items(): 
    print(key, value)

dict和list的比较

dict 有以下几个特点：

• 查找和插入的速度极快，不会随着 key 的增加而增加；
• 需要占用大量的内存，内存浪费多。

而 list 相反：

• 查找和插入的时间随着元素的增加而增加；
• 占用空间小，浪费内存很少。

所以， dict 是用空间来换取时间的一种方法。

序列的增量赋值

增量赋值运算符 += 和 *= 的表现取决于它们的第一个操作对象。以+=为例来介绍：
+= 背后的特殊方法是 __iadd__ （ 用于“就地加法”） 。 但是如果一个类没有实现这个方法的话， Python 会退一步调用 __add__ 。 那样的话 a += b 这个表达式的效果就变得跟 a = a + b 一样了： 首先计算 a + b， 得到一个新的对象， 然后赋值给 a。
考虑下面这个简单的表达式：

a += b      #如果 a 实现了 __iadd__ 方法， 就会调用这个方法。
c = c + d   #将会产生一个新的序列，效率不高。

可变序列一般都实现了 __iadd__ 方法， 因此 += 是就地加法。

序列使用*重复的陷阱

使用*来重复序列，序列里的可变元素将会以引用的方式重复。
举例：

>>> mylist = [[0] * 3] * 3
>>> mylist
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> mylist[0][0] = 1
>>> mylist
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]