python 字典，列表，集合，字符串，基础进阶

python列表基础

首先当然是要说基础啦

列表list
1、L.append(object) -> None
    在列表末尾添加单个元素，任何类型都可以，包括列表或元组等

2、L.extend(iterable) -> None
    以序列的形式，在列表末尾添加多个元素

3、L.insert(index, object) -> None
   在index位置处添加一个元素

4、L.clear() -> None
   清除列表所有元素，成为空列表

5、L.copy() -> list
   获得一个列表副本

6、L.count(A) -> integer
   返回A在列表中出现的次数

7、L.index(A, [start, [stop]])
   返回A在列表中第一次出现的位置，可以指定开始和结束位置  注意：[start,end)

8、L.pop([index]) -> integer
   弹出对应位置的元素，不填参数，默认弹出最后一个元素

9、L.remove(A) -> None
   删除第一个元素A，其余元素A不擅长

10、L.sort(key=None, reverse=False) -> None
   对列表进行排序，默认是升序。如果reverse=True，则改为降序。可以给key参数传递一个函数，如lambda或事先定义好的。然后按照这个函数定义以什么为排序基础，      例如以最后一个数字为排序基础，或以下划线后的数字为排序基础等。
   此方法会改变列表排序

11、L.reverse() -> None
    对列表进行降序
    此方法会改变列表排序

元组tuple
1、T.count(A) -> integer
   返回A在元祖中出现的次数

2、T.index(A, [start, [stop]]) -> integer
   返回A在元祖中第一次出现的位置，可以指定开始和结束范围  注意：[start,end)

 集合set
1、S.add(element) -> None
   添加一个元素到集合里

2、S.clear() -> None
   清除集合所有元素

3、S.copy() -> set
   返回原集合的副本

4、S.remove(element) -> None
   移除集合中的一个元素，如果该元素不在集合中则报错

5、S.discard(element) -> None
   同上，但如果该元素不在集合中不报错

6、S.pop() -> element
   随机弹出一个原集合的元素

7、S.isdisjoint(S2) -> bool
   如果两个集合没有交集，则返回True

8、S.issubset(S2) -> bool
   如果S2（序列或者集合）集合包含S集合，则返回True

9、S.issuperset(S2) -> bool
   如果S集合包含S2（序列或者集合）集合，则返回True

10、S.difference_update(S2) -> None
   S减去S和S2（序列或者集合）的交集，不返回任何值，
   此方法会改变原集合S

11、S.intersection_update(S2) -> None
   S和S2（序列或者集合）的交集，不返回任何值，
   此方法会改变原集合S

12、S.symmetric_difference_update(S2) -> None
   S和S2的并集减去S和S2的交集，不返回任何值
   此方法会改变原集合S

13、S.update(S2) -> None
   S和S2（序列或者集合）的并集，不返回任何值，
   此方法会改变原集合S

14、S.intersection(S2) -> set
   返回S和S2（序列或者集合）的交集

15、S.difference(S2) -> set
   返回S减去S和S2（序列或者集合）的交集

16、S.symmetric_difference(S2) -> set
   返回S和S2的并集减去S和S2的交集，S2可以是序列或集合

17、S.union(S2) -> set
   返回S和S2（序列或者集合）的并集

字典dict
1、D.clear() -> None
   清除字典中所有键值

2、D.copy() -> D
   返回一个字典的副本

3、D.pop(k[,d]) -> value
   弹出k键对应的值，并移除键值。如果k键没有被找到，但设置了d的值，则返回d的值。如果没设置的d值的话，又没找到k键，则报错。

4、D.popitem() -> (k, v)
   以元祖的形式，弹出一个键值（弹出的一般是堆栈的第一个键值）

5、D.keys() -> a set-like object
   已类似列表的形式返回所有键（其实返回的更像是类列表的对象，并不会对重复的值进行处理）

6、D.values() -> a set-like object
   已类似列表的形式返回所有值（其实返回的更像是类列表的对象，并不会对重复的值进行处理）

7、D.items() -> a set-like object
   已类似列表的形式返回所有键值，每个键值以元祖的形式返回（其实返回的更像是类列表的对象，并不会对重复的值进行处理）

