目录
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 range
2-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]: True
2-1-3, 修改
字符串是不可变的,不具备修改特性;需要新的字符串时,只能新建
2-1-4, 删除
需要删除变量时,可使用方法del 变量名
# 删除变量my_str
In [340]: del my_str
2-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]: True
2-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 symbols
2-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 range
3-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]: True
3-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]: True
3-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 range
4-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]: True
4-1-3, 修改
因为元组的不可变特性,不能对元组进行修改;若需要新元组,只能新建
4-1-4, 删除
因为元组的不可变特性,不能删除元组中的元素;可通过del my_tuple,删除整个元组
# 删除元组my_tuple1
In [254]: del my_tuple1
4-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