Python入门基础

Python入门基础

• IDLE是一个Python Shell，基本上来说是一个通过键入文本与程序交互的途径

一、基础语法

• 输出 print()
  正确写法：

print('hello world') #hello world
print("hello world") #hello world
print("hello world"); #hello world
print("hello"+"world") #helloworld
print("hello world" * 3) #hello worldhello worldhello world
print("hello world\n" * 3) #\m 表示回车意思（将光标移动到下一行）
					       #hello world
			               #hello world
						   #hello world
print(3+5) #8
print(123456789123456789*123456789123456789)  #15241578780673678515622620750190521

错误写法

print 'hello world' #SyntaxError: invalid syntax
print("hello world\n" + 3) #Traceback (most recent call last):
 						   # File "<pyshell#9>", line 1, in <module>
   						   #   print("hello world\n" + 3)
						   #TypeError: must be str, not int

• 输入 input()

temp = input() #输入字符给temp变量（不分类型）
print(temp) #输出temp内容

temp = input('hello world:') #可以做提示
print(temp)

• 查看函数 dir()

dir(__builtins__) #查看有哪些函数

• 如何使用函数 help()

help(input) #注意查询的函数不用加括号

• 查看变量的类型 type()

type(True) #<class 'bool'>
type('520') #<class 'str'>

• 生成从start开始到stop结束的的数字序列 range()

#语法：
range(strat,stop,step=1) #前面两个参数可选，第三个参数默认不写值是1表示每次递增多少;如果只传一个参数strat默认从0开始，stop取不包含

range(5) #range(0,5)
list(range(5)) #[0,1,2,3,4]
list(range(2,9)) #[2,3,4,5,6,7,8]
list(range(1,10,2)) #[1,3,5,7,9]

• 判断类型是否与想要的类型一致 isinstance(变量，类型)
  如果变量和你指定的类型一致 ，则返回True否则返回 False

print(isinstance('看看',str)) #True 
print(isinstance('看看',int)) #False

• 断言
  assert这个关键字称之为“断言”，当assert后边的条件为假时，程序自动崩溃并抛出AssertionError异常。一般来说可以用作程序中检查点。
  

• 比较符号

符号	含义
>	左边大于右边
<	左边小于左边
>=	左边大于或等于右边
<=	左边小于或等于右边边
==	左边等于右边
!=	左边不等于右边

value = 3 > 1
print(value) #True

value = 3 < 1
print(value) #False

value = 3 == 1
print(value) #False

• 算术操作符

#幂运算
print(3 ** 3) #27 => 3^3
print(-3 ** 3) #-27 => -(3^3) 注意：幂运算的优先级比

#除法（有小数，注意：在Python2之前是得到整数）
print(10/4) #2.5