8、D.get(k[,d]) -> D[k] if k in D, else d.
   如果字典存在k键则返回对应的值，如果不存在，但填了d值则返回d值，否则返回空值

9、D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
   如果字典存在k键则返回对应的值，如果不存在，但填了d值则在原字典中建立新的键值，并返回该值。但没有填d值的话，则设在k键对应为空值。

10、D.update(D2) -> None
   D2也是字典。将D2的键值合并到D中，如果存在相同的键，则D2覆盖D
   此方法会改变原字典D

11、D.fromkeys(iterable, value=None) -> dict
   此方法用于创建字典。以可迭代的对象的所有元素作为键，value作为唯一的值。返回一个多键对单一值的字典（不论D是不是空字典结果都是一样的）

字符串str
1、S.capitalize() -> str
   将首字母转换成大写，需要注意的是如果首字没有大写形式，则返回原字符串

2、S.upper() -> str
   将原字符串中所有的字母大写

3、S.lower() -> str
   将原字符串中所有的字母小写（只能完成ASCII码中的A-Z）

4、S.casefold() -> str
   将原字符串中所有的字母小写（能识别更多的对象将其输出位小写）

5、S.swapcase() -> str
   将原字符串中存在的字母大小写互换

6、S.replace(old, new[, count]) -> str
   替换字符。count参数代表替换几次old字符。如果不填count参数，默认替换所有的old字符

7、S.expandtabs(tabsize=8) -> str
   将字符串中所有制表符（\t）替换为空格，替换空格数默认为7（8-1，其中tabsize=0表示去掉\t，tabsize=1或2都表示一个空格，其余为n-1个空格）

8、S.rjust(width[, fillchar]) -> str
   如果原字符长度不足width，则剩余部分，在左边补齐空格。如果有填充单字符，则用字符代替空格。（注意：只能是单字符）

9、S.ljust(width[, fillchar]) -> str
   同上。不过是在右边填充。

10、S.center(width[, fillchar]) -> str
   同上。不过左右两边同时填。多出的部分填在右边

11、S.zfill(width) -> str
   如果原字符长度不足width，则剩余部分，在左边补齐0

12、S.find(sub[, start[, end]]) -> int
   返回子字符串在原字符串中第一次出现的位置，可以指定开始和结束位置。如果子字符串不在原字符串中则返回-1  注意：[start,end)

13、S.index(sub[, start[, end]]) -> int
   同上，不过如果子字符串不在原字符串中则报错    注意：[start,end)

14、S.rindex(sub[, start[, end]]) -> int
   同index，不过是从字符串右到左，不过返回的是子字符串最左边的第一个字符位置

15、S.rfind(sub[, start[, end]]) -> int
   同find，不过是从字符串右到左，不过返回的是子字符串最左边的第一个字符位置

16、S.split(sep=None, maxsplit=-1) -> list of strings
   返回一个以sep作为分隔符得到的列表。maxsplit代表分隔几次，默认为全分隔

17、S.rsplit(sep=None, maxsplit=-1) -> list of strings
   同上。不过是从右至左

18、S.splitlines([keepends]) -> list of strings
   返回一个按换行符作为分隔符得到的列表。默认keepends为False，表示得到的列表，列表的元素都去掉了换行符。如果改为True则保留换行符

19、S.partition(sep) -> (head, sep, tail)
   此方法用来根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，则返回一个3元的元组。第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
   如果不包含指定的分隔符，则第一个为原字符串，第二三个为空字符

20、S.rpartition(sep) -> (head, sep, tail)
   同上，但是从右至左，且如果不包含指定的分隔符，则第一二个为空字符，第二个为原字符串

21、strip([chars]) -> str
   默认返回一个去掉左右两边空格的字符串。如果参数写了子字符，则去掉左右两边所有的子字符

22、S.rstrip([chars]) -> str
   同上，但是只去掉右边的字符

23、S.lstrip([chars]) -> str
    同上，但是只去掉左边的字符

24、S.startswith(prefix[, start[, end]]) -> bool
    判断字符串是否以某字符串开头，如果是，则True。可以指定开始和结束位置

25、S.endswith(suffix[, start[, end]]) -> bool
    同上，不过判断的是结尾

26、S.count(sub[, start[, end]]) -> int
   返回子字符串在原字符串中出现的次数。可以指定开始和结束位置

