列表、元组和字符串
1. 列表
列表由一系列按特定顺序排列的元素组成，其中的元素包括任意类型的对象。在Python中，用方括号[]来表示列表，并用逗号来分隔其中的元素。[元素1，元素2，…]
1.1 列表的创建
- 直接创建
x = [2, 3, 4, 5, 6, 7]
- 利用range（）创建
x = list(range(1, 11, 2))
print(x)
# [1, 3, 5, 7, 9]
- 利用推导式创建
x = [i for i in range(10)]
print(x)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- 创建4×3的二维数组
x = [[0 for col in range(3)] for row in range(4)]
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[1][2] = 1
print(x)
# [[0, 0, 0], [0, 0, 1], [0, 0, 0], [0, 0, 0]]
注列表中所保存的是对象的指针。如x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。
a = [0] * 3
x = [a] * 4
print(x)
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x)
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。
1.2 列表的操作
- 添加
list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
此元素如果是一个 list，那么这个 list 将作为一个整体进行追加。list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
x = ['a','b','c']
x.append('d')
print(x)
x.append(['d','e'])
print(x)
x.extend(['d','e'])
print(x)
#['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', ['d', 'e']]
['a', 'b', 'c', 'd', ['d', 'e'], 'd', 'e']
严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。
list.insert(index, obj) 在编号 index 位置插入 obj。
x = ['a','b','c']
x.insert(3,'d')
print(x)
#['a', 'b', 'c', 'd']
x = ['a','b','c']
x.insert(3,['d','e'])
print(x)
#['a', 'b', 'c', ['d', 'e']]
- 删除
list.remove(obj) 移除列表中某个值的第一个匹配项。
x = ['a','b','c']
x.remove('b')
#['a', 'c']
list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
x=['a','b','c']
y=x.pop()
print(y)
#c
x=['a','b','c']
y=x.pop(0)
print(y)
#a
remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
del [var1, var2 ……] 删除单个或多个对象。
x=['a','b','c']
del x[0:2]
print(x)
#['c']
如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。
- 获取
通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
切片的通用写法是 start : stop : step
情况 1 - “start :”
以 step 为 1 (默认) 从编号 start 往列表尾部切片
情况 2 - “: stop”
以 step 为 1 (默认) 从列表头部往编号 stop 切片。
情况 3 - “start : stop”
以 step 为 1 (默认) 从编号 start 往编号 stop 切片。
情况 4 - “start : stop : step”
以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。
情况 5 - " : "
复制列表中的所有元素（浅拷贝）。
x = ['a','b','c','e','f']
print(x[1:])
print(x[:2])
print(x[1:3])
print(x[1:2:3])
print(x[:])
#['b', 'c', 'e', 'f']
#['a', 'b']
#['b', 'c']
#['b']
#['a', 'b', 'c', 'e', 'f']
1.3 列表常用操作符
- 等号操作符：==
- 连接操作符 +
- 重复操作符 *
- 成员关系操作符 in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。 列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
x = ['a','b','c']
y=['d','e']
z=x+y
print(z)
#['a', 'b', 'c', 'd', 'e']
x = ['a','b','c']
z=x*2
print(z)
#['a', 'b', 'c', 'a', 'b', 'c']
x = ['a','b','c']
y=['d','e']
print('a'in x)
print('a'in y)
#True
False
前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
1.4 列表的其他操作
list.count(obj) 统计某个元素在列表中出现的次数
x = ['a','a','b','c']
print(x.count('a'))
print(x.count('b'))
#2
1
list.index(x, start, end) 从列表中找出某个值第一个匹配项的索引位置
x = ['a','b','c']*3
print(x.index('b'))
print(x.index('b',4,8))
#1
4
list.reverse() 反向列表中元素
x = ['a','b','c']
x.reverse()
print(x)
#['c', 'b', 'a']
list.sort(key=None, reverse=False) 对原列表进行排序。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
该方法没有返回值，但是会对列表的对象进行排序。
练习题
- 列表操作练习
lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.append(15)
print(lst)
lst.insert(len(lst)//2,20)
print(lst)
lst.extend([2, 5, 6])
print(lst)
del lst[3]
print(lst)
lst.reverse()
print(lst)
lst.sort(reverse=True)
print(lst)
lst.sort(reverse=False)
print(lst)
'''
结果：
2. [2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
3. [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
4. [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
5. [2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
6. [6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
7. [20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]
8. [2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
'''
- 修改列表
def list_g(list_0):
for i in range(len(list_0)):
if str(list_0[i]).isdigit():
list_0[i]*=2
if isinstance(list_0[i],list): #判断是不是列表类型
list_g(list_0[i])
lst = [1, [4, 6], True]
list_g(lst)
print(lst)
'''
结果：
[2, [8, 12], True]
'''
- 山脉数组的峰顶索引
def data_up(k,i):
y=0
for j in range(i):
if k[j] < k[j+1]:
continue
else:
y=1
return y
def data_down(l,m):
y=0
for a in range(m,len(l)-1):
if l[a] > l[a+1]:
continue
else:
y=1
return y
user_in = input('请一个输入长度大于3的数组').split()
if len(user_in) > 3:
n = user_in.index(max(user_in))
x1 = data_up(user_in,n)
x2 = data_down(user_in,n)
if x1 or x2:
print('False')
else:
print('True')
else:
print('数组长度不够，请重新输入')
结果：
2. 元组
列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网 站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素， 元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
定义语法:
(元素1，元素2，......)
2.1 元组的创建和访问
1.Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
2.元组使用小括号，列表使用方括号。
3.元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
4.创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
5.元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
示例：
x = (1, 2, 'a')
y = 1, 2, 'a'
print(x, type(x))
# (1, 2, 'a') <class 'tuple'>
print(y, type(y))
# (1, 2, 'a') <class 'tuple'>
x = (1)
print(type(x)) # <class 'int'>
x = 2, 3, 4, 5
print(type(x)) # <class 'tuple'>
x = []
print(type(x)) # <class 'list'>
x = ()
print(type(x)) # <class 'tuple'>
x = (1,)
print(type(x)) # <class 'tuple'>
2.2 更新和删除一个元组
元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
x = (1, 2, 3, [4, 5, 6])
print(x) # (1, 2, 3, [4, 5, 6])
x[3][0] = 5
print(x) # (1, 2, 3, [5, 5, 6])
2.3 与元组相关的操作符
元组的操作符与列表相同，详见本文1.3节。
2.4 内置方法
元组大小和内容都不可更改，因此只有 count 和 index 两种方法。其中count是查看某元素出现的次数，index是该元素在元组的索引。
2.5 解压元祖
- 解压（unpack）一维元组（有几个元素左边括号定义几个变量）
x = (1, 2, 'a')
(a, b, c) = x
print(a, b, c)
# 1 2 a
- 解压二维元组（按照元组里的元组结构来定义变量）。
- 如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]
- 如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线‘_’。
t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b) # 1 2
2.6 练习题
- 元祖概念
x1 = (1,2)
x2 = (1,)
x3 = (1)
print(x1*2)
print(x2*2)
print(x3*2)
'''
(1, 2, 1, 2)
(1, 1)
2
'''
分析：
结果1和结果2的对象均为元组，（1，）加了逗号作为元组使用，而*为复制操作符，所以1和2结果均为元组；结果3中（1）没加‘，’作为运算符使用，而不是元组，所以进行的是乘法运算。
- 拆包的过程是什么
a,b = 1,2
拆包的过程是什么
上述过程属于拆包吗？
可迭代对象拆包时，怎么赋值给占位符？
答：
一、对于可迭代对象，如元组、列表、字符串、集合、字典这些可迭代对象都可以被拆包，拆包是指将一个结构中的数据拆分为多个单独变量中。拆包的方式大致有两种，一种是以变量的方式来接收，另一种是用‘*’号。
二、上述过程属于变量的直接赋值，不属于拆包。
三、保证变量的数量和可迭代对象元素的数量一致。有的时候，拆包后的元素我们不一定全部需要，对于不需要的元素可以用任意符号占位。
3. 字符串
3.1 字符串的定义
Python 中字符串被定义为引号之间的字符集合。 Python 支持使用成对的单引号或双引号。
字符串常用转义字符：
- 如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义。
print('l\'m jack') # I'm jack
print('C:\\now') # C:\now
- 原始字符串只需要在字符串前边加一个英文字母 r 即可。
print(r'C:\Program Files\Intel\Wifi\Help')
# C:\Program Files\Intel\Wifi\Help
- 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
para_str = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB ( )。
# 也可以使用换行符 [
# ]。
3.2 字符串的切片与拼接
1.类似于元组具有不可修改性
2.从 0 开始 (和 Java 一样)
3.切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。
4.索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。
3.3 字符串的常用内置方法
capitalize() 将字符串的第一个字符转换为大写。
count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。
endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找。
str2 = "DAXIExiaoxie"
print(str2.find('xi')) # 5
print(str2.find('ix')) # -1
print(str2.rfind('xi')) # 9
isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。
ljust(width[, fillchar]) 返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
rjust(width[, fillchar]) 返回一个原字符串右对齐，并使用fillchar（默认空格） 填充至长度width的新字符串。
lstrip([chars]) 截掉字符串左边的空格或指定字符。
rstrip([chars]) 删除字符串末尾的空格或指定字符。
strip([chars]) 在字符串上执行lstrip()和rstrip()。
str5 = ' I Love LsgoGroup '
print(str5.lstrip()) # 'I Love LsgoGroup '
print(str5.lstrip().strip('I')) # ' Love LsgoGroup '
print(str5.rstrip()) # ' I Love LsgoGroup'
print(str5.strip()) # 'I Love LsgoGroup'
print(str5.strip().strip('p')) # 'I Love LsgoGrou'
partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回(‘原字符串’,’’,’’)。
rpartition(sub) 类似于partition()方法，不过是从右边开始查找。
str5 = ' I Love LsgoGroup '
print(str5.strip().partition('o')) # ('I L', 'o', 've LsgoGroup')
print(str5.strip().partition('m')) # ('I Love LsgoGroup', '', '')
print(str5.strip().rpartition('o')) # ('I Love LsgoGr', 'o', 'up')
replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次。
split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。
splitlines([keepends]) 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。
str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines()) # ['I ', ' Love ', ' LsgoGroup']
print(str6.splitlines(True)) # ['I \n', ' Love \n', ' LsgoGroup']
maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。
str7 = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab, outtab)
print(trantab) # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}
print(str7.translate(trantab)) # th3s 3s str3ng 2x1mpl2....w4w!!!
3.4 字符串格式化
- format 格式化函数
str8 = "{0} Love {1}".format('I', 'Lsgogroup') # 位置参数
print(str8) # I Love Lsgogroup
str8 = "{a} Love {b}".format(a='I', b='Lsgogroup') # 关键字参数
print(str8) # I Love Lsgogroup
str8 = "{0} Love {b}".format('I', b='Lsgogroup') # 位置参数要在关键字参数之前
print(str8) # I Love Lsgogroup
str8 = '{0:.2f}{1}'.format(27.658, 'GB') # 保留小数点后两位
print(str8) # 27.66GB
- Python 字符串格式化符号
- 格式化操作符辅助指令
print('%5.1f' % 27.658) # ' 27.7'
print('%.2e' % 27.658) # 2.77e+01
print('%10d' % 10) # ' 10'
print('%-10d' % 10) # '10 '
print('%+d' % 10) # +10
print('%#o' % 10) # 0o12
print('%#x' % 108) # 0x6c
print('%010d' % 5) # 0000000005
3.5 练习题
- 怎么批量替换字符串中的元素？
- 怎么把字符串按照空格进⾏拆分？
- 怎么去除字符串⾸位的空格？
答：
- 使用replace(old, new )函数。
- 使用str.split(str="", num) 不带参数默认是以空格为分隔符切片字符串。
- 使用str.lstrip(]) 截掉字符串左边的空格。
实现isdigit函数
题目要求：
实现函数isdigit， 判断字符串里是否只包含数字0~9
def isdigit(str_in):
for i in range(len(str_in)):
if (str_in[i] >= '0') and (str_in[i] <= '9'):
continue
else:
return '该字符串不只包含数字'
return '该字符串只包含数字'
use_str = input("请输入字符串")
n=isdigit(use_str)
print(n)
结果：
3. 最长回文子串
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
def find_str(s):
n = len(s)
max_length = 0
start = 0
for i in range(len(s)):
if i - max_length >= 1 and s[i - max_length - 1: i + 1] == s[i - max_length - 1: i + 1][::-1]:
start = i - max_length - 1
max_length += 2
continue
if i - max_length >= 0 and s[i - max_length: i + 1] == s[i - max_length: i + 1][::-1]:
start = i - max_length
max_length += 1
return s[start: start + max_length]
user_in = input("请输入长度小于1000的字符串")
if len(user_in) <= 1000:
out = find_str(user_in)
print(out)
else:
print('字符串长度过长，请重新输入')
'''
结果：
输入: "babad"
输出: "bab"
输入: "cbbd"
输出: "bb"
'''
扫一扫
488
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
