Python基础-字符串、列表

Python基础-字符串

一、字符串相关操作

1、拼接、重复、跨行拼接和索引

字符串的拼接 +
str1 = "我是一名,"
str2 = "python程序员"
res = str1 + str2
print(res)
我是一名,python程序员

# res = res + ",技术很厉害哦"
res += ",技术很厉害哦"
print(res)
我是一名,python程序员,技术很厉害哦

2、字符串的重复 *
strvar = "重要的事情说三遍~"
res = strvar * 3
print(res)
重要的事情说三遍~重要的事情说三遍~重要的事情说三遍~

3、字符串跨行拼接 \
str1 = "我有一块4090的" \
"显卡"
print(str1)
我有一块4090的显卡

str1 = "我有一块4090的" \
"显卡"
print(str1)
str1 = "我有一块4090的" \
"显卡" \
"，很不错"
print(str1)
我有一块4090的显卡，很不错

4、字符串的索引
#          0 1 2 3 4 5
strvar =  "今天是星期五"
#         -6-5-4-3-2-1
print(strvar[1])
天
print(strvar[-1])
五

2、字符串的切片

字符串的切片: (截取)
"""
语法 => 字符串[::]  完整格式：[开始索引:结束索引:间隔值]
	(1)[开始索引:]  从开始索引截取到字符串的最后
	(2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
	(3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
	(4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符
	(5)[:]或[::]  截取所有字符串
"""
(1)[开始索引:]  从开始索引截取到字符串的最后
strvar = "python是这个宇宙当中,最完美,无暇,善良,漂亮,英俊,帅气,潇洒,风流倜傥的编程语言"
res = strvar[3:]
print(res)
hon是这个宇宙当中,最完美,无暇,善良,漂亮,英俊,帅气,潇洒,风流倜傥的编程语言
	
