Python --序列：字符串，列表，元组

目录

1， Python中有哪些数据类型是序列

2， 字符串

2-1， 字符串的创建、查询、修改、删除

创建

查询

修改

删除

2-2， 字符串间的比较

2-3， 连接字符串

2-4， 字符串重复

2-5， 格式化操作符

2-6， 字符串模板

2-7， 原始字符串

2-8， 字符串的内建函数

3， 列表

3-1， 列表的创建，查询，修改、删除

创建

查询

修改

删除

3-2， 连接列表

3-3， 重复列表

3-4， 列表比较大小

3-5， 列表内建函数

4， 元组

4-1， 元组的创建，查询，修改，删除

创建

查询

修改

删除

4-2， 连接元组

4-3， 重复元组

4-4， 内建函数

4-5， 元组比较大小

---

1， Python中有哪些数据类型是序列

有三种：字符串，列表，元组；

序列的数据类型是有序排列的，可以通过下标和切片的形式进行其元素访问；

2， 字符串

字符串是python的一种数据类型，通过单引号，双引号，三引号括起来的一串字符；

字符串是不可变的

三引号括起来的字符串中可以保留特殊字符，如换行符，制表符等；

2-1， 字符串的创建、查询、修改、删除

创建

通过赋值的方式进行创建

In [331]: my_str = 'hello python'

In [332]: my_str
Out[332]: 'hello python'

查询

可通过下标访问字符串的单个字符；

通过切片的方式访问其子串

子串判断，通过成员运算符：in, not in， 存在返回True；不存在返回False

通过迭代方式，逐个访问字符

# 输入变量，返回整个字符串
In [332]: my_str
Out[332]: 'hello python'

# 通过下标，返回下标对应的单个字符
# 下标是从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)
 in 
----> 1 my_str[100]

IndexError: string index out of range

# 通过切片形式访问
# 不带起始下标，返回整个字符串
# 设置起始下标，返回start~(end-1)之间的字符
In [335]: my_str[:]
Out[335]: 'hello python'

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 [358]: my_str[1:]
Out[358]: 'ello python'

# 若结束索引没有设置，开始索引为-1
In [359]: my_str [:-1]
Out[359]: 'hello pytho'

# 切片时，开始和结束索引可以超过字符串长度
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]: ''

# 通过in， not in 判断子串关系，返回bool值
In [365]: 'aa' in my_str
Out[365]: False

In [366]: 'aa' not in my_str
Out[366]: True

# 通过迭代方式，逐个访问字符
In [367]: for char in my_str:
     ...:     print(char)
     ...:
h
e
l
l
o

p
y
t
h
o
n

修改

字符串是不可变的，不具备修改特性；需要新的字符串时，只能新建

删除

字符串是不可变的，不具备删除特性；需要删除变量时，可使用方法：del my_str

In [339]: my_str
Out[339]: 'hello python'

In [340]: del my_str

In [341]: my_str
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
 in 
----> 1 my_str

NameError: name 'my_str' is not defined

2-2， 字符串间的比较

字符串间的比较是通过ASCII码值进行比较的， 从头开始逐一进行比较

通过关系运算符：>, >=，< , <=, ==, != 来进行比较， 返回bool值

In [348]: str1
Out[348]: 'abc'

In [349]: str2
Out[349]: '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， 连接字符串

通过"+"，可以连接不同的字符串

In [368]: str1
Out[368]: 'abc'

In [369]: str2
Out[369]: 'lmn'

In [370]: str1 + str2
Out[370]: 'abclmn'

2-4， 字符串重复

my_str * n：表示字符串重复n次

In [374]: str1
Out[374]: 'abc'

In [372]: str1 * 5
Out[372]: 'abcabcabcabcabc'

2-5， 格式化操作符

python支持的格式化操作符有：%c，%r，%s，%d，%f/%F，%x/%X，%o，%e/E，%g/%G，%%

# 返回对应的字符
In [380]: '%c' % 65
Out[380]: 'A'

# 返回对应的原字符串，不进行转义
In [382]: '%r' % '\n'
Out[382]: "'\\n'"

# 返回对应的字符串，特殊字符会转义
In [383]: '%s' % '\n'
Out[383]: '\n'

In [384]: '%s' % 'aa'
Out[384]: 'aa'

# 返回对应的十进制数
In [385]: '%d' % 10
Out[385]: '10'