27、S.join(iterable) -> str
   将原字符填充到序列的元素之间

28、S.encode(encoding='utf-8', errors='strict') -> bytes
   编码,errors参数可选很多，其中有’ignore’

29、S.isidentifier() -> bool
   是否为Python的关键字等，如果是为True

30、S.isalnum() -> bool
   是否字符串全是由数字、英文或汉字组成（包括罗马数字等），如果是为True

31、S.isdecimal() -> bool
   是否字符串只含有10进制数字
   True：Unicode数字，全角数字(双字节)
   False：罗马数字，汉字数字
   Error：byte数字(单字节)

32、S.isnumeric() -> bool
   是否字符串只含有数字
   True：Unicode数字，全角数字(双字节)，罗马数字，汉字数字
   False：无
   Error：byte数字（单字节）

33、S.isdigit() -> bool
   是否字符串只含有数字
   True：Unicode数字，byte数字(单字节)，全角数字(双字节)，罗马数字
   False：汉字数字
   Error：无

34、S.isspace() -> bool
   是否字符串只含有空格（空格，制表符，换行符），如果是为True

35、S.isalpha() -> bool
   是否字符串只含有字母，如果是为True

36、S.islower() -> bool
   是否字符串中所有的字母都是小写（可以含非字母的字符），如果是为True

37、S.isupper() -> bool
   如果原字符串中的字母（可以包含其他内容，如数字）全为大写，返回True

38、S.isprintable() -> bool
   是否字符串中所有字符是可见状态（例如\n不可见），如果是为True

39、S.istitle() -> bool
   是否字符中每个单词的首写字母都大写了（字符中除字母外，只允许有空格和正常的标点符号），如果是为True

40、S.maketrans(x, y=None, z=None) -> dict

41、S.translate(table) -> str
   参考上面语句（这里的table指的是字典映射表）

42、S.format_map(mapping) -> str

   注意：键不能为纯数字

43、S.title() -> str
   字符中每个单词的首写字母都大写（允许各种字符在中间隔断）

List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用” [ ] “标识，是 python 最通用的复合数据类型。

创建列表的几种方法

默认方法  

list1 = [0,1,2,3,4,5,6]
>>>list1
[0,1,2,3,4,5,6]123

使用range()函数

list2 = list(range(10))
>>>list2
[0,1,2,3,4,5,6,7,8,9]

list3 = list(range(5,10))
>>>list3
[5,6,7,8,9]

list4 = list(range(0,10,2)) #这里的"2"为步长
>>>list4
[0,2,4,6]1234567891011

列表生成式

a = [number for number in range(6)]
>>>a
[1,2,3,4,5]123

使用字符串创建列表

#按住字符串的个数分割列表包括空格等字符
a = list("")
>>>a
['','','','','','']

b = list("1,2,3,4")
>>>b
['',',','',',','',',',4']12345678

使用元组创建列表

a = list((0,1,2,3,4,5,6))
>>>a
[0,1,2,3,4,5,6]123

访问列表的几种方法

指定位置访问列表元素

#注意列表的访问是从0开始
bicycles = ['trek', 'cannondale', 'redline', 'specialized']
>>>print(bicycles[0])
trek

>>>print(bicycles[1])
cannondale

#访问位置从后边开始
>>>print(bicycles[-1])
specialized1234567891011

循环访问列表
遍历整个列表

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician) 

alice
david
carolina12345678

列表的修改

指定位置直接修改  

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles[0] = 'ducati'
print(motorcycles)1234

['honda', 'yamaha', 'suzuki']
['ducati', 'yamaha', 'suzuki']12

列表的添加

使用append添加列表的元素

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)

#append是将添加的元素追加到列表的末尾
motorcycles.append('ducati')
print(motorcycles)123456

['honda', 'yamaha', 'suzuki']
['honda', 'yamaha', 'suzuki', 'ducati']12

使用insert()在指定位置插入元素
insert() 可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, 'ducati')
print(motorcycles)123

['ducati', 'honda', 'yamaha', 'suzuki']1

从列表中删除元素

使用del语句删除元素
使用 del 可删除任何位置处的列表元素，条件是知道其索引
注意！：使用 del 语句将值从列表中删除后，你就无法再访问它了。

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[0]
print(motorcycles)1234

