python入门第七课--数据类型及其相关操作

昨日内容回顾

• while循环补充说明

 1.死循环
 2.全局标志位

• for循环基本使用

 for 变量名 in 待遍历的对象(可迭代对象):
     for循环体代码
 
 1.for循环体代码执行break
 2.for循环体代码执行continue
 3.for与else同级使用
 4.变量名命名建议

• range方法

 range(10)
 range(1,10)
 range(1,10,2)
 可以快速产生内部含有大量数值的工厂

今日内容概要

• 作业讲解
• 数据类型内置方法理论
• 整型相关操作
• 浮点型相关操作
• 字符串相关操作
• 列表相关操作

今日内容详细

pycharm使用小技巧：

1. 多行代码块的一起往后缩进4格，直接按Tab键。
   多行代码块的一起往回缩进4格，Shift+Tab键一起按。
2. debug调试模式(程序员后期找bug必备工具):当代码出现bug时，可以使用将鼠标在代码的左侧点一下，当出现红点时。点到代码行鼠标右击并点击debug，再点击键盘F7或者相对应的图标，就可以分步运行代码行，最终查出代码的bug所在。

作业讲解

1. 计算1-100所有的数之和
all_num = 0           # 定义一个自变量，用来进行叠加计算的初始值。
for i in range(1, 101):  # for循环取值遍历range里面的数据，因为range顾头不顾尾，所以这里写101 
    all_num += i         # for每取出一个数据，就要执行一次它的子代码，all_num = all_num + i，一直要将range里面的数据全部取出，将子代码运行全部次数后，for循环才能结束，最终执行for的平行代码print（）。
print(all_num)

# all_num = all_num + i  for每取出一个值，都会和老的all_num相加，生成一个新的all_num，所以最终的结果就是，把每一个for循环所取得i的值相加。
all_num == 0  1  3  6   10  15   。。。
i ==       1  2  3  4   5    6   。。。
all_num == 1  3  6  10  15  21   。。。

2. 判断列表中数字2出现的次数  
l1 = [11,2,3,2,2,1,2,1,2,3,2,3,2,3,4,3,2,3,2,2,2,2,3,2]

count_num = 0  # 1.先定义一个记录数字2出现次数的计数器
for i in l1:  # 2.循环获取列表中每一个数据值
	if i == 2:  # 3.判断是不是数字2,如果i绑定的数据值是2 则让计数器自增1
		count_num += 1
print(count_num)  # 4.等待for循环运行结束 打印计数器

这题主要考的就是，for循环对列表的取值，及for循环的子代码如何编写完成一个计数功能。

3. 编写代码自动生成所有页网址(注意总共多少页)
	https://movie.douban.com/top250
# 通过登录网址浏览网页，发现规律，每一页数字增加25，重而得出该网页的登录地址模板为：
	https://movie.douban.com/top250?start=0&filter=         #第一页
	 https://movie.douban.com/top250?start=25&filter=       #第二页
	 https://movie.douban.com/top250?start=50&filter=       #第三页
	 https://movie.douban.com/top250?start=225&filter=      #第十页
所以建立模板网页模板：
    base_url = 'https://movie.douban.com/top250?start=%s&filter='    # %s放在要取代的位置
    for i in range(0, 250, 25):   # range顾头不顾尾，所以想取到225，范围必须要写到250
        print(base_url % i)      # 通过格式化输出
这题主要考察，格式化输出与for循环range遍历取值的联合运用，格式化输出代码要作为for循环的子代码运行，才能达到每一个for循环取值并格式化打印出来的效果。
注意此处 for i in 循环取值时，一定不要忘记写range，不写这个循环就会当作元组只取3个值。

。

4.编写代码打印出下列图形,要求print每次只能打印一个*(ps:for循环嵌套)
*****  
*****  
*****  
*****
代码实现
for i in range(4):        # 0 1 2 3            4行
    for j in range(5):    # 0 1 2 3 4          5次
        print('*', end='')
    print()               # 内存循环结束 换行