# 返回对应的八进制数
In [387]: '%o' % 10
Out[387]: '12'

# 带格式返回对应的八进制数
In [388]: '%#o' % 10
Out[388]: '0o12'

# 返回对应的十六进制数
In [389]: '%x' % 10
Out[389]: 'a'

# 带格式返回对应的十六进制数
In [390]: '%#x' % 10
Out[390]: '0xa'

In [391]: '%#X' % 10
Out[391]: '0XA'

# 带格式返回，10：表示返回数占10位， -：表示返回数左对齐；多余的补空格, 与%s联合使用
# 与方法:str.ljust()等价
In [395]: '%-10s' % 1
Out[395]: '1         '

In [396]: '1'.ljust(10)
Out[396]: '1         '

# 带格式返回，多余的位补0
# 等价方法：str.zfill(10)
In [400]: '%010d' % 1
Out[400]: '0000000001'


# 指定位数和小数位进行返回， 与%f联合使用
In [405]: '%010.2f' % 1.236
Out[405]: '0000001.24'

# 带%号输出
In [415]: '%s%%' % 50
Out[415]: '50%'

2-6， 字符串模板

In [416]: from string import Template

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

# 当变量的数量与模块不一致时，该方法会报错
In [422]: print(s.substitute(lang='Python'))
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in 
----> 1 print(s.substitute(lang='Python'))

c:\users\administrator\appdata\local\programs\python\python38\lib\string.py in substitute(self, mapping, **kws)
    124             raise ValueError('Unrecognized named group in pattern',
    125                              self.pattern)
--> 126         return self.pattern.sub(convert, self.template)
    127
    128     def safe_substitute(self, mapping=_sentinel_dict, /, **kws):

c:\users\administrator\appdata\local\programs\python\python38\lib\string.py in convert(mo)
    117             named = mo.group('named') or mo.group('braced')
    118             if named is not None:
--> 119                 return str(mapping[named])
    120             if mo.group('escaped') is not None:
    121                 return self.delimiter

KeyError: 'howmany'


# 相比于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(my_str)：返回字符串的长度

In [439]: my_str
Out[439]: 'hello python'

In [429]: len(my_str)
Out[429]: 12

max(my_str)：返回字符串中，ASCII码最大的字符

In [439]: my_str
Out[439]: 'hello python'

In [430]: max(my_str)
Out[430]: 'y'

min(my_str)：返回字符串中，ASCII码最小的字符

In [439]: my_str
Out[439]: 'hello python'


In [441]: min(my_str)
Out[441]: ' '

enumerate(my_str)：返回一个enumerate对象，通过for循环，可迭代输出字符与其对应的索引

In [442]: my_str
Out[442]: 'hello python'

In [443]: enumerate(my_str)
Out[443]: 

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, str2)：压缩str1,str2为一个zip对象，zip的每个元素由str1，str2相同的索引元素组成，通过for循环迭代输出

In [451]: str1
Out[451]: 'abc'

In [452]: str2 = 'lmn1'

#返回zip对象， 
In [453]: zip(str1, str2)
Out[453]: 

# 只输出了3个元素，因为zip后，以短的列表长度为准
In [454]: for i in zip(str1, str2):
     ...:     print(i)
     ...:
('a', 'l')  
('b', 'm')
('c', 'n')

input()：用于交互式，等待用户输入

In [457]: input(':')
:                     # 等待用户输入

chr(num)：接收一个整数，转换字符

In [435]: chr(10000)
Out[435]: '✐'

ord(char)：接收单个字符，转换为对应的整数

In [458]: ord('a')
Out[458]: 97

my_str.capitalize()：字符串的首字母大写

In [1]: my_str = 'hello python'

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 [15]: my_str = 'hello python'

In [16]: my_str.title()
Out[16]: 'Hello Python'

my_str.center(width，char)：指定宽度width，居中显示字符串, char为填充字符

In [18]: my_str
Out[18]: 'hello python'

# 不指定填充字符，多余为补空格
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)：指定宽度，右对齐显示字符串， 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)：指定宽度，左对齐显示字符串， 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)：指定宽度，又对齐显示字符串，多余的位补‘0’

In [30]: my_str.zfill(20)
Out[30]: '00000000hello python'

my_str.count(sub_str, beg, end)：在给定的范围内，查找子串出现的次数；若beg, end没有设置，则在整个字符串中查找

In [39]: my_str
Out[39]: 'hello python'

