所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们
在 Python 中，序列类型包括字符串、列表、元组，他们支持索引、切片。第一个索引若为0，则指向左端；第一个索引若为负数，则指向右端
切片是指截取序列中的其中一段内容。使用语法：[起始下标：结束下标：步长]，截取的内容不包括结束下标对应的数据，步长是指隔几个下标截取一个项（默认为1）
将字符串的第一个字母变成大写,其他字母变小写
str.capitalize()
test1 = 'i lovE python' print(test1.capitalize()) # 输出 I love python返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写。还有istitle()函数可以检测字符串里面的每个单词的首字母是否为大写
str.title()
str1 = "this is string example....wow!!!" print(str1.title())转换字符串中所有大(小)写字符为小写(大)。
str.lower() str.upper()
test1 = 'i LOVE python' test2 = 'i love python6*' print(test1.lower()) # i love python print(test1.upper()) # I LOVE PYTHON print(test2.lower()) # i love python6* print(test2.upper()) # I LOVE PYTHON6*对字符串的大小写字母进行转换。
str.swapcase();
test1 = 'i LOVE python' test2 = 'i love python6*' print(test1.swapcase()) # I love PYTHON print(test1.swapcase()) # I love PYTHON print(test2.swapcase()) # I LOVE PYTHON6* print(test2.swapcase()) # I LOVE PYTHON6*用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
str.endswith(suffix[, start[, end]])
suffix – 该参数可以是一个字符串或者是一个元素。start – 字符串中的开始位置，从0开始。end – 字符中结束位置，最大为字符串长度。 test1 = 'i love python' # 13个字符 print(test1.startswith('i', 0, 13)) # True，start从0开始 print(test1.startswith('i', 1, 13)) # False print(test1.endswith('on', 0, 13)) # True，end为字符串长度，但不包括最后一个 print(test1.endswith('on', 0, 12)) # False用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
str.endswith(suffix[, start[, end]])
suffix – 该参数可以是一个字符串或者是一个元素。start – 字符串中的开始位置，从0开始。end – 字符中结束位置，默认为字符串的长度。 test1 = 'i love python' # 13个字符 print(test1.startswith('i', 0, 13)) # True，start从0开始 print(test1.startswith('i', 1, 13)) # False print(test1.endswith('on', 0, 13)) # True，end为字符串长度，但不包括最后一个 print(test1.endswith('on', 0, 12)) # False截掉字符串左边（右边或头尾）的空格或指定字符。 注意：strip方法只能删除开头或是结尾的字符，不是删除中间部分的字符。
str.lstrip([chars])，默认截取的是空格 str.rstrip([chars])，默认截取的是空格 str.strip([chars])，默认截取的是空格
chars --指定截取的字符。 test1 = ' i LOVE python ' test2 = '88888i love python88888' print(test1.lstrip()) # i LOVE python ，后面有三个空格 print(test1.rstrip()) # i LOVE python，前面有三个空格 print(test1.strip()) # i LOVE python print(test2.lstrip('88888')) # i love python88888 print(test2.rstrip('88888')) # 88888i love python print(test2.strip('88888')) # i love python msg = ' 22 ' print(msg.rstrip()) # 默认截取的是空格 print(msg.lstrip()) print(msg.strip())是从字符串左边开始查询子字符串匹配的第一个索引 ，如果指定 start（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回第一个索引值，否则返回-1。 rfind()是从字符串右边开始查询字符串匹配到的第一个索引，不过没有lfind()
str.find(str, beg, end)
str – 指定检索的字符串start – 开始索引，默认为0。end – 结束索引，默认为字符串的长度。 test1 = 'i love python' # 13个字符 print(test1.find('i', 0, 13)) # 0 print(test1.find('i', 1, 13)) # -1 print(test1.find('on', 0, 13)) # 11，为查询到的字符串的首个索引 print(test1.find('on', 0, 12)) # -1用于从字符串中找出某个值第一个匹配项的索引位置，它与find()一样，只不过如果str找到就会爆出异常 rindex() 是 从字符串右边开始查询字符串匹配到的第一个索引，不过 没有lindex()
str.index(x[, start[, end]])
x-- 查找的对象。start-- 可选，查找的起始位置。end-- 可选，查找的结束位置。 str1 = 'hello world' print(str1.index('e')) # 1 print(str1.index('e', 1, 4)) # 1 print(str1.index('o', 1, 5)) # 4 print(str1.index('o', 1, 4)) # 报出异常把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
str.replace(old, new[, max])
old – 将被替换的子字符串。new – 新字符串，用于替换old子字符串。max – 可选字符串, 替换不超过 max 次 str1 = "this is string example....wow!!! this is really string" print(str1.replace("is", "was")) # thwas was string example....wow!!! thwas was really string print(str1.replace("is", "was", 3)) # thwas was string example....wow!!! thwas is really string检测字符串（不能有空格）是否由字母或数字组成。
str.isalnum()
test1 = 'i love python666' test2 = 'python666' test3 = 'python' test4 = '666' test5 = '---' print(test1.isalnum()) # False，有空格 print(test2.isalnum()) # True print(test3.isalnum()) # True print(test4.isalnum()) # True print(test5.isalnum()) # False检测字符串是否只由字母组成。
str.isalpha()
test1 = 'i love python666' test2 = 'python666' test3 = 'python' test4 = '666' test5 = '---' print(test1.isalpha()) # False print(test2.isalpha()) # False print(test3.isalpha()) # True print(test4.isalpha()) # False print(test5.isalpha()) # False检测字符串是否只由数字组成。
str.isdigit()
test1 = 'i love python666' test2 = 'python666' test3 = 'python' test4 = '666' test5 = '---' print(test1.isdigit()) # False print(test2.isdigit()) # False print(test3.isdigit()) # False print(test4.isdigit()) # True print(test5.isdigit()) # False检测字符串是否由小写字母组成。
str.islower()
test1 = 'i love python6' test2 = 'i love python-' test3 = 'i love python' test4 = 'I LOVE PYTHON' test5 = 'i LOVE python' print(test1.islower()) # True print(test2.islower()) # True print(test3.islower()) # True print(test4.islower()) # False print(test5.islower()) # Falseencode函数以 encoding指定的编码格式编码字符串而decode函数则是与encode函数相反。errors参数可以指定不同的错误处理方案。encode函数返回编码后的bytes类型对象，decode函数则是返回解码后的字符串。
str.encode([encoding][,errors]) bytes.decode([encoding][,errors])
encoding – 要使用的编码，默认为"UTF-8"。errors – 设置不同错误的处理方案。默认为 ‘strict’。其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。 msg = '你好' res = msg.encode() # 默认为utf-8 res2 = msg.encode('utf-8') print(type(res2)) # <class 'bytes'> print(res == res2) # True print(res.decode()) # # 默认为utf-8用于将序列中的元素以指定的字符连接生成一个新的字符串。
str.join(sequence)
equence – 要连接的元素序列。 str1 = '-' seq = ("a", "b", "c") print(str1.join(seq)) # a-b-c通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔成 num+1 个子字符串
str.split(str, num)
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。num – 分割次数。默认为 -1, 即分隔所有。 str1 = "Line1-abcdef \nLine2-abc \nLine4-abcd" str2 = "Line1-abcdef\nLine2-abc\nLine4-abcd" str3 = "Line1-abcdef\tLine2-abc\tLine4-abcd" str4 = "Line1-abcdef Line2-abc Line4-abcd" print(str1.split()) # ['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] print(str2.split()) #['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] print(str3.split()) #['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] print(str4.split()) #['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] print(str1.split(' ', 1)) #['Line1-abcdef', '\nLine2-abc \nLine4-abcd']用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
str.count(sub, start,end)
sub – 搜索的子字符串start – 字符串开始搜索的位置。默认第一个字符索引值为0。end – 字符串中结束搜索的位置。默认为字符串的长度。 test1 = '88888i lov888e pyth8on88888' # 27个字符，14个8 print(test1.count('8', 0, 27)) # 14 print(test1.count('8', 1, 27)) # 13 print(test1.count('8', 0, 26)) # 13 print(test1.count('8', 1, 26)) # 12列表内数据可以增删查改；当列表内数据改变时，其内存地址不会改变；列表内的数据可以是任何的数据类型；并且它也支持索引和切片
用于在列表末尾添加新的对象。
list.append(obj)
li = ['abcd', 123, True, 12.3] print(li) # ['abcd', 123, True, 12.3] li.append([1, 2]) print(li) # ['abcd', 123, True, 12.3, [1, 2]]用于将指定对象插入列表的指定位置。
list.insert(index, obj)
index – 对象 obj 需要插入的索引位置。obj – 要插入列表中的对象。 aList = [123, 'xyz', 'zara', 'abc', 123] aList.insert(1, 123) print(aList) # [123, 123, 'xyz', 'zara', 'abc', 123]用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
list.extend(seq)
seq – 元素列表。 aList = [123, 'xyz', 'zara', 'abc', 123] bList = [2009, 'manni'] aList.extend(bList) print(aList) # [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']用于统计某个元素在列表中出现的次数。
list.count(obj)
aList = [123, 'xyz', 'zara', 'abc', 123] print(aList.count(123)) # 2 print(aList.count('zara')) # 1用于从列表中找出某个值第一个匹配项的索引位置，当找不到的时候会报错。
list.index(x[, start[, end]])
x-- 查找的对象。start-- 可选，查找的起始位置。end-- 可选，查找的结束位置。 aList = [123, 'xyz', 'zara', 'abc', 123] print(aList.index(123)) # 0 print(aList.index(777)) # 当找不到的时候会报错注意列表没有rindex方法，只要字符串才有‘r’方法
用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
list.pop([index])
index-- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。 aList = [123, 'xyz', 'zara', 'abc', 123] aList.pop() print(aList) # [123, 'xyz', 'zara', 'abc'] aList.pop(0) print(aList) # ['xyz', 'zara', 'abc']用于移除列表中某个值的第一个匹配项，没有找到的话就报出错误。
list.remove(obj)
aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.remove('xyz') print(aList) # [123, 'zara', 'abc', 'xyz']用于删除列表中所有值。
list.clear()
li = ['abcd', 123, True, 12.3] li.clear() # []删除列表内的某项
listA = list(range(10, 20)) print(listA) # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] del listA[0] print(listA) # [11, 12, 13, 14, 15, 16, 17, 18, 19] del listA[1:4] print(listA) # [11, 15, 16, 17, 18, 19]用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
list.sort( key=None, reverse=False)
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。 aList = ['Google', 'Runoob', 'Taobao', 'Facebook'] aList.sort() print("List : ", aList) # List : ['Facebook', 'Google', 'Runoob', 'Taobao']用于反向列表中元素。
list.reverse()
aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.reverse() print(aList) # ['xyz', 'abc', 'zara', 'xyz', 123]元组于列表类似，不同之处在于元组的一级元素不能增、删、改；它也可以进行索引和切片；元组内可以是任何类型；当元组中只有一个元素时，要加上逗号，不然解释器会当做整形来处理
tupleA = ('abcd', 89, 12.3, 'peter', [11, 22], 'peter') print(tupleA.count('peter')) # 2，用来计算'peter'在元组内出现的次数 print(tupleA[0]) # abcd print(tupleA[1:3]) # (89, 12.3) print(tupleA[-1:-3:-1]) # ('peter', [11, 22]) print(tupleA[-2:-1:]) # ([11, 22],)，注意当元组内只有一个元素时有逗号的 tupleA[4][0] = 22 print(tupleA) # ('abcd', 89, 12.3, 'peter', [22, 22], 'peter')，不可以修改元组的值，但可以修改元组值得值 tupleB = (1) print(type(tupleB)) # <class 'int'> tupleC = (1,) print(type(tupleC)) # <class 'tuple'> tupleA[0] = 1 # 元组不能修改，在这里会爆出error print(tupleA)用于统计某个元素在元组中出现的次数。
list.count(obj)
name = (0, 1, 2, 3, 4, 5, 0) print(name.count(1)) # 1 print(name.count(7)) # 0用于从元组中找出某个值第一个匹配项的索引位置，当找不到的时候会报错。
list.index(x[, start[, end]])
x-- 查找的对象。start-- 可选，查找的起始位置。end-- 可选，查找的结束位置。 name = (0, 1, 2, 3, 4, 5, 0) print(name.index(0)) # 0 print(name.index(0, 1)) # 6 print(name.index(0, 1, 6)) # 当找不到的时候会报错装包就是把未命名的参数放到元组中，把命名参数放到字典中，拆包将一个结构中的数据拆分为多个单独变量 参考案例
字典是以键值对的形式存在的 ，字典不可使用索引和切片，它支持添加、修改、删除
dictA = dict([('name', 'ming'), ('age', 20)]) # 列表 dictB = dict((('name', 'ming'), ('age', 21))) # 元组 print(dictA) # {'name': 'ming', 'age': 20} print(dictB) # {'name': 'ming', 'age': 21} dictA = {'name': '李华'} dictA['age'] = 30 # 添加值 print(len(dictA)) # 获得字典长度 print(dictA['age']) dictA['age'] = 40 # 修改值 print(dictA['age']) print(dictA.keys()) print(dictA.values()) print(dictA.items()) dictA.update({'name': '李明'}) print(dictA) for (key, value) in dictA.items(): print('{}为{}'.format(key, value)) pass获得字典的所有键
dictA = {'name': '李华', 'age': 40} print(dictA.keys()) # 结果为dict_keys(['name', 'age']) for value in dictA.keys(): print(value) pass获得字典的所有键值
dictA = {'name': '李华', 'age': 40} print(dictA.values()) # 结果为dict_values(['李华', 40]) for value in dictA.values(): print(value) pass获得字典的所有键对，结果里面的item为tuple类型
dictA = {'name': '李华', 'age': 40} print(dictA.items()) # 结果为dict_items([('name', '李华'), ('age', 40)]) for (key, value) in dictA.items(): # key为键，value为键值 print('{}为{}'.format(key, value)) pass若更新的内容在字典内有则更改，若没有则添加
dictA = {'name': '李华', 'age': 40} dictA.update({'name': '李明'}) # 修改 dictA.update({'class': 1}) # 添加 print(dictA)删除操作，pop() 方法删除字典给定键 key及对应的值，返回值为被删除的值，若没有找值到则返回 default 值，字典没有remove方法
pop(key[,default])
dictA = {'name': '李华', 'age': 40} del dictA['name'] # 删除 dictA.pop('age') print(dictA) dictA.clear() # 清空字典 print(dictA) # {}函数返回指定键的值
dict.get(key, default=None)
key – 字典中要查找的键。default – 如果指定键的值不存在时，返回该默认值。 dictA = {'name': '李华', 'age': 40} print(dictA.get('gender', 'male')) # male print(dictA.get('age', 0)) # 40 print(dictA) # {'name': '李华', 'age': 40}set（集合）也是python里面的一种数据类型，是一无序且不重复的元素集合，它不支持索引与切片
add() – 添加值，不能为重复的值 clear() – 清空set difference() – 取差集， -也可以；而 difference_update() 为取差集并赋值 intersection() – 取交集，&也可以；而 intersection_update() 为取交集并赋值 union() – 取并集，|也可以 symmetric_difference() – 取对称差集，^也可以；而 symmetric_difference_update() 为取对称差集并赋值 pop() – 从集合中随机移除某个元素并获取那个参数，集合pop没有参数，建议使用discard() discard() – 移除指定元素 remove() – 集合中删除指定的元素。此方法与 discard() 不同，因为如果指定项目不存在，remove() 会引发错误，而 discard() 不会。 update() – 更新集合，用于把两个集合合并，并去重
set1 = {1, '2'} # 集合的创建 set2 = {} # 这样不能创建集合 set3 = set() # 集合的创建 list1 = [1, 2, 3] set4 = set(list1) # 使用set方法创建集合 print(type(set1)) # <class 'set'> print(type(set2)) # <class 'set'> print(type(set3)) # <class 'set'> print(type(set4)) # <class 'set'> set1.add((5, 6)) # 添加一个值 print(set1) # {1, (5, 6), '2'} set1.update((5, 6)) # 把元组拆开再添加值 print(set1) # {1, 5, 6, (5, 6), '2'} print(set1.difference(set4)) # 差集，{'2', (5, 6), 5, 6} print(set1.union(set4)) # 并集，{1, 2, 3, 5, 6, (5, 6), '2'} print(set1.intersection(set4)) # 交集，{1} print(set1.symmetric_difference(set4)) # {2, 3, 5, 6, (5, 6), '2'} set1.pop() # 随机删除一个值 print(set1) # {5, 6, (5, 6), '2'} set1.discard('2') # 在集合里面删除对应值 print(set1) # {5, 6, (5, 6)} set1.remove(5) # 在集合里面移除值为5的值 print(set1) # {5, 6, (5, 6)} set1.remove(7) # 在集合里面移除值为7的值 # print(set1) # 因为值不存在，所以报错 set4.clear() # 删除集合里面所有值 print(set4) # set()对所有可迭代的对象进行排序操作。
sorted(iterable, cmp=None, key=None, reverse=False)
iterable – 可迭代对象。cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。注意：Python list内置sort()方法用来排序，也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列。list 的 sort 方法是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
dictA = {'name': '李华', 'age': 40} print(sorted(dictA.items(), key=lambda d: d[0])) # 排序适用于字符串，列表，元组
strA = '123' strB = '456' listA = list(range(10)) listB = list(range(11, 21)) tupleA = (1,) tupleB = (2, 3, 4) dictA = {'name': '李明'} dictB = {'age': 30} print(strA + strB) # 123456 print(listA + listB) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] print(tupleA + tupleB) # (1, 2, 3, 4) print(dictA + dictB) # 报错，字典不可使用+适用于字符串，列表，元组
strA = '123' listA = list(range(10)) tupleA = (1,) dictA = {'name': '李明'} print(strA * 3) # 123123123 print(listA * 3) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print(tupleA * 3) # (1, 1, 1) print(dictA * 3) # 报错，字典不可使用*适用于字符串，列表，元组，字典；而not in则于它相反
strA = '123' listA = list(range(10)) tupleA = (1,) dictA = {'name': '李明'} print('1' in strA) # True print('0' in strA) # False print(1 in listA) # True print(-1 in listA) # False print(1 in tupleA) # True print(0 in dictA) # False print('name' in dictA) # True print('age' in dictA) # False用于查找在内存的物理地址
str1 = 'hello' str2 = str1 print(id(str1)) # 1970902101296 print(id(str2)) # 1970902101296可变类型为对象引用指向的值为可变的，这就意味着当对象重新赋值时对象的引用不会改变，可变的类型有列表、字典
import ctypes # 该库用于查找内存地址对应的值 value = [1, 2] # 定义一个列表 value1_loc = id(value) # 获得当前列表的内存地址 print(value1_loc) # 输出地址，2075718505536 value[0] = 3 # 列表里面的值重新赋值 value2_loc = id(value) # 获得当前列表的内存地址 print(value2_loc) # 输出地址，2075718505536 get_value = ctypes.cast(value1_loc, ctypes.py_object).value # 读取对应地址的值 print(get_value) # 输出对应地址的值，[3, 2]不可变类型为对象引用指向的值为不可变的，这就意味着当对象重新赋值时对象的引用也改变了值，而原来的值还在内存池里面，不可变的类型有int、str、float、元组，下面就可以说明这个问题
import ctypes # 该库用于查找内存地址对应的值 value = 'hello world' # 定义一个字符串变量 value1_loc = id(value) # 获得当前变量的内存地址 print(value1_loc) # 输出地址，1475453744688 value = '你好' # 字符串变量重新赋值 value2_loc = id(value) # 获得当前变量的内存地址 print(value2_loc) # 输出地址，1475458315248 get_value = ctypes.cast(value1_loc, ctypes.py_object).value # 读取对应地址的值 print(get_value) # 输出对应地址的值，hello world本文只用于个人学习与记录