这个首先i取0，执行下面的子代码for循环与print，子代码的for循环每取一次值会打印一个*，子代码的循环5次打印5个*后，子代码for循环运行结束，此时运行它的同级代码print（）完成一次换行。然后再次进行大的for循环取值，此时就取1了。

这个代码里面，虽然用到for的循环取值，但是并没有用到循环取值的i，所以此处for的循环取值的作用有点像计数器了。

此处可以用while循环循环嵌套，加计数器也可以完成同样操作：
代码实现：
count1 = 0
while count1 < 4:
    count = 0
    while count < 5:
        print('*', end='')
        count += 1
    print()
    count1 += 1

while循环嵌套的结构中，需要用到两个计数器，分别控制两个while的循环次数。
子while循环用来打横着的5个*号，然后跳出循环后，重置子循环的计数器，再次执行大的while的循环。

数据类型内置方法理论

我们之前所学习的每一种数据类型本身都含有一系列的操作方法,内置方法是其中最多的(自带的功能)

在python中数据类型  调用内置方法  的统一句式为   句点符
1. 字符串调用内置方法：'jason'.字符串内置方法的英文名   比如  'jason'.format()
2. 绑定字符串的变量名也可以调用内置方法：  绑定字符串的变量名.字符串内置方法

怎么去记住数据类型内置方法

首先数据调用内置方法很简单，数据或者绑定数据的变量名后面，加一个小点.  软件就会自动跳出属于该数据类型的方法供你选择，鼠标双击就可以直接调用。
但数字直接加一个小点. 软件是没法判断你是想输带小数点的数字还是想掉用方法，所以数字的方法调用可以先将数字赋值给变量名，然后变量名加小点.就可以调用出数字的自带的方法了
那么怎么理解怎么去记相关的操作？和代码编写呢？
可以这样理解 首先数据或者变量名加一个小点. 选择调用该数据的软件自带的内置方法，这个时候就可以理解调用的方法对该数据进行了一个处理，
1. 如果调用方法可以直接处理该数据而不需要其他输入信息，那么方法后面的括号（）里面一般就不需要填数据，空在那边就好了。
2. 如果调用方法需要其他的信息才能去处理数据，那么方法后面的括号（）里面，就需要放与方法相关的数据了。
比如字符串的相关方法:
.strip（）  方法是去除字符串首尾的空格符此时（）里面什么都不用放，但是当想去除字符串首尾的其他字符时，你就必须在（）里面输入额外的信息告诉软件你要去除哪个字符。

.split()   方法是切割字符串中指定的字符，此时（）里面如果不输入信息，软件根本就不知道你你要切割字符串中哪个指定的字符，所以（）里面需要输入你要劈的符号比如管道符 |  。

.join（）   比如你要将管道符|，加到几个字符串中间去，形成新的字符串，  比如  '|'.join(['jason', '123', 'read', 'JDB'])  管道符是主体，想将管道符通过.join方法加入到不同字符串之间去，所以括号（）里面要将不同字符串的信息放进去。

.format() 也是一样，前面是主体.format() 括号里面放入需要格式化输出的内容。
可以直接放数据，或者放变量名 = 数据 这种传参，目的都是一个让软件知道你要将什么信息进行格式化输出。
.replace（）代替也一样，前面是主体.replace（）括号里面这样放（主体里原来老的字符,新的字符），你只有把老的字符与新的字符都输入到括号里面去，软件才能知道用新的字符替代主题中的老的字符。
.count()统计也一样，前面是主体.count（）括号里面放你想要统计主体里面的东西。
.startswith（）判断以…开头，前面是主体字符串.startswith（）括号里面放你想要判断是不是主题开头的字符串。

其他的一些方法比如：
.upper（）
.lower()
.isupper()
.title()
主体直接使用这些方法，后就可以直接处理出来了，不需要输入额外信息了

所以说主体在前.方法（）    括号里面放入你想执行该方法所需要添加的额外信息。如果不需要额外信息，括号里面啥都不写就行了。这是数据调用内置方法的通用技巧。