# 整个字符串中查找
In [40]: my_str.count('l')
Out[40]: 2

# 在给定的范围查询，beg，end与字符串的长度不相关
In [41]: my_str.count('l', -100, 100)
Out[41]: 2

# 查找的范围为：start~end-1
In [42]: my_str.count('l', 0, 3)
Out[42]: 1

my_str.find(sub_str, beg, end)：在给定的范围内，从左开始查找子串第一次出现的索引位置（子串首字母）；若没有给定beg, end， 则查找整个字符串；没有找到子串返回-1；beg, end与字符串的长度无关

In [59]: my_str
Out[59]: 'hello python'

# 找到子串，返回子串首字母索引位置
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与字符串的长度无关

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， 则查找整个字符串；没有找到子串则报错；beg, end与字符串的长度无关

In [70]: my_str
Out[70]: 'hello python'

In [71]: my_str.index('python')

# 没有找到则报错
In [72]: my_str.index('1python')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in 
----> 1 my_str.index('1python')

ValueError: substring not found

my_str.rindex(sub_str, beg end)：在给定的范围内，从右开始查找子串第一次出现的索引位置（子串首字母）；若没有给定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)
 in 
----> 1 my_str.rindex('pytho1n')

ValueError: substring not found

my_str.strip(chars)：指定chars, 删除字符串两端匹配的字符；若没有指定，则删除空格

In [76]: my_str
Out[76]: 'hello python'

# 入参'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, 删除字符串右端匹配的字符；若没有指定，则删除空格

# 只删除了右边匹配的，左边没有动
In [81]: 'abceeeecba'.rstrip('bac')
Out[81]: 'abceeee'

my_str.lstrip()：指定sub_str, 删除字符串左端匹配的字符；若没有指定，则删除空格

# 只删除了左边匹配的，右边没有动
In [82]: 'abceeeecba'.lstrip('bac')
Out[82]: 'eeeecba'

my_str.partition(sep)：指定分隔符sep(从左开始首次出现)分割字符串，返回一个元组：(分割符前子串，分割符，分隔符后子串)

In [83]: my_str
Out[83]: 'hello python'

In [84]: my_str.partition('l')
Out[84]: ('he', 'l', 'lo python')

my_str.rpartition(str)：指定分隔符sep(从右开始首次出现)分割字符串，返回一个元组：(分割符前子串，分割符，分隔符后子串)

In [83]: my_str
Out[83]: 'hello python'

In [85]: my_str.rpartition('l')
Out[85]: ('hel', 'l', 'o python')

my_str.split(str=sep, num)：指定分割符sep(从右开始首次出现)分割字符串，返回一个列表：[分割符前子串， 分割符后子串]， 若没有指定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结束，返回bool值；指定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开始，返回bool值；指定beg和end则在指定范围内查找，beg, end与字符串的长度没有关系

[3]: my_str = 'hello python'

In [4]: my_str.endswith('on')
Out[4]: True

my_str.sialnum()：判断字符串是否仅有字母、数字组；是返回True，否返回False

In [13]: my_str
Out[13]: 'hello python'

# 因为my_str中包含空格，所以返回False
In [14]: my_str.isalnum()
Out[14]: False

my_str.isalpha()：判断字符串是否仅有字母组成；是返回True，否返回False

In [15]: 'adfas'.isalpha()
Out[15]: True

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 [34]: my_str
Out[34]: 'hello python'

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 [42]: my_str
Out[42]: 'hello python'

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则替换num次

如果没有指定，则替换所有

# 替换所有
In [46]: 'aaaaa'.replace('a', 'b')
Out[46]: 'bbbbb'

# 指定次数替换：替换两次
In [47]: 'aaaaa'.replace('a', 'b', 2)
Out[47]: 'bbaaa'

my_str.expandtabs(tabsize)：将字符串中的换行符，替换为空格；tabsize为换行符替换成空格的数量

# 不指定空格的数量，默认为8个空格
In [50]: 'aaa\tbbb\tccc'.expandtabs()
Out[50]: 'aaa     bbb     ccc'

# 指定空格的数量为1个
In [51]: 'aaa\tbbb\tccc'.expandtabs(1)
Out[51]: 'aaa bbb ccc'

my_str1.decode('utf-8')：以utf-8格式解码字符串

In [58]: my_str1 = my_str.encode('utf-8')

In [59]: my_str1
Out[59]: b'hello python'

