目录
一、Python解释器
解释器的作用：
下载Python解释器：
安装Python解释器：
二、注释
三、变量
定义变量：
标识符：
命名习惯：
变量使用：
变量的数据类型：
四、输出
格式化输出
格式化符号：
转义字符
结束符
五、输入
输⼊的语法：
六、转换数据类型
转换数据类型的作⽤
转换数据类型的函数
七、运算符
分类：
算数运算符：
赋值运算符：
复合赋值运算符
⽐较运算符
逻辑运算符
拓展
[八、if 语法](#八、if 语法)
if...else...
多重判断的语法
if嵌套
九、三目运算符
十、循环
while的语法
for循环
else
十一、break和continue
十二、字符串
字符串特征
字符串输出
字符串输⼊
下标：
切片：
常⽤操作⽅法
判断
十三、元组
元组的常⻅操作
十四、列表
列表的格式
列表的常⽤操作
一、Python解释器
解释器的作用：
Python解释器作⽤：运⾏⽂件，通俗的来说，就是将程序员写的代码能让计算机看懂，翻译成计算机能够识别的01流
Python解释器种类：
CPython，C语⾔开发的解释器[官⽅]，应⽤⼴泛的解释器。
IPython，基于CPython的⼀种交互式解释器。
其他解释器
PyPy，基于Python语⾔开发的解释器。
Jython，运⾏在Java平台的解释器，直接把Python代码编译成Java字节码执⾏。
IronPython，运⾏在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
下载Python解释器：
下载地址：Python Release Python 3.7.2 | Python.org
单击上述链接\] -- 查找⽬标⽂件：Windows x86-64 executable installer -- 单击即可下载。
#### 安装Python解释器：
双击可执⾏⽂件 --- 勾选\[pip\] -- \[Next\] -- \[勾选添加环境变量\] -- \[Install\]，按提示操作即可。
### 二、注释
通过⽤⾃⼰熟悉的语⾔，在程序中对某些代码进⾏标注说明，这就是注释的作⽤，能够⼤⼤增强程序的可读性。
注释分为两类：单⾏注释 和 多⾏注释。
单⾏注释
只能注释⼀⾏内容，语法如下：
```python
# 注释内容
```
多⾏注释
可以注释多⾏内容，⼀般⽤在注释⼀段代码的情况， 语法如下：
```python
# 输出函数
print("123")
# 注释不影响程序的执行结果
# 单行注释
print("123")
"""
多行注释
多行注释
"""
print("123")
'''
多行注释
多行注释
'''
print("123")
```
### 三、变量
程序中，数据都是临时存储在内存中，为了更快速的查找或使⽤这个数据，通常我们把这个数据在内存中存储之后定义⼀个名称，这个名称就是变量。
#### 定义变量：
```python
变量名 = 值
```
变量名⾃定义，要满⾜标识符命名规则。
#### 标识符：
标识符命名规则是Python中定义各种名字的时候的统⼀规范，具体如下：
*
*
*
* 由数字、字⺟、下划线组成
* 不能数字开头
* 不能使⽤内置关键字
* 严格区分⼤⼩写
#### 命名习惯：
*
*
* ⻅名知义。
* ⼤驼峰：即每个单词⾸字⺟都⼤写，例如： MyName 。
* ⼩驼峰：第⼆个（含）以后的单词⾸字⺟⼤写，例如： myName 。
* 下划线：例如： my_name 。
#### **变量使用：**
```python
# 定义变量
a = 0
print(a)
# 定义变量：存储数据TOM
my_name = 'TOM'
print(my_name)
# 定义变量：原神启动！
name = '原神启动！'
print(name)
```
#### 变量的数据类型：
在 Python ⾥为了应对不同的业务需求，也把数据分为不同的类型。
检测数据类型的⽅法： type()
```python
# 检测数据类型 type()函数
num1 = 1
num2 = 1.1
a = 'Hello World'
b = True
c = [1,2,3] # 列表数据类型list
d = (10,20,30) # 元组数据类型tuple
e = {10,20,30} # 集合数据类型set
f = {'name':'TOM',
'age':18} # 字典数据类型dict
print(type(num1))
print(type(num2))
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))
print(type(f))
```
### 四、输出
#### 格式化输出
所谓的格式化输出即按照⼀定的格式输出内容。
#### 格式化符号：
常用：
%06d，表示输出的整数显示位数，不⾜以0补全，超出当前位数则原样输出。
%.2f，表示⼩数点后显示的⼩数位数。
格式化字符串除了%s，还可以写为 f'{表达式}'
```python
age = 18
name = 'TOM'
weight = 75.5
student_id = 1
# 我的名字是TOM
print('我的名字是%s' % name)
# 我的学号是0001
print('我的学号是%4d' % student_id)
# 我的体重是75.50公⽄
print('我的体重是%.2f公⽄' % weight)
# 我的名字是TOM，今年18岁了
print('我的名字是%s，今年%d岁了' % (name, age))
# 我的名字是TOM，明年19岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))
# 我的名字是TOM，明年19岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')
```
f-格式化字符串是Python3.6中新增的格式化⽅法，该⽅法更简单易读。
#### 转义字符
\\n ：换⾏。
\\t ：制表符，⼀个tab键（4个空格）的距离。
#### 结束符
想⼀想，为什么两个print会换⾏输出？
```python
print('输出的内容', end="\n")
```
在Python中，print()， 默认⾃带 end="\\n" 这个换⾏结束符，所以导致每两个 print 直接会换⾏展示，⽤户可以按需求更改结束符。
### 五、输入
程序接收⽤户输⼊的数据的功能即是输⼊。
#### 输⼊的语法：
```python
input("提示信息")
```
输⼊的特点：
*
*
* 当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。
* 在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。
* 在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理。
```python
password = input('请输⼊您的密码：')
print(f'您输⼊的密码是{password}')
#
print(type(password))
```
### 六、转换数据类型
#### 转换数据类型的作⽤
问：input()接收⽤户输⼊的数据都是字符串类型，如果⽤户输⼊1，想得到整型该如何操作？
答：转换数据类型即可，即将字符串类型转换成整型。
#### 转换数据类型的函数
```python
# 1. float() -- 转换成浮点型
num1 = 1
print(float(num1))
print(type(float(num1)))
# 2. str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))
# 3. tuple() -- 将⼀个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))
# 4. list() -- 将⼀个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))
# 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))
```
### 七、运算符
#### 分类：
*
* 算数运算符
* 赋值运算符
* 复合赋值运算符
* ⽐较运算符
* 逻辑运算符
#### 算数运算符：
注意：
混合运算优先级顺序： () ⾼于 \*\* ⾼于 \* / // % ⾼于 + -
#### 赋值运算符：
单个变量赋值：
```python
num = 1
print(num)
```
多个变量赋值：
```python
num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)
```
多变量赋相同值：
```python
a = b = 10
print(a)
print(b)
```
#### 复合赋值运算符
```python
a = 100
a += 1
# 输出101 a = a + 1,最终a = 100 + 1
print(a)
b = 2
b *= 3
# 输出6 b = b * 3,最终b = 2 * 3
print(b)
c = 10
c += 1 + 2
# 输出13, 先算运算符右侧1 + 2 = 3， c += 3 , 推导出c = 10 + 3
print(c)
```
#### ⽐较运算符
⽐较运算符也叫关系运算符， 通常⽤来判断。
```python
a = 7
b = 5
print(a == b) # False
print(a != b) # True
print(a < b) # False
print(a > b) # True
print(a <= b) # False
print(a >= b) # True
```
#### 逻辑运算符
```python
a = 1
b = 2
c = 3
print((a < b) and (b < c)) # True
print((a > b) and (b < c)) # False
print((a > b) or (b < c)) # True
print(not (a > b)) # True
```
#### 拓展
数字之间的逻辑运算
```python
a = 0
b = 1
c = 2
# and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个⾮0数字
print(a and b) # 0
print(b and a) # 0
print(a and c) # 0
print(c and a) # 0
print(b and c) # 2
print(c and b) # 1
# or运算符，只有所有值为0结果才为0，否则结果为第⼀个⾮0数字
print(a or b) # 1
print(a or c) # 2
print(b or c) # 1
```
### 八、if 语法
语法：
```python
if 条件:
条件成⽴执⾏的代码1
条件成⽴执⾏的代码2
......
```
#### if...else...
作⽤：条件成⽴执⾏if下⽅的代码; 条件不成⽴执⾏else下⽅的代码。
```python
if 条件:
条件成⽴执⾏的代码1
条件成⽴执⾏的代码2
......
else:
条件不成⽴执⾏的代码1
条件不成⽴执⾏的代码2
......
```
#### 多重判断的语法
```python
if 条件1:
条件1成⽴执⾏的代码1
条件1成⽴执⾏的代码2
......
elif 条件2：
条件2成⽴执⾏的代码1
条件2成⽴执⾏的代码2
......
......
else:
以上条件都不成⽴执⾏执⾏的代码
```
多重判断也可以和else配合使⽤。⼀般else放到整个if语句的最后，表示以上条件都不成⽴的时候执⾏的代码。
#### if嵌套
```python
if 条件1：
条件1成⽴执⾏的代码
条件1成⽴执⾏的代码
if 条件2：
条件2成⽴执⾏的代码
条件2成⽴执⾏的代码
```
注意：条件2的if也是出于条件1的缩进关系内部。
### 九、三目运算符
三⽬运算符也叫三元运算符或三元表达式。
语法如下：
```python
条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式
```
例如：
```python
a = 1
b = 2
c = a if a > b else b
print(c)
```
### 十、循环
循环分为 while 和 for 两种，最终实现效果相同。
#### while的语法
```python
while 条件:
条件成⽴重复执⾏的代码1
条件成⽴重复执⾏的代码2
......
```
例如：计算1-100累加和
```python
i = 1
result = 0
while i <= 100:
result += i
i += 1
# 输出5050
print(result)
```
#### for循环
```python
for 临时变量 in 序列:
重复执⾏的代码1
重复执⾏的代码2
......
```
例如：
```python
str1 = 'it'
for i in str1:
print(i)
```
#### else
循环可以和else配合使⽤，else下⽅缩进的代码指的是当循环正常结束之后要执⾏的代码。
while...else：
```python
while 条件:
条件成⽴重复执⾏的代码
else:
循环正常结束之后要执⾏的代码
```
for...else
```python
for 临时变量 in 序列:
重复执⾏的代码
...
else:
循环正常结束之后要执⾏的代码
```
所谓else指的是循环正常结束之后要执⾏的代码，即如果是break终⽌循环的情况，else下⽅缩进的代码将不执⾏。
### 十一、break和continue
break和continue是循环中满⾜⼀定条件退出循环的两种不同⽅式。
举例：⼀共吃5个苹果，吃完第⼀个，吃第⼆个...，这⾥"吃苹果"的动作是不是重复执⾏？
情况⼀：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作停⽌，这⾥就是break控制循环流程，即终⽌此循环。
情况⼆：如果吃的过程中，吃到第三个吃出⼀个⼤⾍⼦...,是不是这个苹果就不吃了，开始吃第四个苹果，这⾥就是continue控制循环流程，即退出当前⼀次循环继⽽执⾏下⼀次循环代码。
使用break后，不会执行else中的内容，使用continue，循环结束以后，仍然会执行。
### 十二、字符串
字符串是 Python 中最常⽤的数据类型。我们⼀般使⽤引号来创建字符串。创建字符串很简单，只要为变量分配⼀个值即可。
```python
a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))
```
注意：控制台显示结果为 ， 即数据类型为str(字符串)。
#### 字符串特征
⼀对引号字符串
```python
name1 = 'Tom'
name2 = "Rose"
```
三引号字符串
```python
name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom,
nice to meet you! '''
b = """ i am Rose,
nice to meet you! """
```
注意：三引号形式的字符串⽀持换⾏。
思考：如果创建⼀个字符串 I'm Tom ?
```python
c = "I'm Tom"
d = 'I\'m Tom'
```
#### 字符串输出
```python
print('hello world')
name = 'Tom'
print('我的名字是%s' % name)
print(f'我的名字是{name}')
```
#### 字符串输⼊
在Python中，使⽤ input() 接收⽤户输⼊。
```python
name = input('请输⼊您的名字：')
print(f'您输⼊的名字是{name}')
print(type(name))
password = input('请输⼊您的密码：')
print(f'您输⼊的密码是{password}')
print(type(password))
```
#### 下标：
"下标" ⼜叫 "索引" ，就是编号。⽐如⽕⻋座位号，座位号的作⽤：按照编号快速找到对应的座位。同理，下标的作⽤即是通过下标快速找到对应的数据。
字符串 name = "abcdef" ，取到不同下标对应的数据。
```python
name = "abcdef"
print(name[1])
print(name[0])
print(name[2])
```
注意：下标从0开始。
#### 切片：
切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作。
语法：
```python
序列[开始位置下标:结束位置下标:步⻓]
```
注意
1. 不包含结束位置下标对应的数据， 正负整数均可；
2. 步⻓是选取间隔，正负整数均可，默认步⻓为1。
```python
name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 负1表示倒数第⼀个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba
```
#### 常⽤操作⽅法
字符串的常⽤操作⽅法有查找、修改和判断三⼤类。
查找：
所谓字符串查找⽅法即是查找⼦串在字符串中的位置或出现的次数。
find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。
```python
字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
```
```python
mystr = "hello world and Python"
print(mystr.find('and')) # 12
print(mystr.find('and', 15, 30)) # 23
print(mystr.find('ands')) # -1
```
index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。
```python
字符串序列.index(⼦串, 开始位置下标, 结束位置下标)
```
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
```python
mystr = "hello world and Python"
print(mystr.index('and')) # 12
print(mystr.index('and', 15, 30)) # 23
print(mystr.index('ands')) # 报错
```
rfind()： 和find()功能相同，但查找⽅向为右侧开始。
rindex()：和index()功能相同，但查找⽅向为右侧开始。
count()：返回某个⼦串在字符串中出现的次数。
replace()：替换
```python
字符串序列.replace(旧⼦串, 新⼦串, 替换次数)
```
注意：替换次数如果查出⼦串出现次数，则替换次数为该⼦串出现次数。
```python
mystr = "hello world and Python"
# 结果：hello world he Python
print(mystr.replace('and', 'he'))
# 结果：hello world he Python
print(mystr.replace('and', 'he', 10))
# 结果：hello world and Python
print(mystr)
```
注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。
split()：按照指定字符分割字符串。
```python
字符串序列.split(分割字符, num)
```
注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。
```python
mystr = "hello world and Python"
# 结果：['hello world ',' Python']
print(mystr.split('and'))
# 结果：['hello world ',' itheima and Python']
print(mystr.split('and', 2))
# 结果：['hello', 'world', 'and','Python']
print(mystr.split(' '))
# 结果：['hello', 'world', 'and Python']
print(mystr.split(' ', 2))
```
注意：如果分割字符是原有字符串中的⼦串，分割后则丢失该⼦串。
join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。
```python
字符或⼦串.join(多字符串组成的序列)
```
```python
list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果：chuan_zhi_bo_ke
print('_'.join(list1))
# 结果：aa...b...cc...ddd
print('...'.join(t1))
```
capitalize()：将字符串第⼀个字符转换成⼤写。
```python
mystr = "hello world and Python"
# 结果：Hello world python
print(mystr.capitalize())
```
注意：capitalize()函数转换后，只字符串第⼀个字符⼤写，其他的字符全都⼩写。
title()：将字符串每个单词⾸字⺟转换成⼤写。
```python
mystr = "hello world and Python"
# 结果：Hello World And Python
print(mystr.title())
```
lower()：将字符串中⼤写转⼩写。
```python
mystr = "hello world and Python"
# 结果：hello world and python
print(mystr.lower())
```
upper()：将字符串中⼩写转⼤写。
```python
mystr = "hello world and Python"
# 结果：HELLO WORLD AND PYTHON
print(mystr.upper())
```
lstrip()：删除字符串左侧空⽩字符。
rstrip()：删除字符串右侧空⽩字符。
strip()：删除字符串两侧空⽩字符。
ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串。
```python
字符串序列.ljust(⻓度, 填充字符)
```
rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。
center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。
#### 判断
所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。
startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
```python
字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
```
```python
mystr = "hello world and Python "
# 结果：True
print(mystr.startswith('hello'))
# 结果False
print(mystr.startswith('hello', 5, 20))
```
endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
```python
字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标)
```
```python
mystr = "hello world and Python"
# 结果：True
print(mystr.endswith('Python'))
# 结果：False
print(mystr.endswith('python'))
# 结果：False
print(mystr.endswith('Python', 2, 20))
```
isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。
```python
mystr1 = 'hello'
mystr2 = 'hello12345'
# 结果：True
print(mystr1.isalpha())
# 结果：False
print(mystr2.isalpha())
```
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
```python
mystr1 = 'aaa12345'
mystr2 = '12345'
# 结果： False
print(mystr1.isdigit())
# 结果：False
print(mystr2.isdigit())
```
isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False。
```python
mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果：True
print(mystr1.isalnum())
# 结果：False
print(mystr2.isalnum())
```
isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。
```python
mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果：False
print(mystr1.isspace())
# 结果：True
print(mystr2.isspace())
```
### 十三、元组
列表可以⼀次性存储多个数据，但是列表中的数据允许更改。
⼀个元组可以存储多个数据，元组内的数据是不能修改的。
元组特点：定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型。
```python
# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)
```
注意：如果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的这个数据的数据类型
```python
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str
```
#### 元组的常⻅操作
元组数据不⽀持修改，只⽀持查找，具体如下：
按下标查找数据
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa
```
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index⽅法相同。
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0
```
count()：统计某个数据在当前元组出现的次数。
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2
```
len()：统计元组中数据的个数。
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4
```
注意：元组内的数据如果直接修改则⽴即报错
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'
```
但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的。
```python
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)
```
### 十四、列表
#### 列表的格式
```python
[数据1, 数据2, 数据3, 数据4......]
```
列表可以⼀次性存储多个数据，且可以为不同数据类型。
#### 列表的常⽤操作
列表的作⽤是⼀次性存储多个数据，程序员可以对这些数据进⾏的操作有：增、删、改、查。
查找
下标：
```python
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose
```
函数：
index()：返回指定数据所在位置的下标 。
```python
列表序列.index(数据, 开始位置下标, 结束位置下标)
```
```python
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1
```
注意：如果查找的数据不存在则报错。
count()：统计指定数据在当前列表中出现的次数。
```python
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1
```
len()：访问列表⻓度，即列表中数据的个数。
```python
name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3
```
判断是否存在
in：判断指定数据在某个列表序列，如果在返回True，否则返回False
```python
name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)
```
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
```python
name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)
```
增加：
作⽤：增加指定数据到列表中。
append()：列表结尾追加数据。
```python
列表序列.append(数据)
```
```python
name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)
```
列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型数据。
注意点：如果append()追加的数据是⼀个序列，则追加整个序列到列表
```python
name_list = ['Tom', 'Lily', 'Rose']
name_list.append(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)
```
extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
```python
列表序列.extend(数据)
```
```python
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)
```
```python
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)
```
insert()：指定位置新增数据。
列表序列.insert(位置下标, 数据)
```python
name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)
```
删除：
```python
del ⽬标
```
删除列表
```python
name_list = ['Tom', 'Lily', 'Rose']
# 结果：报错提示：name 'name_list' is not defined
del name_list
print(name_list)
```
删除指定数据
```python
name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
# 结果：['Lily', 'Rose']
print(name_list)
```
pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。
```python
列表序列.pop(下标)
```
```python
name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果：Lily
print(del_name)
# 结果：['Tom', 'Rose']
print(name_list)
```
remove()：移除列表中某个数据的第⼀个匹配项。
```python
列表序列.remove(数据)
```
```python
name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
# 结果：['Tom', 'Lily']
print(name_list)
```
clear()：清空列表
```python
name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 结果： []
```
修改
修改指定下标数据
```python
name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果：['aaa', 'Lily', 'Rose']
print(name_list)
```
逆置：reverse()
```python
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)
```
排序：sort()
```python
列表序列.sort( key=None, reverse=False)
```
注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
```python
num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)
```
复制
函数：copy()
```python
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)
```
列表的循环遍历：
```python
name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
```
```python
name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
print(i)
```
列表嵌套
所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表。
应⽤场景：要存储班级⼀、⼆、三这三个班级学⽣姓名，且每个班级的学⽣姓名在⼀个列表。
```python
name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四','王五']]
```
```python
# 第⼀步：按下标查找到李四所在的列表
print(name_list[2])
# 第⼆步：从李四所在的列表⾥⾯，再按下标找到数据李四
print(name_list[2][1])
```