列表（list）
在学习列表前我觉得有必要先简述一下序列：
一.序列（sequence）
- 序列是Python中最基本的一种数据结构
- 数据结构指计算机中数据存储的方式
- 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引
- 序列的分类：
可变序列（序列中的元素可以改变）：
> 列表（list）
不可变序列（序列中的元素不能改变）：
> 字符串（str）
> 元组（tuple）
列表前述：
- 列表是Python中的一个对象
- 对象（object）就是内存中专门用来存储数据的一块区域
- 之前我们学习的对象，像数值，它只能保存一个单一的数据
- 列表中可以保存多个有序的数据
- 列表是用来存储对象的对象
- 列表的使用：
1.列表的创建
2.操作列表中的数据
二. 列表的定义
列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, ..., 元素n]。
-
关键点是「中括号 []」和「逗号 ,」
-
中括号 把所有元素绑在一起
-
逗号 将每个元素一一分开
三.创建列表
创建列表的方法：
-
直接创建一个普通列表
-
利用range()创建列表
-
利用推导式来创建列表
# 创建列表，通过[]来创建列表
my_list = [] # 创建了一个空列表
# print(my_list , type(my_list))
# 列表存储的数据，我们称为元素
# 一个列表中可以存储多个元素，也可以在创建列表时，来指定列表中的元素
my_list = [10] # 创建一个只包含一个元素的列表
# 当向列表中添加多个元素时，多个元素之间使用,隔开
my_list = [10,20,30,40,50] # 创建了一个保护有5个元素的列表
# 列表中可以保存任意的对象
my_list = [10,'hello',True,None,[1,2,3],print]
# 列表中的对象都会按照插入的顺序存储到列表中，
# 第一个插入的对象保存到第一个位置，第二个保存到第二个位置**注：**由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。
1.range()
- range()是一个函数，可以用来生成一个自然数的序列（之前学习过，这里回顾一下）
# range()是一个函数，可以用来生成一个自然数的序列
r = range(5) # 生成一个这样的序列[0,1,2,3,4]
r = range(0,10,2)
r = range(10,0,-1)
# 该函数需要三个参数
# 1.起始位置（可以省略，默认是0）
# 2.结束位置
# 3.步长（可以省略，默认是1）
# print(list(r))
# 通过range()可以创建一个执行指定次数的for循环
# for()循环除了创建方式以外，其余的都和while一样，
# 包括else、包括break continue都可以在for循环中使用
# 并且for循环使用也更加简单
# 将之前使用while循环做的练习，再使用for循环完成一次！
for i in range(30):
print(i)
# for s in 'hello':
# print(s)四.向列表中添加元素
list.append(obj)在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）list.insert(index, obj)在编号index位置插入obj。
# 向列表中添加元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# print('原列表：',stus)
# append()
# 向列表的最后添加一个元素
stus.append('唐僧')
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧']
# insert()
# 向列表的指定位置插入一个元素
# 参数：
# 1.要插入的位置
# 2.要插入的元素
stus.insert(2,'唐僧')
# ['孙悟空', '猪八戒', '唐僧', '沙和尚', '唐僧']
# extend()
# 使用新的序列来扩展当前序列
# 需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
stus.extend(['唐僧','白骨精'])
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']
stus += ['唐僧','白骨精']
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']
print(stus)注： 注意append()和extend()的区别；在append()中，此元素如果是一个 list，那么这个 list 将作为一个整体进行追加；严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。
# append()和extand()的区别
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.extend(['唐僧','白骨精'])
# 将新列表的元素合并到原列表中
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']
stus.append(['唐僧','白骨精'])
# 将新列表作为一个整体追加到原列表中
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', ['唐僧', '白骨精']]
print(stus)五.删除列表中的元素
list.remove(obj)移除列表中某个值的第一个匹配项list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值del var1[, var2 ……]删除单个或多个对象。list.clear()清空列表
##删除列表中的元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# clear()
# 清空序列
stus.clear()
# []
# del stus[val1:val2]
del stus[0:2]
# ['沙和尚', '唐僧']
# pop()
# 根据索引删除并返回被删除的元素
result = stus.pop(2) # 删除索引为2的元素
result = stus.pop() # 删除最后一个
print('result =',result)
# result = 唐僧
# remove()
# 删除指定值得元素，如果相同值得元素有多个，只会删除第一个
stus.remove('猪八戒')
# ['孙悟空', '沙和尚', '唐僧']
print(stus)**注：**如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。
六. 获取列表中的元素
- 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
- 通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
1.切片
切片指从现有列表中，获取一个子列表；
# 切片
# 创建一个列表，一般创建列表时，变量的名字会使用复数
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
# 列表的索引可以是负数
# 如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个 以此类推
print(stus[-2]) # 蜘蛛精
# 通过切片来获取指定的元素
# 语法：列表[起始:结束]
# 通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
# 做切片操作时，总会返回一个新的列表，不会影响原来的列表
# 起始和结束位置的索引都可以省略不写
# 如果省略结束位置，则会一直截取到最后
# 如果省略起始位置，则会从第一个元素开始截取
# 如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
print(stus[1:]) # ['猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
print(stus[:3]) # ['孙悟空', '猪八戒', '沙和尚']
print(stus[:]) # ['孙悟空', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
print(stus) #['孙悟空', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
# 语法：列表[起始:结束:步长]
# 步长表示，每次获取元素的间隔，默认值是1
print(stus[0:5:3]) # ['孙悟空', '唐僧']
# 步长不能是0，但是可以是负数
print(stus[::0]) # ValueError: slice step cannot be zero
# 如果是负数，则会从列表的后部向前边取元素
print(stus[::-1]) # ['白骨精', '蜘蛛精', '唐僧', '沙和尚', '猪八戒', '孙悟空']-
情况 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 - " : "
复制列表中的所有元素（浅拷贝）。
也可通过切片来修改和删除元素：
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
print("修改前：",stus)
# 通过切片来修改列表
# 在给切片进行赋值时，只能使用序列
stus[0:2] = ['牛魔王','红孩儿'] # 使用新的元素替换旧元素
stus[0:2] = ['牛魔王','红孩儿','二郎神']
stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素
# 当设置了步长时，序列中元素的个数必须和切片中元素的个数一致
stus[::2] = ['牛魔王','红孩儿','二郎神']
# 通过切片来删除元素
del stus[0:2]
del stus[::2]
stus[1:3] = []
print('修改后：',stus)
# 以上操作，只适用于可变序列2.浅拷贝和深拷贝
将一个列表的数据复制到另一个列表中。使用列表[:]，可以调用copy模块。
import copy
A = [21,22,23,24,['a','b','c','d'],25,26]
B = A #直接赋值
C = A[:] #浅拷贝
D = copy.copy(A) #浅拷贝
E = copy.deepcopy(A) #深拷贝
# 看看深拷贝与浅拷贝的区别
# 在A数组的最尾处加一个数
A.append(99)
#在A数组里面的数组最尾处加一个数
A[4].append(66)
print("起始列表A------------>",A)
print("直接把A列表赋值给B---->",B)
print("直接浅拷贝A列表给C---->",C)
print("直接浅拷贝A列表给D---->",D)
print("直接深拷贝A列表给E---->",E)
'''
输出结果：
起始列表A------------> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26, 99]
直接把A列表赋值给B----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26, 99]
直接浅拷贝A列表给C----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26]
直接浅拷贝A列表给D----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26]
直接深拷贝A列表给E----> [21, 22, 23, 24, ['a', 'b', 'c', 'd'], 25, 26]
'''浅拷贝和深拷贝的区别：
1、直接赋值,其实就是默认浅拷贝传递对象的引用而已,原始列表改变，被赋值的B也会做相同的改变；
2、浅拷贝，没有拷贝子对象，所以原始数据改变，子对象也会改变；
3、深拷贝，包含对象里面的子对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变。
七. 列表的常用操作符
- 等号操作符：
== - 连接操作符
+ - 重复操作符
* - 成员关系操作符
in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
# + 和 *
# +可以将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6] # [1, 2, 3, 4, 5, 6]
# * 可以将列表重复指定的次数
my_list = [1,2,3] * 5 # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
print(my_list)
# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
# in 和 not in
# in用来检查指定元素是否存在于列表中
# 如果存在，返回True，否则返回False
# not in用来检查指定元素是否不在列表中
# 如果不在，返回True，否则返回False
print('牛魔王' not in stus) # True
print('牛魔王' in stus) # False
# len()获取列表中的元素的个数
# min() 获取列表中的最小值
# max() 获取列表中的最大值
arr = [10,1,2,5,100,77]
print(min(arr) , max(arr)) # 1 100八.列表的其它方法
list.count(obj)统计某个元素在列表中出现的次数list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置list.reverse()反向列表中元素list.sort(key=None, reverse=False)对原列表进行排序。key– 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse– 排序规则，reverse = True降序，reverse = False升序（默认）。- 该方法没有返回值，但是会对列表的对象进行排序。
# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
# 两个方法（method），方法和函数基本上是一样，只不过方法必须通过 对象.方法() 的形式调用
# xxx.print() 方法实际上就是和对象关系紧密的函数
# s.index() 获取指定元素在列表中的第一次出现时索引
print(stus.index('沙和尚')) # 2
# index()的第二个参数，表示查找的起始位置 ， 第三个参数，表示查找的结束位置
print(stus.index('沙和尚',3,7)) # 6
# 如果要获取列表中没有的元素，会抛出异常
print(stus.index('牛魔王')) # ValueError: '牛魔王' is not in list
# s.count() 统计指定元素在列表中出现的次数
print(stus.count('牛魔王')) # 0stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# print('原列表：',stus)
# reverse()
# 用来反转列表
# stus.reverse()
# sort()
# 用来对列表中的元素进行排序，默认是升序排列
# 如果需要降序排列，则需要传递一个reverse=True作为参数
my_list = list('asnbdnbasdabd')
my_list = [10,1,20,3,4,5,0,-2]
print('修改前',my_list)
my_list.sort(reverse=True)
print('修改后',my_list)
print('修改后：',stus)
'''
原列表： ['孙悟空', '猪八戒', '沙和尚', '唐僧']
修改前 [10, 1, 20, 3, 4, 5, 0, -2]
修改后 [20, 10, 5, 4, 3, 1, 0, -2]
修改后： ['唐僧', '沙和尚', '猪八戒', '孙悟空']
'''
x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]
x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]九.练习题
1、列表操作练习
列表lst 内容如下
lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
请写程序完成下列操作：
- 在列表的末尾增加元素15
- 在列表的中间位置插入元素20
- 将列表[2, 5, 6]合并到lst中
- 移除列表中索引为3的元素
- 翻转列表里的所有元素
- 对列表里的元素进行排序，从小到大一次，从大到小一次
答：
lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
# 在列表的末尾增加元素15
lst.append(15)
print(lst) #
# 在列表的中间位置插入元素20
lst.insert(len(lst) // 2,20)
print(lst) #
# 将列表[2, 5, 6]合并到lst中
newLst = [2, 5, 6]
lst.extend(newLst)
print(lst) #
# 移除列表中索引为3的元素
lst.pop(3)
print(lst) #
# 翻转列表里的所有元素
lst.reverse()
print(lst) #
# 对列表里的元素进行排序，从小到大一次，从大到小一次
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)
'''
输出结果：
[2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
[2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
[6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
[2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
[20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]
'''2、修改列表
问题描述：
lst = [1, [4, 6], True]
请将列表里所有数字修改成原来的两倍
答：
def DoubleNum(lst):
for index, value in enumerate(lst):
if isinstance(value, bool):
pass
elif isinstance(value, (int, float)):
lst[index] *= 2
elif isinstance(value, list):
DoubleNum(value)
else:
pass
lst = [1, [4, 6], True]
DoubleNum(lst)
print(lst)
'''
结果为：
[2, [8, 12], True]
'''3、leetcode 852题 山脉数组的峰顶索引
如果一个数组k符合下面两个属性，则称之为山脉数组
数组的长度大于等于3
存在 i i i， i i i >0 且 i < len ( k ) − 1 i<\operatorname{len}(k)-1 i<len(k)−1， 使得 k [ 0 ] < k [ 1 ] < … < k [ i − 1 ] < k [ j ] > k [ i + 1 ] … > k [ len ( k ) − 1 ] \mathrm{k}[0]<\mathrm{k}[1]<\ldots<\mathrm{k}[\mathrm{i}-1]<\mathrm{k}[\mathrm{j}]>\mathrm{k}[\mathrm{i}+1] \ldots>\mathrm{k}[\operatorname{len}(\mathrm{k})-1] k[0]<k[1]<…<k[i−1]<k[j]>k[i+1]…>k[len(k)−1]
这个 i i i就是顶峰索引。
现在，给定一个山脉数组，求顶峰索引。
示例:
输入：[1, 3, 4, 5, 3]
输出：True
输入：[1, 2, 4, 6, 4, 5]
输出：False
答：
# 山脉数组
def MountainList(lst):
left = 0
right = len(lst) - 1
while left <= right: # 二分法找顶峰索引
mid = (left + right) // 2
if lst[mid] > lst[mid + 1] and lst[mid] > lst[mid - 1]: # 找到顶峰索引
midToMin = mid
midToMax = mid
while midToMin > 0:
if lst[midToMin] > lst[midToMin - 1]:
midToMin -= 1
else:
return False
while midToMax < len(lst) - 1:
if lst[midToMax] > lst[midToMax + 1]:
midToMax += 1
else:
return False
return True # 遍历结束，是山脉数组
elif lst[mid] < lst[mid - 1]:
right = mid - 1
elif lst[mid] < lst[mid + 1]:
left = mid + 1
lst1 = [1, 3, 4, 5, 3]
result = MountainList(lst1)
print(result)
lst2 = [1, 2, 4, 6, 4, 5]
result = MountainList(lst2)
print(result)
'''
输出结果：
True
False
'''元组（tuple)
- 元组 tuple
- 元组是一个不可变的序列
- 它的操作的方式基本上和列表是一致的
- 所以你在操作元组时，就把元组当成是一个不可变的列表就ok了
- 一般当我们希望数据不改变时，就使用元组，其余情况都使用列表
一.创建和访问一个元组
- Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
- 元组使用小括号，列表使用方括号。
- 元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
# 创建元组
# 使用()来创建元组
my_tuple = () # 创建了一个空元组
print(my_tuple,type(my_tuple)) # <class 'tuple'>
my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组
# 元组是不可变对象，不能尝试为元组中的元素重新赋值
my_tuple[3] = 10 # TypeError: 'tuple' object does not support item assignment
print(my_tuple[3]) # 4
# 当元组不是空元组时，括号可以省略
# 如果元组不是空元组，它里边至少要有一个,
my_tuple = 10,20,30,40
my_tuple = 40,
print(my_tuple , type(my_tuple)) # (40,) <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'>
# 创建一个二维数组
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))
print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python
print(x[0][0:2])
# (1, 10.31)二.更新和删除一个数组
元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
# 元组中的元素可更改
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[1] = 10
print(t1) # TypeError: 'tuple' object does not support item assignment
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])三. 元组相关的操作符
- 等号操作符：
== - 连接操作符
+ - 重复操作符
* - 成员关系操作符
in、not in
# == 只有成员、成员位置都相同时才返回True
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)
print(t1 == t2) # False
print(t1 == t3) # True
# 元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
t4 = t1 + t2
print(t4) # (123, 456, 456, 123)
t5 = t3 * 3
print(t5) # (123, 456, 123, 456, 123, 456)
t3 *= 3
print(t3) # (123, 456, 123, 456, 123, 456)
print(123 in t3) # True
print(456 not in t3) # False四. 内置方法
count()
count(self,__value) 是记录在元组中value出现的次数
index()
index(self,__value: Any,start: int = ...,__stop: int = ...) 是找到value在元组的索引start、stop指的是查询元组的起始位置。
# 内置方法
t1 = (1, 2, 3, [4, 5, 6],4,6,3,2,1)
print(t1.count(3)) # 2
# index()是在元组中顺序查询，且查询到第一个符合条件元素的位置时即停止
print(t1.index(3)) # 2
print(t1.index(3,3)) # 6index()是在元组中顺序查询，且查询到第一个符合条件元素的位置时即停止，所以才需start和stop两个参数来划清查询的范围。
五. 解压元组
一般我们也称之为元组的解包或者解构：
- 解包指就是将元组当中每一个元素都赋值给一个变量
- 解压（unpack）一维元组（有几个元素左边括号定义几个变量）
- 解压二维元组（按照元组里的元组结构来定义变量）
- 如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。
- 如果你根本不在乎通配符标识的变量，那么就用通配符「*」加上下划线「_」。
# 元组的解包（解构）
# 解包指就是将元组当中每一个元素都赋值给一个变量
my_tuple = 10 , 20 , 30 , 40
a,b,c,d = my_tuple
print("a =",a)
print("b =",b)
print("c =",c)
print("d =",d)
'''
a = 10
b = 20
c = 30
d = 40
'''
a = 100
b = 300
print(a , b) # 100 300
# 交互a 和 b的值，这时我们就可以利用元组的解包
a , b = b , a
print(a , b) # 300 100
my_tuple = 10 , 20 , 30 , 40
# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
a , b , *c = my_tuple
a , *b , c = my_tuple
'''
a = 10
b = [20, 30]
c = 40
'''
*a , b , c = my_tuple
'''
a = [10, 20]
b = 30
c = 40
'''
a , b , *c = [1,2,3,4,5,6,7]
'''
a = 1
b = 2
c = [3, 4, 5, 6, 7]
'''
a , b , *c = 'hello world'
a , b , *_ = 'hello world'
'''
a = h
b = e
c = ['l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
'''
# 不能同时出现两个或以上的*变量
# *a , *b , c = my_tuple SyntaxError: two starred expressions in assignment
print('a =',a)
print('b =',b)
print('c =',c)练习题
1、元组概念
写出下面代码的执行结果和最终结果的类型
(1, 2)*2
(1, )*2
(1)*2
分析为什么会出现这样的结果.
a = (1, 2)*2 # (1, 2, 1, 2) <class 'tuple'>
a = (1, )*2 # (1, 1) <class 'tuple'>
a = (1)*2 # 2 <class 'int'>
print(a,type(a))答： 1.（1，2）是一个元组，*为元组的重复操作符，即为将元组重复两次，输出结果仍为一个元组；
2.（1，）也是一个元组，且该元组中只有一个元素，*为元组的重复操作符，即为将元组重复两次，输出结果仍为一个元组；
3.（1）元素后无逗号隔开，不会当作是一个元组，（）被当作是运算符使用，即1*2，输出结果为一个整型数字。
2、拆包过程是什么？
a, b = 1, 2
上述过程属于拆包吗？
可迭代对象拆包时，怎么赋值给占位符？
答： 拆包过程是指利用一句赋值语句将元组当中每一个元素都赋值给一个变量。
上述过程属于拆包，1, 2已经定义了一个元组，与左边结构相对应，可以算作解压元组。
在可迭代对象拆包时，使用_(单个元素)，*_(连续多个元素)进行占位。
字符串(str)
一.字符串的定义
-
Python 中字符串被定义为引号之间的字符集合。
-
Python 支持使用成对的 单引号 或 双引号。
-
Python 的常用转义字符
| 转义字符 | 描述 |
|---|---|
\\ | 反斜杠符号 |
\' | 单引号 |
\" | 双引号 |
\n | 换行 |
\t | 横向制表符(TAB) |
\r | 回车 |
# 字符串(str)
# 字符串用来表示一段文本信息，字符串是程序中使用的最多的数据类型
# 在Python中字符串需要使用引号引起来
s = 'hello'
# s = abc # 字符串必须使用引号引起来，不使用不是字符串
# 引号可以是双引号，也可以是单引号，但是注意不要混着用
s = 'hello'
s = "hello"
# s = 'hello" 引号不能混合使用 SyntaxError: EOL while scanning string literal
# 相同的引号之间不能嵌套
# s = "子曰:"学而时习之，乐呵乐呵！""
s = '子曰:"学而时习之，乐呵乐呵！"'
# 长字符串
# 单引号和双引号不能跨行使用
s = '锄禾日当午，\
汗滴禾下土，\
谁知盘中餐，\
粒粒皆辛苦'
# 使用三重引号来表示一个长字符串 ''' """
# 三重引号可以换行，并且会保留字符串中的格式
s = '''锄禾日当午，
汗滴禾下土，
谁知盘中餐，
粒粒皆辛苦'''
# 转义字符
# 可以使用 \ 作为转义字符，通过转义字符，可以在字符串中使用一些特殊的内容
# 例子：
# \' 表示'
# \" 表示"
# \t 表示制表符
# \n 表示换行符
# \\ 表示反斜杠
# \uxxxx 表示Unicode编码
s = "子曰:\"学而时习之，\\\\n乐呵乐呵！\""
s = '\u2250'
print(s)注：
- 如果字符串中需要出现单引号或双引号，可以使用转义符号
\对字符串中的符号进行转义。 - 原始字符串只需要在字符串前边加一个英文字母 r 即可。
- 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
t1 = 'i love Python!'
print(t1, type(t1))
# i love Python! <class 'str'>
t2 = "I love Python!"
print(t2, type(t2))
# I love Python! <class 'str'>
print(5 + 8) # 13
print('5' + '8') # 58
print('let\'s go') # let's go
print("let's go") # let's go
print('C:\\now') # C:\now
print("C:\\Program Files\\Intel\\Wifi\\Help")
# C:\Program Files\Intel\Wifi\Help
print(r'C:\Program Files\Intel\Wifi\Help')
# C:\Program Files\Intel\Wifi\Help
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB ( )。
# 也可以使用换行符 [
# ]。
para_str = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB ( )。
# 也可以使用换行符 [
# ]。二.字符串的切片与拼接+
1.切片
- 类似于元组具有不可修改性
- 从 0 开始 (和 Java 一样)
- 切片通常写成
start:end这种形式，包括「start索引」对应的元素，不包括「end索引」对应的元素。 - 索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。
str1 = 'I Love LsgoGroup'
print(str1[:6]) # I Love
print(str1[5]) # e
print(str1[:6] + " 插入的字符串 " + str1[6:])
# I Love 插入的字符串 LsgoGroup
s = 'Python'
print(s) # Python
print(s[2:4]) # th
print(s[-5:-2]) # yth
print(s[2]) # t
print(s[-1]) # n2.拼接与复制
# 创建一个变量来保存你的名字
name = '孙悟空'
# 使用四种方式来输出，欢迎 xxx 光临
# 拼串
print('欢迎 '+name+' 光临！')
# 多个参数
print('欢迎',name,'光临！')
# 占位符
print('欢迎 %s 光临！'%name)
# 格式化字符串
print(f'欢迎 {name} 光临！')
# 字符串的复制（将字符串和数字相乘）
a = 'abc'
# * 在语言中表示乘法
# 如果将字符串和数字相乘，则解释器会将字符串重复指定的次数并返回
a = a * 20
print(a)
'''
欢迎 孙悟空 光临！
欢迎 孙悟空 光临！
欢迎 孙悟空 光临！
欢迎 孙悟空 光临！
abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc
'''三.字符串的常用内置方法
capitalize()将字符串的第一个字符转换为大写。
str2 = 'xiaoxie'
print(str2.capitalize()) # Xiaoxielower()转换字符串中所有大写字符为小写。upper()转换字符串中的小写字母为大写。swapcase()将字符串中大写转换为小写，小写转换为大写。
str2 = "DAXIExiaoxie"
print(str2.lower()) # daxiexiaoxie
print(str2.upper()) # DAXIEXIAOXIE
print(str2.swapcase()) # daxieXIAOXIEcount(str, beg= 0,end=len(string))返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。
str2 = "DAXIExiaoxie"
print(str2.count('xi')) # 2endswith(suffix, beg=0, end=len(string))检查字符串是否以指定子字符串suffix结束，如果是，返回 True，否则返回 False。如果beg和end指定值，则在指定范围内检查。startswith(substr, beg=0,end=len(string))检查字符串是否以指定子字符串substr开头，如果是，返回 True，否则返回 False。如果beg和end指定值，则在指定范围内检查。
str2 = "DAXIExiaoxie"
print(str2.endswith('ie')) # True
print(str2.endswith('xi')) # False
print(str2.startswith('Da')) # False
print(str2.startswith('DA')) # Truefind(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')) # 9isnumeric()如果字符串中只包含数字字符，则返回 True，否则返回 False。
str3 = '12345'
print(str3.isnumeric()) # True
str3 += 'a'
print(str3.isnumeric()) # Falseljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
str4 = '1101'
print(str4.ljust(8, '0')) # 11010000
print(str4.rjust(8, '0')) # 00001101lstrip([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次。
str5 = ' I Love LsgoGroup '
print(str5.strip().replace('I', 'We')) # We Love LsgoGroupsplit(str="", num)不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。
str5 = ' I Love LsgoGroup '
print(str5.strip().split()) # ['I', 'Love', 'LsgoGroup']
print(str5.strip().split('o')) # ['I L', 've Lsg', 'Gr', 'up']u = "www.baidu.com.cn"
# 使用默认分隔符
print(u.split()) # ['www.baidu.com.cn']
# 以"."为分隔符
print((u.split('.'))) # ['www', 'baidu', 'com', 'cn']
# 分割0次
print((u.split(".", 0))) # ['www.baidu.com.cn']
# 分割一次
print((u.split(".", 1))) # ['www', 'baidu.com.cn']
# 分割两次
print(u.split(".", 2)) # ['www', 'baidu', 'com.cn']
# 分割两次，并取序列为1的项
print((u.split(".", 2)[1])) # baidu
# 分割两次，并把分割后的三个部分保存到三个变量
u1, u2, u3 = u.split(".", 2)
print(u1) # www
print(u2) # baidu
print(u3) # com.cn- 去掉换行符
c = '''say
hello
baby'''
print(c)
# say
# hello
# baby
print(c.split('\n')) # ['say', 'hello', 'baby']string = "hello boy<[www.baidu.com]>byebye"
print(string.split('[')[1].split(']')[0]) # www.baidu.com
print(string.split('[')[1].split(']')[0].split('.')) # ['www', 'baidu', 'com']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!!!四.字符串格式化
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 字符串格式化符号
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串，用str()方法处理对象 |
| %r | 格式化字符串，用rper()方法处理对象 |
| %d | 格式化整数 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | 根据值的大小决定使用%f或%e |
| %G | 作用同%g，根据值的大小决定使用%f或%E |
print('%c' % 97) # a
print('%c %c %c' % (97, 98, 99)) # a b c
print('%d + %d = %d' % (4, 5, 9)) # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 我叫 小明 今年 10 岁!
print('%o' % 10) # 12
print('%x' % 10) # a
print('%X' % 10) # A
print('%f' % 27.658) # 27.658000
print('%e' % 27.658) # 2.765800e+01
print('%E' % 27.658) # 2.765800E+01
print('%g' % 27.658) # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text) # I said: I am 22 years old..
print("I said: %r." % text) # I said: 'I am 22 years old.'- 格式化操作符辅助指令
| 符号 | 功能 |
|---|---|
m.n | m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话） |
- | 用作左对齐 |
+ | 在正数前面显示加号( + ) |
# | 在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) |
0 | 显示的数字前面填充’0’而不是默认的空格 |
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- 练习
# 格式化字符串
a = 'hello'
# 字符串之间也可以进行加法运算
# 如果将两个字符串进行相加，则会自动将两个字符串拼接为一个
a = 'abc' + 'haha' + '哈哈'
# a = 123
# 字符串只能不能和其他的类型进行加法运算，如果做了会出现异常 TypeError: must be str, not int
# print("a = "+a) # 这种写法在Python中不常见
a = 123
# print('a =',a)
# 在创建字符串时，可以在字符串中指定占位符
# %s 在字符串中表示任意字符
# %f 浮点数占位符
# %d 整数占位符
b = 'Hello %s'%'孙悟空'
b = 'hello %s 你好 %s'%('tom','孙悟空')
b = 'hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3-5之间
b = 'hello %s'%123.456
b = 'hello %.2f'%123.456
b = 'hello %d'%123.95
b = '呵呵'
# print('a = %s'%a)
# 格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串
# 在格式化字符串中可以直接嵌入变量
c = f'hello {a} {b}'
print(f'a = {a}')五.练习题：
1、字符串函数回顾
-
怎么批量替换字符串中的元素？
答：
b = "I think I like it" print(b.replace('I','We')) # We think We like it -
怎么把字符串按照空格进⾏拆分？
答：
b = 'Hello %s'%'孙悟空' print(b.split()) # ['Hello', '孙悟空'] -
怎么去除字符串⾸位的空格？
答：
b = ' Hello %s'%'孙悟空' print(b.lstrip()) # Hello 孙悟空
2、实现isdigit函数
题目要求
实现函数isdigit， 判断字符串里是否只包含数字0~9
答：
def isdigit(string):
if string.isnumeric():
return True
else:
return False
num = str(input("请输入一段字符："))
print(isdigit(num))
'''
请输入一段字符：123456
True
请输入一段字符：asd12
False
'''3、leetcode 5题 最长回文子串
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例:
输入: “babad”
输出: “bab”
输入: “cbbd”
输出: “bb”
答：
def findString(string):
result = ''
flag = False
if string == string[::-1]:
result = string
else:
current = len(string) - 1
while current > 0:
for i in range(len(string) - current + 1):
tmp = string[i:i + current]
if tmp == tmp[::-1]:
result = tmp
flag = True
break
if flag:
break
current -= 1
return result
a = str(input("请输入一串字符："))
print(findString(a))
'''
请输入一串字符：babad
bab
请输入一串字符：cbbd
bb
'''
扫一扫
2130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