In [60]: my_str1.decode('utf-8')
Out[60]: 'hello python'

my_str.encode('utf-8')：以utf-8格式编码my_str

In [57]: my_str.encode('utf-8')
Out[57]: b'hello python'

3， 列表

列表是python的一种数据类型；

列表成员是有序排列的，所以可以通过下标和切片的形式进行访问其元素；

列表是可变的；

列表中元素可以是任何数据类型，无长度限制

3-1， 列表的创建，查询，修改、删除

创建

可以通过操作符[]方式直接创建

也可以通过工厂方法进行创建

# 直接通过列表符号创建
In [68]: my_list1 = [123, 'abc', 4.56, ['inner', 'list'], 7-9j]

# 通过列表符号，创建一个空列表
In [69]: my_list2 = []

# 通过工厂方法创建， 字符串中的每个字符，都变成列表一个元素
In [74]: my_list3 = list('abcd')

# 通过工厂方法创建一个空列表
In [75]: my_list4 = list()


In [71]: my_list1
Out[71]: [123, 'abc', 4.56, ['inner', 'list'], (7-9j)]

In [72]: my_list2
Out[72]: []

In [76]: my_list3
Out[76]: ['a', 'b', 'c', 'd']

In [77]: my_list4
Out[77]: []

查询

通过单个下标可访问列表的单个元素；

通过切片可以访问列表中的多个元素；

通过in, not in判断元素是否存在列表中；

通过for循环可迭代列表的所有元素；

# 输入变量，返回整个列表
In [81]: my_list
Out[81]: [123, 'abc', 4.56, ['inner', 'list'], (7-9j)]

# 通过下标，返回下标对应的单个元素
# 下标是从0开始， len(my_str)-1结束
# 当下标为-1时，返回最后一个元素
In [82]: my_list[0]
Out[82]: 123

In [83]: my_list[-1]
Out[83]: (7-9j)

# 通过不存在的索引进行访问，会报错
In [88]: my_list[100]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in 
----> 1 my_list[100]

IndexError: list index out of range

# 不带起始下标，返回整个列表
In [86]: my_list[:]
Out[86]: [123, 'abc', 4.56, ['inner', 'list'], (7-9j)]

# 设置起始下标，返回start~(end-1)之间的元素
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']]

# 设置步进为2， 返回列表的元素
In [87]: my_list[::2]
Out[87]: [123, 4.56, (7-9j)]

# 逆向返回整个列表
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]: []

# 通过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

# 通过迭代方式，逐个访问列表元素
In [97]: for i in my_list:
    ...:     print(i)
    ...:
123
abc
4.56
['inner', 'list']
(7-9j)

修改

修改单个值：通过my_list[index]方式

修改多个值：通过my_list[beg:end]方式

修改结果映射到原来的列表上

In [98]: my_list
Out[98]: [123, 'abc', 4.56, ['inner', 'list'], (7-9j)]

# 修改单个元素
In [100]: my_list[2] = 'hahaha'

In [103]: my_list
Out[103]: [123, 'abc', 'hahaha', ['inner', 'list'], (7-9j)]

# 通过切片方式修改多个元素
In [104]: my_list[0:3] = [1, 1, 1]

In [105]: my_list
Out[105]: [1, 1, 1, ['inner', 'list'], (7-9j)]

删除

del my_list[index]：通过指定列表索引，删除对应的元素；

my_list.remove(obj)：指定列表的元素，进行删除；

In [105]: my_list
Out[105]: [1, 1, 1, ['inner', 'list'], (7-9j)]

# 通过索引删除单个元素
In [106]: del my_list[3]

In [110]: my_list
Out[110]: [1, 1, 1, (7-9j)]


# 指定元素进行删除
In [111]: my_list.remove(1)

In [112]: my_list
Out[112]: [1, 1, (7-9j)]

3-2， 连接列表

列表之间的连接通过符号"+"进行；生成一个新列表

In [117]: my_list1 = list('1234')

In [118]: my_list2 = list('abcd')

In [119]: my_list1 + my_list2
Out[119]: ['1', '2', '3', '4', 'a', 'b', 'c', 'd']

3-3， 重复列表

列表元素重复可以通过：my_list * n的方式，n表示列表元素重复的次数；生成一个新列表

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)：返回列表元素的个数

In [137]: my_list
Out[137]: [0, 1, 2, 3]

In [138]: len(my_list)
Out[138]: 4