(2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
res = strvar[:6]
print(res)
python
	
(3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = strvar[10:16]
print(res)
宙当中,最完

(4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符

从左向右截取
res = strvar[::3]
# 0 3 6 9 12 15 ... 
print(res)
ph是宇中完无善漂英帅潇风傥程

从右向左截取
res = strvar[::-1]
# -1 -2 -3 -4 -5 -6 .... 
print(res)
言语程编的傥倜流风,洒潇,气帅,俊英,亮漂,良善,暇无,美完最,中当宙宇个这是nohtyp


res = strvar[-3:-10:-2]
# -3 -5 -7 -9   秘的倜风
print(res)
程的倜风

print("<====>")
"""从左到右截,间隔值为正值,反过来,间隔值是负值,才能保证截取到数据"""
"""
res = strvar[-3:-10:10] # 错误的逻辑 
print(res)
res = strvar[1:10]
print(res)
"""

二、字符串的格式化format

• 顺序传参
• 索引传参
• 关键字传参
• 容器类型数据(列表或元组)传参
• format的填充符号的使用( ^ > < )
• 进制转换等特殊符号的使用( :d :f 😒 :, )

字符串的格式化format

(1)顺序传参 # 按照顺序进行占位
"""{}是format中的占位符"""
strvar = "{}向{}发起了语音通话" .format("诸葛亮","孔明")
print(strvar)
诸葛亮向孔明发起了语音通话

(2)索引传参  # 按照索引下边进行占位
strvar = "{1}向{0}发起了语音通话" .format("诸葛亮","孔明")
print(strvar)
孔明向诸葛亮发起了语音通话

(3)关键字传参 # 通过指定关键字进行占位
strvar = "{who1}拿了{who2}的耳机".format(who1="张三",who2="李四")
print(strvar)
strvar = "{who1}拿了{who2}的耳机".format(who1="赵六",who2="王五")
print(strvar)
张三拿了李四的耳机
赵六拿了王五的耳机

(4)容器类型数据(列表或元组)传参
方法一  # 通过获取容器的下标进行占位
strvar = "{0[0]}向{1[1]}发出了好友申请".format(["苏洵","苏轼","苏辙"] , ("韩愈","柳宗元"))
print(strvar)
苏洵向柳宗元发出了好友申请
strvar = "{1[0]}向{0[2]}发出了好友申请".format(["苏洵","苏轼","苏辙"] , ("韩愈","柳宗元"))
print(strvar)
韩愈向苏辙发出了好友申请

方法二(推荐)  # 将容器分为组，以关键字命名，通过获取关键字下标
strvar = "{group1[1]}向{group2[0]}发出了好友申请".format(group1=["苏洵","苏轼","苏辙"] , group2=("韩愈","柳宗元"))
print(strvar)
苏轼向韩愈发出了好友申请

方法三(推荐) 
注意一.如果该容器是字典,通过键取值时,不需要加引号  
注意二.通过下标取值时,不能使用负号(逆向索引)

strvar = "{group1[sx]}向{group2[1]}发出了好友申请".format(group1={"sx":"苏洵","ss":"苏轼","sz":"苏辙"} , group2=("韩愈","柳宗元"))
print(strvar)
苏洵向柳宗元发出了好友申请



(5)format的填充符号的使用( ^ > < )
^ 原字符串居中显示
> 原字符串居右显示
< 原字符串居左显示

{who:*^10}  # *是填充符号  ^是原字符串居中显示 10表示填充之后一个10个字符
* : 填充的符号
^ : 原字符串居中显示
10: 原字符串长度 + 填充符号的长度 = 10

strvar = "{who:*^10}去淄博吃烧烤,{do:%>10}去青岛{eat:&^9},感觉{feel:!<10}".format(who="张三",do="李四",eat="喝啤酒",feel="棒极了")
print(strvar)
****张三****去淄博吃烧烤,%%%%%%%%李四去青岛&&&喝啤酒&&&,感觉棒极了!!!!!!!
{who:*^10}              {do:%>10}       {eat:&^9}      {feel:!<10}



(6)进制转换等特殊符号的使用( :d :f :s :, )

:d 整型占位符 (强制要求类型是整型)
strvar = "你的电脑cpu是{:d}核心的".format(8)
print(strvar)
你的电脑cpu是8核心的


:3d 占3位,不够三位拿空格来补位(原字符串居右)
# {:3d} 不够用空格补位 默认占位字符串居右
strvar = "你的电脑cpu是{:3d}核心的".format(8)
print(strvar)
你的电脑cpu是  8核心的

# {:^3d} 指定占位字符串居中
strvar = "你的电脑cpu是{:^3d}核心的".format(8)
print(strvar)
你的电脑cpu是 8 核心的

# {:<3d} 指定占位字符串居左
strvar = "你的电脑cpu是{:<3d}核心的".format(8)
print(strvar)
你的电脑cpu是8  核心的


:f 浮点型占位符 (强制要求类型是浮点型) 默认保留小数6位
strvar = "你当前的体温是{:f}℃".format(35.8)
print(strvar)
你当前的体温是35.800000℃

:.2f 小数点后保留2位,存在四舍五入
strvar = "你当前的体温是{:.2f}℃".format(35.8)   # 保留小数点后两位
print(strvar)
你当前的体温是35.80℃
strvar = "你当前的体温是{:.2f}℃".format(35.888)  #四舍五入
print(strvar)
你当前的体温是35.89℃

:s 字符串占位符
strvar = "{:s}".format("我是一名python工程师")
print(strvar)
我是一名python工程师

strvar = "我喜欢{:s}".format("python")
print(strvar)
我喜欢python


:, 金钱占位符 
strvar = "{:,}".format(12345678)
print(strvar)
12,345,678

综合案例
strvar = "{:s}是一名{:s},每月工资{:.2f}元,全款购买了{:d}辆{:s}".format("孙权","python工程师",12000,1,"奥迪A6")
print(strvar)
孙权是一名python工程师,每月工资12000.00元,全款购买了1辆奥迪A6

三、字符串的相关函数

1、概述

*capitalize 字符串首字母大写 
*title 每个单词的首字母大写 
*upper 将所有字母变成大写
*lower 将所有字母变成小写 
*swapcase 大小写互换 
*len 计算字符串的长度 
*count 统计字符串中某个元素的数量 
*find 查找某个字符串第一次出现的索引位置 
*index 与 find 功能相同 find找不到返回-1,index找不到数据直接报错
*startswith 判断是否以某个字符或字符串为开头 
*endswith 判断是否以某个字符或字符串结尾 

*isupper 判断字符串是否都是大写字母 
*islower 判断字符串是否都是小写字母 
#istitle 判断字符串是否每个单词都首字母大写 
#isalnum 判断字符串是否是由数字、字母、汉字组成 
*isalpha 判断字符串是否由字母和文字组成 
*isdigit 检测字符串数是数字组成 接受二进制字节流 
*isdecimal 检测字符串是否以数字组成  必须是纯数字
#isnumeric 检测字符串是否以数字组成 接受中文"四"
#isspace   判断字符串是否由空白符组成

*split 按某字符将字符串分割成列表(默认字符是空格)
*join  按某字符将列表拼接成字符串(容器类型都可)
#splitlines 按换行来进行切分(\n)
#zfill  填充字符串(默认填充0,原字符串右对齐)
#ljust  填充字符串,原字符居左 (默认填充空格)
#rjust  填充字符串,原字符居右 (默认填充空格)
*center 填充字符串,原字符居中 (默认填充空格)
*strip  默认去掉首尾两边的空白符 
#rstrip 去掉右边某个字符 
#lstrip 去掉左边某个字符 

*replace()
	功能:   把字符串的旧字符换成新字符
	格式:   字符串.replace('旧字符','新字符'[, 限制替换的次数])
	返回值: 替换之后的字符串

#maketrans translate 是一对
maketrans()
	功能:   制作用于字符串替换的映射表
	格式:   字符串.maketrans('查找字符','替换字符')两个字符必须长度相等
	返回值: 字典
translate()
	功能:   进行字符串替换操作
	格式:   字符串.translate(maketrans返回的字典)
	返回值: 替换之后的字符串

2、详情

*capitalize 字符串首字母大写 
strvar = "how are you"
res = strvar.capitalize()  # 前提strvar必须是字符串
print(res)
How are you

*title 每个单词的首字母大写
strvar = "how old are you"
res = strvar.title()
print(res)
How Old Are You

*upper 将所有字母变成大写
strvar = "how old are you"
res = strvar.upper()
print(res)
HOW OLD ARE YOU

*lower 将所有字母变成小写
strvar = "HOW OLD ARE YOU"
res = strvar.lower()
print(res)
how old are you

*swapcase 大小写互换  # 小写变大写 大写变小写
strvar = "How old Are You"
res = strvar.swapcase()
print(res)
hOW OLD aRE yOU

*len 计算字符串的长度 
strvar = "python"
res = len(strvar)
print(res)
6

*count 统计字符串中某个元素的数量 
"""count(字符,[开始值,结束值])"""
#    下标  0 1 2 3 4 5 6
strvar = "你真好好好好啊"
res = strvar.count("好")  # 统计字符串中的"好"的数量
print(res)
4

res = strvar.count("好",5)   # 指定下标为5，设置开始范围
print(res)
1

res = strvar.count("真",2,3)  # 指定开始下标2，结束下标3
print(res)
0

*find 查找某个字符串第一次出现的索引位置 (推荐)
"""find(字符,[开始值,结束值])"""
strvar = "To be or not to be that is a question"
res = strvar.find("to")  # 显示出字符串to第一次出现的下标索引
print(res)
13

res = strvar.find("be",4)  # 指定下标为4，设置开始范围
print(res)
16

res = strvar.find("be",4,10)  # # 指定开始下标2，结束下标3
print(res)
-1  # find在当前指定的区间找不到返回字符串，返回-1


*index 
与 find 功能相同，find找不到返回-1,index找不到数据直接报错
strvar = "To be or not to be that is a question"
res = strvar.index("to")  # 显示出字符串to第一次出现的下标索引
print(res)
13
res = strvar.index("be",4)  # 指定下标为4，设置开始范围
print(res)
16

strvar = "To be or not to be that is a question"
res = strvar.index("be",4,10)  # 指定开始下标2，结束下标3
print(res)
# ValueError: substring not found  找不到，报错


*startswith 判断是否以某个字符或字符串为开头
"""
语法一致
startswith(字符,[开始值,结束值])
endswith(字符,[开始值,结束值])
都是从左到右，没有间隔值
"""
strvar = "To be or not to be that is a question"
res = strvar.startswith("To")  # 判断字符串是否以To开头，是True，不是False
print(res)
True
res = strvar.startswith("To",10)   # 指定下标为10，设置开始范围
print(res)
Flase
res = strvar.startswith("to",13)   # 指定下标为10，设置开始范围
print(res)
True


*endswith 判断是否以某个字符或字符串结尾
strvar = "To be or not to be that is a question"
res = strvar.endswith("question")
print(res)
True

res = strvar.endswith("is",-14,-11) #  is
print(res)
True

res = strvar.endswith("is",3,10) #  be or n
print(res)
False

res = strvar.endswith("that",-21,-14)  # be that
print(res)
True



is系列
# 返回的不是真 即是假

*isupper 判断字符串是否都是大写字母 # 加中文和符号不影响，只判断大小写
strvar = "HOW  A  YOU"
res = strvar.isupper()
print(res)
True

strvar = "HOW  are  YOU"
res = strvar.isupper()
print(res)
False

*islower 判断字符串是否都是小写字母 
strvar = "asdf - as"
res = strvar.islower()
print(res)
True

*isdecimal 检测字符串是否以数字组成  必须是纯数字
strvar = "abcdefg"
res = strvar.isdecimal()
print(res)
False  # 不是数字

strvar = "2134234.123"
res = strvar.isdecimal()
print(res)
False  # 不是纯数字

strvar = "2134234"
res = strvar.isdecimal()
print(res)
 


核心系列

*split 按某字符将字符串分割成列表(默认字符是空格)    # 将字符串分割为列表
strvar = "you can you up no can no say"
lst = strvar.split()  # 默认以空格分割，不需要指定分隔符
print(lst)

strvar = "you#can#you#up#no#can#no#say"  # 用#分割
lst = strvar.split("#")  # 指定分割为#
print(lst)
['you', 'can', 'you', 'up', 'no', 'can', 'no', 'say']

strvar = "python"
lst = strvar.split()
strvar = "p#y#th#no"
lst = strvar.split("#")
print(lst)
['p', 'y', 'th', 'no']

*join  按某字符将列表拼接成字符串(容器类型都可)  # 将列表拼接为字符串
lst = ['you', 'can', 'you', 'up', 'no', 'can', 'no', 'say
strvar = " ".join(lst)
print(strvar)
you can you up no can no say

strvar = "#".join(lst)
print(strvar)
you#can#you#up#no#can#no#say

*replace 把字符串的旧字符换成新字符 
"""字符串.replace('旧字符','新字符'[, 限制替换的次数])"""
strvar = "买，不买，买，不买，买，不买"
res = strvar.replace("不买","买")  # 全部替换
print(res)
买，买，买，买，买，买

# 选择替换的次数
res = strvar.replace("不买","买",1)  # 指定替换次数，从左到右
print(res)
买，买，买，不买，买，不买
       
*strip  默认去掉首尾两边的空白符 
"""空白符 空格 \n \t \r ... """
strvar = "     周润发  "
res = strvar.strip()
print(strvar)
print(res)
     周润发  
周润发

rstrip 去掉右边某个字符
strvar = "python"
res = strvar.rstrip("n")
print(res)
pytho
       
lstrip 去掉左边某个字符
strvar = "python"
res = strvar.lstrip("py")
print(res)
thon
       
*center 填充字符串,原字符居中 (默认填充空格)
"""center(字符长度,填充符号)"""
strvar = "python"
res = strvar.center(10)
# res = strvar.center(10,"*")
print(res)
  python  
       
strvar = "python"
res = strvar.center(10,"$")
print(res)
$$python$$

Python基础-列表

一、列表相关操作

列表的相关操作
lst1 = ["孟凡伟","康与众"]
lst2 = ["康与众","张宇"]
1、列表的拼接   (同元组) # 列表的拼接和元组拼接一致
res = lst1 + lst2
print(res)
['戴尔', '外星人', '联想', '拯救者']

2、列表的重复   (同元组) # 列表的重复和元组重复一致
lst1 = ["戴尔","外星人"]
lst2 = ["联想","拯救者"]
res = lst1 * 3
print(res)
res = lst2 * 2
print(res)
['戴尔', '外星人', '戴尔', '外星人', '戴尔', '外星人']
['联想', '拯救者', '联想', '拯救者']

3、列表的切片   (同元组) # 列表的切片和元组切片一致

语法 => 列表[::]  完整格式：[开始索引:结束索引:间隔值]
	(1)[开始索引:]  从开始索引截取到列表的最后
	(2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
	(3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
	(4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
	(5)[:]或[::]  截取所有列表

#正向索引  0     1      2       3       4      5
lst = ["戴尔","联想","机械师","机械革命","惠普","苹果"]
(1)[开始索引:]  从开始索引截取到列表的最后
lst = ["戴尔","联想","机械师","机械革命","惠普","苹果"]
res =lst[2:]  # 包含2
print(res)
['机械师', '机械革命', '惠普', '苹果']

(2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
res =lst[:3]  # 不包含3
print(res)
['戴尔', '联想', '机械师']

(3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = lst[3:5]
print(res)
['机械革命', '惠普']

(4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
# 正向截取
res = lst[::5]  # 遍历全部，间隔值为5
print(res) # 0 5 10
['戴尔', '苹果']

# 逆向截取
res = lst[::-3]  # 遍历全部，间隔值为-3(逆向)
print(res)  # -1 -4 -7
['苹果', '机械师']

(5)[:]或[::]  截取所有列表
res = lst[:]
print(res)
res = lst[::]
print(res)
['戴尔', '联想', '机械师', '机械革命', '惠普', '苹果']
['戴尔', '联想', '机械师', '机械革命', '惠普', '苹果']

4、列表的获取   (同元组) # 列表的获取和元组获取一致
#       0  1  2
lst = [10,20,30] #通过索引下标进行获取
#     -3  -2 -1
print(lst[-1])
30

5、列表的修改   ( 可切片 )
lst = ['戴尔', '联想', '机械师', '机械革命', '惠普', '苹果']
# 改单个值
lst[1] = "拯救者"
print(lst)
['戴尔', '拯救者', '机械师', '机械革命', '惠普', '苹果']

1.改多个值 (如果使用切片进行修改,要求数据必须是Iterable可迭代性数据：容器数据)
lst[1:4] = ["暗影精灵","小新","华为"]
print(lst)
['戴尔', '暗影精灵', '小新', '华为', '惠普', '苹果']

lst[1:4] = "你好"
print(lst)
['戴尔', '你', '好', '惠普', '苹果']

2.改多个值(带有步长#[::3])
"""带有步长的切片修改,切出几个元素就修改几个元素,数量要一致."""
lst = ['戴尔', '拯救者', '机械师', '机械革命', '惠普', '苹果','华为']
"""0 3 6 """
lst[::3] = "abc"
# lst[::3] = "ab" error
print(lst)
['a', '拯救者', '机械师', 'b', '惠普', '苹果', 'c']

6、列表的删除   ( 可切片 )
1.一次删一个
lst = ['戴尔', '拯救者', '机械师', '机械革命', '惠普', '苹果','华为']
del lst[2]
print(lst)
['戴尔', '拯救者', '机械革命', '惠普', '苹果', '华为']

2.一次删一堆
del lst[1:-1] #设置范围，只剩0和-1
print(lst)
['戴尔', '华为']

3.注意点
res = lst[1:-1]
del res   # 删除的是res这个变量 和 列表无关
print(lst)


额外的注意点  # 列表本身不能改，可以改列表内的数值
tup = (1,2,3,4,[10,11,12])
print(tup[-1])
tup[-1][-1] = 13 
print(tup)

二、列表的相关函数

1、增

append()

append
功能：向列表的末尾添加新的元素
格式：列表.append(值)
返回值：None
注意：新添加的值在列表的末尾，该函数直接操作原有列表

lst = ['戴尔', '拯救者', '机械师']
lst.append("暗影精灵")
print(lst)

['戴尔', '拯救者', '机械师', '暗影精灵']  #在原有列表增加

insert()

insert
功能：在指定索引之前插入元素
格式：列表.insert(索引,值)
返回值:None
注意：直接改变原有列表

lst = ['戴尔', '拯救者', '机械师']
lst.insert(1,"小新")  # 指定索引，插入数据
print(lst)

['戴尔', '小新', '拯救者', '机械师']

extend()

extend
功能：迭代追加所有元素
格式：列表.extend(可迭代性数据)
返回值：None
注意：直接改变原有列表

"""迭代追加的数据是可迭代性数据(容器类型数据,range对象,迭代器)"""
lst = ['戴尔', '拯救者', '机械师']
tup = (1,2,3)
lst.extend(tup)
print(lst)
['戴尔', '拯救者', '机械师', 1, 2, 3]

strvar = "abc"
lst.extend(strvar)
print(lst)
['戴尔', '拯救者', '机械师', 'a', 'b', 'c']

lst.extend(range(3))
print(lst)
['戴尔', '拯救者', '机械师', 0, 1, 2]

2、删

pop()

pop 
功能：通过指定索引删除元素,若没有索引移除最后那个
格式：列表.pop(索引)
返回值：删除的元素
(注意：没有指定索引，默认移除最后一个元素 )

lst = ['戴尔', '拯救者', '机械师', '机械革命', '惠普', '苹果']
# 不指定下标,默认删除最后一个
res = lst.pop()
print(res)
print(lst)
苹果
['戴尔', '拯救者', '机械师', '机械革命', '惠普']

# 指定下标,删除具体某个元素
res = lst.pop(1)
print(res)
print(lst)
拯救者
['戴尔', '机械师', '机械革命', '惠普', '苹果']

remove()

remove 
功能：通过给予的值来删除,如果多个相同元素,默认删除第一个
格式：列表.remove(值)
返回值：无
(注意：如果有索引的情况推荐使用pop,效率高于remove)

lst = ['戴尔', '拯救者', '机械师', '机械革命', '惠普', '苹果']
lst.remove('戴尔')  #指定值
print(lst)
['拯救者', '机械师', '机械革命', '惠普', '苹果']


# 如果多个相同元素,默认删除第一个
lst = ['戴尔', '拯救者', '戴尔', '机械革命', '惠普', '戴尔']
lst.remove('戴尔')  #指定值
print(lst)
['拯救者', '戴尔', '机械革命', '惠普', '戴尔']

clear()

clear
功能：清空列表
格式：列表.clear()
返回值：空列表

lst = ['戴尔', '拯救者', '机械师', '机械革命', '惠普', '苹果']
lst.clear()
print(lst)

[]  # 返回空列表

3、改查

参考
一、列表相关操作

4、列表的其他相关函数

index()

index 
功能：获取某个值在列表中的索引号
格式：列表.index(值[,start][,end]) # []  表达参数可选项 
返回值：找到返回索引  (找不到报错)

lst = ['戴尔', '拯救者', '苹果'，'机械师', '苹果'，'机械革命', '惠普', '苹果']
res = lst.index("机械师")
print(res)
2

lst = ['戴尔', '拯救者', '机械师', '机械革命', '惠普', '苹果','机械师']
res = lst.index("机械师",3)
print(res)
6

res = lst.index("机械师",3,6) # 3 4 5
# res = lst.index("机械师") error

count()

count 
功能：计算某个元素出现的次数
格式：列表.count(值)
返回值：次数

lst = ['戴尔', '拯救者', '苹果','机械师', '苹果','机械革命', '惠普', '苹果']
res = lst.count("苹果") # 没有范围的概念 只能统计次数
print(res)
3

sort()

sort
功能：列表排序(默认小到大排序)  # 只能对列表排序
格式：列表.sort(reverse=False)                        
返回值：None
注意：直接更改原列表

lst = [-90,-100,-1,90,78]
# 从小到大进行排序
lst.sort()
print(lst)
[-100, -90, -1, 78, 90]

# 从大到小进行排序
lst.sort(reverse=True)   # 反转=True 即是从大到小
print(lst)
[90, 78, -1, -90, -100]

# 对字符串进行排序(按照ascii编码)
参考链接：https://zhuanlan.zhihu.com/p/614006911

lst = ["computer","games","wzry","cyhx","yxlm"]
lst.sort()
print(lst)
['computer', 'cyhx', 'games', 'wzry', 'yxlm']

# 是否可以对中文排序(了解 无规律可循)
lst = ['戴尔', '拯救者', '苹果','机械师', '苹果','机械革命', '惠普', '苹果']
lst.sort()
print(lst)
['惠普', '戴尔', '拯救者', '机械师', '机械革命', '苹果', '苹果', '苹果']

reverse()

reverse 
功能：列表反转操作
格式：列表.reverse()
返回值：None
注意：直接更改原列表

列表反转操作

lst = [1,2,"a","苹果","华为"]
lst.reverse()
print(lst)
['华为', '苹果', 'a', 2, 1]

三、列表的深浅拷贝

列表的深浅拷贝
a = 100
b = a
a = 200
print(b)
100

lst1 = [1,2,3]
lst2 = lst1
lst1.append(4)
print(lst2)
[1, 2, 3, 4]

copy模块中有 浅拷贝 和 深拷贝 两种方法
(1)浅拷贝:  浅拷贝只拷贝外层列表  内层列表跟随原列表进行改变
	浅拷贝copy.copy(listvar) 或者 listvar.copy()
(2)深拷贝:  拷贝整个列表  内外列表都不跟随原列表进行改变
	深拷贝copy.deepcopy(listvar)
注意:copy模块的copy方法 和 python内置的函数copy一样 都是浅拷贝


1、浅拷贝
import copy
"""模块.方法() 同名模块下的同名方法"""
import copy.copy()

方法一 (推荐)

import copy
lst1 = [1,2,3]
lst2 = copy.copy(lst1)  # list2复制list1
lst1.append(10)   #list1追加10
print(lst2)
print(lst1)
[1, 2, 3]
[1, 2, 3, 10]

# 方法二
lst1 = [1,2,3]
lst2 = lst1.copy()
lst1.append(11)
print(lst1)
print(lst2)
[1, 2, 3, 11]
[1, 2, 3]

2、深拷贝
把所有层级的容器元素都单独拷贝一份,放到独立的空间中
# 现象 
浅拷贝只拷贝一级容器
# 一级容器
import copy
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.copy(lst1)
lst1.append(8888)
print(lst2)
[1, 2, 3, [4, 5, 6]]

# 二级容器 
import copy
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.copy(lst1)
lst1[-1].append(77)
print(lst2)
[1, 2, 3, [4, 5, 6, 77]]



深拷贝————
import copy
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.deepcopy(lst1)
lst1[-1].append(999)
print(lst2)
print(lst1)
[1, 2, 3, [4, 5, 6]]
[1, 2, 3, [4, 5, 6, 999]]


# 其他容器的深拷贝
import copy
lst1 = (1,2,3,{"a":1,"b":[10,20]})
lst2 = copy.deepcopy(lst1)
lst1[-1]["b"].append(30)
print(lst1)
print(lst2)
(1, 2, 3, {'a': 1, 'b': [10, 20, 30]})
(1, 2, 3, {'a': 1, 'b': [10, 20]})



总结:
浅拷贝:
	只拷贝一级容器中的所有元素独立出一个单独的空间. 速度快，占用空间小
深拷贝:
	把所有层级的容器中所有元素都单独拷贝一份,形成独立的空间 速度慢，占用空间大



tuple 元组 只有count  index 两个方法 使用同列表
元组的相关操作除了不能修改和删除其中的元素之外 , 剩下操作都和列表相同.
元组里面能用的方法只有 index 和 count 

P