由于上一节只写到Number，string。本章将将在原有的基础上拓展
元组、列表、字典
准备好了么，Follow Me，Go～
string
- String遍历
a = "Payne"# 根据索引取值，注意此处索引值从0开始# 例如print(a[0]) # Pprint(a[1]) # a# 字符串的遍历的三种方式，加入end的原因是阻止print会换行输出。for _ in a: print(_, end="") # Payneprint()for i in range(len(a)): print(a[i], end="") # Payneprint()for j in enumerate(a): print(j, end="") # (0, 'P')P(1, 'a')a(2, 'y')y(3, 'n')n(4, 'e') print(j[1], end="") # Payne
- 字符串的基本处理
print(a.split()) # ['Payne']print(b) # Payneprint(b.split(" ")) # ['', '', '', '', 'Payne', '', '', '', '']print(b.strip()) # Payneprint(b.swapcase()) # pAYNEprint(b.title()) # Payneprint(b.upper()) # PAYNE
- Split
使用sep作为分隔符字符串，返回字符串中单词的列表。
- strip:
返回删除前导和尾随空格的字符串副本
- swapcase
将大写字符转换为小写，将小写字符转换为大写。
- title
返回字符串的版本，每个单词都用大写字母表示。
- translate
使用给定的转换表替换字符串中的每个字符。
- upper
返回转换为大写的字符串的副本。
列表
在其他语言中通常有数组这么一个概念，而Python衍生出，动态数组-列表、及静态数组-元组。
数组（Array）是有序的元素序列。[1] 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
# 列表的定义_list = [] list1 = ['physics', 'chemistry', 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = ["a", "b", "c", "d"]# 列表的索引取值(索引有正负之分，符号代表方向) [start:end] or [::sep]print("list1[0]: ", list1[0]) # list1[0]: physicsprint("list2[1:5]: ", list2[1:5]) # list2[1:5]: [2, 3, 4, 5]print(list1[:]) # ['physics', 'chemistry', 1997, 2000]print("list2[::-1]", list2[::-1]) # list2[::-1] [5, 4, 3, 2, 1] 倒序取值# 列表的循环遍历# 索引遍历for _ in range(len(list1)): print(list1[_], end=" ") # physics chemistry 1997 2000print()# 直接遍历for i in list2: print(i, end=" ") # 1 2 3 4 5print()for j in enumerate(list3): # (0, 'a') (1, 'b') (2, 'c') (3, 'd') print(j, end=" ")
- 列表的操作
operating_list = [1]# append:追加，在末尾追加元素operating_list.append(2) print(operating_list) # [1, 2]# 清空:clean# print(operating_list.clear()) # None# 计数print(operating_list.count(1)) # 1# 根据值获取索引，从前往后，返回且仅返回第一个"找到"的值print(operating_list.index(1)) # 0print(operating_list.index(2)) # 1# 插入, 若插入的索引已有数据，则会将其后移一位，进行插入。若超出索引则会实现appeendoperating_list.insert(1, 6) print(operating_list) # [1, 6, 2]# pop：与append恰恰相反，pop(index) 如果index为空时，默认推出最后一位数字。# 若有索引值，则pop出索引所对应的值print(operating_list.pop()) # 2 pop出的值print(operating_list) # [1, 6]operating_list.pop(1) # [6]print(operating_list) # [1]# remove 从列表中删除对应的值operating_list.remove(1) print(operating_list) # []# reverse：列表反转# sort 列表排序
List Api
class list(object): """ Built-in mutable sequence. If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified. """ def append(self, *args, **kwargs): # real signature unknown """ Append object to the end of the list. """ pass def clear(self, *args, **kwargs): # real signature unknown """ Remove all items from list. """ pass def copy(self, *args, **kwargs): # real signature unknown """ Return a shallow copy of the list. """ pass def count(self, *args, **kwargs): # real signature unknown """ Return number of occurrences of value. """ pass def extend(self, *args, **kwargs): # real signature unknown """ Extend list by appending elements from the iterable. """ pass def index(self, *args, **kwargs): # real signature unknown """ Return first index of value. Raises ValueError if the value is not present. """ pass def insert(self, *args, **kwargs): # real signature unknown """ Insert object before index. """ pass def pop(self, *args, **kwargs): # real signature unknown """ Remove and return item at index (default last). Raises IndexError if list is empty or index is out of range. """ pass def remove(self, *args, **kwargs): # real signature unknown """ Remove first occurrence of value. Raises ValueError if the value is not present. """ pass def reverse(self, *args, **kwargs): # real signature unknown """ Reverse *IN PLACE*. """ pass def sort(self, *args, **kwargs): # real signature unknown """ Sort the list in ascending order and return None. The sort is in-place (i.e. the list itself is modified) and stable (i.e. the order of two equal elements is maintained). If a key function is given, apply it once to each list item and sort them, ascending or descending, according to their function values. The reverse flag can be set to sort in descending order. """ pass
元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
tup1 = () # 创建空元组tup1 = ('physics', 'chemistry', 1987, 2010) tup2 = (1, 2, 3, 4, 5 ) tup1 = (20,) # 元组中只包含一个元素时，需要在元素后面添加逗号
元组操作
# 访问元组tuple_1 = (1, 2, 3, 4, 5, 6) print(tuple_1[0]) # 1print(tuple_1[1]) # 2print(tuple_1[2]) # 3# 元组遍历for _ in range(len(tuple_1)): print(tuple_1[_], end=" ") # 1 2 3 4 5 6print()for i in enumerate(tuple_1): print(i, end=" ") # (0, 1) (1, 2) (2, 3) (3, 4) (4, 5) (5, 6)print()for j in tuple_1: print(j, end=" ") # 1 2 3 4 5 6# 删除元组del tuple_1 print(tuple_1) # print(tuple_1) NameError: name 'tuple_1' is not defined# 修改元组# 我们仅可对元组进行拼接，无法像list一样修改内部的值
元组与列表的区别
元组固定且不可变，这意味着元组一旦被创建，和列表不同它的内容无法被修改及它的大小也无法被改变
虽然他并不支持改变大小，但是我们的可以将两个元组合并生成一个新的元组。这一操作类似于列表的resize操作，但我们不需要为新生成的元组分配任何额外的空间
元组与列表的append 相比较，我们会开到他们的复杂度时O(n)而不是列表的O(1)。这是因为对元组没添加一个新元素都会有分配与复制的操作。而不是列表那样仅在额外空间耗尽的时候发生
元组的静态特性的另一个好处在于Python后台发生的事情：资源缓存
Python是一门垃圾回收语言，这意味着当一个变量不再被使用时，Python会将该变量使用的内存释放会操作系统，以供其他程序或变量使用。然而，对于长度为1～20 的元组，即使他们不在被使用，他们的内存空间并不会立即返还给操作系统，而是留下来以待未来使用。
字典(Dictionary)
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }# 定义d = {} or d = dict()# 键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。d = {'a': 1, 'b': 2, 'b': '3'}# 访问字典里的值d = {'a': 1, 'b': 2, 'c': '3'} print(d['a']) # 1print(d['b']) # 2print(d['c']) # 3# 修改字典d = {'Name': 'Payne', 'Age': 20, 'Class': 'First'} d['Age'] = 8 # 更新d['School'] = "school" # 添加print(d) # {'Name': 'Payne', 'Age': 8, 'Class': 'First', 'School': 'school'}# 删除字典的值del dict['Name'] # 删除键是'Name'的条目dict.clear() # 清空字典所有条目del dict # 删除字典# 2）键必须不可变，所以可以用数字，字符串或元组充当# 字典的遍历d = {'Name': 'Payne', 'Age': 20, 'Class': 'First'}for i in d.keys(): print(i, end=" ") # Name Age Classfor j in d.values(): print(j, end=" ") # Payne 20 First
集合
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...} 或者 set(value)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}>>> print(basket) # 这里演示的是去重功能{'orange', 'banana', 'pear', 'apple'}>>> 'orange' in basket # 快速判断元素是否在集合内True>>> 'crabgrass' in basketFalse>>> # 下面展示两个集合间的运算....>>> a = set('abracadabra')>>> b = set('alacazam')>>> a {'a', 'r', 'b', 'c', 'd'}>>> a - b # 集合a中包含而集合b中不包含的元素{'r', 'd', 'b'}>>> a | b # 集合a或b中包含的所有元素{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}>>> a & b # 集合a和b中都包含了的元素{'a', 'c'}>>> a ^ b # 不同时包含于a和b的元素{'r', 'd', 'b', 'm', 'z', 'l'}# 集合的基本操作s.add( x )>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.add("Facebook")>>> print(thisset) {'Taobao', 'Facebook', 'Google', 'Runoob'}# 还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：s.update( x )>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.update({1,3})>>> print(thisset) {1, 3, 'Google', 'Taobao'}>>> thisset.update([1,4],[5,6]) >>> print(thisset) {1, 3, 4, 5, 6, 'Google', 'Taobao'}# 清空集合s.clear() set_1 = set({1, 2, 3, 2}) print(set_1) # {1, 2, 3} 去重set_1.clear() print(set_1) # None 清空# 判断集合是否存在某值x in set print(1 in set_1) # Trueprint(6 in set_1) # False
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