max(my_list)：返回列表元素中，最大的元素

In [140]: my_list
Out[140]: [0, 1, 2, 3]

In [141]: max(my_list)
Out[141]: 3

min(my_list)：返回列表元素中，最小的元素

In [142]: my_list
Out[142]: [0, 1, 2, 3]

In [143]: min(my_list)
Out[143]: 0

sorted(my_list)：升序排序my_list

In [149]: my_list = ['They', 'stamp', 'them', 'when', "they're", 'small']

# 注意：sorted是按词典序进行排列的，升序排序
# 词典序：即按照字母的ASCII码进行比较
In [150]: for i in sorted(my_list):
     ...:     print(i)
     ...:
They
small
stamp
them
they're
when

reversed(my_list)：返回一个reversed对象，通过for循环迭代出my_list中的元素（倒转的）

In [153]: my_list
Out[153]: ['They', 'stamp', 'them', 'when', "they're", 'small']

# 倒转my_list后，迭代输出每个元素
In [154]: for i in reversed(my_list):
     ...:     print(i)
     ...:
small
they're
when
them
stamp
They

enumerate(my_list)：返回一个enumerate对象，通过for循环迭代出每个元素与元素对应索引

In [153]: my_list
Out[153]: ['They', 'stamp', 'them', 'when', "they're", 'small']

In [156]: enumerate(my_list)
Out[156]: 

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循环迭代出每个元素；

In [161]: my_list1 = list('abcd')

In [162]: my_list2 = list('efghi')

In [164]: zip(my_list1, my_list2)
Out[164]: 

# 元素的个数以短的列表长度一致
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]

In [167]: sum(my_list)
Out[167]: 45

my_list.append(obj)：想列表中添加元素obj；结果映射到原列表，无返回值

In [168]: my_list = list('abcd')

In [169]: my_list.append('f')

In [170]: my_list
Out[170]: ['a', 'b', 'c', 'd', 'f']

my_list.count(obj)：计算列表中的元素"obj"出现的次数

In [170]: my_list
Out[170]: ['a', 'b', 'c', 'd', 'f']

In [171]: my_list.count('a')
Out[171]: 1

my_list.extend(seq)：添加序列seq到my_list中(末尾处添加)；结果映射到原列表，无返回值

In [179]: my_list = list('abc')

# 注意：序列中的字符组个添加
In [180]: my_list.extend('123')

In [181]: my_list
Out[181]: ['a', 'b', 'c', '1', '2', '3']

# 注意：列表中的元素组个添加
In [182]: my_list.extend(['a', 'b'])

In [183]: my_list
Out[183]: ['a', 'b', 'c', '1', '2', '3', 'a', 'b']

# 注意：元组中的元素组个添加
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']

In [188]: my_list.index('b')
Out[188]: 1

# 当obj不存在时，会报错
In [189]: my_list.index('b1')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in 
----> 1 my_list.index('b1')

ValueError: 'b1' is not in list

my_list.insert(index, obj)：在列表索引为index的位置，插入元素obj；结果映射到原列表，无返回值

In [191]: my_list
Out[191]: ['a', 'b', 'c', '1', '2', '3', 'a', 'b', '1', '2']

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，则删除index对应的元素；均返回删除的元素；结果映射到原列表

In [195]: my_list
Out[195]: ['a', 'fdsafsad', 'b', 'c', '1', '2', '3', 'a', 'b', '1', '2']

# 不指定index，默认删除列表最后一个元素
In [196]: my_list.pop()
Out[196]: '2'

In [197]: my_list
Out[197]: ['a', 'fdsafsad', 'b', 'c', '1', '2', '3', 'a', 'b', '1']

# 指定index进行删除
In [198]: my_list.pop(1)
Out[198]: 'fdsafsad'

In [199]: my_list
Out[199]: ['a', 'b', 'c', '1', '2', '3', 'a', 'b', '1']

# 指定的索引不存在时，会报错
In [201]: my_list.pop(1000)
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in 
----> 1 my_list.pop(1000)

IndexError: pop index out of range

my_list.remove(obj)：移除列表中首次出现的obj；结果映射到原列表，无返回值

In [202]: my_list
Out[202]: ['a', 'b', 'c', '1', '2', '3', 'a', 'b', '1']

In [203]: my_list.remove('a')

In [204]: my_list
Out[204]: ['b', 'c', '1', '2', '3', 'a', 'b', '1']