整型的内置方法与操作

1. 类型转换(将其他数据类型转换成整型)
	int(浮点型或字符串)    # 除了这两个，其他类型的都转不了整型。
注意：
浮点型可以直接转，但是小数点后直接一刀切，不会四舍五入。
字符串想要转，必须满足内部是纯数字才可以转。


2. 进制数转换（补充知识点）
	十进制转其他进制的方法：掉不同的方法  转二bin    转八oct  转十六hex
十转二       print(bin(100))  # 0b1100100     数字开头是ob表示这串数字是二进制的
十转八       print(oct(100))  # 0o144         0o开头表示是八进制的
十转十六     print(hex(100))  # 0x64          0x开头表示是十六进制的

3. int具有将其他进制转十进制的功能
		print(int(0b1100100))   # 100
        print(int(0o144))       # 100
        print(int(0x64))        # 100
通过数字前面的代号判断是几进制的数字，然后用相关的公式进行转化为十进制。
4. 当手上是其他进制的字符串类型的数字时，转整型的方法：
		print(int("0b1100100", 2))       # 100
        print(int("0o144", 8))           # 100
        print(int("0x64", 16))           # 100

5. python自身对数字的敏感度较低(精确度低)
	python这门语言其实真的一点都不厉害 主要是因为它背后有太多大佬
	如果需要进准的计算需要借助于模块numpy.....

浮点型内置方法与操作

1. 类型转换
	float(其他数据类型)       只有整型和是数字的字符串，能转
	整型可以直接转，整数自动加上.0
	字符串内部是纯数字，可以转。
	字符串里面数字有一个小数点也可以转。
	其他类型数据都不能转浮点型

字符串内置方法与操作----重要！！！！！！！！！！！

1. 类型转换:

	str(其他数据类型)   任意数据类型可以转字符串(只需要在前后加引号即可)
比如：将列表转为字符串
info = ['jason', 123, 'aaaa','啊啊啊啊']
print(str(info))             # 将列表转为字符串
print(type(str(info)))       # 查看数据类型
['jason', 123, 'aaaa', '啊啊啊啊']   
<class 'str'>
注意： print默认将字符串的''去掉打印出来。所以此处打印看不出来列表已经转化为字符串了。但是看打印类型的时候就能看出来了。
注意：列表转为字符串后，就是在列表的整体上在列表两边加上''单引号。这个时候，打印是看不出来该列表已经转化尾字符串了，因为print打印字符串，会默认将字符串的两个单引号去掉打印出来

2. 字符串的相关操作方法：

切片、切片方向与步长的操作都可以看成是索引取值操作的加强版
只是索引取值只要用一个数字，切片要用两个数字，反方向跨步切片需要三个数字，才能让软件知道你的意图。

s1 = 'helloworld'
1. 索引取值
print(s1[0])          # 索引取值(注意：起始位置0开始 超出范围直接报错)
h

print(s1[-1])         # 支持负数 从末尾开始取值  [-2]结果就是l
d

2.切片操作的符号  [ : ]   冒号两边放索引值    属于索引的操作的加强版。
print(s1[1:5])        # 顾头不顾尾 从索引1一直切取到索引4
ello

print(s1[-1:-5])      # 默认的顺序是从左往右取，所以程序运行，但什么结果没有。
print(s1[-5:-1])      # 默认的顺序是从左往右取，还是顾头不顾尾。从-5索引到-2
worl

3. 修改切片的方向与间隔的方法 仍然属于索引操作的加强版

s1 = 'helloworld'

print(s1[1:5:1])     # 默认是1    1的含义是从左往右取且没有间隔 索引从1到4
ello

print(s1[1:5:2])    # 从左往右隔一个取一个 索引从1到4
el

print(s1[-1:-5:-1])  # -1从右往左取且没有间隔
dlro

print(s1[:])         # 不写数字就默认都要
helloworld

