容器数据类型
- 列表`<class 'list'>`
- 元组`<class 'tuple'>`
- 字典`<class 'dict'>`
- 集合`<class 'set'>`
- 字符串`<class 'str'>`
· 列表
1、列表定义
-基本概念：列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象
-形式：[元素1, 元素2, ..., 元素n]
2、列表创建
1）创建普通列表
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday']
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))
-输出结果
3）利用推导式创建列表
x = [1] * 5
print(x, type(x))
x = [0 for i in range(5)]
print(x, type(x))
x = [i for i in range(1, 10, 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))
-输出结果
4）创建一个 4×3的二维数组
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]
print(x, type(x))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] <class 'list'>
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]] <class 'list'>
x[0][0] = 1（接上上面）
print(x, type(x))
# [[1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
**重点注意**
列表中所保存的是对象的指针
`x = [a] * 4`操作中，只是创建4个指向list的引用，所以一旦`a`改变，`x`中4个`a`也会随之改变。
*example
x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>
5）创建一个混合列表
mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))
6）创建一个空列表
empty = []
print(empty, type(empty))
3、列表的添加、删除及获取
1）添加
三种方式：append、extend、insert
i. list.append(obj)
在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
*example
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append('Thursday')
print(x)
-------------------------
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append([‘Thursday', ’Sunday‘])
print(x)
-输出结果
ii. list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
x=[1, 2, 3, 4, 5]
x.extend([7, 2, 9])
print(x)
-输出结果
**extend 和append的区别**
-`append` 是追加，把一个东西整体添加在列表后
整体添加
-`extend` 是扩展，把一个东西里的所有元素添加在列表后
逐个添加
iii. list.insert(index, obj)
在编号 `index` 位置插入 obj
*example
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
#输出结果
['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
2）删除
I、list.remove(obj)
移除列表中某个值的第一个匹配项（remove指定删除的值）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x)
-输出结果['Tuesday', 'Wednesday', 'Thursday', 'Friday']
ii、list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。（pop指定要删除的索引）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y)
-输出结果： Friday
y = x.pop(0)
print(y)
-输出结果：Monday
iii、del var1[, var2...]
删除单个或多个对象
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x)
-输出结果：['Wednesday', 'Thursday', 'Friday']
3）获取
通过索引取值，注意索引为-1表示返回列表最后一个元素，以此类推。
**切片通用写法：‘start：stop：step’**
·情况1 ：‘start：’
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:])
输出结果： ['Thursday', 'Friday'] 从索引为3的开始到最后
print(x[-3:])
输出结果： ['Wednesday', 'Thursday', 'Friday'] 从倒数第三个开始到最前
·情况2：‘：stop’
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3])
输出结果：['Monday', 'Tuesday', 'Wednesday'] 索引为3时的值为Thursday，注意不包含索引为stop时候的值
print(week[:-3])
输出结果： ['Monday', 'Tuesday']
·情况3：‘start：stop’
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3])
输出结果： ['Tuesday', 'Wednesday'] 以 `step` 为 1 (默认) 从编号1往编号 3切片（但是不包含索引为3的元素）
print(week[-3:-1])
输出结果：['Wednesday', 'Thursday']
·情况4： ‘start : stop : step’
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2])
输出结果： ['Tuesday', 'Thursday']
print(week[:4:2])
输出结果：['Monday', 'Wednesday'] start没有指定时，默认为从头开始
print(week[1::2])
输出结果：['Tuesday', 'Thursday'] stop没有指定时，默认为到最后一个元素
print(week[::-1])
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
`step` 设为 -1，相当于将列表反向排列
·情况5：‘：’ 复制列表中的 所有元素 （浅拷贝）
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])
输出结果：['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
**探讨浅拷贝与深拷贝**
-浅拷贝：增加了一个指针指向已存在的内存地址
-深拷贝：增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存
通俗来说 ：
假设B复制了A，修改A的时候，看B是否发生变化：
如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）
4、列表的常用操作符
归纳整理如图
总结如下
1）、比较操作符：>、<、==。
注意：列表比较大小的时候是从第一个元素开始比较，而不看列表长度，返回True或者False
2）、逻辑操作符：and、or、not等，可以加括号，也可以不加
3）、连接操作符：+
例如：通过‘+’可以将两个列表连接起来。将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
4）、重复操作符：‘*’ 复制
5）、成员关系操作符：in 和 not in
5、列表中的一些重点函数及方法
*课后练习及解答
1、列表lst 内容如下
lst = \[2, 5, 6, 7, 8, 9, 2, 9, 9]
请写程序完成下列操作：
·在列表的末尾增加元素15
·在列表的中间位置插入元素20
·将列表\[2, 5, 6]合并到lst中
·移除列表中索引为3的元素
·翻转列表里的所有元素
·对列表里的元素进行排序，从小到大一次，从大到小一次
解答如下：
注意排序可以用sorted()函数，设置reverse参数可以决定降序还是升序。
输出结果
2、修改列表
问题描述：
lst = \[1, \[4, 6], True]
请将列表里所有数字修改成原来的两倍
解答如下：
lst = [1, [4, 6], True]
for index, elem in enumerate(lst):
if isinstance(elem, list):
for index1, elem1 in enumerate(elem):
lst[index][index1] = elem1 * 2
elif isinstance(elem, bool):
pass
else:
lst[index] = elem * 2
print(lst)
·元组
1、元组的创建和访问
「元组」定义语法为：`(元素1, 元素2, ..., 元素n)`
**元组创建后不可修改，列表可修改
*元组也是用索引和切片来进行访问
*元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
x = (1)
print(type(x))
输出： <class 'int'>
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][0], x[0][1], x[0][2])
输出：1 10.31 python
2、元组的更新和删除
元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
t1 = (1, 2, 3, [4, 5, 6])
print(t1)
t1[3][0] = 9
print(t1)
输出：(1, 2, 3, [9, 5, 6])
3、相关操作符和方法
操作符
- 等号操作符：`==`
- 连接操作符 `+`
- 重复操作符 `*`
- 成员关系操作符 `in`、`not in`
方法
元组大小和内容都不可更改，因此只有 `count` 和 `index` 两种方法。
4、解压元组
**拆包**
拆包: 对于函数中的多个返回数据, 去掉元组, 列表 或者字典直接获取里面数据的过程
即拆包将一个结构中的数据拆分为多个单独变量
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
输出结果：1 10.31 OK python
通配符 * ：在计算机语言中代表一个或多个元素
如图所示举例：
*课后练习及解答
1、元组概念
写出下面代码的执行结果和最终结果的类型
(1, 2)*2
(1, )*2
(1)*2
分析为什么会出现这样的结果.
解答如下：
输出结果如图所示
第一个是包含1和2两个元素的元组，执行复制拼接操作，所以结果为（1，2，1，2）
第二个是包含1这一个元素的元组，执行复制拼接操作
第三个（1）并不是一个元组，而是整型数字1，执行乘法操作，所以结果为2
2、拆包过程是什么？
a, b = 1, 2
上述过程属于拆包吗？
可迭代对象拆包时，怎么赋值给占位符？
解答如下
1）拆包过程：将一个结构中的数据拆分为多个单独变量
2）属于，左边1,2就形成了元组（1，2）。
3）在可迭代对象拆包时，使用_(单个元素)，*_(连续多个元素)进行占位
· 字符串
1 基本概念
1.1 基本定义
- Python 中字符串被定义为引号之间的字符集合。
- Python 支持使用成对的 单引号 或 双引号：‘I love Jackson’ “I love you”
-三引号允许一个字符串跨多行：“”” “””、 ‘’‘ ’‘’‘
*example
para_str = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print(para_str)
输出：这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
1.2 常用转义字符
2 切片与拼接
**切片通常写成 `start : end` 这种形式**
str1 = 'I Love LsgoGroup'
print(str1[5])
输出： e
print(str1[:6] + " 插入的字符串 " + str1[6:])
输出：I Love 插入的字符串 LsgoGroup
3 常用内置方法
3.1 有关大小写转换
a = “gaoqi love programming, loveSXT”
3.2 常用的查找方法
a=’’‘我是高兴,今年 18 岁了,我在北京尚学堂科技上班。我的儿子叫高洛希，他 6 岁了。我是一个编程教育的普及者，希望影响 6000 万学习编程的中国人。我儿子现在也开始学习编程，希望他 18 岁的时候可以超过我’’’
count、startwith、endwith、find、rfind这几个方法可以有三个参数，大同小异。
以count为例：count(str, beg= 0,end=len(string))返回`str`在 string 里面出现的次数，如果`beg`或者`end`指定则返回指定范围内`str`出现的次数。
3.3 字符串的填充与删除
a='1101'
b=' I love Jackson'
Python中strip用于去除字符串首尾字符，同理，lstrip用于去除左边的字符，rstrip用于去除右边的字符。
*注意：
输出结果：yes no
解释：testString依次被去除首尾在['s','a','y']数组内的字符，直到剩余字符不再数组内。所以输出yes no。
4 字符串格式化
4.1 字符串格式化符号
4.2 格式化操作符辅助指令
*课后练习及解答
1、字符串函数回顾
- 怎么批量替换字符串中的元素？ 使用replace函数替换
- 怎么把字符串按照空格进⾏拆分？ 使用string.split()实现
- 怎么去除字符串⾸位的空格？ 使用string.lstrip()实现
2、实现isdigit函数
题目要求：实现函数isdigit， 判断字符串里是否只包含数字0\~9
解答如下：
def isdigit(string):
"""
判断字符串只包含数字
:param string:
:return:
"""
# your code here
flag = True if string.isnumeric() else False
return flag
a = input("请输入：")
flag = isdigit(a)
print(flag)
3、leetcode 5题 最长回文子串
给定一个字符串 `s`，找到 `s` 中最长的回文子串。你可以假设 `s` 的最大长度为 1000。
解答如下：
class Solution:
def longestPalindrome(self, s: str) -> str:
l = len(s)
maxlength = 0
maxstr = ''
for i in range(l):
for j in range(i+1,l+1):
temp =s[i:j]
if temp == temp[::-1] and j-i > maxlength:
maxstr = s[i:j]
maxlength = j-i
return maxstr