my_list.reverse()：翻转列表；结果映射到原列表，无返回值

In [205]: my_list
Out[205]: ['b', 'c', '1', '2', '3', 'a', 'b', '1']


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']

In [211]: my_list.sort()

In [212]: my_list
Out[212]: ['1', '1', '2', '3', 'a', 'b', 'b', 'c']

4， 元组

元组是python的一种数据类型, 其元素可以是任意类型

因为元组是有序的，可以通过下标和切片方式访问其元素

元组是不可变的

4-1， 元组的创建，查询，修改，删除

创建

通过操作符()进行创建

通过工厂方法进行创建tuple()

# 通过()进行创建
In [217]: my_tuple1 = (123, 'abc', 4.56, ['inner', 'tuple'], 7-9j)

# 入参为空，则创建一个空元组
In [218]: my_tuple2 = ()

# 创建单个元组，需要在元素后加：逗号
In [219]: my_tuple3 = (1,)

In [220]: my_tuple1
Out[220]: (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))

In [221]: my_tuple2
Out[221]: ()

In [222]: my_tuple3
Out[222]: (1,)

# 通过工厂方法进行创建
In [223]: my_tuple1 = tuple('abcd')

In [224]: my_tuple2 = tuple()

In [225]: my_tuple3 = tuple('1')

In [226]: my_tuple1
Out[226]: ('a', 'b', 'c', 'd')

In [227]: my_tuple2
Out[227]: ()

In [228]: my_tuple3
Out[228]: ('1',)

查询

通过单个下标可访问元组的单个元素；

通过切片可以访问元组中的多个元素；

通过in, not in判断元素是否存在元组中；

通过for循环可迭代列表的所有元素；

# 输入变量，返回整个列表
In [233]: my_tuple1
Out[233]: (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))

# 通过下标，返回下标对应的单个元素
# 下标是从0开始， len(my_str)-1结束
# 当下标为-1时，返回最后一个元素
In [229]: my_tuple1 = (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))

In [230]: my_tuple1[0]
Out[230]: 123

In [231]: my_tuple1[-1]
Out[231]: (7-9j)

# 通过不存在的索引进行访问，会报错
In [234]: my_tuple1[-10]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in 
----> 1 my_tuple1[-10]

IndexError: tuple index out of range

# 不带起始下标，返回整个元组
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'])

# 设置步进为2， 返回元组的元素
In [242]: my_tuple1[::2]
Out[242]: (123, 4.56, (7-9j))

# 逆向返回整个元组
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]: ()

# 通过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

# 通过迭代方式，逐个访问元组元素
In [251]: for i in my_tuple1:
     ...:     print(i)
     ...:
123
abc
4.56
['inner', 'tuple']
(7-9j)

修改

因为元组的不可变特性，不能对元组进行修改；若需要新元组，只能新建

删除

因为元组的不可变特性，不能删除元组中的元素；可通过del my_tuple的方法，删除整个元组

In [252]: my_tuple1
Out[252]: (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))

In [254]: del my_tuple1

In [255]: my_tuple1
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
 in 
----> 1 my_tuple1

NameError: name 'my_tuple1' is not defined

4-2， 连接元组

通过符号"+"， 可以连接多个元组，返回一个新的元组

In [256]: my_tuple1 = (['xyz', 123], 23, -103.4)

In [257]: my_tuple1 + my_tuple1
Out[257]: (['xyz', 123], 23, -103.4, ['xyz', 123], 23, -103.4)

4-3， 重复元组

通过符号"*"，my_tuple * N, 可以重复N次元组的元素，返回一个新的元组

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)：返回元组中的最大值元素； 元素需要是同一种类型

In [267]: my_tuple
Out[267]: (0, 1, 2, 3, 4)

In [268]: max(my_tuple)
Out[268]: 4

min(my_tuple)：返回元组中的最小值元素； 元素需要是同一种类型

In [267]: my_tuple
Out[267]: (0, 1, 2, 3, 4)

In [269]: min(my_tuple)
Out[269]: 0

4-5， 元组比较大小

步骤如下（元组中的元素类型需要为同一种）：

从第一项开始比较；

若是数字，执行必要的数字类型转换，然后比较；

若为字符串，则通过ASCII码进行比较；

若第一项相等，则以此比较后面的项；

若有一个列表首先到达末尾，则另一个长一点的元组为大；

若前面的步骤都相等，则列表相等

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