print(s1[2:])        # 冒号后面没有数字，就代表从索引2开始往后都要
lloworld

print(s1[:5])        # 冒号前面没有数字，就代表从索引0开始，不顾尾，所以到4
hello

print(s1[::2])       # 索引全都要，从左往右隔一个取一个
hlool

4. 求字符串字符数，或者说字符串长度

s1 = 'helloworld'
方法1：先定义一个计数器，再对字符串来一个for循环，每次循环后计数器加一，for循环结束，计数器的值就是字符串的长度。代码实现：
s1 = 'helloworld'
count = 0
for i in s1:
    count += 1
print(count)

方法2：print(len(s1))
# 这个地方实际上还是可以 s1.len 按下Tab系统自动将s1补到len（）的括号里面去，所以也可以不用记要不要把s1放在len（）的括号里面。

5. 字符串其他的一些相关操作

注意： 字符串在调用内置方法之后并不会修改自己 而是产生了一个新的结果!!!

strip 脱去；剥去（V）
字符串.strip() 括号内不写默认移除字符串首尾的空格

5.1 移除字符串首尾指定的字符 .strip() 用的非常多！！！！！！

字符串用了.strip方法剥去了首尾的空格或特殊字符后，还是字符串！！！！

1.1 剥除字符串首尾的空格
很多软件的登录界面都含有该程序，很多人输入完账号密码后，可能会下意识地按下空格，该程序目的就是将输入的字符串首尾空格移除后，以便进行后续if条件的判断。
username = input('username>>>:').strip()
if username == 'jason':
print('登录成功')

5.2 剥除字符串首尾的特殊字符 用的非常多！！！！！！！！！！！！

res1 = '$$jason$$'
print(res1.strip('$'))      # 括号里面写下想要移除的符号
jason

print(res1.lstrip('$'))     # 移除左边的符号
jason$$
print(res1.rstrip('$'))     # 移除右边的符号
$$jason

5.3 切割字符串中指定的字符 用的非常多！！！！！！！！！

一个大的字符串经过切割后切割后形成的每一个数据都还是字符串！！！

并且切割出来的所有的一个小字符串共同组成一个列表！！！

所以一般在对字符串进行切割后，会紧接着解压赋值给变量比如
username，password = zifuchuan.split(|)

一般情况下可能会切割字符串中的字符有：管道符| 换行符\n 这两个切的最多！！！

写个不单单只能切割一个字符，比如字符串'abcdefg' 可以用split切掉中间的大部分，甚至全部。

split 劈开；分离(v)

res = 'jason|123|read'
要求用3个变量将字符串里面的信息分别绑定
print(res.split('|'))  # 该方法的处理结果是变成一个列表，并且"|"没了，按照管道符把字符串劈了。
['jason', '123', 'read']
name, pwd, hobby = res.split('|')   # 字符串res经过切割方法后变为列表，并经过解压赋值，将列表中的信息分别赋值给3个变量名。这一步非常重要，一定要掌握！！！！！！！！

print(res.split('|', maxsplit=1))   # maxsplit最大切割数 ，并默认从左往右切
['jason', '123|read']

print(res.rsplit('|',maxsplit=1))   # rsplit 从右往左切
['jason|123', 'read']

5.4 字符串格式化输出，注意字符串的格式化输出后，数据类型还是字符串

format 版式；格式(n)

format玩法1:{}等价于占位符        和%s的用法很像，有几个%s，后面就要写几个要替换的字符。
res = 'my name is {} my age is {}'.format('jason', 123)
print(res)
my name is jason my age is 123

也可以写成这样：
n = 'my name is {} my age is {}
print(n.format('jason', 123))

format玩法2:    这种一般用在有好多地方要替换的格式化输出情况下。
这种方法相当于提前在格式化输出的字符串中想要替换的地方，提前已经将要替换进去的数据的索引值放到{}花括号里面去了。

