一直想学习python，把高淇老师400集的课程下了好几个月了，结果几个月的时间就看了不到30节。这次在西安隔离，待在宿舍好无聊，于是决定，一定要静下心来，把python学完，好吧。那么把这几天的笔记整理一下， 刚好复习一下。

本笔记以高淇老师的课程讲解而来的，大家可以去看看高淇老师的python课程，讲的非常好。那么开始吧。

import turtle
t = turtle.Pen()
for x in range(360):
    t.forward(x)
    t.left(59)

• 逻辑行首的空白（空格和制表符）用来觉得逻辑行的缩进层次，从而用来决定语句的分组
• 语句从新行的第一列开始
• 缩进风格统一：
  • 每个缩进层次使用 单个制表符或四个空格
  • python用缩进，不是用{}表示程序块

注释

行注释：每行注释前加#号。当解释器看到#，则忽略这一行#后面的内容 段注释：使用三个连续单引号（'''）。当解释看到'''，则会扫描到下一个'''，然后忽略他们之间的内容。

#1.行注释
'''
  2.
  段
  注
  释
'''

行链接符

一行程序长度是没有限制的，但是为了可读性更强，通常将一行比较长的程序分为多行。这时，我们可以使用\行连接符，把它放在行结束的地方。Python 解释器仍然将它们解释为同一行。

a = [10,20,30,40,\
50,60,70,\
80,90,100]
# 输出：[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

a = 'abcdefghijklmnopqrstuvwxyz'

b = 'abcdefg\
hijklmn\
opqrst\
uvwxyz'

c = 'abcdefg\
    hijklmn\
    opqrst\
    uvwxyz'
# 输出： 
# a：abcdefghijklmnopqrstuvwxyz
# b：abcdefghijklmnopqrstuvwxyz
# c：abcdefg    hijklmn    opqrst    uvwxyz

对象

对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作

• 标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数 id(obj)可返回对象 obj 的标识。
• 类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的操作。可以使用 type(obj)获得对象的所属类型。

print(id(3))    #2573173418352
print(type(3))  #<class 'int'>
a=3
print(id(b))    #2573173418352
print(type(b))  #<class 'int'>

b="我爱你"
print(id("我爱你"))  #2166580334832
print(id(b))        #2166580334832
print(type("我爱你"))#<class 'str'>
print(type(b))      #<class 'str'>

引用

在 Python 中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。 变量通过地址引用了“对象”。 变量位于：栈内存（压栈出栈等细节，后续再介绍）。 对象位于：堆内存。

标识符

• 区分大小写。如：sxt 和 SXT 是不同的
• 第一个字符必须是字母、下划线。其后的字符是：字母、数字、下划线
• 不能使用关键字。比如：if、or、while 等。
• 以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如：__init__是类的构造函数

删除变量和垃圾回收机制

a=123
del a

赋值

链式赋值：链式赋值用于同个对象赋值给多个变量 x=y=123 相当于：x=123; y=123 

系列解包赋值：给对应相同个数的变量 a,b,c=4,5,6 相当于：a=4;b=5;c=6

a,b,c=1,2,3
print(a,b,c) #1 2 3
a,b,c=c,b,a
print(a,b,c) #3 2 1

常量

Python 不支持常量，即没有语法规则限制改变一个常量的值。我们只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改。

最基本内置数据类型

1. 整型：2345,10,50
2. 浮点型：小数，3.14 或者科学计数法 314e-2
3. 布尔型：表示真假，仅包含：True、False
4. 字符串型：由字符组成的序列。 “abc”,”sxt”,“尚学堂”,”百战程序员”

运算符

加法 3+2    =5

减法 30-5   =25

乘法 3*6     =18

/ 浮点数除法 8/2        =4.0

// 整数除法 7//2         =3

% 模（取余） 7%4   =3

** 幂 2**3                  =8