['honda', 'yamaha', 'suzuki']
['yamaha', 'suzuki']12

使用pop()删除元素

方法 pop() 可删除列表末尾的元素，并让你能够接着使用它
术语 弹出 （ pop ）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
popped_motorcycle = motorcycles.pop()
print(motorcycles)
print(popped_motorcycle)12345

['honda', 'yamaha', 'suzuki']
['honda', 'yamaha']
suzuki123

术语 弹出 （ pop ）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素
每当你使用 pop() 时，被弹出的元素就不再在列表中了
如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用 del 语句；如果你要在删除元
素后还能继续使用它，就使用方法 pop() 。

motorcycles = ['honda', 'yamaha', 'suzuki']
first_owned = motorcycles.pop(0)
print('The first motorcycle I owned was a ' + first_owned + '.')  123

The first motorcycle I owned was a honda. 1
根据值删除元素

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)
motorcycles.remove('ducati')
print(motorcycles)1234

['honda', 'yamaha', 'suzuki', 'ducati']
['honda', 'yamaha', 'suzuki']12

使用 remove() 从列表中删除元素
注意！:方法 remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)
too_expensive = 'ducati'
motorcycles.remove(too_expensive)
print(motorcycles)
print("\nA " + too_expensive + " is too expensive for me.")123456

['honda', 'yamaha', 'suzuki', 'ducati']
['honda', 'yamaha', 'suzuki']
A Ducati is too expensive for me.123

列表进阶

对列表进行操作的小方法

使用方法 sort()  对列表进行永久性排序

#这里请注意sort()是必须吸先对列表进行排序才可以输出
#这里是按照首字母排序的
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)12345

['audi', 'bmw', 'subaru', 'toyota']1

你还可以按与字母顺序相反的顺序排列列表元素，为此，只需向 sort() 方法传递参数 reverse=True 

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse=True)
print(cars)123

['toyota', 'subaru', 'bmw', 'audi']1

使用函数 sorted()  对列表进行临时排序
注意：这里的sorted()是临时的，并没有改变原来列表的结构。
注意：sort()必须是先申明再进行输出而sorted()则可以直接在print()语句中使用

cars = ['bmw', 'audi', 'toyota', 'subaru']
print("Here is the original list:")
print(cars)
print("\nHere is the sorted list:")
print(sorted(cars))
print("\nHere is the original list again:")
print(cars)1234567

Here is the original list:
['bmw', 'audi', 'toyota', 'subaru']
Here is the sorted list:
['audi', 'bmw', 'subaru', 'toyota']
Here is the original list again:
['bmw', 'audi', 'toyota', 'subaru']123456

倒着打印列表

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)1234

['bmw', 'audi', 'toyota', 'subaru']
['subaru', 'toyota', 'audi', 'bmw']12

确定列表的长度

 cars = ['bmw', 'audi', 'toyota', 'subaru']
 len(cars)

 41234

列表的切片

例子1

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])

['charles', 'martina', 'michael']1234

例子2
注意！：要切记列表的下标索引是从’0’开始的

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[1:4])

['martina', 'michael', 'florence']1234

例子3
如果你没有指定第一个索引， Python 将自动从列表开头开始：

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[:4])

['charles', 'martina', 'michael', 'florence']1234

例子4
要让切片终止于列表末尾，也可使用下边的格式
注意！：这种格式是包括列表末尾元素的

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[2:])

['michael', 'florence', 'eli']1234

例子5
如果你要输出名单上的最后三个元素

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[-3:])

['michael', 'florence', 'eli']1234

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[-3:-1])

['michael', 'florence']1234

例子6
这里的“2”为步长

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[1::2])12

['martina', 'florence']1

遍历切片

例子1

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("Here are the first three players on my team:")
for player in players[:3]:
    print(player.title())1234

Here are the first three players on my team:
Charles
Martina
Michael1234

列表的复制

有一个列表，其中包含你最喜欢的四种食品，而你还想创建另一个列表，在其中包含一位朋友喜欢的所有食品。不过，你喜欢的食品，这位朋友都喜欢，因此你可以通过复制来创建这个列表
在不指定任何索引的情况下从列表 my_foods 中提取一个切片，从而创建了这个列表的副本，再将该副本存储到变量 friend_foods

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)123456