res = 'my name is {0} my age is {1} {0} {0} {1}'.format('jason', 123)
print(res)
也可以写成：
n = 'my name is {0} my age is {1} {0} {0} {1}'
print(n.format('jason', 123))

索引取值并支持反复使用，比第一种的方法方便，需要重复输出的数据值，在括号里面写一遍就行了。可以把（）括号里面的数据看成一个元组，花括号{}里面只需要输入索引数字就可以将元组里面的数据取过来了。

format玩法3关键字传参:   占位符见名知意       这种用法用的较少！
res = 'my name is {name1} my age is {age1} {name1} {age1} {name1}'.format(name1='jason', age1=123)
print(res)

format玩法4 f 最方便，最常用的！！！！！！！！

用法：在字符串的前面加一个f，然后直接在字符串里面想要的位置插一个花括号，花括号里面直接用前面出现过的变量名，变量名所绑定的数值就会自动放进去了。就可以完成格式化输出了。

也就是说：对于一个字符串，想要在该字符串任意位置插入其他字符，用该方法最简单。

该用法的关键是：必须提前把想插入的字符或输入的字符用变量名绑定一下！！！
后才能，把变量名往花括号里面一放就好了。f'ab{变量名1}cd{变量名2}efgh'

name = input('username>>>:')
age = input('age>>>:')
res = f'my name is {name} my age is {age}'
print(res)
my name is jason my age is 16
注意f后面只能是字符串'my name is {name} my age is {age}'  不能是变量名！！！提前将该字符串赋值给一个变量名，然后用f'变量名' ，这种操作方法是错误的，操作不了。

你前面输入的名字与年龄就会自动加到对应变量名的地方了
输入jason
输入16

6.字符串需要了解的方法

.

1. 大小写转换

res = 'hElLO WorlD 666'
print(res.upper())          # .upper()字符串英语字母转大写，其他的不受影响
HELLO WORLD 666

print(res.lower())          # .lower()字符串英语字母转小写，其他的不受影响
hello world 666

应用场景：
'''
图片验证码:生成没有大小写统一的验证码 展示给用户看获取用户输入的验证码 将用户输入的验证码和当初产生的验证码统一转大写或者小写再比对
'''
代码实现：
code = '8Ja6Cc'             #  假如系统随机生成一串代码
print('展示给用户看的图片验证码', code)
confirm_code = input('请输入验证码').strip()    # 移除输入数据的首尾空格
if confirm_code.upper() == code.upper():     # 将用户与系统的字符串同意转为大写并比较
     print('验证码正确')

.

2. 大小写判断，只能判断英语字母

是否是纯大写用 .isupper() 是否是纯小写用 .islower()
upper 上面的，上层的（adj）引申为大写的
lower 较低的，低等的（adj）引申为小写的

res = 'hello world'
print(res.isupper())         # .isupper()判断字符串是否是纯大写并得出一个布尔值
False

print(res.islower())         # islower()判断字符串是否是纯小写并得出一个布尔值
True

res = 'hello world111123'
print(res.islower())
True                         # 判断只管英文字母，不管里面的数字。

.

3. 判断字符串中是否是纯数字，并生成一个布尔值 .isdigit()

digit 数字；手指（n）

res = 'jason'
print(res.isdigit())  # 判断字符串中是否是纯数字
False

猜年龄的游戏：       这串代码重要！！！
guess_age = input('guess_age>>>:').strip()    # 讲输入的信息移除首尾的空格
if guess_age.isdigit():       # 判断字符串是否是纯数字，是执行子代码
    guess_age = int(guess_age)    # 再将字符串转化为整型数字
else:
     print('年龄都不知道怎么输吗???')

4. 替换字符串中指定的内容 变量名.replace（ ，） 也比较常用!!!

