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("123456") >>>a ['1','2','3','4','5','6'] b = list("1,2,3,4") >>>b ['1',',','2',',','3',',',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"])