print(7/3)   #2.3333333333333335
print(7//3)  #2

使用 int()实现类型转换

print(int(123))               #123
print(int(123.453453453))     #123
print(int("435353"))          #435353
print(int(True))              #1
print(int(False))             #0
# （错误）print(int("2342sfsdgdg"))     #这种无法转换，会报错

时间的表示

计算机时间的表示是从“1970年1月1日 00:00:00 ”开始，以毫秒（1/1000秒）进行计算。我们也把1970年这个时刻成为“unix时间点”

import time
print(time.time())          #从1970年到今天有1635488450.2000031秒
totalSecond=int(time.time())#从1970年到今天有1635488510秒
totalMinute=totalSecond//60 #从1970年到今天有27258143分钟
totalHour=totalMinute//60   #从1970年到今天有454302小时
totalDay=totalHour//24      #从1970年到今天有18929天
totalYear=totalDay//365     #从1970年到今天有51年

布尔值

布尔值：True 和 False 定义成了关键字，但他们的质还是 1 和 0，甚至可以和数字相加

比较运算符

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价

以下假设变量 a 为 15，变量 b 为 30：

• ==（等于） ： 比较对象的值是否相等 (a == b) 返回 False
• !=（不等于）： 比较两个对象的值是否不相等 (a != b) 返回 true

• >（大于）：返回 x 是否大于 y (a > b) 返回 False

• <（小于）：返回 x 是否小于 y (a < b) 返回 true

• =（大于等于）：返回 x 是否大于等于 y。 (a >= b) 返回 False

• <=（小于等于）： 返回 x 是否小于等于 y。 (a <= b) 返回True

逻辑运算符

• or逻辑或（x or y）：x 为 true，则不计算 y，直接返回 true；x 为 false，则返回 y
• and逻辑与（x and y）： x 为 true，则返回 y 的值；x 为 false，则不计算 y，直接返回 false
• not逻辑非（not x）：x 为 true，返回 false

print(3==4)        #False
print(3<4)         #True
print(5!=5)        #False
print(3 and True)  #True
print(3 and False) #False
print(3>5 or True) #True
print(not 3)       #False

同一运算符

• 同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。
• 运算符描述
  • is：is 是判断两个标识符是不是引用同一个对象
  • is not：is not 是判断两个标识符是不是引用不同对象
• is 与 == 区别
  • is 用于判断两个变量引用对象是否为同一个，即比较对象的地址
  • == 用于判断引用变量引用对象的值是否相等，默认调用对象的 eq() 方法

整数缓存问题

Python 仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不一样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。

总结

• is 比较两个对象的 id 值是否相等，是否指向同一个内存地址
• == 比较的是两个对象的内容是否相等，值是否相等
• 小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用
• is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is

print(id(3))   #140715204334688
a=3            # 3 有一块地址，a指向存放3的地址，b也是
b=3
print(id(a))   #140715204334688
print(id(b))   #140715204334688
print(a == b)  #True   比较两个数值是否相等
print(a is b)  #True   比较两个地址是否相等
print(a is 3)  #True   
print(a is 4)  #False

字符串

a='sxt'                 #sxt
b="sxt"                 #sxt
c="I'm a teacher"       #I'm a teacher
#（错误）d='I'm a teacher'       # '与句子中的'配对，所以此时最好用双引号
e='my_name is "YanShen"'  # my_name is "YanShen"
#（错误）f="my_name is "YanShen""  # ''与句子中的''配对，所以此时最好用单引号
# 三引号可以写很多行，还有避免句子中 ''和 ' 的配对问题
resume='''name="言深"          
company = "浴池"  age = 13
lover = "TOM" '''
g=''
print(a,b,'\n',c,'\n',e,'\n',resume,'\n',g)  
print(len(g),len(resume))  #0 50

ord() & chr()

• ord()可以把字符转换成对应的 Unicode码
• chr()可以把十进制数字转换成对应的字符

print(ord('A'))   #65
print(ord('言'))  #39640
print(chr(66))    #'B'
print(ord('深'))  #28103

转义字符

(在行尾时) 续行符

\ 反斜杠符号

' 单引号

" 双引号

\b 退格

\n 换行

\t 横向制表符

\r 回车

a = 'I\nlove\nU'     
'''
I
love
U
'''
print(a)
print('aaabb\
cccddd')   
# aaabbcccddd

字符串拼接

可以使用+将多个字符串拼接起来。

例如：'aa'+ 'bb' ==>'aabb'

• 如果+两边都是字符串，则拼接
• 如果+两边都是数字，则加法运算
• 如果+两边类型不同，则抛出异常

a='aa''bb'
print(a)   #aabb
a='aa'
b='bb'
print(a+b) #aabb

可以将多个字面字符串直接放到一起实现拼接。例如：'aa''bb'==>'aabb'

字符串复制

a='abc'
print(a*10)  # abcabcabcabcabcabcabcabcabcabc

str()实现数字转型字符串

str()可以帮助我们将其他数据类型转换为字符串

str(5.20) ==> '5.20'

str(3.14e2)==>'314.0'

str(True) ==> 'True'

当我们调用 print()函数时，解释器自动调用了 str()将非字符串的对象转成了字符串

a=123
b=345
print(a+b)     #468
a=str(a)
b=str(b)
print(a+b)     #123456

使用[]提取字符

字符串的本质就是字符序列，我们可以通过在字符串后面添加[]，在[]里面指定偏移量，可以提取该位置的单个字符

• 最左侧第一个字符，偏移量是 0，第二个偏移量是 1，直到 len(str)-1为止
• 最右侧第一个字符，偏移量是-1，倒数第二个偏移量是-2，直到-len(str)为止

a="abcdefg"
a_len=len(a)
print(a[1])         # 第二个字符 b
print(a[1+2])       # b 右两个字符 d
print(a[a_len-1])   # 最后一个字符 g
print(a[a_len-1-2]) # g 左两个字符 e
print(a[-1])        # 最后一个字符 g
print(a[-7])        # 从尾部算起第7个字符，也就是第一个字符 a

replace()实现字符串替换

• 字符串是“不可改变”的，我们通过[]可以获取字符串指定位置的字符，但是我们不能改变字符串。我们尝试改变字符串中某个字符，发现报错了
• 字符串不可改变。但是，我们确实有时候需要替换某些字符。这时，只能通过创建新的字符串来实现

a="abcdefg"
print(a) #abcdefg  a指向存放abcdefg的空间
b=a.replace('c','言')
print(b) #ab高defg b指向出发ab高defg的空间
a=b
print(a) #ab高defg  a指向b指向的空间

字符串切片操作

a="abcdefghijklmn"
print(a[1:3])     # bc 输出第2个到第3个字符之间
print(a[1:5:2])   # bd 第2个到第6个字符之间每隔1个字符输出一下
print(a[1:500])   # abcdefghijklmn 如果超出字符数量范围，直接按字符串长度去算
print(a[1:500:2]) # 同理
#----------------------------------------------------
print(a[:])       # abcdefghijklmn 输出全部字符
print(a[1:])      # bcdefghijklmn  输出从第二个开始的全部字符
print(a[:7])      # abcdefg 从开头到第7个字符
print(a[::2])     # acegikm 从第1个字符开始，每隔1个输出一个字符
#----------------------------------------------------
print(a[-1:-3])   # 无输出
print(a[-3:-1])   # lm 从倒数第3个输出到倒数第2个
print(a[:-1])     # abcdefghijklm 输出从开头到倒数第2个字符
print(a[-1:])     # n 从倒数第1个开始输出接下来所有字符
print(a[::-1])    # nmlkjihgfedcba 反过来输出
print(a[::-2])    # nljhfdb 从最后一个开始，每隔1个输出1个字符

split()分割字符串

a="to be or not to be"
b=a.split()
# b=['to','be','or','not','to','be']
# 若不指定分隔符，则默认使用空白字符(换行符/空格/制表符)
# 可以基于指定分隔符将字符串分隔成多个子字符串
print(b[1])
b=a.split('be')
# 以 be 作为分隔符
print(b[0],b[1])
# b=['to','or not to']

join()合并字符串

b=['to','be','or','not','to','be']
a='*'.join(b)
print(a) # to*be*or*not*to*be
a=''.join(b)
print(a) # tobeornottobe

字符串驻留机制

字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制驻留机制。但对于pycharm而言，是否符合标识符规则好像都能启动驻留机制

a="abd_33"
b="abd_33"
c="dd#"
d="dd#"
print(a is b) # True
print(c is d) # True

成员操作符

in /not in 关键字，判断某个字符(子字符串)是否存在于字符串中。

a="aabbccdd"
print("aa" in a) # True
print('a' in a)  # True
print("aabbccdd" in a) # True

常用查找方法

len()

startswith()

endswith()

find()

rfind()

count()

isalnum()

a="我是言深，言深爱做视频"
print(len(a))   # 字符串长度 96
print(a.startswith('我是言深')) #True 以指定字符串开头 
print(a.endswith('做视频')) #True 以指定字符串结尾 
print(a.find('言')) #2 第一次出现指定字符串的位置 
print(a.rfind('言'))#5 最后一次出现指定字符串的位置 
print(a.count("言深")) #2 指定字符串出现了几次 
print(a.isalnum()) #False 所有字符全是字母或数字 

去除首尾信息

strip()

print("   haha     ".strip())  # 默认清除首尾空白符 haha
print("***haha***".strip("*")) # 清楚首尾 * 符号 haha
print("**h*a*h*a**".strip("*")) # 清楚首尾 * 符号，但中间的*不除掉 h*a*h*a
print("*****haha*".lstrip("*")) # 除掉左边的 * 符号，haha*

大小写转换

capitalize()

title()

upper()

lower()

swapcase()

a = "gaoqi love programming, love SXT"
print(a.capitalize())  # 产生新的字符串，单词首字母大写，其余小写 'Gaoqi love programming, love sxt'
print(a.title()) # 产生新的字符串,每个单词都首字母大写 'Gaoqi Love Programming, Love Sxt'
print(a.upper()) #产生新的字符串,所有字符全转成大写 'GAOQI LOVE PROGRAMMING, LOVESXT'
print(a.lower()) #产生新的字符串,所有字符全转成小写 'gaoqi love programming, love sxt'
print(a.swapcase()) #产生新的,所有字母大小写转换 'GAOQI LOVE PROGRAMMING, LOVEsxt'

格式排版

center()

ljust()

rjust()

a="SXT"
print(a.center(10,"*")) # 中间对齐，总共10个字符，其余的地方用 *填充 ***SXT****
print(a.center(10))    # 中间对齐，总共10个字符，其余的地方用空格填充
print(a.ljust(10,"*")) # 左对齐，总共10个字符，其余的地方用* 填充

检查

isalnum()

isalpha()

isdigit()

isupper()

islower()

print("sxt100".isalnum()) #是否为字母或数字 True
print("sxt 尚学堂".isalpha()) #检测字符串是否只由字母组成(含汉字) False
print("234.3".isdigit()) #检测字符串是否只由数字组成 False，因为有小数点
print("23423".isdigit()) # True
print("aB".isupper())#是否为大写字母 False
print("A".isupper())#True
print("\t\n".isspace())#检测是否为空白符 True
print("aa".islower() )#是否为小写字母 True

字符串的格式化

format()

a = "名字是:{0},年龄是：{1}"
# {} 表示占位符，0,1表示第0个，第1个
print(a.format("言深",18)) #输出： '名字是:言深,年龄是：18'
# 用占位符 {} 的话，就要注意元素的顺序 
b = "名字是：{0}，年龄是{1}。{0}是个好小伙"
print(b.format("言深",18)) # '名字是：言深，年龄是 18。言深是个好小伙'
c = "名字是{name}，年龄是{age}"
print(c.format(age=19,name='言深'))# '名字是言深，年龄是 19'
# 这种模式下，元素就无需考虑顺序了

对齐与填充

# ^、<、>分别是居中、左对齐、右对齐，后面带宽度
# :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
print("{:*>8}".format("245"))
# '*****245'
print("我是{0},我喜欢数字{1:*^8}".format("言深","666"))
# '我是言深,我喜欢数字**666***'

数字格式化

a = "我是{0}，我的存款有{1:.2f}"
print(a.format("言深",3888.234342))
# '我是言深，我的存款有 3888.23'
print("{:.2f}".format(-3.12))   # 保留小数点后两位  -3.12
print("{:+.2f}".format(-3.124)) # 带符号保留小数点后两位  -3.12
print("{:.0f}".format(3.123))   # 不带小数  3
print("{:.0f}".format(3.983))   #          4
print("{:,}".format(1000000000)) # 以逗号分隔的数字格式 1,000,000,000
print("{:.3%}".format(0.4533425)) # 百分比格式  45.334%
print("{:.2e}".format(10000000000)) # 指数记法 1.00e+10

可变字符串

在 Python 中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象。但是，经常我们确实需要原地修改字符串，可以使用 io.StringIO对象或 array 模块

import io
s = "hello,sxt"
sio = io.StringIO(s)
print(sio) # <_io.StringIO object at 0x000001FF26533708>
print(sio.getvalue()) # hello, sxt
sio.seek(7)        # 找到第8个字符，即x 
sio.write("g")     # 改为 g
print(sio.getvalue()) # hello, sgt

不换行打印

end = “任意字符串”。实现末尾添加任何内容

print("agdf",end='')           #agdf结尾空字符不换行
print("sdaffs",end='\n')       #sdaffs结尾换行符
print("fsfsdfs",end="%#%#$%#") #fsfsdfs结尾%#%#$%#不换行
'''
输出：
agdfsdaffs
fsfsdfs%#%#$%#
'''

从控制台读取字符串

我们可以使用 input()从控制台读取键盘输入的内容

myname=input("请输入名字：")  # 请输入名字：***言深***
print(myname)               # 言深

列表

列表的创建

list()

range()

# 第一种
a = [10,20,'YanShen','sxt']
b = [] #创建一个空列表
# 第二种
# 使用 list()可以将任何可迭代的数据转化成列表。
a = list() # 创建一个空的列表对象
b = list(range(10)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
c = list("YanShen,sxt") # ['Y', 'a', 'n', 'S', 'h', 'e', 'n', ',', 's', 'x', 't']
# range()创建整数列表
'''
range()  语法格式为：range([start,] end [,step])
start 参数：可选，表示起始数字。默认是 0  
end 参数：必选，表示结尾数字
step 参数：可选，表示步长，默认为 1
python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其转换成列表对象。
'''
list(range(3,15,2))  # [3, 5, 7, 9, 11, 13]
list(range(15,3,-1)) # [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
list(range(3,-10,-1))# [3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
# 第三种
# 推导式生成列表
a = [x*2 for x in range(5)] #循环创建多个元素 [0, 2, 4, 6, 8]
b = [x*2 for x in range(100) if x%9==0] 
# 通过 if 过滤元素 [0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

列表元素的增加与删除

当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。

append()

# 原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。
a=[10,20,30,40]
a.append(50)
print(a)

+运算符操作

a=[10,20,30,40]
print(id(a)) # 3089976854920
a=a+[50]
print(a) # 10 20 30 40 50
print(id(a)) # 3089550303880
# 通过如上测试，我们发现变量 a 的地址发生了变化。也就是创建了新的列表对象

extend()

# 将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。
a=[10,20,30,40]
b=[50,60]
a.extend(b) 
print(a) # [10, 20, 30, 40, 50, 60]

insert()

使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。

a=[10,20,30,40]
a.insert(1,9) 
print(a) # [10, 9, 20, 30, 40]

乘法扩展

a=[10,20,30,40]
a=a*3
print(a) # [10, 20, 30, 40, 10, 20, 30, 40, 10, 20, 30, 40]

列表元素的删除

del()

# 删除列表指定位置的元素。
a=[10,20,30,40,50]
del a[1]
print(a) # [10, 30, 40, 50]

pop()

# pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素
a=[10,20,30,40,50]
print(a.pop())  # 50
print(a)        # [10, 20, 30, 40]
print(a.pop(1)) # 20
print(a)        # [10, 30, 40]

remove()

# 删除首次出现的指定元素，若不存在该元素抛出异常。
a = [10,20,30,40,50,20,30,20,30]
a.remove(20)
print(a) # [10, 30, 40, 50, 20, 30, 20, 30]

列表元素访问和计数

通过索引直接访问元素

a=[10,20,30,40,50]
print(a[2])  # 30

index()

# 获得指定元素在列表中首次出现的索引
# index()可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])。
# 其中，start 和 end 指定了搜索的范围。
a=[10,20,30,40,50,10,20,10]
b = a.index(10)      # 0 
c = a.index(10,1)    # 5 第2个元素之后10的位置
d = a.index(10,3,7)  # 5 第4个元素到第8个元素之间，10的位置

count()

a=[10,20,30,40,50,10,20,10]
# count()可以返回指定元素在列表中出现的次数
print(a.count(10)) # 3

len()返回列表长度

a=[10,20,30,40,50,10,20,10] # len()返回列表长度，即列表中包含元素的个数。
print(len(a))  # 8

成员资格判断

a=[10,20,30,40,50,10,20,10]
print(20 in a)      # True
print(100 not in a) # True
print(30 not in a)  # False

切片操作

'''
切片 slice 操作可以让我们快速提取子列表或修改。标准格式为：
[起始偏移量 start:终止偏移量 end[:步长 step]]
注：当步长省略时顺便可以省略第二个冒号

# [:]：提取整个列表     
# [start:]：从 start 索引开始到结尾    
# [:end]：从头开始知道 end-1 
# [start:end]：从 start 到 end-1 
# [start:end:step]：从 start 提取到 end-1，步长是 step 
# 其他操作（三个量为负数）的情况：
# [10,20,30,40,50,60,70][-3:] 倒数三个 [50,60,70]
#  -7 -6 -5 -4 -3 -2 -1                     
# [10,20,30,40,50,60,70][-5:-3] 倒数第五个到倒数第三个(包头不包尾) [30,40]
# [10,20,30,40,50,60,70][::-1]  步长为负，从右到左
# 反向提取 [70, 60, 50, 40, 30, 20, 10]
'''

列表的遍历

a=[10,20,30,40,50,10,20,10]
for x in a:
    print(x,end=' ')  # 10 20 30 40 50 10 20 10 

列表排序

# 第一种
a = [20,10,30,40]
a.sort() #默认是升序排列
print(a)  # [10, 20, 30, 40]
a = [10,20,30,40]
a.sort(reverse=True) #降序排列
print(a) # [40, 30, 20, 10]
import random
random.shuffle(a) #打乱顺序
print(a) # [40, 30, 20, 10]
random.shuffle(a) #打乱顺序
print(a) # [10, 20, 40, 30] 每次打乱都可能不一样

# 第二种 建新列表的排序
# 我们也可以通过内置函数 sorted()进行排序，这个方法返回新列表，不对原列表做修改。
a = [20,10,30,40]
id(a) # 46016008
a = sorted(a) #默认升序
id(a) # 45907848
a = [20,10,30,40]
id(a) # 45840584
b = sorted(a)
id(a) # 45840584
id(b) # 46016072
print(a) # [20, 10, 30, 40] 
print(b) # [10, 20, 30, 40]
c = sorted(a,reverse=True) #降序
# 通过上面操作，我们可以看出，生成的列表对象 b 和 c 都是完全新的列表对象。

reversed()返回迭代器

# reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。
a = [20,10,30,40]
c = reversed(a)
print(c)  # 不是列表类型
# <list_reverseiterator object at 0x000002382F9760F0>
print(list(c)) # [40, 30, 10, 20]