目录
1， 序列类型
python中的序列类型的数据类型有， 字符串，列表，元组
序列中的元素是有序排列的，可通过下标和切片形式进行元素访问
2， 字符串
字符串是通过单引号，双引号，三引号括起来的一串字符
字符串是不可变的
三引号括起来的字符串中可以保留特殊字符，如换行符，制表符等
2-1， 字符串操作
2-1-1， 创建
通过赋值进行创建
In [331]: my_str = 'hello python'2-1-2， 查询
2-1-2-1， 整个字符串查询
通过输入变量名，返回整个字符串
# 输入变量，返回整个字符串
In [332]: my_str
Out[332]: 'hello python'2-1-2-2， 单个字符查询
通过"变量名[下标]"， 访问字符串的单个字符
# 下标是从0开始， len(my_str)-1结束
# 当下标为-1时，返回最后一个字符
In [333]: my_str[0]
Out[333]: 'h'
In [334]: my_str[-1]
Out[334]: 'n'
# 通过不存在的索引进行访问，会报错
In [362]: my_str[100]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-362-76547f658746> in <module>
----> 1 my_str[100]
IndexError: string index out of range2-1-2-3， 子串查询
通过"变量名[起始下标：结束下标]"， 切片方式访问字符串子串
起始下标的范围与字符串长度无关
# 不带起始下标，返回整个字符串
In [335]: my_str[:]
Out[335]: 'hello python'
# 设置起始下标，返回start~(end-1)之间的字符
In [336]: my_str[1:4]
Out[336]: 'ell'
# 逆向返回整个字符串
In [337]: my_str[::-1]
Out[337]: 'nohtyp olleh'
# 根据设置的步进返回字符串
In [338]: my_str[::2]
Out[338]: 'hlopto'
# 若开始索引不设置，开始索引为0
In [359]: my_str [:-1]
Out[359]: 'hello pytho'
# 若结束索引没有设置，开始索引为-1
In [358]: my_str[1:]
Out[358]: 'ello python'
# 切片时，开始和结束索引可以超过字符串长度
In [361]: my_str[-100:100]
Out[361]: 'hello python'
# 切片时，起始索引必须小于结束索引，否在返回空串
In [363]: my_str[3:1]
Out[363]: ''
In [364]: my_str[-1:-3]
Out[364]: ''2-1-2-4， 子串判断
通过成员运算符in, not in， 存在返回True， 不存在返回False
# 通过in， not in 判断子串关系，返回bool值
In [365]: 'aa' in my_str
Out[365]: False
In [366]: 'aa' not in my_str
Out[366]: True2-1-3， 修改
字符串是不可变的，不具备修改特性；需要新的字符串时，只能新建
2-1-4， 删除
需要删除变量时，可使用方法del 变量名
# 删除变量my_str
In [340]: del my_str2-2， 字符串比较
通过ASCII码值从头开始逐一进行比较， 返回bool值
# 字符串之间的比较是通过算数运算符进行，如下
In [348]: str1, str2
Out[349]: ('abc', 'lmn')
In [350]: str1 > str2
Out[350]: False
In [351]: str1 >= str2
Out[351]: False
In [352]: str1 < str2
Out[352]: True
In [353]: str1 <= str2
Out[353]: True
In [354]: str1 == str2
Out[354]: False
In [355]: str1 != str2
Out[355]: True2-3， 连接字符串
通过符号"字符串1+字符串2"，可连接字符串， 生成一个新字符串
In [35]: str1, str2
Out[35]: ('abc', 'lmn')
# 注意：连接后两个字符串之间是没有空格
In [36]: str1 + str2
Out[36]: 'abclmn'2-4， 字符串重复
通过"字符串* n"， 表示字符串重复n次
In [374]: str1
Out[374]: 'abc'
In [372]: str1 * 5
Out[372]: 'abcabcabcabcabc'2-5， 格式化操作符
通过%c，可输出数字对应的字符
# 返回对应的字符
In [380]: '%c' % 65
Out[380]: 'A'通过%r，可原样输出字符串
# 返回对应的原字符串，不进行转义
In [382]: '%r' % '\n'
Out[382]: "'\\n'"通过%s，可原样输出字符串
# 返回对应的字符串，特殊字符会转义
In [383]: '%s' % '\n'
Out[383]: '\n'
# 指定格式返回，"10"表示返回数占10位， "-"表示返回数左对齐；多余的补空格
In [395]: '%-10s' % 1
Out[395]: '1 '
# 带%号输出
In [415]: '%s%%' % 50
Out[415]: '50%'通过%d， 输出十进制数
# 指定格式返回，多余的位补0， "10"表示返回数位宽
In [400]: '%010d' % 1
Out[400]: '0000000001'通过%o或%#o， 输出八进制数
# 返回对应的八进制数
In [387]: '%o' % 10
Out[387]: '12'
# 带格式返回对应的八进制数
In [388]: '%#o' % 10
Out[388]: '0o12'
通过%x或%#x， 输出十六进制数
# 返回对应的十六进制数
In [389]: '%x' % 10
Out[389]: 'a'
# 带格式返回对应的十六进制数
In [390]: '%#x' % 10
Out[390]: '0xa'
In [391]: '%#X' % 10
Out[391]: '0XA'通过%f， 以浮点数返回
# 指定位数和小数位进行返回， '%010.2f'表示返回数位宽为10， 保留2位小数，多余补0
In [405]: '%010.2f' % 1.236
Out[405]: '0000001.24'
2-6， 字符串模板
通过from string import Template， 可以使用字符串模块功能
In [416]: from string import Template
# 定义字符串模板， ${howmany}、${lang}是变量
In [417]: s = Template('There are ${howmany} ${lang} question symbols')
# 传入变量lang，howmany即可打印预制的字符串
In [418]: print(s.substitute(lang='Python', howmany=3))
There are 3 Python question symbols
# 注意：当实参的数量与指定的字符串模板中形参数量不一致时，该方法会报错
# 相比于substitute方法，更放松，即使变量与模块个数不一致，也不报错
In [420]: print(s.safe_substitute(lang='aa', howmany=4))
There are 4 aa question symbols
# 对于少了形参，直接与变量的形式打印
In [421]: print(s.safe_substitute(lang='aa'))
There are ${howmany} aa question symbols2-7， 原始字符串
在字符串前面加上r或者R，该字符串表示原始字符串， 其中的特殊字符不转义
# 返回的是'\n'字符，而不是换行符
In [423]: r'\n'
Out[423]: '\\n'2-8， 字符串内建函数
通过len(字符串)， 返回字符串的长度
In [439]: my_str
Out[439]: 'hello python'
In [429]: len(my_str)
Out[429]: 12通过max(字符串)， 返回字符串中ASCII码最大的字符
In [430]: max(my_str)
Out[430]: 'y'通过min(字符串)， 返回字符串中ASCII码最小的字符
In [441]: min(my_str)
Out[441]: ' '通过enumerate(字符串)， 返回一个enumerate对象(可迭代)，通过for循环，可迭代输出字符与其对应的索引
In [443]: enumerate(my_str)
Out[443]: <enumerate at 0x26a2eeafb00>
In [444]: for k, v in enumerate(my_str):
...: print(k, v)
...:
0 h
1 e
2 l
3 l
4 o
5
6 p
7 y
8 t
9 h
10 o
11 n通过zip(str1, str1)， 可压缩str1， str2为一个zip对象(可迭代)，zip的每个元素由str1，str2相同的索引元素组成，通过for循环迭代输出
In [451]: str1, str2
Out[451]: ('abc', 'lmn1')
#返回zip对象，
In [453]: zip(str1, str2)
Out[453]: <zip at 0x26a2e7c71c0>
# 只输出了3个元素，因为zip后，以短的列表长度为准
In [454]: for i in zip(str1, str2):
...: print(i)
...:
('a', 'l')
('b', 'm')
('c', 'n')通过chr(num)， 接收一个整数转换成对应的字符
In [435]: chr(10000)
Out[435]: '✐'通过ord(char)， 接收单个字符，转换为对应的整数
In [458]: ord('a')
Out[458]: 97通过my_str.capitalize()， 字符串首字母大写
In [2]: my_str.capitalize()
Out[2]: 'Hello python'通过my_str.lower()， 字符串的所有字母转换为小写
In [8]: my_str = 'AAFDfdafADF'
In [9]: my_str.lower()
Out[9]: 'aafdfdafadf'通过my_str.upper()， 字符串的所有字母转换为大写
In [11]: my_str = 'aaAAfads'
In [12]: my_str.upper()
Out[12]: 'AAAAFADS'通过my_str.swapcase()， 翻转字符串的大小写
In [13]: my_str = 'AbCd'
In [14]: my_str.swapcase()
Out[14]: 'aBcD'通过my_str.title()， 标题化字符串，即单词的首字母大写
In [16]: my_str.title()
Out[16]: 'Hello Python'通过my_str.center(width，char)， 指定宽度width，居中显示字符串, char为填充字符
# 不指定填充字符，多余为补空格
In [19]: my_str.center(20)
Out[19]: ' hello python '
# 指定字符：'1'进行补齐
In [24]: my_str.center(20, '1')
Out[24]: '1111hello python1111'
通过my_str.rjust(width， char)， 指定宽度width，右对齐显示字符串， char为填充字符
# 不指定填充字符，多余的位补空格
In [26]: my_str.rjust(20)
Out[26]: ' hello python'
# 指定填充为'a'进行补齐
In [27]: my_str.rjust(20, 'a')
Out[27]: 'aaaaaaaahello python'通过my_str.ljust(width， char)， 指定宽度width，左对齐显示字符串， char为填充字符
# 指定填充符：‘1’进行补齐
In [28]: my_str.ljust(20, '1')
Out[28]: 'hello python11111111'
# 不指定填充符，多余的补空格
In [29]: my_str.rjust(20)
Out[29]: ' hello python'
通过my_str.zfill(width)， 指定宽度width，右对齐显示字符串，多余的位补‘0’
In [30]: my_str.zfill(20)
Out[30]: '00000000hello python'
通过my_str.count(sub_str, beg, end)， 在指定的范围内(beg~end-1)，查找子串出现的次数；若beg, end没有设置，则在整个字符串中查找
# 查找整个字符串
In [40]: my_str.count('l')
Out[40]: 2
# 在给定的范围查询，beg，end与字符串的长度不相关
In [41]: my_str.count('l', -100, 100)
Out[41]: 2
In [42]: my_str.count('l', 0, 3)
Out[42]: 1
通过my_str.find(sub_str, beg, end)， 在指定的范围内(beg~end-1)，从左开始查找子串第一次出现的索引位置（子串首字母）；若没有给定beg, end， 则查找整个字符串；没有找到子串返回-1；beg，end与字符串的长度不相关
# 找到子串，返回子串首字母索引位置
In [60]: my_str.find('python')
Out[60]: 6
# 没有找到返回-1
In [65]: my_str.find('python1')
Out[65]: -1通过my_str.rfind(sub_str, beg, end)， 在指定的范围内(beg~end-1)，从右开始查找子串第一次出现的索引位置（子串首字母）；若没有给定beg, end， 则查找整个字符串；没有找到子串返回-1；beg, end与字符串的长度无关
In [62]: my_str
Out[62]: 'hello python'
In [63]: my_str.rfind('python')
Out[63]: 6
# 没有找到返回-1
In [66]: my_str.rfind('pytho1n')
Out[66]: -1通过my_str.index(sub_str, beg, end)， 在指定的范围内(beg~end-1)，从左开始查找子串第一次出现的索引位置（子串首字母）；若没有给定beg, end， 则查找整个字符串；没有找到子串则报错；beg, end与字符串的长度无关
In [71]: my_str.index('py')
Out[72]: 6
# 没有找到则报错
In [72]: my_str.index('1python')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-72-83dbc59d407e> in <module>
----> 1 my_str.index('1python')
ValueError: substring not found通过my_str.rindex(sub_str, beg end)， 在指定的范围内(beg~end-1)，从右开始查找子串第一次出现的索引位置（子串首字母）；若没有给定beg, end， 则查找整个字符串；没有找到子串则报错；beg, end与字符串的长度无关
In [73]: my_str.rindex('python')
Out[73]: 6
# 没有找到则报错
In [74]: my_str.rindex('pytho1n')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-74-3b354f3e3812> in <module>
----> 1 my_str.rindex('pytho1n')
ValueError: substring not found通过my_str.strip(chars)， chars为匹配字符， 按chars删除字符串两端匹配的字符；若没有指定，则删除空格
# 入参'no'当着两个字符使用，先匹配到n，在匹配到o，所以删除了no部分
# 若字符串的最后一位与指定的字符都不匹配，则不删除
In [77]: my_str.strip('no')
Out[77]: 'hello pyth'
# 因为匹配到了h，所以删去了h
In [79]: my_str.strip('th')
Out[79]: 'ello python'
通过my_str.rstrip(chars)， chars为匹配字符， 按chars删除字符串右端匹配的字符；若没有指定，则删除空格
# 只删除了右边匹配的，左边没有动
In [81]: 'abceeeecba'.rstrip('bac')
Out[81]: 'abceeee'通过my_str.lstrip(chars)， chars为匹配字符， 按chars删除字符串左端匹配的字符；若没有指定，则删除空格
# 只删除了左边匹配的，右边没有动
In [82]: 'abceeeecba'.lstrip('bac')
Out[82]: 'eeeecba'通过my_str.partition(sep)， 指定分隔符sep(从左开始首次出现)分割字符串，返回一个元组
In [83]: my_str
Out[83]: 'hello python'
# 从左边出现的第一个"l"进行分割
In [84]: my_str.partition('l')
Out[84]: ('he', 'l', 'lo python')通过my_str.rpartition(sep)：指定分隔符sep(从右开始首次出现)分割字符串，返回一个元组
In [83]: my_str
Out[83]: 'hello python'
# 从右边第一个开始出现的"l"进行分割
In [85]: my_str.rpartition('l')
Out[85]: ('hel', 'l', 'o python')通过my_str.split(str=sep, num)， 指定分割符sep(从右开始首次出现)分割字符串，返回一个列表， num指的是分割次数， 若没有指定num，则会一直分割到元素中，不包含分割符；若指定num，则分割num次
In [95]: my_str
Out[95]: 'hello python'
# 以分割符'l'进行分割，第一次分割完为：['he', 'lo python']
# 返回的元素中还存在‘l’，再次分割元素：'lo python'， 分割的结果为['', 'o python']
# 所以最终的结果为：['he', '', 'o python']
In [96]: my_str.split('l')
Out[96]: ['he', '', 'o python']
In [99]: my_str
Out[99]: 'hello python'
# 以‘l’， 分割1次
In [100]: my_str.split('l', 1)
Out[100]: ['he', 'lo python']通过my_str.splitlines()， 可按行进行分割， 返回一个列表
In [130]: my_str1
Out[130]: 'line1\nline2\nline3\nline4'
In [131]: my_str1.splitlines()
Out[131]: ['line1', 'line2', 'line3', 'line4']通过my_str.endswith(sub_str, beg, end)， 判断字符串是否以sub_str结束；是返回True，否返回False， 若指定beg和end则在指定范围内查找；beg, end与字符串的长度没有关系
In [1]: my_str = 'hello python'
In [2]: my_str.startswith('hello')
Out[2]: True通过my_str.startswith(sub_str, beg, end)， 判断字符串是否以sub_str开始；是返回True，否返回False， 若指定beg和end则在指定范围内查找，beg, end与字符串的长度没有关系
[3]: my_str = 'hello python'
In [4]: my_str.endswith('on')
Out[4]: True通过my_str.sialnum()， 判断字符串是否仅有字母、数字组成；是返回True，否返回False
# 因为my_str中包含空格，所以返回False
In [14]: my_str.isalnum()
Out[14]: False通过my_str.isalpha()， 判断字符串是否仅有字母组成；是返回True，否返回False
# 'adfas'仅有字母组成，所以返回True
In [15]: 'adfas'.isalpha()
Out[15]: True
# '1fda'含有数字1，所以返回False
In [24]: '1fda'.isalpha()
Out[24]: False通过my_str.idsecimal()， 判断字符串是否仅有十进制数组成；是返回True，否返回False
In [21]: hex(100).isdecimal()
Out[21]: False
In [23]: '123'.isdecimal()
Out[23]: True通过my_str.isdight()， 判断字符串是否仅有数字组成；是返回True，否返回False
In [26]: '12af'.isdigit()
Out[26]: False
In [27]: '124'.isdigit()
Out[27]: True通过my_str.isnumeric()， 判断字符串是否仅有数字组成；是返回True，否返回False
In [28]: my_str.isnumeric()
Out[28]: False
In [29]: '1234'.isnumeric()
Out[29]: True通过my_str.islower()， 判断字符串是否全是小写；是返回True，否返回False
In [35]: my_str.islower()
Out[35]: True通过my_str.isupper()， 判断字符串是否全是大写；是返回True，否返回False
In [34]: my_str
Out[34]: 'hello python'
In [36]: my_str.isupper()
Out[36]: False通过my_str.isspace()， 判断字符串是否全是空格组成；是返回True，否返回False
In [37]: my_str.isspace()
Out[37]: False通过my_str.istitle()， 判断字符串是否标题化（单词首字母大写，其他小写）；是返回True，否返回False
In [38]: my_str
Out[38]: 'hello python'
In [39]: my_str.istitle()
Out[39]: False通过分割符.join(my_str)， 以分割符连接字符串中所有的字符
In [43]: '-'.join(my_str)
Out[43]: 'h-e-l-l-o- -p-y-t-h-o-n'通过my_str.replace(str1, str2, num)， 将字符串中的str1, 替换成str2；num为替换次数
# 没有指定替换次数， 替换所有
In [46]: 'aaaaa'.replace('a', 'b')
Out[46]: 'bbbbb'
# 数字2， 表示指定替换两次
In [47]: 'aaaaa'.replace('a', 'b', 2)
Out[47]: 'bbaaa'通过my_str.expandtabs(tabsize)， 将字符串中的制表符，替换为空格；tabsize为替换成空格的数量
# 不指定tabsize，\t默认为8个空格
In [50]: 'aaa\tbbb\tccc'.expandtabs()
Out[50]: 'aaa bbb ccc'
# 指定tabsize=1, 则\t被替换为1个空格
In [51]: 'aaa\tbbb\tccc'.expandtabs(1)
Out[51]: 'aaa bbb ccc'通过my_str1.decode(编码格式)， 可指定编码格式解码字符串
# 以utf-8格式解码字符串
In [60]: my_str1.decode('utf-8')
Out[60]: 'hello python'通过my_str.encode('utf-8')， 可指定编码格式编码字符串
# 以utf-8格式编码字符串
In [57]: my_str.encode('utf-8')
Out[57]: b'hello python'3， 列表
列表是通过[]括原来的一组元素， 列表是可变的， 元素可以是任何数据类型，无长度限制
3-1， 列表操作
3-1-1， 创建
通过列表操作符[]方式创建
# 通过列表符号创建
In [68]: my_list1 = [123, 'abc', 4.56, ['inner', 'list'], 7-9j]
# 通过列表符号，创建一个空列表
In [69]: my_list2 = []通过工厂方法list(seq)创建
# 通过工厂方法创建， 字符串中的每个字符，都变成列表一个元素
In [74]: my_list3 = list('abcd')
# 通过工厂方法创建一个空列表
In [75]: my_list4 = list()3-1-2, 查询
3-1-2-1， 整个列表查询
通过输入变量名， 返回整个列表
# 输入变量，返回整个列表
In [81]: my_list
Out[81]: [123, 'abc', 4.56, ['inner', 'list'], (7-9j)]3-1-2-2， 单个元素查询
通过变量名[下标]可访问列表的单个元素， 下标是从0开始， 到列表长度-1结束
# 下标为"0", 返回列表的第一个元素
In [82]: my_list[0]
Out[82]: 123
# 下标为"-1", 返回列表的最后一个元素
In [83]: my_list[-1]
Out[83]: (7-9j)
# 通过不存在的索引进行访问，会报错
In [88]: my_list[100]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-88-452c52ef7c16> in <module>
----> 1 my_list[100]
IndexError: list index out of range3-1-2-3， 多个元素查询
通过变量名[下标1：下标2：步进]， 切片方式可以访问列表多个元素
# 不带起始下标， 返回整个列表
In [86]: my_list[:]
Out[86]: [123, 'abc', 4.56, ['inner', 'list'], (7-9j)]
# 设置起始下标， 返回start~(end-1)之间的元素， 这里返回第3~4个元素
In [89]: my_list[2:4]
Out[89]: [4.56, ['inner', 'list']]
# 只设置起始索引， 返回[起始索引对应的元素~列表最后一个元素]
In [84]: my_list[1:]
Out[84]: ['abc', 4.56, ['inner', 'list'], (7-9j)]
# 只设置结束索引， 返回[列表第0个元素~(结束索引-1)对应的元素]
In [85]: my_list[:-1]
Out[85]: [123, 'abc', 4.56, ['inner', 'list']]
# 设置步进n， 表示间隔n-1个元素进行获取
# 这里的步进为2， 表示间隔一个元素获取
In [87]: my_list[::2]
Out[87]: [123, 4.56, (7-9j)]
# 变量[::-1]表示逆向返回整个列表
In [90]: my_list[::-1]
Out[90]: [(7-9j), ['inner', 'list'], 4.56, 'abc', 123]
# 切片时，起始索引与列表的长度无关
In [91]: my_list[-100:100]
Out[91]: [123, 'abc', 4.56, ['inner', 'list'], (7-9j)]
# 切片时，起始索引必须小于结束索引，否则返回空列表
In [92]: my_list[3:1]
Out[92]: []
In [93]: my_list[-1:-3]
Out[93]: []3-1-2-4， 元素归属判断
通过in， not in判断元素是否存在列表中
# 通过in， not in 判断元素是否存在列表中，存在返回True；不存在返回False
In [94]: my_list
Out[94]: [123, 'abc', 4.56, ['inner', 'list'], (7-9j)]
In [95]: 'aa' in my_list
Out[95]: False
In [96]: 'aa' not in my_list
Out[96]: True3-1-3， 修改
因为列表是可变对象， 所有的修改结果映射到原来的列表
3-1-3-1， 单元素修改
通过变量名[下标]=xxx， 可修改列表某个元素的值
# 修改my_list列表，第三个元素的值为'hahaha'
In [100]: my_list[2] = 'hahaha'3-1-3-2， 多元素修改
通过变量名[下标1：下标2]=列表x， 可修改列表多个元素值， 变量名[下标1：下标2]和列表x的元素长度需要相等
# 通过切片修改my_list列表第0个~第2个元素
In [104]: my_list[0:3] = [1, 1, 1]
In [105]: my_list
Out[105]: [1, 1, 1, ['inner', 'list'], (7-9j)]
3-1-4， 删除
通过del 变量[下标]， 可删除列表对应的元素
# 从my_list列表中， 删除下标为3的元素
In [106]: del my_list[3]
通过变量.remove(元素值)， 可指定列表的元素，进行删除
In [110]: my_list
Out[110]: [1, 1, 1, (7-9j)]
# 指定my_list中的元素进行删除， 这里的1是列表的元素值，不是下标
# 若存在多个相同的值，删除从左到右遇到的第一个元素
In [111]: my_list.remove(1)
In [112]: my_list
Out[112]: [1, 1, (7-9j)]3-2， 连接列表
通过列表1+列表2， 可连接多个列表， 结果为新列表
In [66]: my_list1, my_list2
Out[66]: (['1', '2', '3', '4'], ['a', 'b', 'c', 'd'])
# 通过"+"连接my_list1、my_list2 ， 结果为新列表
In [69]: my_list1 + my_list2
Out[69]: ['1', '2', '3', '4', 'a', 'b', 'c', 'd']3-3， 重复列表
通过变量 * n， 可重复列表元素n次， 结果为新列表
# my_list1的元素重复3次， 结果为新列表
In [121]: my_list1 * 3
Out[121]: ['1', '2', '3', '4', '1', '2', '3', '4', '1', '2', '3', '4']3-4， 列表比较
流程如下：
从第一项开始逐个比较
若比较项是数字，执行必要的数字类型转换后进行比较
若比较项是字符串，则通过ASCII码进行比较
若比较项相等，则以此比较后面的项
若某项的值比较出大小，则返回比较结果
若有一个列表首先到达末尾，则另一个列表为大
若所有项相等，则列表相等；
In [127]: my_list1 = [1, 2, 3]
In [128]: my_list2 = [2]
In [129]: my_list1 > my_list2
Out[129]: False
In [130]: my_list1 < my_list2
Out[130]: True
In [131]: my_list1 == my_list2
Out[131]: False
In [132]: my_list1 >= my_list2
Out[132]: False
In [133]: my_list1 <= my_list2
Out[133]: True
In [134]: my_list1 != my_list2
Out[134]: True3-5， 列表内建函数
通过len(my_list)， 返回列表长度
# 表示my_list的长度为4
In [138]: len(my_list)
Out[138]: 4通过max(my_list)， 返回列表元素中最大元素
# my_list列表最大元素为3
In [141]: max(my_list)
Out[141]: 3通过min(my_list)， 返回列表元素中最小元素
# my_list最小元素为0
In [143]: min(my_list)
Out[143]: 0通过sorted(my_list)， 升序(字典序)排序my_list， 返回新列表
# sorted(list1)， 升序排序list1， 返回是的新列表
In [82]: sorted(list1)
Out[82]: ['a', 'b', 'd', 'e']
# 注意：sorted是按词典序进行排列的，升序排序
# 词典序：即按照字母的ASCII码进行比较通过reversed(my_list)， 返回一个reversed对象(可迭代)，通过for循环迭代出my_list中的元素（倒转的）
In [85]: list1
Out[85]: ['d', 'a', 'b', 'e']
# 返回的是reversed对象，可迭代
In [86]: reversed(list1)
Out[86]: <list_reverseiterator at 0x1a890780490>
# 反向输出列表的每个元素
In [87]: for i in reversed(list1):
...: print(i)
...:
e
b
a
d通过enumerate(my_list)， 返回一个enumerate对象(可迭代)，通过for循环迭代出(元素, 元素索引)
# enumerate(my_list)， 返回一个enumerate对象
In [156]: enumerate(my_list)
Out[156]: <enumerate at 0x232911eec80>
# 迭代enumerate对象是，逐个输出(key, value)
In [157]: for k, v in enumerate(my_list):
...: print(k, v)
...:
0 They
1 stamp
2 them
3 when
4 they're
5 small通过zip(my_list1, my_list2)， 接收多个列表，返回一个zip对象(可迭代)， 通过for循环迭代出每个元素， 元素为列表对应索引的元素组成， 如(my_list1[0], my_list2[0])
In [161]: my_list1 = list('abcd')
In [162]: my_list2 = list('efghi')
# 通过zip(my_list1, my_list2)，返回的是一个zip对象
In [164]: zip(my_list1, my_list2)
Out[164]: <zip at 0x2329110e9c0>
# 通过for迭代输出的值为， 由各个列表对应索引的元素组成， 如(my_list1[0], my_list2[0])
# 元素的个数以短的列表长度一致
In [163]: for i in zip(my_list1, my_list2):
...: print(i)
...:
('a', 'e')
('b', 'f')
('c', 'g')
('d', 'h')通过sum(my_list)， 计算列表的元素和（序列表的元素均为数字）
In [166]: my_list
Out[166]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 计算my_list元素的和
In [167]: sum(my_list)
Out[167]: 45通过my_list.append(obj)， 向列表中添加元素obj， 结果映射到原列表，无返回值
# 向列表my_list添加元素'f'
In [169]: my_list.append('f')
In [170]: my_list
Out[170]: ['a', 'b', 'c', 'd', 'f']通过my_list.count(obj)， 计算列表中的元素"obj"出现的次数
# 元素'a'在列表my_list中出现次数为1
In [171]: my_list.count('a')
Out[171]: 1通过my_list.extend(seq)， 添加序列seq所有元素到my_list(末尾处添加)， 结果映射到原列表，无返回值
In [179]: my_list = list('abc')
# 添加元素'1', '2', '3'到my_list中
In [180]: my_list.extend('123')
In [181]: my_list
Out[181]: ['a', 'b', 'c', '1', '2', '3']
# 添加元素'a', 'b'到my_list中
In [182]: my_list.extend(['a', 'b'])
In [183]: my_list
Out[183]: ['a', 'b', 'c', '1', '2', '3', 'a', 'b']
# 添加元素'1', '2'到my_list中
In [184]: my_list.extend(('1', '2'))
In [185]: my_list
Out[185]: ['a', 'b', 'c', '1', '2', '3', 'a', 'b', '1', '2']通过my_list.index(obj)， 返回元素obj在列表中的第一次出现的索引
In [187]: my_list
Out[187]: ['a', 'b', 'c', '1', '2', '3', 'a', 'b', '1', '2']
# 返回my_list列表中，第一次出现元素'b'的索引
In [188]: my_list.index('b')
Out[188]: 1
# 当obj不存在时，会报错
In [189]: my_list.index('b1')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-189-8433b4efb173> in <module>
----> 1 my_list.index('b1')
ValueError: 'b1' is not in list通过my_list.insert(index, obj)， 在列表索引为index的位置，插入元素obj， 结果映射到原列表，无返回值
# 在列表my_list的第一索引位置插入元素'fdsafsad'
In [192]: my_list.insert(1, 'fdsafsad')
In [194]: my_list
Out[194]: ['a', 'fdsafsad', 'b', 'c', '1', '2', '3', 'a', 'b', '1', '2']通过my_list.pop(index)， 指定index删除列表中对应元素， 返回删除的元素， 结果映射到原列表
# 不指定index，默认删除列表最后一个元素， 即删除my_list的最后一个元素
In [196]: my_list.pop()
Out[196]: '2'
# 指定index进行删除， 即删除my_list[1]元素
In [198]: my_list.pop(1)
Out[198]: 'fdsafsad'
# 指定的索引不存在时，会报错
In [201]: my_list.pop(1000)
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-201-1052659ca131> in <module>
----> 1 my_list.pop(1000)
IndexError: pop index out of range通过my_list.reverse()， 翻转列表， 结果映射到原列表，无返回值
In [205]: my_list
Out[205]: ['b', 'c', '1', '2', '3', 'a', 'b', '1']
# 翻转列表my_list
In [207]: my_list.reverse()
In [208]: my_list
Out[208]: ['1', 'b', 'a', '3', '2', '1', 'c', 'b']
通过my_list.sort()， 升序排序列表， 结果映射到原列表，无返回值
In [210]: my_list
Out[210]: ['b', 'c', '1', '2', '3', 'a', 'b', '1']
# 升序列表my_list
In [211]: my_list.sort()
In [212]: my_list
Out[212]: ['1', '1', '2', '3', 'a', 'b', 'b', 'c']4， 元组
列表是通过()括原来的一组元素， 元组是不可变的， 元素可以是任何数据类型，无长度限制
4-1， 元组操作
4-1-1， 创建
通过操作符()创建
# 通过()进行创建
In [217]: my_tuple1 = (123, 'abc', 4.56, ['inner', 'tuple'], 7-9j)
# 入参为空，则创建一个空元组
In [218]: my_tuple2 = ()
# 单元素元组，需要在元素后加"逗号"
In [219]: my_tuple3 = (1,)
通过工厂方法tuple(seq)创建
# 通过工厂方法tuple()创建
In [223]: my_tuple1 = tuple('abcd')
In [224]: my_tuple2 = tuple()
# 单元素不用加"逗号"
In [225]: my_tuple3 = tuple('1')4-1-2， 查询
4-1-2-1， 整个元组查询
通过变量名称， 可查询整个元组
# 输入变量，返回整个列表
In [233]: my_tuple1
Out[233]: (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))4-1-2-2， 单个元素查询
通过变量[下标]， 可查询元组中单个元素， 下标是从0开始， len(变量)-1结束
# 下标为0，返回my_tuple1第一个元素
In [230]: my_tuple1[0]
Out[230]: 123
# 下标为-1，返回my_tuple1最后一个元素
In [231]: my_tuple1[-1]
Out[231]: (7-9j)
# 通过不存在的索引进行访问，会报错
In [234]: my_tuple1[-10]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-234-2d49f3b52a74> in <module>
----> 1 my_tuple1[-10]
IndexError: tuple index out of range4-1-2-3， 多个元素查询
通过变量[下标1：下标2：步进]， 可查询元组中多个元素
# 不带起始下标， 返回整个元组
In [237]: my_tuple1[:]
Out[237]: (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))
# 设置起始下标，返回start~(end-1)之间的元素
In [238]: my_tuple1[1:4]
Out[238]: ('abc', 4.56, ['inner', 'tuple'])
# 只设置起始索引， 返回【起始索引对应的元素~元组最后一个元素】
In [240]: my_tuple1[1:]
Out[240]: ('abc', 4.56, ['inner', 'tuple'], (7-9j))
# 只设置结束索引， 返回【元组第0个元素~(结束索引-1)对应的元素】
In [241]: my_tuple1[:-1]
Out[241]: (123, 'abc', 4.56, ['inner', 'tuple'])
# 设置步进n， 表示间隔n-1个元素进行获取
# 这里的步进为2， 表示间隔一个元素获取
In [242]: my_tuple1[::2]
Out[242]: (123, 4.56, (7-9j))
# my_tuple1[::-1]表示逆向返回整个元组
In [243]: my_tuple1[::-1]
Out[243]: ((7-9j), ['inner', 'tuple'], 4.56, 'abc', 123)
# 切片时，开始和结束索引与元组的长度无关
In [245]: my_tuple1[-100:100]
Out[245]: (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))
# 切片时，起始索引必须小于结束索引，否在返回空元组
In [246]: my_tuple1[3:1]
Out[246]: ()
In [247]: my_tuple1[-1:-3]
Out[247]: ()4-1-2-4， 元素归属判断
通过in， not in判断元素是否存在元组中
# 通过in， not in 判断元素是否存在元组中，存在返回True；不存在返回False
In [248]: my_tuple1
Out[248]: (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))
In [249]: '123' in my_tuple1
Out[249]: False
In [250]: '123' not in my_tuple1
Out[250]: True4-1-3， 修改
因为元组的不可变特性，不能对元组进行修改；若需要新元组，只能新建
4-1-4， 删除
因为元组的不可变特性，不能删除元组中的元素；可通过del my_tuple，删除整个元组
# 删除元组my_tuple1
In [254]: del my_tuple14-2， 连接元组
通过元组1 + 元组2， 可以连接多个元组，返回一个新的元组
# 通过"+"连接my_tuple1和my_tuple1
In [257]: my_tuple1 + my_tuple1
Out[257]: (['xyz', 123], 23, -103.4, ['xyz', 123], 23, -103.4)4-3， 重复元组
通过元组 * n， 可重复n次元组的元素，返回一个新的元组
# my_tuple1的元素重复出现3次
In [260]: my_tuple1 * 3
Out[260]: (['xyz', 123], 23, -103.4, ['xyz', 123], 23, -103.4, ['xyz', 123], 23, -103.4)4-4， 元组内建函数
通过max(my_tuple)， 返回元组最大值元素， 元素需要是同一种类型
# 返回my_tuple的最大元素4
In [268]: max(my_tuple)
Out[268]: 4
通过min(my_tuple)， 返回元组最小值元素， 元素需要是同一种类型
# 返回my_tuple的最小元素0
In [269]: min(my_tuple)
Out[269]: 0通过my_tuple.count(obj)， 计算元组中的元素"obj"出现的次数
In [3]: my_tuple1= tuple('aabbccdd')
# 计算my_tuple1元组中， 元素'b'出现的次数
In [6]: my_tuple1.count('b')
Out[6]: 2通过my_tuple.index(obj)， 计算元组中的元素"obj"的索引
# 返回元组my_tuple1中， 元素'b'第一次出现的索引号
In [7]: my_tuple1.index('b')
Out[7]: 2
In [8]:4-5， 元组比较大小
步骤如下：
同列表的比较步骤
In [295]: my_tuple1
Out[295]: ('1', '2', '3')
In [296]: my_tuple2
Out[296]: ('a', 'b', 'c')
In [297]: my_tuple1 > my_tuple2
Out[297]: False
In [298]: my_tuple1 >= my_tuple2
Out[298]: False
In [299]: my_tuple1 < my_tuple2
Out[299]: True
In [300]: my_tuple1 <= my_tuple2
Out[300]: True
In [301]: my_tuple1 == my_tuple2
Out[301]: False
In [302]: my_tuple1 != my_tuple2
Out[302]: True
831
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
