1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、Python中的字符串不能改变。

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

加号 + 是列表连接运算符，星号 * 是重复操作。

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表


['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与Python字符串不一样的是，列表中的元素是可以改变的：

Python 列表截取可以接收第三个参数，参数作用是截取的步长，如果第三个参数为负数表示逆向读取。

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。join()方法语法：str.join(sequence)，sequence – 要连接的元素序列。返回通过指定字符连接序列中元素后生成的新字符串。

str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );
a-b-c

Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

split() 方法语法：

str.split(str="", num=string.count(str)).

参数
str – 分隔符，默认为所有的空字符，包括空格、换行( )、制表符( )等。
num – 分割次数。默认为 -1, 即分隔所有。
返回值
返回分割后的字符串列表。

str = "Line1-abcdef 
Line2-abc 
Line4-abcd";
print str.split( );       # 以空格为分隔符，包含 

print str.split(' ', 1 ); # 以空格为分隔符，分隔成两个
以上实例输出结果如下：
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '
Line2-abc 
Line4-abcd']
以下实例以 # 号为分隔符，指定第二个参数为 1，返回两个参数列表。
txt = "Google#Runoob#Taobao#Facebook"
 # 第二个参数为 1，返回两个参数的一个列表
x = txt.split("#", 1)
 print x
以上实例输出结果如下：

['Google', 'Runoob#Taobao#Facebook']

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
 print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。修改元组元素的操作是非法的
其实，可以把字符串看作一种特殊的元组。
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

student = {‘Tom’, ‘Jim’, ‘Mary’, ‘Tom’, ‘Jack’, ‘Rose’}

print(student) # 输出集合，重复的元素被自动去掉(集合中不能存在重复的元素，数学知识）

成员测试

if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')

set可以进行集合运算

a = set('abracadabra')
b = set('alacazam')
 
print(a)
 
print(a - b)     # a 和 b 的差集
 
print(a | b)     # a 和 b 的并集
 
print(a & b)     # a 和 b 的交集
 
print(a ^ b)     # a 和 b 中不同时存在的元素

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
语法

index()方法语法：

list.index(x[, start[, end]])

参数

x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。

返回值

该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted 语法：
sorted(iterable, cmp=None, key=None, reverse=False)
参数说明：
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。返回重新排序的列表。

cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
cmp( x, y )
参数

x -- 数值表达式。
y -- 数值表达式。

返回值
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

list中的sort()方法：

def sort(self, key=None, reverse=False): # real signature unknown; restored from doc
“”" L.sort(key=None, reverse=False) -> None – stable sort IN PLACE “”"
pass
‘’’
key:是排序的条件,可以是：key=int，key=len， key=lambda…
reverse:表示是否反序，默认从小到大，默认为Flase

‘’’
##一个list调用sort方法后，对原list进行排序

1、最简单的排序

l = [5,2,3,1,4 ]
l .sort()
print(l) ##输出：[1, 2, 3, 4, 5]

l.sort(reverse=True)#反序
print(l) ##输出：[5, 4, 3, 2, 1]

##2、字符串排序
StrList = [‘fb’, ‘bx’, ‘csw’, ‘qb’, ‘qqa’, ‘eeeed’]
2.1 一般字典序排列，但是大写在前，小写在后！！
StrList.sort()
print(StrList) ##字符串列表是按照第一个字符的大小排序的
##输出：[‘Fast’, ‘Smooth’, ‘fast’, ‘is’, ‘is’, ‘smooth’]

Python lower() 方法转换字符串中所有大写字符为小写。
语法
字符串.lower()
lower()方法语法：
无参数
返回将字符串中所有大写字符转换为小写后生成的字符串。
str.lower()
2.2忽略大小写，按abcd顺序
StrList.sort(key=str.lower)
print(StrList) ##输出：[‘Fast’, ‘fast’, ‘is’, ‘is’, ‘Smooth’, ‘smooth’]

2.3按照字符串长度排序

StrList.sort(key=len)
print(StrList)##输出：['is', 'is', 'fast', 'Fast', 'Smooth', 'smooth']

StrList.sort(key=len, reverse=True)#反序
print(StrList) ##输出：['Smooth', 'smooth', 'fast', 'Fast', 'is', 'is']

l = [[2, 2, 3], [1, 4, 5], [5, 4, 9]]
l.sort(lambda x:x[0]) ##按照第一个元素进行排序
print(l) ##输出：[[1, 4, 5], [2, 2, 3], [5, 4, 9]]
‘’’
匿名函数的x，表示的是l列表中的每一个成员元素

x[0] :表示列表里面列表的第一个成员元素

‘’’

def sorted(*args, **kwargs): # real signature unknown
“”"
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
"""

‘’’
sorted(L)返回一个排序后的L，不改变原始的L；
　　L.sort()是对原始的L进行操作，调用后原始的L会改变，没有返回值。【所以a = a.sort()是错的啦！a = sorted(a)才对！
sorted()适用于任何可迭代容器，list.sort()仅支持list（本身就是list的一个方法）

‘’’

>>> class Student:
        def __init__(self, name, grade, age):
                self.name = name
                self.grade = grade
                self.age = age
        def __repr__(self):
                return repr((self.name, self.grade, self.age))
>>> student_objects = [
        Student('john', 'A', 15),
        Student('jane', 'B', 12),
        Student('dave', 'B', 10),
]
>>> sorted(student_objects, key=lambda student: student.age)   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

如果第一个排序条件相同，则按照第二个条件排序

a = [[2,3],[4,1],(2,8),(2,1),(3,4)]
b = sorted(a,key=lambda x: (x[0], -x[1]))
print(b)

'''
  b = sorted(a,key=lambda x:(条件a，条件b))  
'''

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
下例能将关键字参数顺序不重要展示得更清楚：

#可写函数说明

def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
 
#调用printinfo函数
printinfo( age=50, name="miki" );

以上实例输出结果：

Name: miki
Age 50

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：

可写函数说明

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return;
 

调用printinfo 函数

printinfo( 10 );
printinfo( 70, 60, 50 );

以上实例输出结果：

输出:
10
输出:
70
60
50

实例展示了 count() 方法的使用方法：
1
2
3
4
5
6

aL = [123, 'Google', 'Runoob', 'Taobao', 123];
 
print ("123 元素个数 : ", aL.count(123))
print ("Runoob 元素个数 : ", aL.count('Runoob'))

以上实例输出结果如下：
1
2
123 元素个数 : 2
Runoob 元素个数 : 1
set()函数将列表转换为集合
list（）函数把集合转化为列表