阿里云天池 Python训练营Task2: Python基础练习：数据结构大汇总 学习笔记
本学习笔记为阿里云天池龙珠计划Python训练营的学习内容，学习链接为：https://tianchi.aliyun.com/specials/promotion/aicamppython?spm=5176.22758685.J_6770933040.1.6f103da1tESyzu
目录
一、学习知识点概要
二、学习内容
I.列表（list）
1.定义
2.创建列表
3.列表的添加、删除操作
4.列表元素选取
5.列表常用操作符
6.列表的其他方法
II.元组（tuple）
1.定义
2.创建元组
3.元组的更新和删除
4. 元组常用操作符
5.元组的内置方法
6.解压元组
III.字符串（str）
1.定义
2.字符串常用转义字符
3.字符串的索引和切片
4.字符串的操作符
5.字符串的内置方法
6.字符串格式化
IV.字典（dict）
1.定义
2.创建和索引
3.字典的内置方法
V.集合（set）
1.定义
2.创建
2.访问集合中的值
3.集合的内置方法
4.不可变集合（frozenset）
VI.序列
三、学习问题与解答
四、学习思考与总结
一、学习知识点概要
本次主要学习Python中的容器（序列）类型，包括：
- 列表（list）
- 元组（tuple）
- 字符串（str）
- 字典（dict）
- 集合（set）
二、学习内容
I.列表（list）
1.定义
列表(list)为有序集合，可以保存任意类型的对象，语法为[元素1,元素2,……,元素n]。列表的语法点在于用中括号“[]”将元素放在一起，用逗号“,”将元素隔开
2.创建列表
列表可以通过直接赋值创建，也可以用内置方法list(sub)把可迭代对象sub转化为列表，其中sub可以为range对象、字符串等。此外，在上次的学习中学习的列表推导式也可以用于创建列表,例如：
a=[1,2,'Python',True] #直接赋值创建列表，元素为任意对象，列表中保存的是对象的引用
print(a,type(a))#运行结果：#[1,2,'Pthon',True] <class'list'>b=list(range(1,11)) #通过list()方法将range对象转换为列表
print(b,type(b))#运行结果：#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] <class 'list'>c=[i*2 for i in b] #通过推导式创建列表
print(c,type(c))#运行结果：#[2, 4, 6, 8, 10, 12, 14, 16, 18, 20] <class 'list'>d=[] #创建空列表，之后可以用list类的内置方法添加元素，详见下文f=[[1,2,3]]*3 #列表的元素也可以是容器类型
print(f,type(f)) #*3的操作意为将创建了3份原列表的引用，看似是3个相同的列表拼在了一起
f[0][1]=5 #其实这3个相同列表的引用都是一样的，都指向原列表
print(f,type(f)) #只要一个列表产生变化，原列表就会变化，其他被拼接起来的列表也会变化#运行结果：#[[1, 2, 3], [1, 2, 3], [1, 2, 3]] <class 'list'>#[[1, 5, 3], [1, 5, 3], [1, 5, 3]] <class 'list'>3.列表的添加、删除操作
列表中有一些内置方法，可对列表进行添加或删除元素的操作。这些操作对列表的id不产生影响，这表明列表是可变的。字典和集合也是可变的，而数值、元组、字符串是不可变的。
判断一个数据可不可变可以用hash()方法判断，如果参数的数据类型是可变的，那么就会报错。
(1)添加元素
- list.append(obj)在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类。append()方法一次只添加一个元素，若参数obj为一个列表，那么这个列表会作为一个整体添加到 list 中；
- list.extend(seq)在列表末尾一次性追加另一个序列中的多个值，参数seq为列表，此方法用新列表seq拓展原列表list。相当于把seq接到list的末尾，是对list的操作，无返回值；
- list.insert(index,obj)在编号index的位置插入元素obj。对参数obj的要求和append()一样，index表示第几个间隔，index从0数起。
例程：
x=list(range(1,6))
print(x) #运行结果:[1,2,3,4,5]x.append(6) #在末尾添加元素6
print(x) #运行结果:[1,2,3,4,5,6]x.append([7,8]) #参数obj为列表，将列表整体当作一个元素添加到末尾
print(x) #运行结果:[1,2,3,4,5,6,[7,8]]x.extend([9,10]) #用列表[9,10]拓展x，即将[9,10]中的所有元素添加到x的末尾
print(x) #运行结果:[1,2,3,4,5,6,[7,8],9,10]x.insert(0,'Numbers') #在第0个间隔之间(即最左端)插入字符串'Numbers'
print(x) #运行结果:['Numbers',1,2,3,4,5,6,[7,8],9,10](2)删除元素
- list.remove(obj)删除列表中第一个与obj相同的元素。remove()方法为对list的一项操作，无返回值；
- list.pop([index=-1])返回并删除列表中index位置的元素。index为可选参数，表示列表的索引，索引相关详见下文。pop()方法默认取出列表中的最后一个元素；
- del语句可以用于删除单个或多个列表对象。具体用法为 del list[var1]，或del list[start:end:step]。del 语句原本就可以用于删除变量，若del 后面写的是列表则删除整个列表，若写的是列表的切片则删除列表中相对应的元素。
例程：
x=['I','Love','Python',1,2,3]
print(x,type(x)) #运行结果:['I','Love','Python',1,2,3] class<'list'>x.remove('I') #删除x中的'I'
print(x) #运行结果:['Love', 'Python', 1, 2, 3]y=x.pop() #从x中取出最后一个元素赋给y
print('x=',x,'\ny=',y,sep="") #运行结果:x=['Love', 'Python', 1, 2]# y=3del x[2],x[2] #删除x中的第3个元素，依次执行
print(x) #注意：del语句后的删除对象是依次执行的，先执行完一次#删除x[2]后x[3]就没有了，然后再执行一次删除x[2]
#运行结果：['Love', 'Python']4.列表元素选取
(1)索引
可以通过list[index]的方式表示列表list中的元素，index为索引值，整数，从0开始。
若index为负数，则从右到左数起。例如list[-1]是列表list的最后一个元素，list[-2]是列表list的倒数第二个元素。
(2)切片
切片是一种一次性从列表里进行多个索引的方式，写法为list[start:end:step=1]，start为选取的第一个元素，end为选取的最后一个元素，step为步长，默认为1。切片有四种用法：
- list[start:] 从start位置开始，选取后面的所有元素
- list[:end] 从第一个元素开始，选取到end位置的前一个元素（含头不含尾）
- list[start:end] 从start位置开始，选取到end位置的前一个元素
- list[start:end:step] 从start位置开始，每隔step个间隔选取一个元素，直到end位置为止（不含end位置上的元素）
- list[:] 选取所有元素，进行浅拷贝
例如：
x=list(range(1,11))
print(x) #[1,2,3,4,5,6,7,8,9,10]
print(x[5:]) #[6,7,8,9,10]
print(x[:7]) #[1,2,3,4,5,6,7]
print(x[2:7]) #[3,4,5,6,7]
print(x[0:8:2]) #[1,3,5,7]y=x[:] #y为x的浅拷贝
z=x #z为x的深拷贝
x[0]=11
print(y) #[1,2,3,4,5,6,7,8,9,10]
print(z) #[11,2,3,4,5,6,7,8,9,10]
浅拷贝是将列表的各个元素的引用依次给新的列表，而深拷贝则是将列表的引用直接赋给新的列表，这就导致对原本的列表进行操作时，浅拷贝出来的列表不会受到影响，而深拷贝出来的列表会和原列表一致。
5.列表常用操作符
- == 用于判断两个列表是否相等，只有当对应位置上的元素都相等才返回True
- + 用于拼接两个列表
- * 后面接整数n，用于把原列表重复n次形成新列表，若n小于或等于0则生成空列表
- in 判断元素是否在列表内
- not in 判断元素是否不在列表内
将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
6.列表的其他方法
- list.count(obj) 统计obj元素在list列表中出现多少次
- list.index(obj,[start[,end]]) 返回obj元素在list列表里[start:end]范围内第一次出现的索引值
- list.reverse() 将列表list里的元素反方向排列，对list直接操作，无返回值
- list.sort(key=None,reverse=False) 将列表进行排序。key主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse排序规则，为True时降序，为False时升序（默认）。
例如：
x=[1,2,3]*4
print(x) #[1,2,3,1,2,3,1,2,3,1,2,3]print(x.count(1)) #计1出现的次数#4print(x.index(2,2,6)) #在下表[2,6]的范围内检查2第一次出现的下标#4x.reverse() #将x反向排序
print(x) #[3,2,1,3,2,1,3,2,1,3,2,1]x.sort() #将x排序
print(x) #[1,1,1,1,2,2,2,2,3,3,3,3]II.元组（tuple）
1.定义
与列表类似，不同点在于元组用小括号()将元素绑在一起，元组不可修改。与列表类似，元组也可以用整数进行索引和切片。
2.创建元组
- 元组可以直接赋值创建，赋值时若有多个元素，可以不加小括号；若只有一个元素，则需要在元素后面加上一个逗号，否则会被认为是其他数据类型
- 元组可以用内置方法tuple(sub)将可迭代对象对象sub转化为元组
- 可以用小括号创建空元组
- 可以用推导式创建可迭代对象，再转换成元组
例：
a=(4,5,6) #直接赋值创建元组
print(a,type(a)) #(4, 5, 6) <class 'tuple'>b=(1,) #单个元素创建元组需要在元素后面加上逗号
c=(1)
d=1,2,3 #多个元素时可以不加小括号
print(type(b),type(c),type(d),sep="\n") #<class 'tuple'>#<class 'int'>#<class 'tuple'>f=tuple(range(1,6)) #用tuple()方法把range对象转换为元组
print(f,type(f)) #(1, 2, 3, 4, 5) <class 'tuple'>g=() #创建空元组
print(g,type(g)) #() <class 'tuple'>h=tuple((i*3 for i in f)) #推导式创建可迭代对象，再转换成元组
print(h,type(h)) #(3, 6, 9, 12, 15) <class 'tuple'>
3.元组的更新和删除
元组有不可更改的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改，那么我们可以直接更改其元素，注意这跟赋值其元素不同。（列表、字典、集合可以改变）
例：
a=(1,2,3,[4,5,6])
a[3][0]=8
print(a,type(a)) #(1, 2, 3, [8, 5, 6]) <class 'tuple'>del a[3][0]
print(a,type(a)) #(1, 2, 3, [5, 6]) <class 'tuple'>
4. 元组常用操作符
元组的常用操作符有「==」，「+」，「*」，「in」，「not in」。用法与列表的操作符相同，此处不作赘述。
5.元组的内置方法
由于元组的不可改变性，元组的内置方法只有count()和index()。用法也与列表的count()和index()相同，此处不作赘述。
6.解压元组
通过(变量1 , 变量2 , …… , 变量n)=元组 的方式可以将元组中的元素依次付给等号左边的变量，等号左边的括号结构要与元组的结构相同（长度、维度）
如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。
例：
x=(1,2,'Python',[10.2,6])
(a,b,c,[d,f])=x
print(a,b,c,d,f) #1 2 Python 10.2 6y=tuple(range(1,6))
q,w,*rest,r=y
print(q,w,r) #1 2 5
print(rest) #[3, 4] rest为一个列表t=1,2,3,4,5
a,b,*_=t
print(a,b) # 1 2III.字符串（str）
1.定义
字符串为用引号之间的字符集合，可以用单引号也可以用双引号。例如 'Python' ，"S-PLUS"都是字符串。
2.字符串常用转义字符
由于反斜杠「\」、单引号「'」、双引号「"」在字符串中有特殊性，因此如果要在字符串中出现这三个符号，需要在前面再加上一个反斜杠。
- \\ 反斜杠
- \' 单引号
- \" 双引号
- \n 换行符
- \r 回车符
- \t 横向制表符
若要表示原始字符串则只需在字符串之前加上小字母「r」即可。
三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
例：
print("I\nLove\nPython")
#I
#Love
#Pythonprint(r"I\nLove\nPython")
#I\nLove\nPythonpara_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB ( )。
# 也可以使用换行符 [
# ]。
3.字符串的索引和切片
字符串的索引和切片与列表和元组的类似，每一个字符都为字符串的元素，此处不作赘述。
4.字符串的操作符
字符串的操作符也为「==」，「+」，「*」，「in」，「not in」，用法与列表和元组相同。
5.字符串的内置方法
- str.capitalize() 返回一个新字符串，将字符串的第一个字符转换为大写，其他的转为小写
- str.lower() 返回一个新字符串，转换字符串中所有大写字符为小写
- str.upper() 返回一个新字符串，转换字符串中所有大写字符为大写
- str.swapcase() 返回一个新字符串，将字符串中大写转换为小写，小写转换为大写
- str.count(str1,beg=0,end=len(str)) 统计字符串str1在str的指定范围(beg,end)出现的次数
- str.endswith(suffix, beg=0, end=len(string)) 检查指定范围内的字符串是否以suffix结束
- str.startswith(substr, beg=0,end=len(string)) 检查指定范围内的字符串是由以substr开始
- str.find(str1, beg=0, end=len(string)) 从左查找str1在指定范围字符串内的位置，返回索引值，若str1不在指定范围内则返回-1
- str.rfind(str, beg=0,end=len(string)) 与find()类似，从右开始查找
- str.isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
- str.ljust(width[,fillchar=" "]) 返回一个新字符串，用fillchar扩充原字符串至长度width为止，原字符串向左对齐
- str.rjust(width[,fillchar=" "]) 和ljust()类似，原字符串向右对齐
- str.lstrip([chars]) 删除字符串左边的空格或指定字符
- str.rstrip([chars]) 删除字符串右边的空格或指定字符
- str.strip([chats]) 执行lstrip()和rstrip()
- str.partition(sub) 找到子字符串sub，把字符串分为一个元组('左边的字符串','sub','右边的字符串')，如果字符串中不包含sub则返回('原字符串','','')
- str.rpartition(sub) 与partition()类似，从右边开始查找
- str.replace(old,new[,max]) 把将字符串中的old替换成new，如果max指定，则替换不超过max次
- str.split(str=" ",num) 不带参数默认是以空格为分隔符分开字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表
- str.splitlines([keepends]) 如果字符串按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符
- str.maketrans(intab,outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
- str.translate(table,deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。
6.字符串格式化
可以用str.format()格式化方法进行格式化，例如：
str8 = "{0} Love {1}".format('I', 'Lsgogroup') # 位置参数
print(str8) # I Love Lsgogroupstr8 = "{a} Love {b}".format(a='I', b='Lsgogroup') # 关键字参数
print(str8) # I Love Lsgogroupstr8 = "{0} Love {b}".format('I', b='Lsgogroup') # 位置参数要在关键字参数之前
print(str8) # I Love Lsgogroupstr8 = '{0:.2f}{1}'.format(27.658, 'GB') # 保留小数点后两位
print(str8) # 27.66GB格式化符号：
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串，用str()方法处理对象 |
| %r | 格式化字符串，用rper()方法处理对象 |
| %d | 格式化整数 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | 根据值的大小决定使用%f或%e |
| %G | 作用同%g，根据值的大小决定使用%f或%E |
例：
print('%c' % 97) # a
print('%c %c %c' % (97, 98, 99)) # a b c
print('%d + %d = %d' % (4, 5, 9)) # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 我叫 小明 今年 10 岁!
print('%o' % 10) # 12
print('%x' % 10) # a
print('%X' % 10) # A
print('%f' % 27.658) # 27.658000
print('%e' % 27.658) # 2.765800e+01
print('%E' % 27.658) # 2.765800E+01
print('%g' % 27.658) # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text) # I said: I am 22 years old..
print("I said: %r." % text) # I said: 'I am 22 years old.'格式化操作符辅助命令：
| 符号 | 功能 |
|---|---|
| m.n | m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话） |
| - | 用作左对齐 |
| + | 在正数前面显示加号( + ) |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
例：
print('%5.1f' % 27.658) # ' 27.7'
print('%.2e' % 27.658) # 2.77e+01
print('%10d' % 10) # ' 10'
print('%-10d' % 10) # '10 '
print('%+d' % 10) # +10
print('%#o' % 10) # 0o12
print('%#x' % 108) # 0x6c
print('%010d' % 5) # 0000000005IV.字典（dict）
1.定义
- 字典是无序的，由大括号绑起来的(key:value)键值对集合，语法结构为{key1:value1,key2:value2, …… ,key n:value n}
- 同一字典内的键(key)是不重复的
- 字典用不可变数据作为键，而值没有这个要求
- 字典内的排放顺序与键的放入顺序无关
- 字典的每一个元素为(key:value)键值对
- 冒号用于分开键和值
2.创建和索引
字典可以通过直接赋值创建，也可以用推导式创建，还可以用dict()创建一个字典。
dict()内的参数可以是n×2维的列表，列表内的元素为二维的元组，这样会将元组的两个元素分别作为键值对创建字典
也可以直接用dict(key1=value1,key2=value2, ……)的方式创建字典，但是这样的字典的键只能是字符串
例：
dic={'李宁':'一切皆有可能','耐克':' Just do it','阿迪达斯':'Impossible is nothing'}
print('耐克的口号是:',dic['耐克'])# 耐克的口号是: Just do itb={i:i%2==0 for i in range(10) if i % 3 == 0} #推导式创建
print(b)
# {0: True, 3: False, 6: True, 9: False}c=dict() #创建空字典
c['a']=1
c['b']=2
print(c)
# {'a':1 ,'b':2}dic2=dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2) # {'peach': 4127, 'cherry': 4098, 'apple': 4139}dic = dict(name='Tom', age=10)
print(dic,type(dic)) # {'name': 'Tom', 'age': 10} <class 'dict'>字典的索引只能通过键来索引，语法结构为dict[key]，返回的是对应键的值value，如果索引的键不存在，则会报错。
3.字典的内置方法
- dict.fromkeys(seq[,value]) 用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值
- dict.keys() 返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键
- dict.values() 与keys()类似，不过返回的内容是所有的值
- dict.items() 以n×2列表的形式返回可遍历的 (键, 值) 元组数组，列表元素为元组
- dict.get(key,default=None) 与dict[key]类似，返回指定键的值，但如果值不在字典中则返回默认值default
- dict.setdefault(key,default=None) 与get()类似，类似，如果键不存在于字典中，将会添加键并将值设为默认值
- in 和 not in 操作符 字典也可以使用in和not in 操作符，不过只能检查键key是否在字典中
- dict.pop(key[,default]) 抛出给定键key对应的值，若key不存在，则必须设置默认值default并会返回默认值
- del dict[key] 删除字典中给定的键所在的元素
- dict.popitem() 随机抛出字典中的一个值，若字典为空，则会报错
- dict.clear() 删除字典中的所有元素
- dict.copy() 返回字典的一个浅拷贝
- dict.update(dict2) 键字典型参数dict2中的元素更新到dict中
V.集合（set）
1.定义
- 集合与字典相似，由大括号将元素绑在一起，但是集合只保存键(key)
- 由于字典中key不可重复，所以集合中也没有重复的元素
- 集合中的元素（即key）为不可变型数据
2.创建
集合可以通过直接赋值创建，也可以用推导式创建，还可以用set(value)函数将可迭代对象转换成集合，重复元素会被自动过滤。
例：
a={1,2,3,4,4} #直接赋值创建集合，重复元素自动过滤
print(a,type(a)) #{1, 2, 3, 4} <class 'set'>b={i*2 for i in range(1,11) if i%3==0} #推导式创建集合
print(b,type(b)) #{18, 12, 6} <class 'set'>c=set(list(range(5,12))) #set()将列表转化为集合
print(c,type(c)) #{5, 6, 7, 8, 9, 10, 11} <class 'set'>d=set() #创建空集合只能用set()创建
print(d,type(d)) #{} <class 'set'>2.访问集合中的值
由于集合的无序性，我们不能用索引取得集合中的值，但我们仍然可以用一些方法得到一些值
- 用针对序列的方法len(set)可以返回集合set的大小，即元素的个数
- 集合作为可迭代对象也可以用for循环一个个读取出来
例：
b={i*2 for i in range(1,11) if i%3==0}
print(b) #{18, 12, 6}for j in b:print(j) #18#12#6
- 可以用 in 和 not in 操作符判断一个元素是否在集合里
3.集合的内置方法
- set.add(elmnt) 用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作
- set.update(set2) 与字典的update()方法类似，将集合set2中的元素更新到集合set里
- set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误
- set.discard(item) 与remove()类似，但不会报错
- set.pop() 随机抛出一个元素
- set.intersection(set2) 返回set与set2的交集，操作与set & set2 相同
- set.intersection_update(set2) 将set更新为原set和set2的交集
- set.union(set2) 返回set与set2的并集，操作与set | set2 相同
- set.difference(set2) 返回set与set2的差集，操作与set - set2 相同
- set.difference_update(set2) 将set更新为原set和set2的差集
- set.symmetric_difference(set2) 返回set与set2的异或，操作与set ^ set2 相同，也与(set | set2) - (set & set2)相同
- set.symmetric_difference_update(set2) 将set与set2的异或更新到set中
- set.issubset(set2) 判断set是否被set2包围，操作与set <= set2 相同
- set.issuperset(set2) 判断set是否包围set2，操作与set >= set2相同
- set.isdisjoint(set2) 判断set与set2是否不相交，不相交则返回True
4.不可变集合（frozenset）
普通的集合是可变的，但是Python提供了实现不可变集合的方法，不可变集合与集合不属于同一类，不可变集合属于<frozenset>
不可变集合与普通集合类似，但是不能添加或删除元素，因此不能用代有update的方法
frozenset([iterable])可以将可迭代对象iterable转换为不可变集合，如果没有参数则生成不可变的空集
VI.序列
序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。
一般的有转换类型的方法如：list()、tuple()和str()等，此外还有一些通用的方法：
- len(s) 返回序列类型s的元素个数（长度）
- max(sub) 返回序列或者参数集合中的最大值，若sub为字符串，则比较ASCII码值
- min(sub) 返回序列或者参数集合中的最小值
- sum(iterable[,start=0]) 返回序列（可迭代对象）iterable与可选参数start的总和
- sorted(iterable,key=None,reverse=Flase) 对所有可迭代对象iterable进行排序操作，key和reverse参数和前文提到的sort()方法相同
- reversed(seq) 返回一个反转的可迭代对象
- enumerate(sequence[,start=0]) 将可枚举的对象（序列）组合为一个索引序列，常用在for循环中
- zip(iter1 [,iter2 [...]]) 将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。若不同对象的长度不同，则返回的列表长度与最短的对象相同，用*zip()可以将zip对象解压
三、学习问题与解答
本次学习遇到的主要问题是出现的方法很多，每种类型的内置方法都很多。遇到的一些具体的问题比如：用切片的时候经常会弄不懂是怎么切的，我是通过自己上机实验和百度直到切片的一个原则是含头不含尾，才弄清楚切片。
四、学习思考与总结
学习编程语言的一个重要的学习方法就是一定要多上手，要自己打代码运行才能更好的知道各个操作和方法的作用。
阿里云天池 Python训练营Task2: Python基础练习：数据结构大汇总 学习笔记相关推荐
- 阿里云天池AI龙珠计划-Python训练营考试题
阿里云天池AI龙珠计划-Python训练营考试题 简介:题目有25道,每次题目都是题库中选的,包含单选和多选,每题4分,以下是我考试时所做的题目(全是正确答案) 链接: https://tianchi ...
- 阿里云天池SQL训练营学习记录
SQL训练营任务 打卡目录 SQL训练营任务 前言 一.Task01打卡 二.Task02打卡 三.Task03打卡 总结 一.算术函数 二.字符串函数 三.日期函数 四.转换函数 五.LIKE谓词 ...
- 阿里云天池SQL训练营task6笔记
本笔记为阿里云天池龙珠计划SQL训练营的学习内容,链接为: Task06:综合练习题-10道经典题目-天池龙珠计划SQL训练营-天池技术圈-天池技术讨论区 (aliyun.com) 如果你 ...
- 阿里云天池机器学习训练营(Day10):幸福感预测
1 赛题背景 在社会科学领域,幸福感的研究占有重要的位置.这个涉及了哲学.心理学.社会学.经济学等多方学科的话题复杂而有趣:同时与大家生活息息相关,每个人对幸福感都有自己的衡量标准.如果能发现影响幸 ...
- 阿里云天池AI龙珠计划-Python训练营学习笔记task2
数据结构 数据结构一直以来就是我学编程的一个问题,因为我是主修硬件对编程的一些概念不是很清楚所以很多理解只能靠记和背很难说出自己的理解. 列表 列表的定义: 列表是有序集合,没有固定大小,能够保存任意 ...
- 阿里云天池AI龙珠计划-Python训练营 最终测试
最终考试,先来分享一下成绩 因为担任过python课程的助教,所以感觉好多题目都好熟悉,这些题目也可以用来当作期末考试的题库使用. 1.关于内存管理,下列说法错误的是? (B) A. 变量不必事先声明 ...
- 阿里云天池AI龙珠计划-Python训练营学习笔记task1
作为一个工科生,学习代码和语言是必经之路,我个人对硬件比较感兴趣所以C语言,C++,Java都会一些.但作为一个物联网专业的学生那么大数据方面的知识还是要具备的,所以在参加了龙珠计划进行学习.为了是了 ...
- 【阿里云天池AI龙珠计划-Python训练营】学习笔记task1
作为一个工科生,学习代码和语言是必经之路,我个人对C语言比较感兴趣.但作为一个物联网专业的学生那么大数据方面的知识还是要具备的,所以参加了龙珠计划进行学习.是为了了解大数据的基本知识和学会Python ...
- 阿里云天池，母婴数据分析python,可视化
本次综合实验以阿里巴巴天池的婴儿用品购买数据集为例,进行相关分析并提出建议. 数据来源说明:该数据源自于阿里天池,数据具体为2012年7月2日至2015年2月5日发生在淘宝天猫交易平台关于婴幼儿商品的 ...
最新文章
- 同步、异步、堵塞、非堵塞和函数调用及I/O之间的组合概念
- bs4库的prettify()方法|粉饰的意思。就是多了换行！
- vim文本编辑器使用技巧
- 乐观锁、悲观锁简单分析，回忆旧（新）知识...
- NOJ 20 吝啬的国度
- python commands模块在python3.x被subprocess取代
- SpringBoot整合oss实现文件的上传,查看,删除,下载
- 给你的网站添加运行时间
- python 爬虫库比较_公认8个效率最高的爬虫框架
- 继微信支付后 支付宝宣布向银联云闪付开放线上场景
- Laravel教程 四：数据库和Eloquent
- springboot在线外卖点餐系统毕业设计毕设作品开题报告开题答辩PPT
- 密码学入门（5）：单向散列函数
- 访问网页出现503服务器,503错误,详细教您网页出现503错误怎么解决
- 北京大学计算机科学技术研究所研究员万小军：机器写稿技术与应用 | CCF-GAIR 2017...
- Java对接腾讯IM以及一些方法的简单封装
- c语言sizeof用法计算char,C语言里sizeof（char）是什么意思
- 如何录制音频文件mp3？给你推荐好用的几款音频录制软件
- php图片不显示怎么处理,如何解决php图片因存在错误而无法显示
- 基于深度学习的行为识别方法综述