#除法（整数）
print(10//4) #2

#取余
print(10%3) #1

优先级	类型	例如
最高	幂运算	**
↓	正负号	+x 、-x
↓	算术操作符	*、/、//、+、-
↓	比较操作符	<、<=、>、>=、==、!=
↓	逻辑运算符	not、and、or

• 三元操作符

#语法：
#如果条件为True值为x反之为y
x if 条件 else y 

x,y = 4,5
if x < y
	small = x
else
	small = y

#可以表达成：
small = x if x < y else y

• 条件分支

#语法：
#格式: 注意缩进和if 和 else 最后有个冒号
if 条件:
	#条件为真 True 执行
else:
	#条件为假 False 执行

temp = input('输入一个你想的数字:')
guess = int(temp)
if guess == 8:
    print('猜中啦！')
else:
    if guess > 8:
        print('数字大了')
    else:
        print('数字小了')
print('结束')

• while循环

#语法：
while 条件:
	#条件为真True执行,如果条件为假False不会进入该循环

• for循环

#语法：
for 目标 in 表达式:
	循环体

string = 'ABCD' 
for i in string:  #循环字符长度次数
    print(i , end=' ') #每次打印一个字符,end=' '表示在每打印一个字符结束后加一个空格
#输出结果:A B C D

string = ['哈哈哈','嘿嘿','嗨']  #定义一个列表
for i in string:
    print(i,len(i),len(string))#第一个参数：每次打印 第 i 个元组数据
    			   			   #第二个参数：打印第i个元组数据的字符
    			   			   #第三个参数：打印一共有多少个元组
#输出结果:哈哈哈 3 3
#		 嘿嘿 2 3
#		 嗨 1 3

• break 和 continue

#break: 表示结束循环
#continue:表示退出当前循环，进入到下一次循环

for i in range(10): # 从0开始到9结束
    if i%2 != 0:  #相当于找出不是2的倍数
        print(i)#1 3 5 7 9
        continue

for i in range(10):
    if i%2 != 0:
        continue
    elif i == 4 : 
        break
    print(i) #0 2        

• 逻辑运算符

符号	含义	例如
and	只有两个都对才是True否则是False	3>2 and 1<2返回True
or	只要有1个对就是True,两个都错才是 False	3>2 or 1>2返回True, 3<2 or 1>2返回False
not	取反	not(True)返回False

• 类型转换

转为整型数：int()

#字符串转为整数
string = '520'  #定义一个字符串为520
number = int(string)  #把字符520转为整型给number
print(value)   #输出整型 520

#浮点类型转为整数
a = 5.99
b = int(a)
print(b) #5 注意：浮点类型转换为整数，Python会采用截断处理把小数点后面的数据直接不要

转为浮点型数：float()

#字符串转为浮点型数
string = '520'  
number = float(string)  
print(value)   #输出浮点型 520.0

#整数转为浮点型数
a= 520 
b = float(a)  
print(b)   #520.0

转为字符型数：str()

#整数转为字符串
number = 520
string = str(number) 
print(string)   #输出字符型 '520'

a= 5e19
b = str(a) 
print(b)   #输出字符型 '5e19'

二、变量

• 把一个值赋值给一个名字时，他会存储在内存中，称之为变量。在大多数语言中，把这种行为称为“给变量赋值”或者“把值存储在变量中”。不过Python并不算把值存储在变量中，而更像是把名字贴在值的上边。
• 变量可以改变
  1.使用变量之前必须赋值。
  2.可包括字母、下划线、数字、但变量名不能以数字开头。
  3.字母可以大写和小写，但大写和小写是不同的变量。
  4.等号 ‘=’ 表示赋值的意思（变量 = 值）。
  5.变量的命名理论上可以取任何合法的名字，但尽量给变量取一个专业的名字能一眼看懂。
  

三、字符串（英文的单引号或双引号都行，但必须成对）

特殊字符

符号	说明
\ ’	单引号
\ "	双引号
\a	发出系统响铃声
\b	退格符
\n	换行符
\t	横向制表符（TAB）
\v	纵向制表符
\r	回车符
\f	换页符
\o	八进制数代表的字符
\x	十六进制数代表的字符
\0	表示一个空字符
\ \	反斜杠

• 带引号的字符

string = 'Let\'s go!' #方法一：使用转义字符 反斜杠(\)
string = r'Let\s go!' #方法二：使用原始字符串在前面加上字母 r

• 带反斜杠的字符

str = 'C:\\now'
str = r'C:\now' #注意：使用原始字符串不能用\结尾

• 长字符串

str = '''啦啦啦,
嘤嘤嘤，
耶耶耶....
''' #使用三引号（可单引号 也可双引号）

常用函数

• 把字符串第一个字符改为大写 capitalize()

string = 'esther'
string = string.capitalize()
print(string) #Esther

• 把整个字符串所有字符转换为小写 casefold()

string = 'EstHeR'
string = string.casefold()
print(string) #esther

• 将字符串居中且使填充至长度width的新字符串 center()

string = 'esther' 
string = string.center(20,'*') #第二个参数不写默认为空格
print(string) #*******esther******* 总共长20

• 检查字符串是否以子字符串结束 endswith()

string = 'esther'
print(string.endswith('er')) #True
print(string.endswith('re')) #False

• 把字符串中的tab符号（\t）转换为空格 expandtabs()

string = 'esther\tty' 
string1 = string.expandtabs() #如不指定参数，默认的空格数是 tabsize=8
string2 = string.expandtabs(tabsize=12) 
print(string1) #'esther  ty'
print(string2) #'esther      ty'

• 检测子字符串是否包含在字符串中 find()

#find(sub[,start[,end]])
string = 'esther'
print(string.find('ww')) #-1 没有则返回-1
print(string.find('er')) #4 有则返回索引值

#index(sub,[start[,end]])
string = 'esther'
print(string.index('ww')) #没有会抛出异常
print(string.index('er')) #4 有则返回索引值

• 检测字符串是否只有字母或数字或中文 isalnum()

string1 = 'esther11来啦'
string2 = 'esther 来啦'
print(string1.isalnum()) #True
print(string2.isalnum()) #False

• 检测字符串是否只有字母和中文 isalpha()

string1 = 'esther11来啦'
string2 = 'esther来啦'
print(string1.isalpha()) #False
print(string2.isalpha()) #True

• 检测字符串中是否只有十进制数字 isdecimal()

#注意：半角数字 和 全角数字（双字节） 都会返回True
#0-9对应Unicode编码范围：半角——’\u0030’ 到 ‘\u0039’ 全角——’\uff10’到’\uff19’
string1 = '123' #半角
string2 = '\uff10' #全角
print(string1.isdecimal()) #True
print(string2.isdecimal()) #True

• 检测字符串中是否只有数字 isdigit()

#注意：半角数字 和 全角数字（双字节）bytes数字 都会返回True
string1 = '123' #半角
string2 = '\uff10' #全角
string3 = b'5'
print(string1.isdigit()) #True
print(string2.isdigit()) #True
print(string3.isdigit()) #True

• 检测字符串中是否没有大写字母 islower()

string1 = 'hello*//'
print(string1.islower()) #True

• 检测字符串中是否只有数字字符 isnumeric()

#注意：半角数字 和 全角数字（双字节） 罗马数字、汉字数字 都会返回True
string1 = '3' #半角 3
string2 = '\uff13' #全角 3
string3 = 'Ⅲ' #罗马 3
string4 = '三' #汉字 三
print(string1.isnumeric()) #True
print(string2.isnumeric()) #True
print(string3.isnumeric()) #True
print(string4.isnumeric()) #True

• 检测字符串中是否只有空格 isspace()

string1 = '     ' 
string1 = '  q   ' 
print(string1.isspace()) #True
print(string2.isspace()) #False

• 检测字符串中是否标题化（所有单词以大写开头其余字母均小写） isupper()

string1 = 'Esther'
string2 = 'EstherT'
print(string1.isupper()) #True
print(string2.isupper()) #False

• 符串作为分隔符，插入到子字符串中所有的字符之间 join()

string = '哔哩哔哩' 
print(string.join('12345')) #1哔哩哔哩2哔哩哔哩3哔哩哔哩4哔哩哔哩5

• 字符串左对齐 ljust()

string = 'Esther'
print(string.ljust(10)) #Esther  如不指定参数，默认使用空格填空至长度为10的新字符串
print(string.ljust(15,'*')) #Esther********* 长度为15的新字符串

• 转换字符串中所有大写字符为小写 lower()

string = 'EsTHer'
print(string.lower()) #esther  

• 去掉字符串左边的空格 lstrip()

string = '     hello world'
print(string.lstrip()) #hello world

• 去掉字符串右边的空格 rstrip()

string = 'hello world      '
print(string.rstrip()) #hello world

• 去掉字符串两边空格 strip()

string = '      hello world      '
print(string.strip()) #hello world 不传参默认删除前后空格
print(string.strip('h')) #ello world 默认删除前后空格和 h

• 找到子字符串把字符串分成3个元组 partition()

string = 'hello world'
print(string.partition('wo')) #('hello ', 'wo', 'rld')
print(string.partition('ee')) #('hello world', '', '') 注意：如果字符串中不包含子字符串则返回（'原字符串','',''）

• 替换新的字符串 replace()

string = 'hello world' 
print(string.replace('hello','Hi'))  #Hi world

• 字符串分隔成列表 split()

string = 'hello world' 
print(string.split())  #['hello', 'world'] 注意：默认不传参是以空格分隔
print(string.split('o'))  #['hell', ' w', 'rld']

• 翻转字符串的大小写 swapcase()

string = 'EstHeR'
string = string.swapcase()
print(string) #eSThEr

• 把所有小写字符转换为大写 upper()

string = 'EstHeR'
string = string.upper()
print(string) #ESThER

字符串格式化

• 字符串格式化方法

str = "{0} love {1}.{2}".format("I","Love","you")
print(str) #'I love Love.you'

str = "{a} love {b}.{c}".format(a="I",b="Love",c="you")
print(str) #'I love Love.you'

str = "{0} love {b}.{c}".format("I",b="Love",c="you")
print(str) #'I love Love.you'

str = "{0:.1f}{1}".format(27.658,"GB")
print(str) #'27.7GB'

• 字符串格式化符号含义

符号	说明
%c	格式化字符及其 ASCII 码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同 %e，用科学计数法格式化浮点数
%g	根据值的大小决定使用 %f 或 %e
%G	作用同 %g，根据值的大小决定使用 %f 或者 %E

#%c运用
print('%c' % 'a') #97 注意：ASCII码a是数字97
print('%c %c %c' % ('97,98,99') #'a b c'
print('%c' % 97) #a 注意：ASCII码97是字符 a

#%s运用
print('%s' % 'hello world') #'hello world'

#%d运用
print(' %d + %d = %d' % (4,5,4+5)) #'4 + 5 = 9'

#%o运用
print('%o' % 10)  #'12'  注意：是以8进制格式打印出来  

#%x运用
print('%x' % 10) #'a' 注意：是以16进制格式打印出来  

#%X运用
print('%X' % 10) #'A' 注意：是以16进制大写格式打印出来  

#%f运用
print('%f' % 27.658)  #'27.658000' 注意：默认是6位小数没有是会补0
print('%.2f' % 27.658) #'27.66' 注意：显示2位小数

#%e运用
print('%e' % 27.658)  #'2.765800e+01'

#%E运用
print('%E' % 27.658) #'2.765800E+01'

#%g运用
print('%g' % 27.658) #'27.658'

#%G运用
print('%G' % 27.658) #'27.658'

• 格式化操作符辅助命令

符号	说明
m.n	m 是显示的最小总宽度，n 是小数点后的位数
-	用于左对齐
+	在正数前面显示加号（+）
#	在八进制数前面显示 ‘0o’，在十六进制数前面显示 ‘0x’ 或 ‘0X’
0	显示的数字前面填充 ‘0’ 取代空格

# m.n 运用
print('%5.1f' % 27.658) #' 27.7' 注意：要显示最小总宽度为5，前面有一个空格（可以省略m）
print('%.2f' % 27.658)  #'27.66 

# - 运用
print('%10d' % 5)  #'         5' 
print('%-10d' % 5) #'5         '

# + 运用
print('%+d' % 5) #'+5'
print('%+d' % -5) #'-5'

# # 运用
print('%#o' % 10) #'0o12' 
print('%#X' % 108) #'0X6C'
print('%#d' % 10) #'10'

# 0 运用
print('%010d' % 5)  s#'0000000005'
print('%-010d' % 5) #'5         '

三、random模块

• randint()： 返回随机的一个整数

import random #使用某个模块时需要先导入该模块
secret = random.randint(1,10) #设定随机数为1——10的整数数字
temp = input('输入一个你想的数字:')
guess = int(temp)
while guess !=secret:
    temp = input('猜错了请重新输入:')
    guess = int(temp)
    if guess == secret:
        print('猜中啦！')
    else:
        if guess > secret:
            print('数字大了')
        else:
            print('数字小了')
print('结束')

四、数值类型

• 整型： 表示整数
• 浮点型： 带有小数点，对于位数很多的数字，可以用e记法表示（e代表10，后面表示10的多少次方）

print(15e4) #150000.0
print(0.00000000000000000012) #1.2e-19

• 布尔类型： 可以用True或False表示，也可以当做整数看True表示1，False表示0（一般不推荐）

print(True + True) #2
print(True + False) #1
print(True * False) #0

五、列表

创建列表

• 普通列表

string = ['小明','小王','小李']
print(string) #['小明', '小王', '小李']

number = [1,2,3]
print(string) #[1,2,3]

• 混合列表

value = ['小明',2,5.02,[1,2,3]]
print(value) #['小明',2,5.02,[1,2,3]]

• 空列表

empty = []
print(empty) #[]

向列表添加元素

• 添加单个元素 append()

string = ['小明','小王','小李']
string.append('小张') #注意：只能追加到末尾
print(string) #['小明', '小王', '小李','小张'] 

• 添加多个元素 extend()

string = ['小明','小王','小李']
string.extend(['小张','小赵']) #注意：只能追加到末尾，且追加多个时需用[],用逗号隔开
print(string) #['小明', '小王', '小李','小张','小赵'] 

• 插入一个元素位置自定 insert()

#插入第一个位置
string = ['小明','小王','小李']
string.insert(0,'小张') #注意：列表的索引是从0开始的
print(string) #['小张','小明', '小王', '小李'] 

#插入中间位置
string = ['小明','小王','小李']
string.insert(len(string)//2,'小张') 
print(string) #['小明','小张', '小王', '小李'] 

互换元素的位置

string = ['小明','小张', '小王', '小李']
#我想让 小张 和 小王 互换一下位置
#首先你得知道小张位于string[1]，小王是位于string[2]
#互换先把小张放入一个临时变量， 然后把小王放入第一个string[1]里面，然后再把临时变量里面的值赋给string[2]
temp = string[1] #把小张放入一个临时变量
string[1] = string[2] #把小王放到第一个string[0]
string[2] = temp #把临时变量里面的值赋给string[2]
print(string) #['小明','小王', '小张', '小李']

列表删除元素

• 通过名字来删除 remove()

string = ['小明','小张', '小王', '小李']
string.remove('小张') #如果输入的元素列表中没有则报错
print(string) #['小明', '小王', '小李']

• 通过索引删除 或 整个列表删除 del (不是方法是一个语句)

#通过索引删除
string = ['小明','小张', '小王', '小李']
del string[0]
print(string) #['小张', '小王', '小李']

#整个列表删除
string = ['小明','小张', '小王', '小李']
del string
print(string) #NameError: name 'string' is not defined

• 从列表中取出一个元素删除 pop()

#删除最后一个元素
string = ['小明','小张', '小王', '小李']
str = string.pop() 
print(str) #'小李'
print(string) #['小明','小张', '小王']

#通过索引删除
string = ['小明','小张', '小王', '小李']
str = string.pop(1) 
print(str) #'小张'
print(string) #['小明', '小王', '小李']

列表分片（拷贝）

• 部分拷贝

string = ['小明','小张', '小王', '小李']
str = string[1:3] #从索引1开始取值,取到索引为2（3是不包含的）
print(str) #['小张', '小王']

string = ['小明','小张', '小王', '小李']
str = string[:3] #从索引0开始取值,取到索引为2
print(str) #['小明','小张', '小王']

string = ['小明','小张', '小王', '小李']
str = string[1:] #从索引1开始取值,取到结尾
print(str) #['小张', '小王', '小李']

• 全部拷贝

string = ['小明','小张', '小王', '小李']
str = string[:] 
print(str) #['小明','小张', '小王', '小李']

列表的常用操作符

• 比较操作符

list1 = [123,456]
list2 = [124,123]
print(list1 > list2) #False 注意：是拿第一个元素进行比较

• 逻辑操作符

list1 = [123,456]
list2 = [124,123]
list3 = [124,456]
print((list1 < list2) and (list1 == list3)) #True

• 连接操作符

list1 = [123,456]
list2 = [124,123]
list3 = list1 + list2
print(list3) #[123,456,124,123]

• 重复操作符

list1 = [123,456]
print(list1 * 3) #[123,456,123,456,123,456]

• 成员关系操作符(看列表里面是否有要找的元素)

list1 = [123,456,'小明','阿巴阿巴']
print('小明' in list1) #True 查找是否有小明这个元素  
print('小王' not in list1) #True 查找是否没有小王这个元素  

list2 = [123,456,'小明','阿巴阿巴',['小王',123]]
print('小王' in list1) #False 
print('小王' in list1[4]) #True 

查询元素出现次数 count()

list1 = [123,456]
list1 *= 5 #list1 = list1 * 5
list1.count(123) #5

查询元素出现位置 index()

list1 = [123,456]
list1 *= 5 #list1 = list1 * 5
#第一次出现位置
list1.index(123) #0
#根据范围出现位置
list1.index(123,3,6) #4 看看123从索引为3到索引为6在列表第一次出现的位置

列表翻转 reverse()

list1 = [123,456,789]
list1.reverse() 
print(list1) #[789,456,123]

列表排序 sort()

• 从小到大进行排序

list1 = [9,5,6,2,7,8,1,3,4,10]
list1.sort() #默认是从小到大进行排序
print(list1) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

• 从大到小进行排序

#方法一
list1 = [9,5,6,2,7,8,1,3,4,10]
list1.sort() 
list1.reverse() 
print(list1) [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

#方法二
list1 = [9,5,6,2,7,8,1,3,4,10]
list1.sort(reverse=True) #默认为False，表示从小到大进行排序，如果为True则表示从大到小进行排序
print(list1) [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

六、元组（不可直接更改，用跟列表差不多）

创建元组

• 普通元组（可以省略小括号）

tuple = ('小明','小王','小李')
print(tuple) #('小明', '小王', '小李')

tuple = (1,2,3)
print(tuple) #(1,2,3)

• 单个元组（需要在后面加一个逗号）

tuple = (1)
print(tuple) #1 注意：不是元组类型 是整型
print(type(tuple)) #<class 'int'>

tuple = (1,)
print(tuple) #(1,)
print(type(tuple)) #<class 'tuple'>

• 混合元组

value = ('小明',2,5.02,(1,2,3))
print(value) #('小明', 2, 5.02, (1, 2, 3))

• 空元组

empty = ()
print(empty) #()

• 元组的多次增加

tuple = 3 * (1,)
print(tuple) #(1, 1, 1)

#如果不写逗号
tuple = 3 * (1)
print(tuple) #3

更新元组

• 插入一个元素位置自定

#插入第一个位置
string = ('小明','小王','小李')
string = ('小张',) + string[:]
print(string) #('小张', '小明', '小王', '小李')

#插入中间位置
string = ('小明','小王','小李')
string = string[:1] + ('小张',) + string[1:]
print(string) #('小明', '小张', '小王', '小李')

#插入最后位置
string = ('小明','小王','小李')
string =  string[:] + ('小张',)
print(string) #('小张', '小明', '小王', '小李')

删除元组（一般不使用）

#语法
del 数组名字

七、序列

列表、元组、字符串共同点

• 都可以通过索引得到每一个元素
• 默认索引值从0 开始
• 可以通过分片的方法得到一个范围内的元素集合
• 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

常用函数

• 把一个可迭代对象转换为列表 list()

str = 'hello world'
print(list(str)) #['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

num = (1,21,4,9)
print(list(num)) #[1, 21, 4, 9]

• 把一个可迭代对象转换为元组 tuple()

str = 'hello world'
print(tuple(str)) #('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')

num = [1,21,4,9]
print(tuple(num)) #(1, 21, 4, 9)

• 返回参数长度 len()

str = 'hello world'
print(len(str)) #11

• 返回序列或者参数集合中最大值 max()

#注意：要保证数据类型统一
str = 'hello world'
num = (1,21,4,-24)
print(max(str)) #w 注意：每个字符都有个ASCII 码，根据ASCII码比较最大值
print(max(num)) #21 

• 返回序列或者参数集合中最小值 min()

#注意：要保证数据类型统一
str = '1234567890'
num = (1,21,4,-24)
print(min(str)) #0
print(min(num)) #-24 

• 返回序列和可选参数的总和 sum()

#注意：要保证数据类型统一
num = (3.1,2.3,3.4) 
str = '1234567890'
print(sum(str)) #报错
print(sum(num)) #8.8
print(sum(num,8)) #16.8 注意：第二个参数可以不写，如果有则前面总和加上后面的参数

• 对序列进行从小到大排序 sorted()

num = (1,21,4,-24)
print(sorted(num)) #[-24, 1, 4, 21]

• 翻转列表返回一个集合对象 reversed()

num = (1,21,4,-24)
print(reversed(num)) #<reversed object at 0x000001CC43014C88> 注意：这里是一个对象，可以通过list()方法得到值
print(list(reversed(num))) #[-24, 4, 21, 1]

• 枚举 enumerate()

num = (1,21,4,-24)
print(enumerate(num)) #<enumerate object at 0x000001CC4309B900>
print(list(enumerate(num))) #[(0, 1), (1, 21), (2, 4), (3, -24)]

• 返回由各个参数的序列组成的序列 zip()

a = [1,2,3,4,5,6,7,8]
b = [5,6,7,8]
print(zip(a,b)) #<zip object at 0x000001CC4309ADC8>
print(list(zip(a,b))) #[(1, 5), (2, 6), (3, 7), (4, 8)]