列表、元组和字符串

一、列表

一、列表
简单的数据类型：整形int浮点型float布尔型bool
容器数据类型：列表list元组tuple字典dict集合set字符串str

1、列表的定义

列表是有序集合，没有固定大小，能够保存任意数量任意类型的Python对象，语法为[元素1，元素2，…，元素n]
关键点是[]和,
[]把所有元素绑在一起
, 将每个元素一一分开

2、列表的创建

##1)创建一个普通列表
x=['Monday','Tuesday','Wednesday','Thursday','Friday']
print(x,type(x))

x = [2,3,4,5,6,7]
print(x,type(x))

##2）利用range()创建列表
x = list(range(10))
print(x,type(x))

x=list(range(1,11,2))
print(x,type(x))

x = list(range(10,1,-2))
print(x, type(x))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
[1, 3, 5, 7, 9] <class 'list'>
[10, 8, 6, 4, 2] <class 'list'>

## 3)利用推导式创建列表
x= [0]*5
print(x,type(x))

x = [0 for i in range(5)]
print(x,type(x))

x = [i for i in range(10)]
print(x,type(x))

x = [i for i in range(1,10,2)]
print(x,type(x))

x = [i for i in range(10,1,-2)]
print(x,type(x))

x = [i ** 2 for i in range(1,10)]
print(x,type(x))

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x,type(x))