My favorite foods are:
['pizza', 'falafel', 'carrot cake']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake']1234

给上边两个列表添加值

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
my_foods.append('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)12345678

My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'ice cream']1234

倘若我们只是简单地将 my_foods 赋给 friend_foods ，就不能得到两个列表

my_foods = ['pizza', 'falafel', 'carrot cake']
# 这行不通
friend_foods = my_foods
my_foods.append('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods123456789

My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']1234

列表的深浅拷贝

要了解拷贝就必须要知道可变类型和不可变类型

不可变类型： 整型，浮点数，复数，布尔，字符串，元组
可变类型：列表，字典。
赋值：简单地拷贝对象的引用，两个对象的id相同。
浅拷贝：创建一个新的组合对象，这个新对象与原对象共享内存中的子对象。
深拷贝：创建一个新的组合对象，同时递归地拷贝所有子对象，新的组合对象与原对象没有任何关联。虽然实际上会共享不可变的子对象，但不影响它们的相互独立性。

浅拷贝和深拷贝的不同仅仅是对组合对象来说，所谓的组合对象就是包含了其它对象的对象，如列表，类实例。而对于数字、字符串以及其它“原子”类型，没有拷贝一说，产生的都是原对象的引用。
浅拷贝

注意：浅拷贝和深拷贝的不同仅仅是对组合对象来说，所谓的组合对象就是包含了其它对象的对象，如列表，类实例。而对于数字、字符串以及其它“原子”类型，没有拷贝一说，产生的都是原对象的引用。 

a = ['A', 'B', 'C']
b = list(a)
print(id(a), id(b))          # a和b身份不同
print()
for x, y in zip(a, b):       # 但它们包含的子对象身份相同
    print(id(a), id(b))123456

42617288 42618248

42617288 42618248
42617288 42618248
42617288 4261824812345

深拷贝

所谓“深拷贝”，是指创建一个新的对象，然后递归的拷贝原对象所包含的子对象。深拷贝出来的对象与原对象没有任何关联。
深拷贝只有一种方式：copy模块中的deepcopy函数。

import copy
a = ['A', 'B', 'C']
b = copy.deepcopy(a)
print(id(a), id(b))
print()
for x, y in zip(a, b):
  print(id(x), id(y))1234567

41261064 41261256

36352888 36352888
40111552 40111552
40111440 4011144012345

为什么使用了深拷贝，a和b中元素的id还是一样呢？
答：这是因为对于不可变对象，当需要一个新的对象时，python可能会返回已经存在的某个类型和值都一致的对象的引用。而且这种机制并不会影响 a 和 b 的相互独立性，因为当两个元素指向同一个不可变对象时，对其中一个赋值不会影响另外一个。

我们可以用一个包含可变对象的列表来确切地展示“浅拷贝”与“深拷贝”的区别：

import copy
a = [[1, 2], [5, 6], [8, 9]]

b = copy.copy(a)              # 浅拷贝得到b
c = copy.deepcopy(a)          # 深拷贝得到c
print(id(a), id(b))           # a 和 b 不同
print()
for x, y in zip(a, b):        # a 和 b 的子对象相同
  print(id(x), id(y))
print()
print(id(a), id(c))           # a 和 c 不同
print()

for x, y in zip(a, c):        #a 和 c 的子对象也不同
  print(id(x), id(y))
print(id(x), id(y))12345678910111213141516

37526920 37526856

37525512 37525512
37525704 37525704
37526984 37526984

37526920 37526792

37525512 37526728
37525704 37526600
37526984 37526536
37526984 37526536
--------------------- 

一、元组(tuple)
1.特性：不可更改的数据序列。【理解：一旦创建元组，则这个元组就不能被修改，即不能对元组进行更新、增加、删除操作】
2.创建：一对圆括号“（）”和其包含的元素（若没有元素，则为空元组）。
　　　　创建一般元组：即一维元组。如：tempTuple = ("one","two","three",4,5,6)。
　　　　创建嵌套元组：元组中还可以包含元组，即嵌套元组或二维（多维）元组。如：mulTuple = (("you","are","a","dog"),"you","too")。
　　注：若想创建包含一个元素的元组，则必须在该元素后面加逗号“,”，否则创建的不是一个元组，而是一个字符串。
　　　　如：aTuple = ("one",)，aString = ("one")。type(aTuple) -> "tuple"，type(aString) ->"string"。
3.访问：元组名[index],index为元素在元组中的索引，索引为整数，从0开始。注意：index不能越界，否则会报错。
　　　　访问一般元组：tempTuple[0] -> "one",tempTuple[3] -> 4。
　　　　访问嵌套元组：mulTuple[0][1] ->"are"。
　　注：可以使用负数作为索引来访问元组。-1代表最后一个元素，-2代表倒数第二个，以此类推。如：tempTuple[-1] ->"too"。
　　      可用for循环遍历元组。如：for element in tempTuple: print(elment)。
4.求长：len(元组名)。如len(tempTuple) ->6。（长度也即元组中元素的个数）。
5.打印：print(元组名)，可打印元组中的所有元素。
6.类型：type(元组名) ->"tuple"。
7.删除：del 元组名，删除元组，当访问被删除的元组时会报错，提示：元组未定义。（其他类型也可以用此方法）
二、列表(list)
1.特性：可更改的数据数列。(区别于元组，可动态增加，删除，更新)
2.创建：一对方括号“[]”和其包含的元素,单个元素可以不加逗号，同元组一样，可以创建嵌套列表。如：tempList = ["one","two","three"]。
3.基本操作及方法：
　　（1）访问、遍历、求长、打印、类型等操作同元组
　　（2）更新：给列表中的元素重新赋值，不可给列表中不存在的元素赋值。如：tempList[2] = 3 ->tempList = ["one","two",3]，tempList[3] = "four" ->报错！！！
　　（3）删除：删除元素后（若不是最后一个），右边的元素会左移。
　　　　1)del:删除指定元素。如：del tempList[0] ->tempList = ["two","three"]
　　　　2)pop：删除指定位置的元素并返回被删除的元素，默认删除最后一个。如：element = tempList.pop(1) ->element = two,tempList = ["one","three"]。
　　（4）增加(插入)：
　　　　1)append:向列表末尾添加一个元素,参数不能为空，否则报错。如：tempList.append("four") ->tempList = ["one","two","three","four"]。
　　　　2)extend:向列表末尾添加多个元素，参数不能为空，不能是int型，可为字符串（当成列表处理，每个字符就是一个元素）、元组、列表。如：
　　　　　　　　　参数为字符串：tempList.extend("str") ->tempList = ["one","two","three","s","t","r"]。
　　　　　　　　　参数为元组或列表：tempList.extend(("four",“five”)) ->tempList = ["one","two","three","four",“five”]。
　　　　3)list[index:index] = [value]:向列表list指定的位置index插入一个元素。如：tempList[1:1] = ["add"] -> tempList = ["one","add","two","three"].
　　　　　　注：更一般的形式：listname[start:end] = 元组/列表/字符串，可插入多个元素.
4.高级操作及方法：
　　(1)产生一个数值递增列表：
　　　　　　1)pList = range(N)，产生一个元素值为0~N-1的列表。如：pList = range(10) ->pList = [0,1,2,3,...,9]。
　　　　　　2)pList = range(sn,en),产生一个元素值为sn~en-1的列表。如：pList =  range(1,5) ->pList = [1,2,3,4]。
　　　　　　3)pList = range(sn,en,inc),产生一个元素值以inc递增的列表。如：pList = range(1,10,2) ->pList = [1,3,5,7,9]
　　(2)固定值初始化：pList = [value for index  in range(N)]，产生一个长度为N的列表，元素值都为value.
　　　　　　如：value = "x",N=10,则pLsit = ["x","x",...,"x"]
　　　　更简单的形式：pList = [value]*N。
　　(3)操作符：
　　　　1)"+"：两个列表相加，将合成为一个列表。如 pL1 = [1,2],pL2 = [3,4],pL1+pL2 ->[1,2,3,4]
　　　　2)"*"：形式：[value]*N。如value="a",N=4,则得到列表["a","a","a","a"]。
　　　　3)del：del pL[index]:删除指定位置的元素。 del pL[sIndex:eIndex]:删除sIndex~eIndex-1位置的元素。
　　(4)列表复制：
　　　　1)pL1 = pL：pL1为pL的别名，即pL1和pL实质为同一个列表，修改其中一个列表，另一个列表也随之变化。
　　　　　　　　如：pL = [1,2,3],pL1 = pL,pL1[2] = 33,->pL = pL1 = [1,2,33]
　　　　2)pL2 = pL[:]：pL2为pL的一个克隆（或拷贝），即pL2和pL为不同的列表，修改其中一个列表，另一个不会受影响。
　　(5)常用方法：
　        1)L.append(value):向列表末尾插入一个元素
　　　　2)L.insert(index,value)：向列表的index位置插入一个元素value。
　　　　3)L.pop(index)： 从列表中删除指定位置index的元素并返回元素值，默认删除最后一个元素。
　　　　4)L.remove(value)：删除在列表中第一次出现的元素value。如：pList = [1,2,3,2],pList.remove(2) ->pList = [1,3,2]。
　　　　5)L.count(value)：返回元素value在列表中出现的次数。
　　　　6)L.index(value) ：该元素第一次出现的的位置,无则抛异常 。
　　　　7)L.extend(list/tuple/string) ：向列表末尾插入多个元素。
　　　　8)L.sort()：排序
　　　　9)L.reverse()：倒序
三、字典(dictionary)
1.特性：以名称索引的分组数据。元组和列表以数字顺序索引，而字典的索引可以数字，字母，字符串，符号等。
　　　　在字典中，索引叫做：键，即key,对应的值叫做值，即value。
2.创建：dic = {key1:value1,key2:value2},可先创建空字典dic =｛｝，然后再初始化，如dic["one"] = "firstValue"。
　　　　注：键是唯一的，字典只认最后一个赋的键值。如：dic = {1:1,2:2,1:3} ->dic = {1:3,2:2},最后一个元素（1:3）被“舍弃”。
3.访问：dic[key]，获得key对应的值，若key不存在，则报错。
4.常用方法和操作：
　　　　1)D.get(key, defualtValue)：获得key对应的值，若key不存在，则返回设置的默认值defualtValue,若没有设置默认值则返回None。
　　　　2)D.has_key(key) ：检查字典中是否存在键key，有该键返回TRUE，否则FALSE。
　　　　3)D.keys()：返回由字典所有键构成的列表。
　　　　4)D.values()：返回由字典所有值构成的列表。
　　　　5)D.items()：返回由字典所有键值对构成的列表，即[(key1,value1),(key2,value2),(key3,value3),...]。
　　　　6)D.update(dic2)：将字典dic2中的元素合并到字典D中。
　　　　7)D.popitem()：随机删除字典中的一个键值对（一项），并返回值。若字典为空则抛出异常。
　　　　8)D.clear()：清空字典中的元素并返回None
　　　　9)D.pop(key)：删除指定键所对应的项，并返回key对应的值。key不能为空，也不默认删除排在最后的元素，因为字典是无序的，注意和列表的区别！！！
　　　 10)D.copy()：拷贝字典，两个字典不是同一个字典。如d = {1:1,2:2},d1 = d.copy() ->d1 = {1:1,2:2}。
　　　 11)cmp(dict1,dict2)：比较字典，(优先级为元素个数、键大小、键值大小)，第一个大则返回1，第一个小则返回-1，一样大则返回0。

四、字符串(string)
1.特性：不能修改的字符序列。除了不能修改，可把字符串当成列表一样处理。
2.访问：访问字符串中某个字符同访问元组或列表中的元素是一样的，专业术语叫“分片（slicing）”。如：str = "aString",str[0] = "a",str[1] = "S"。
　　这里不做深入讨论字符串，把字符串放在这里主要是为了说明字符串具备列表的一些特点。
五、集合(set)
1.特性：与字典类似，但只包含键，而没有对应的值，包含的数据不重复。
2.创建：s = set(list or tuple or string)。重复的值在集合中只存在一个。如：
　　　　列表list：s = set([1,2,3,3]) ->s = set([1,2,3])
　　　　元组tuple：s = set((1,2,3))  ->s = set([1,2,3])
　　　　字符串string：s = set("abc") ->s = set(["a","b","c"])