replace  取代，代替（V）
（ ，）逗号左边放需要替换的旧的字符串，右边放新的字符
```python
res = 'my name is jason jason jason jason jason'
print(res.replace('jason', 'tonySB'))
my name is tonySB tonySB tonySB tonySB tonySB

print(res.replace('jason', 'tonySB', 1))  # 如果需要控制替换的个数，在新的字符串后面，加上需要替换的个数。
my name is tonySB jason jason jason jason

5. 字符串的拼接 变量名.join() 使用频率相对低一点

该方法可以看成是split方法的逆运算，字符串插到列表里面各数据中间去，最终形成一个整的字符串。
注意：其他数据类型的数据类型想要与字符串拼接必须转化为字符串，并形成列表后，后才能执行。
打个比方  'a'想要插在'jason' 123 [11, 12, 44]这3个数据的中间，那么必须先把数字与列表转为字符串，并将这3各数据形成一个列表后才行。代码实现：
print('a'.join(['jason', '123', '[11, 12, 44]']))
jasona123a[11, 12, 44]            # 每个数据中间都插入了a，注意生成的数据还是字符串

ss1 = 'hello'
ss2 = 'world'
print(ss1 + '$$$' + ss2)     # 字符串之间是支持加法运算的
print(ss1 * 10)              # 字符串也是支持乘法法运算的

print('|'.join(['jason', '123', 'read', 'JDB']))   # 该方法可以看成是split方法的逆运算，将特定的字符串拼接到列表各数据中间。
jason|123|read|JDB               # 注意该数据还是字符串
print('|'.join(['jason', 123]))  # 注意参与拼接的数据值必须都是字符串，所以此处会报错。123必须要加引号'123'

6. 统计指定字符在字符串里出现的次数 字符串.count() （）括号里放指定的字符

res = 'hello world'
print(res.count('l'))
3

7. 判断字符串在不在另一个字符串开头，并得出一个布尔值。 另一个字符串.startswith(字符串) startswith 意思 以什么开头

res = 'jason say hello'
print(res.startswith('jason'))    # True
print(res.startswith('j'))        # True
print(res.startswith('jas'))      # True

print(res.startswith('a'))        # False
print(res.startswith('son'))      # False
print(res.startswith('say'))      # False

判断字符串在不在另一个字符串结尾，并得出一个布尔值。      另一个字符串.endswith(字符串)
print(res.endswith('o'))          # True
print(res.endswith('llo'))        # True
print(res.endswith('hello'))      # True

8. 其他方法补充
   title 题目, 标题(n)
   capitalize 把……首字母大写(v)
   swapcase 大小写交换
   index 指数；索引；指标；指针(n)

res = 'helLO wORld hELlo worLD'
print(res.title())              # 将整个字符串中所有单词的首字母大写
Hello World Hello World

print(res.capitalize())         # 将整个字符串的第一个字母大写
Hello world hello world

swap 交换(n)     case情况；实例；箱(n)
print(res.swapcase())           # 将整个字符串的所有字母大小写翻转
HELlo WorLD HelLO WORld

print(res.index('O'))           # 找到字符在字符串里面的索引值，默认找到第一个符合的，当字符不在字符串里面时，会直接报错。
4

print(res.find('O'))            # 找到字符在字符串里面的索引值，默认找到第一个符合的，当字符不在字符串里面时，会报-1 。
4

print(res.index('c'))      # 找不到直接报错
print(res.find('c'))       # 找不到默认返回-1
find与index方法除了这一点有区别，作用都是找索引值。

列表内置方法及操作

1. 其他数据类型转列表:

	list(其他数据类型)           能够被for循环的数据类型都可以转成列表。
可以看成先对其他数据类型进行一个for循环，然后把每一次for循环得到的数据，都放到列表里面去。

print(list('hello'))                         # 将整个字符串转为单各字符串组成的列表。
['h', 'e', 'l', 'l', 'o']

print(list({'name': 'jason', 'pwd': 123}))   # 将整个字典转为，键组成的列表。
['name', 'pwd']

print(list((1, 'name', 3, 4)))   # 将整个元组转为列表，原元组里面的数据类型不做改变。
[1, 'name', 3, 4]

print(list({1, 2, 'jason', 4, 5}))   # 将整个集合转为列表，原集合里面的数据类型不做改变。
[1, 2, 4, 5, 'jason']

2. 需要掌握的方法

1. 列表的索引取值(正负数)

l1 = [111, 222, 333, 444, 555, 666, 777, 888]
print(l1[0])
111
print(l1[-1])
888

2. 切片操作（索引取值的加强版操作）与字符串的切片操作一致
注意切片操作不会改变列表的数据类型    与字符串讲解操作一致
实际上可以把切片操作看作是索引取值的加强版，索引取值[]方括号里面只能输入单个数字，切片操作可以在[]里面输入比如[2:5]从而把原列表里面索引值2-4的数据值切割下来，形成一个新的列表。

l1 = [111, 222, 333, 444, 555, 666, 777, 888]
print(l1[0:5])   # 还是顾头不顾尾，只取0-4个索引 。
[111, 222, 333, 444, 555]

print(l1[:])  # 方括号里面放个冒号，意思就是从头切到最后，相当于还是原列表 。
[111, 222, 333, 444, 555, 666, 777, 888]

3. 间隔数 步长 方向 实际上也可理解为切片操作的加强版操作 与字符串的操作一致

第2个冒号后面数字，就是告诉你从那个方向切，隔几个切一个。         与字符串讲解操作一致
l1 = [111, 222, 333, 444, 555, 666, 777, 888]
print(l1[::-1])           # 确定方向与步长  步长为1，就是没有间隔的切下来
[888, 777, 666, 555, 444, 333, 222, 111]

print(l1[-1:-3:-1])    # 最后一个数字告诉你反方向切，还是顾头不顾尾，把索引-1到-2的切下来
[888, 777]

print(l1[-1:-8:-2])     # 反方向切，还是顾头不顾尾，把索引-1到-7，切一个隔一个再切一个这样的切下来。
[888, 666, 444, 222]

4. 统计列表中数据值的个数 与字符串的操作一致

print(len(l1))  # 8

5. 列表数据值修改 这个重要！！！！！

相当于是列表索引取值的加强版操作，对列表的索引值重新赋值。
l1[0] = 123
print(l1)
[123, 222, 333, 444, 555, 666, 777, 888]

6. 往列表添加数据值 .append('数据值') .insert('数据值') .extend() 这几个重要！！！

.append(）这个append的操作有点类似于剪切粘贴的意思，将括号里面要剪切的数据剪切粘贴到列表的最后去。
append 附加，增补（v）

*方式1:   尾部追加数据值
l1 = [111, 222, 333, 444, 555, 666, 777, 888]
l1.append('干饭')         # .append（）括号里面加什么数据，该数据就加到原列表数据的而最后一位 。
print(l1)
[111, 222, 333, 444, 555, 666, 777, 888, '干饭']

l1.append(['jason', 'kevin', 'jerry'])
print(l1)                  # append(）括号里面可以放的数据类型有：字符串、列表、
[111, 222, 333, 444, 555, 666, 777, 888, ['jason', 'kevin', 'jerry']]
n = l1.append(['jason', 'kevin', 'jerry'])    # 注意！！！
print(n)
None
注意：也就是说l1.append(['jason', 'kevin', 'jerry']) 本身它要插入的数据值已经剪切粘贴到l1列表里面去了，所以这个数据本身里面已经空掉了，什么都没有了。

*方式2:    任意位置插入数据值   重要！！！！！      .insert()
还是列表索引取值的加强版操作，在索引值的位置插入，原数据不改变，相应的往后整体移一格。

l1.insert(0, 'jason')
print(l1)
['jason', 111, 222, 333, 444, 555, 666, 777, 888]

l1.insert(1, [11, 22, 33, 44])
print(l1)
[111, [11, 22, 33, 44], 222, 333, 444, 555, 666, 777, 888]

方式3:      扩展列表     就是合并列表      重要！！！！！
extend 延伸；扩大，延长（V）
ll1 = [11, 22, 33]
ll2 = [44, 55, 66]
3种方法：直接相加、.extend() 、 for循环加.append()
print(ll1 + ll2)
[11, 22, 33, 44, 55, 66]

ll1.extend(ll2)        # 底层原理类似于  for循环+append  两个方法结合到一起了。
print(ll1)
[11, 22, 33, 44, 55, 66]

for i in ll2:
    ll1.append(i)
print(ll1)
[11, 22, 33, 44, 55, 66]

7. 删除列表数据 del remove pop

l1 = [111, 222, 333, 444, 555, 666, 777, 888]
方式1: del   按索引取值删除    实际上解除数据值与索引值的关系
del l1[0]
print(l1)
[222, 333, 444, 555, 666, 777, 888]

remove  移开，拿开；除去（V）
方式2: remove
l1.remove(444)                # 括号内填写数据值
print(l1)
[111, 222, 333, 555, 666, 777, 888]

pop  （使）砰地爆开，砰地脱落（V）
方式3: pop        这个用的最多一点
l1.pop(3)                    # 按索引索引值跳出
print(l1)
[111, 222, 333, 555, 666, 777, 888]

l1.pop()                     # 默认尾部弹出数据值
print(l1)
[111, 222, 333, 444, 555, 666, 777]


pop与remove的区别：
l1 = [111, 222, 333, 444, 555, 666, 777, 888]
res = l1.pop(3)
print(res)
444

res1 = l1.remove(444)
print(res1) 
None
pop与remove的区别：都可以移去列表里面的数据，pop是按索引值将列表里面的数据跳出去，remove直接按数据值将列表里面的数据移除。pop这个操作本身是将数据值跳出列表，remove这个操作本身是直接将数据删除了。

8. 列表数据的排序 排序只针对于列表里面的数据都是数字而言

sort 将…分类；将…排序（v）

ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
ss.sort()                    # 默认是升序，从小到大
print(ss)
[12, 33, 43, 54, 55, 76, 76, 88, 99, 99, 100]

ss.sort(reverse=True)         # 改为降序
print(ss) 
[100, 99, 99, 88, 76, 76, 55, 54, 43, 33, 12]
sort方法里面自带的是 reverse=False     把False改为true后，排序方向就反过来了，变成从大到小排序了。

9. 统计列表中某个数据值出现的次数 .count()

l1 = [111, 222, 333, 444, 555, 666, 777, 888]
print(l1.count(111))
1

10. 颠倒列表顺序 .reverse()

reverse 颠倒，反转（v）

ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
ss.reverse()
print(ss)
[33, 100, 99, 88, 76, 43, 12, 76, 55, 99, 54]

可变类型与不可变类型

注意： 字符串在调用内置方法之后并不会修改自己!!! 而是产生了一个新的结果!!!

s1 = '$$jason$$'
s1.strip('$')
print(s1)
$$jason$$

s1 = '$$jason$$'
res = s1.strip('$')
print(res)
jason

如何查看调用方法后有没有产生新的结果，可以在调用该方法的代码左侧添加变量名和赋值符号。

注意： 列表在调用内置方法之后改变的就是自身!!! 并没有产生一个额外的新的结果!!!

l1 = [11, 22, 33]
ret = l1.append(44)
print(l1)
[11, 22, 33, 44]

print(ret)
None

.
.
.
.

可变类型: 值改变 内存地址不变 列表 字典 集合 都是可变类型

l1 = [11, 22, 33]
print(l1)
print(id(l1))  # 1321776855560
[11, 22, 33]


l1.append(44)
print(id(l1))  # 1321776855560
[11, 22, 33, 44]


值改变，内存地址不变！！！

.
.
.
.
.
.

不可变类型:值改变 内存地址肯定变

元祖、字符串、整形、浮点型、布尔 都是不可变类型

res = '$$hello world$$'
print(res)  # $$hello world$$
print(id(res))  # 2253987129776



res.strip('$')
print(res)  # hello world
print(id(res))  # 2253987935856



值改变 内存地址肯定变！！！