[0, 0, 0, 0, 0] <class 'list'>
[0, 0, 0, 0, 0] <class 'list'>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
[1, 3, 5, 7, 9] <class 'list'>
[10, 8, 6, 4, 2] <class 'list'>
[1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'>
[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'list'>

#创建一个4*3的二位数组
x = [[1,2,3],[4,5,6],[7,8,9],[0,0,0]]
print(x,type(x))

for i in x:
    print(i, type(i))
    
x = [[0 for col in range(3)] for row in range(4)]
print(x,type(x))

x[0][0] = 1
print(x,type(x))

x = [[0]* 3 for row in range(4)]
print(x,type(x))

x[1][1] = 1
print(x,type(x))

'''
由于LIst的元素可以是任何对象，因此list中保存的是对象的指针。
即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象

x=[a]*4操作中，只是创建4个指向List的引用，所以一旦a改变，x中4个a也会随之改变
'''

[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] <class 'list'>
[1, 2, 3] <class 'list'>
[4, 5, 6] <class 'list'>
[7, 8, 9] <class 'list'>
[0, 0, 0] <class 'list'>
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
[[1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
[[0, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x = [[0] * 3]*4
print(x,type(x))

x[0][0] = 1
print(x,type(x))

a = [0]*3
x = [a]*4
print(x,type(x))

x[0][0] = 1
print(x,type(x))

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

#创建一个混合列表
mix = [1, 'lsgo',3.14,[1,2,3]]
print(mix,type(mix))

[1, 'lsgo', 3.14, [1, 2, 3]] <class 'list'>

#创建一个空列表
empty = []
print(empty, type(empty))

[] <class 'list'>

3.向列表中添加元素

#列表不像元组，列表内容可更改mutable,因此附加(append,extend)、插入(insert)、删除(remove,pop)

#list.append(obj)在List末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在list中保持原结构类型
x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
x.append('Thursday')
print(x)
print(len(x))

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
6

#如果添加元素是list，那么这个List将作为一个整体进行追加。
x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
x.append(['Thursday','Sunday'])
print(x)
print(len(x))

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
6

#list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展苑来的列表)
x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
x.extend(['Thursday','Sunday'])
print(x)
print(len(x))

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
7

#append是追加，把一个东西整体添加在list后，extend是扩展，是把一个东西所有元素添加在列表后
#list.insert(index,obj)在编号index位置插入Obj

x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
x.insert(2,'Sunday')
print(x)
print(len(x))

['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
6

4.删除列表中的元素

##1）list.remove(obj) 移除列表中某个值的第一个匹配项

x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
x.remove('Monday')
print(x)

['Tuesday', 'Wednesday', 'Thursday', 'Friday']

##2） list.pop([index=-1])移除列表中的一个元素（默认最后一个元素),并且返回该元素的值
x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
y = x.pop()
print(y)

y = x.pop(0)
print(y)
print(x)

y = x.pop(-2)
print(y)
print(x)

#remove和pop都可以删除元素，前者是指定具体要删的元素，后者是指定一个索引

Friday
Monday
['Tuesday', 'Wednesday', 'Thursday']
Wednesday
['Tuesday', 'Thursday']

##3） del var1[,var2...]删除单个或多个对象，适用于知道要删除的元素在列表中的位置
x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
del x[0:2]
print(x)

#如果要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句
#如果要在删除元素后还能继续使用它， 就使用pop()

['Wednesday', 'Thursday', 'Friday']

5、获取列表中的元素

通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的
通过将索引指定为-1，可让Python返回最后一个列表元素，索引-2返回倒数第二个列表元素，以此类推

x = ['Monday','Tuesday','Wednesday',['Thursday','Friday']]
print(x[0],type(x[0]))
print(x[-1],type(x[-1]))
print(x[-2],type(x[-2]))

Monday <class 'str'>
['Thursday', 'Friday'] <class 'list'>
Wednesday <class 'str'>

#切片的通用写法是 start:stop:step
##1)  start:    从start往List尾部切片
x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(x[3:])
print(x[-3:])

['Thursday', 'Friday']
['Wednesday', 'Thursday', 'Friday']

##2)  ：stop  从list头部往stop切片
x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(x[:3])
print(x[:-3])

['Monday', 'Tuesday', 'Wednesday']
['Monday', 'Tuesday']

##3) start:stop  start往stop切片
week = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(week[1:3])
print(week[-3:-1])

['Tuesday', 'Wednesday']
['Wednesday', 'Thursday']

##4) start:stop:step   
week = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(week[1:4:2])
print(week[:4:2])
print(week[1::2])
print(week[::-1])  #step=-1相当于将列表反向排列

['Tuesday', 'Thursday']
['Monday', 'Wednesday']
['Tuesday', 'Thursday']
['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']

##5） :  复制列表中的所有元素（浅拷贝）
week = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(week[:])

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

#浅拷贝与深拷贝
list1 = [123,456,789,213]
list2 = list1
list3 = list1[:]

print(list2)
print(list3)
list1.sort()
print(list2)
print(list3)

list1 = [[123,456],[789,213]]
list2 = list1
list3 = list1[:]
print(list2)
print(list3)
list1[0][0] = 111
print(list2)
print(list3)

[123, 456, 789, 213]
[123, 456, 789, 213]
[123, 213, 456, 789]
[123, 456, 789, 213]
[[123, 456], [789, 213]]
[[123, 456], [789, 213]]
[[111, 456], [789, 213]]
[[111, 456], [789, 213]]

6) 列表的常用操作符

等号操作符 ==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
[等号==]，只有成员、成员位置都相同时才返回True
列表拼接有两种方式，用加号+和乘号*，前者首位拼接，后者复制拼接

list1 = [123,456]
list2 = [456,123]
list3 = [123,456]

print(list1 == list2)
print(list1 == list3)

list4 = list1 + list2
print(list4)

list5 = list3 * 3
print(list5)

list3 *= 3
print(list3)

print(123 in list3)
print(456 not in list3)

False
True
[123, 456, 456, 123]
[123, 456, 123, 456, 123, 456]
[123, 456, 123, 456, 123, 456]
True
False

'''
append extend insert 可对列表增加元素，没有返回值，直接修改元数据对象
将两个List相加，需要创建新的List对象，从而需要消耗额外的内存，因此list较大时尽量不要使用+添加list
'''

7、列表的其他方法

##1) list.count(obj) 统计某个元素在List中出现的次数
list1 = [123,456]*3
print(list1)
num = list1.count(123)
print(num)

[123, 456, 123, 456, 123, 456]
3

##？2) list.index(x[, start[,end]])从列表中找出某个值第一个匹配项的索引位置
list1 = [123,456] * 5
print(list1.index(123))
print(list1.index(123,1))
print(list1.index(123,3,7))

0
2
4

## 3）list.reverse() 反向列表中元素
x = [123,456,789]
x.reverse()
print(x)

[789, 456, 123]

## 4) list.sort(key=None, reverse=False) 对源列表进行排序
'''
   key   主要是用来继续宁比较的元素，只有一个参数
         具体的函数的参数就是取自于可迭代对象中，指定一可迭代对象中的一个元素来进行排序
   reverse  排序规则 reverse = True降序，reverse = False 升序(默认)
   该方法没有返回值，但是会对列表的对象进行排序
'''

x = [123,456,789,213]
x.sort()
print(x)

x.sort(reverse=True)
print(x)

#获取列表的第二个元素
def takeSecond(elem):
    return elem[1]

x = [(2,2),(3,4),(4,1),(1,3)]
x.sort(key=takeSecond)
print(x)

x.sort(key=lambda a:a[0])
print(x)

[123, 213, 456, 789]
[789, 456, 213, 123]
[(4, 1), (2, 2), (1, 3), (3, 4)]
[(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的元素
翻转列表里的所有元素
对列表里的元素进行排序，从小到大一次，从大到小一次
2、修改列表
问题描述：
lst = [1, [4, 6], True]
请将列表里所有数字修改成原来的两倍
3、leetcode 852题 山脉数组的峰顶索引
如果一个数组k符合下面两个属性，则称之为山脉数组
数组的长度大于等于3
存在$i$，$i$ >0 且$i<\mathrm{len}(k)-1$， 使得$$\mathrm{k}[0]<\mathrm{k}[1]<\dots <\mathrm{k}[\mathrm{i}-1]<\mathrm{k}[\mathrm{j}]>\mathrm{k}[\mathrm{i}+1]\dots >\mathrm{k}[\mathrm{len}(\mathrm{k})-1]$$
这个$i$就是顶峰索引。
现在，给定一个山脉数组，求顶峰索引。
示例:
输入：[1, 3, 4, 5, 3]
输出：True
输入：[1, 2, 4, 6, 4, 5]
输出：False
class Solution:
def peakIndexInMountainArray(self, A: List[int]) -> int:

# your code here

二、元组

元组定义语法为（元素1，元素2，…元素N)
小括号把所有元素绑在一起
逗号将每个元素一一分开

1、创建和访问一个元组

Python的元组和列表类似，不同之处在于tuple被创建后不能对其修改，类似字符串
tuple使用(),list使用[]
tuple与List类似，也用整数来对它进行索引indexing和切片slicing

t1 = (1,10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1,type(t1))
print(t2,type(t2))
#创建元组可以用()，也可以不用，为了可读性建议用

tuple1 = (1,2,3,4,5,6,7,8)
print(tuple1[1])
print(tuple1[5:])
print(tuple1[:5])
tuple2 = tuple1[:]
print(tuple2)

(1, 10.31, 'python') <class 'tuple'>
(1, 10.31, 'python') <class 'tuple'>
2
(6, 7, 8)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5, 6, 7, 8)

#tuple中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当做运算符使用

x=(1)
print(type(x))
x=2,3,4,5
print(type(x))
x=[]
print(type(x))
x=()
print(type(x))
x=(1,)
print(type(x))

<class 'int'>
<class 'tuple'>
<class 'list'>
<class 'tuple'>
<class 'tuple'>

print(8 * (8))
print(8 * (8,))

64
(8, 8, 8, 8, 8, 8, 8, 8)

#创建二维元组  **
x = (1, 10.31, 'python'),('data',11)
print(x)

print(x[0])

print(x[0][0],x[0][1],x[0][2])

print(x[0][0:2])

((1, 10.31, 'python'), ('data', 11))
(1, 10.31, 'python')
1 10.31 python
(1, 10.31)

2、更新和删除一个元组

week = ('Monday','Tuesday','Thursday','Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week)

('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

#元组有不可更改immutable的性质，因此不能直接给元组的元素赋值
#但只要元组中的元素可更改mutable，那么可以直接更改其元素，这跟赋值其元素不同

t1=(1,2,3,[4,5,6])
print(t1)

t1[3][0]=9
print(t1)

(1, 2, 3, [4, 5, 6])
(1, 2, 3, [9, 5, 6])

3、元组相关的操作符

等号操作符 == 连接操作符 + 重复操作符 * 成员关系操作符 in、not in
[等号==]，只有成员、成员位置都相同时才返回True
元组拼接有两种方式，用加号+和乘号*，前者首位拼接，后者复制拼接

t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)

print(t1 == t2)
print(t1 == t3)

t4 = t1 + t2
print(t4)

t5 = t3 *3
print(t5)

t3 *= 3
print(t3)

print(123 in t3)
print(456 not in t3)

False
True
(123, 456, 456, 123)
(123, 456, 123, 456, 123, 456)
(123, 456, 123, 456, 123, 456)
True
False

4、内置方法

元组大小和内容都不可更改，因此只有count和index两种方法

t = (1, 10.31, 'python')
print(t.count('python'))  #count记录在tuple中该元素出现几次
print(t.index(10.31))     #index找到该元素在tuple的索引

1
1

5、解压元组

#解压unpack一维元组（有几个元素左边括号定义几个变量）
t = (1, 10.31, 'python')
(a,b,c) = t
print(a,b,c)

1 10.31 python

#unpack二维元组（按照元组里的元组结构来定义变量)
t=(1,10.31,('OK','python'))
(a,b,(c,d))=t
print(a,b,c,d)

1 10.31 OK python

#如果只想要tuple其中几个元素，用通配符*(wildcard),在计算机语言中代表一个或多个元素
t=1,2,3,4,5
a,b,*rest,c=t  #将多个元素丢给rest变量
print(a,b,c)
print(rest)

1 2 5
[3, 4]

#如果不在乎rest变量，就用通配符*加上下划线_
t = 1,2,3,4,5
a,b,*_ = t
print(a,b)

1 2

练习题

#1、元组概念
写出下面代码的执行结果和最终结果的类型
(1, 2)*2 #((1,2),(1,2))
(1, )*2 #(1,1)
(1)*2 #2

a=(1, 2)*2
b=(1, )*2
c=(1)*2

print(a)
print(b)
print(c)

(1, 2, 1, 2)
(1, 1)
2

2、拆包过程时什么？
a,b = 1,2
上述过程属于拆包吗？

可迭代对象拆包时，怎么赋值给占位符？

三 字符串

1 字符串的定义

Python中字符串被定义为引号之间的字符集合
Python支持承兑的’'或""

t1 = 'i love Python!'
print(t1,type(t1))

t2 = "I love Python"
print(t2, type(t2))

print(5+8)
print('5' + '8')

i love Python! <class 'str'>
I love Python <class 'str'>
13
58

#1) Python常用的转义字符
\ 反斜杠符号
’ 单引号
" 双引号
\n 换行
\t 横向制表符(TAB)
\r 回车

# 如果字符串中需要出现单引号或双引号，可以使用转义符号\
print('let\'s go')
print("let's go")
print('C:\\now')
print("C:\\Program Files\\Intel\\Wifi\\Help")

let's go
let's go
C:\now
C:\Program Files\Intel\Wifi\Help

# 原始字符串只需要在字符串前边加一个英文字母r即可
print(r'C:\Program Files\Intel\Wifi\Help')

C:\Program Files\Intel\Wifi\Help

# 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB( \t )。
也可以使用换行符[\n]。
"""

print(para_str)

para_str = '''这是一个多行字符串的实例
多行字符串可以使用子表夫
TAB(\t)。
也可以使用换行符[\n]。
'''
print(para_str)

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB( 	 )。
也可以使用换行符[
]。

这是一个多行字符串的实例
多行字符串可以使用子表夫
TAB(	)。
也可以使用换行符[
]。

2、字符串的切片与拼接

类似于tuple,具有不可修改行
从0开始(同Java)
切片通常携程start:end 的形式，包括start对应的元素，不包括end对应的元素
索引值可正可负，正索引从0开始，从左往右；
负索引从-1开始，从右往左
使用夫索引是，会从最后一个元素开始计数，最后一个元素的位置编号是-1

str1 = 'I Love LsgoGroup'
print(str1[:6])  #空格也占位
print(str1[5])
print(str1[:6] + " 插入的字符串 " + str1[6:])

s = 'Python'
print(s)
print(s[2:4])
print(s[-5:-2])
print(s[2])
print(s[-1])

I Love
e
I Love 插入的字符串  LsgoGroup
Python
th
yth
t
n

3、字符串的常用内置方法

#capitalize() 将str的第一个字符转换为大写
str2 = 'xiaoxie'
print(str2.capitalize())

Xiaoxie

#lower() 转换str中所有大写字符为小写
#upper() 转换str中所有小写字符为大写
#swapcase() 将字符串中大写转换为小写，小写转换为大写

str2 = "DAXIExiaoxie"
print(str2.lower())
print(str2.upper())
print(str2.swapcase())

daxiexiaoxie
DAXIEXIAOXIE
daxieXIAOXIE

#count(str, beg=-0,end=len(string)) 返回str在string里出现的次数
#如果beg或者end指定则返回指定范围内str出现的次数
str2 = "DAXIExiaoxie"
print(str2.count('xi'))

2

'''
endswith(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'))
print(str2.endswith('xi'))
print(str2.startswith('Da'))
print(str2.startswith('DA'))

True
False
False
True

'''
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'))
print(str2.find('ix'))
print(str2.rfind('xi'))

5
-1
9

#isnumeric() 如果字符串中只包含数字字符，则返回True，否则返回False
str3 = '12345'
print(str3.isnumeric())
str3 += 'a'
print(str3.isnumeric())

True
False

'''
ljust(width[,fillchar])返回一个原字符串左对齐，并使用fillchar(默认空格)填至长度width的新字符串
rjust(width[,fillchar])返回一个原字符串右对齐，并使用fillchar(默认空格)填充至长度width的新字符串
'''
str4 = '1101'
print(str4.ljust(8,'0'))
print(str4.rjust(8,'0'))

11010000
00001101

#lstrip([chars])截掉字符串左边的空格或指定字符
#rstrip([chars])删除字符串末尾的空格或指定字符
#strip([chars])在字符串上执行lstrip()和rstrip()
str5 = ' I Love LsgoGroup '
print(str5.lstrip())
print(str5.lstrip().strip('I'))
print(str5.rstrip())
print(str5.strip())
print(str5.strip().strip('p'))

I Love LsgoGroup 
 Love LsgoGroup 
 I Love LsgoGroup
I Love LsgoGroup
I Love LsgoGrou

str5 = ' I Love LsgoGroup '
#partition(sub)找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)
print(str5.strip().partition('o'))
print(str5.strip().partition('m')) #如果字符串中不包含sub则返回('源字符串','','')
#repartition(sub)类似于partition()方法，不过是从右边开始查找
print(str5.strip().rpartition('o'))

('I L', 'o', 've LsgoGroup')
('I Love LsgoGroup', '', '')
('I Love LsgoGr', 'o', 'up')