python内置的数据结构有：
列表(list)
元组(tuple)
字典(dict)
集合(set)
在python语言中，以上4种数据结构和基础数据类型（整数、浮点数等）统称为“内置类型”（Built-in Types）。
参考：http://wed.xjx100.cn/news/317220.html?action=onClick
# 定义空列表
test = []
# 使用 list() 构造函数创建列表：
test = list(('apple', 'banana', 'cherry'))
# 定义非空列表
name = ['Tom','Jack','John']
pet = ['cat','dog','bird']
# 打印列表
print(name) # ['Tom', 'Jack', 'John']
print(pet) # ['cat', 'dog', 'bird']
range() 为 python 的自有类，range() 带有内置的迭代方法iter() 和 next() ，它是一个可迭代对象，我们可以通过 for 访问 range() 创建的迭代器。
range 类初始化参数说明：
range(stop): 从0开始到stop结束（不包含 stop）返回一个产生整数序列的迭代对象
range(start, stop[, step]): 从 start 开始到 stop 结束（不包含 stop）返回一个整数序列的迭代对象, step 为他的步长
# 循环输出1-10之间的数字
for num in range(11):
print(num,end=" ")
# 输出1-10之间的偶数
for num in range(2,11,2):
print(num,end=" ")
# 输出1-10之间的奇数
for num in range(1,11,2):
print(num,end=" ")
# 输出1-10之间的奇数的平方
for num in range(1,11,2):
print(num**2,end=" ")
# 创建一个数字列表
numbers = list(range(1,11))
print(numbers)
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：
# 通过索引读取列表中的元素，索引从0开始，-1代表最后一个元素
print(name[0]) # Tom 查看列表中第一个
print(pet[2]) # bird 查看列表中第二个
print(name[-1]) # John 查看列表中最后一个
print(pet[-2]) # dog 查看列表中倒数第二个
print(name[0:2]) # ['Tom', 'Jack'] 查看索引2之前的元素
切片是 python 序列的重要操作之一，适用于列表、元组、字符串、range 对象等类型。切片使用2个冒号分隔的3个数字来完成：
第一个数字表示切片的开始位置，默认为0，
第二个数字表是切片的截止（但不包含）位置（默认为列表长度），
第三个数字表示切片的步长(默认为1)，当步长省略时，顺便可以省略最后一个冒号。
可以使用切片来截取列表中的任何部分，得到一个新列表，也可以通过切片来修改和删除列表中部分元素，甚至可以通过切片操作为列表对象增加元素。与使用下标访问列表元素不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。
# 创建一个列表
pets = ['cat','dog','duck','pig']
# 1、读取列表中2和3的元素
pets[1:3]
# 2、读取列表中1到4的元素
pets[0:4]
# 3、读取列表中的第一个元素
pets[0]
# 4、读取列表中的最后一个元素
pets[-1]
# 5、读取列表中，从第二个元素开始的所有元素
pets[1:]
# 6、读取列表中，从第一个元素开始的所有元素
pets[0:]
# 7、读取列表中，从倒数第三个元素开始的所有元素
pets[-3:]
# 8、循环输出列表中，从倒数第三个元素开始的所有元素
for pet in pets[-3:]:
print(pet,end=" ")
# 9.读取列表中，从第三个开始的所有数据，并组合一下数据
games = ['王者','吃ji','抢滩登陆']
# friend_games = ['王者','吃ji']
friend_games = games[:2]
print('我喜欢的游戏有:'+str(games)) # 我喜欢的游戏有:['王者', '吃ji', '抢滩登陆']
print('我朋友喜欢的游戏有:'+str(friend_games)) # 我朋友喜欢的游戏有:['王者', '吃ji']
向 python 列表里面添加元素主要有三种方法：
append() 对于列表的操作主要实现的是在列表最后添加一个元素，并且只能一次添加一个元素，并且只能在列表最后；
name.append(元素A)
# 在列表末尾添加新元素
name.append('Bob')
extend() 对于列表的操作主要实现的是对于特定列表的扩展和增长，可以一次添加多个元素，不过也只能添加在列表的最后；
name.extend([元素A，元素B，……])
name.extend(['Xgp','Wsd'])
insert() 对于列表的操作主要是在列表的特定位置添加想要的元素，比较常用，这里的特定位置是指元素在列表中的索引号，需要注意的是这里的索引号都是从0开始的，不是从1开始的。
?pet.insert(A, 元素B)：表示在列表pet的第A处加入元素B
# 在列表指定位置添加新元素
pet.insert(0,'penguin') #在列表最前面添加数据
pet.insert(-2,'pig') #在列表倒数第二个添加数据
使用链表索引，直接赋值即可。
与之前 python 列表的添加元素相对，删减列表里面的一些元素也有三种方法：
它的作用是删除列表中索引号为n 的元素，这里需要注意的是del是一种操作语句。
del pet[n]
# 根据索引从列表中删除元素
del pet[0] # 删除开头的元素
del pet # 删除列表
它的作用有两个
pop() 返回列表最后一个元素，并且删除
temp=pet.pop() # 这里temp等于列表最后一个元素。
pop(n) 弹出指定位置的元素，并且删除
print(pet)
temp=pet.pop(2) # ['cat', 'dog', 'penguin', 'bird'] 弹出指定位置的元素
print(pet, temp) # ['cat', 'dog', 'bird'] penguin
remove() 的作用是移除列表的特定元素，不返回；
pet.remove(元素A)
# 根据元素的值进行删除：remove()
print(pet) # ['cat', 'dog', 'penguin', 'bird'] 查看源列表
temp=pet.remove('cat') #删除cat
print(pet,temp) # ['dog', 'penguin', 'bird'] None 打印列表
clear() 方法用于清空列表，类似于 del a[:]。
语法： list.clear()
word = ['A', 'B', 'C']
word.clear()
print(word) # []
sort() 排序方法：此函数方法对列表内容进行正向排序，排序后的新列表会覆盖原列表（id不变），也就是sort排序方法是直接修改原列表list排序方法。
# 定义列表：汽车的品牌
print('原始排序：')
brand = ['audi','bmw','toyota','luhu']
print(brand) # ['audi', 'bmw', 'toyota', 'luhu']
# 永久排序: sort()
print('正序排序：')
brand.sort()
print(brand) # ['audi', 'bmw', 'luhu', 'toyota']
sorted() 方法：即可以保留原列表，又能得到已经排序好的列表.
#临时排序
print('临时排序：')
print(sorted(brand)) # ['audi', 'bmw', 'luhu', 'toyota']
reverse=[True|False] 列表反转排序：是把原列表中的元素顺序从左至右的重新存放，而不会对列表中的参数进行排序整理。如果需要对列表中的参数进行整理，就需要用到列表的另一种排序方式 sort() 正序排序。
# 倒序排序
print('倒序排序:')
brand.sort(reverse=True)
print(brand) # ['toyota', 'luhu', 'bmw', 'audi']
总结：
print() # 打印输出
len() # 确定列表项目
type() # 返回变量类型
list() # 转换为列表
max() # 返回列表元素最大值
min() # 返回列表元素最小值
del # 删除列表
append(obj) # 在列表末尾添加新的对象
insert(index, obj) # 在指定位置添加元素
extend(seq) # 将列表元素（或任何可迭代的元素）添加到当前列表的末尾
count(obj) # 统计某个元素在列表中出现的次数
index(obj) # 返回具有指定值的第一个元素的索引
sort( key=None, reverse=False) # 对原列表进行排序
copy() # 复制列表
reverse() # 颠倒列表的顺序
pop([-1]) # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
remove(obj) # 移除列表中某个值的第一个匹配项
clear() # 清空列表
#与字符串一样，列表之间可以使用 + 号和 * 号实现元组的连接和复制，这就意味着它们可以生成一个新的列表。
# 1、+ 连接（合并）
x = [1, 2, 3]
y = [4, 5, 6]
print(x + y) # [1, 2, 3, 4, 5, 6]
# 2、*复制
x = ['Hello']
print(x * 5) # ['Hello', 'Hello', 'Hello', 'Hello', 'Hello']
# 使用嵌套列表即在列表里面创建其他列表。
x = [1, 2, 3]
y = ['a', 'b', 'c']
z = [x, y]
print(z) # [[1, 2, 3], ['a', 'b', 'c']]
# 列表比较需要引入 operator 模块的 eq 方法。
# 导入 operator 模块
import operatora = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a, b):", operator.eq(a, b)) # operator.eq(a, b): False
print("operator.eq(b, c):", operator.eq(b, c)) # operator.eq(b, c): True
# 打印输出 print()
my_list = ['pink', True, 1.78, 65]
print(my_list) # ['pink', True, 1.78, 65]
# 确定列表项目 len()
fruit_list = ['apple', 'banana', 'cherry']
print(len(fruit_list)) # 3
# 返回变量类型 type()
info_list = ['name', 'gender', 'age', 'height', 'weight']
# 当对info_list使用 type() 确定变量类型时，会返回<class 'list'>，表明这是一个列表。
print(type(info_list)) # <class 'list'>
# 转换为list list()
# 将字符串转换为列表
str1 = 'Hello Python'
print(list(str1)) # ['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n']
# 将元组转换为列表
tuple1 = ('Hello', 'Python')
print(list(tuple1)) # ['Hello', 'Python']
# 将字典转换为列表
dict1 = {'Hello': 'Python', 'name': 'pink'}
print(list(dict1)) # ['Hello', 'name']
# 将集合转换为列表
set1 = {'Hello', 'Python', 'name', 'pink'}
print(list(set1)) # ['Python', 'name', 'pink', 'Hello']
# 将区间转换为列表
range1 = range(1, 6)
print(list(range1)) # [1, 2, 3, 4, 5]
# 元素最大/小值 max()、min()
list1 = [4, 6, 2, 0, -5]
print(max(list1)) # 6
print(min(list1)) # -5
list2 = ['a', 'z', 'A', 'Z']
print(max(list2)) # z
print(min(list2)) # A
# 元素出现次数 count()
# count() 方法用于统计某个元素在列表中出现的次数。
# 语法：list.count(value)
# 必需。任何类型（字符串、数字、列表、元组等）。要搜索的值。
num = [1, 4, 2, 9, 7, 8, 9, 3, 1]
print(num.count(9)) # 2
# 指定值索引 index()
# index() 方法用于从列表中找出某个值第一个匹配项的索引位置。
# 语法： list.index(element)
# element 必需。任何类型（字符串、数字、列表等）。要搜索的值。
num = [4, 55, 64, 32, 16, 32]
print(num.index(32)) # 3
# 复制列表 copy()
# copy() 方法用于复制列表，类似于 a[:]。
# 语法： list.copy()
fruits = ['apple', 'banana', 'cherry', 'orange']
x = fruits.copy()
print(x) # ['apple', 'banana', 'cherry', 'orange']
# 颠倒列表顺序 reverse()
# reverse() 方法用于反向列表中元素。
# 语法：list.reverse()
fruits = ['apple', 'banana', 'cherry']
fruits.reverse()
print(fruits) # ['cherry', 'banana', 'apple']
python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
# 空
_tup = ()
print(_tup, type(_tup)) # () <class 'tuple'>
# 一个元素的写法
_tup = (666,) # 此处加‘,’的原因是要区分括号的作用
print(_tup, type(_tup)) # (666,) <class 'tuple'>
_tup = (666)
print(_tup, type(_tup)) # 666 <class 'int'>
# 多个元素的写法
(1,2,3)
# 多个对象，以逗号隔开，默认为元组
_tup = 1,2,3,"sz"
print(_tup, type(_tup)) # (1, 2, 3, 'sz') <class 'tuple'>
# 从列表转换成元组
_lst = [1, 2, 3, 4, 5]
_tup = tuple(_lst)
print(_tup, type(_tup)) # (1, 2, 3, 4, 5) <class 'tuple'>
# 元组嵌套
(1,2,("a","b")) # 元组中的元素可以是元组
获取单个元素：tuple[index] ，index 为索引可以为负
#定义元组
numbers = (4,5,6)
print(numbers[0]) #查看元组中第一个元素
for num in numbers:
print(num,end=" ")
获取多个元素：切片
tuple[start：end：step]
start 查询的开始位置
end 查询的结束位置
step 查询的步长
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
# 计算元素个数
print(len((1, 2, 3))) # 3
# 连接
print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)
# 复制
print(('Hi!',) * 4) # ('Hi!', 'Hi!', 'Hi!', 'Hi!')
# 元素是否存在
print(3 in (1, 2, 3)) # True
# 迭代
for x in (1, 2, 3):
print (x,) # 1\n 2\n 3
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
print(numbers)
numbers = (0,1,2) # 对元祖重新赋值允许
print(numbers)
print(numbers) #查看元组
del numbers #删除元组
print ("删除后的元组 numbers : ")
print(numbers) #因为删除了元组，所以看不到了，就会报错
# 统计元组中指定元素（item）的个数
tuple.count(item)
# 获取元组中指定元素（item）的索引
tuple.index(item)
# 统计元组中元素的个数
len(tuple)
# 返回元组中元素最大的值
max(tuple)
# 返回元组中元素最小的值
min(tuple)
# 元素 in 元组
# 元素 not in 元组
t1 = (1,2,3,4,5,6,'a',"a","abc")
print(1 in t1) #输出 True
print(5 not in t1) #输出 False
print('a' in t1) #输出 True
# 比较运算符 == > <
t1 = (1,2,3,4,5,6,'a',"a","abc")
t2 = (5,2,6,4,8,2,)
print(t2 == t1) #输出 False
print(t2 > t1) #输出 True
print(t2 < t1) #输出 False
# 拆包
a,b ,c= (10,20,30)
print(a) #输出 10
print(b) #输出 20
print(c) #输出 30
_tup = ("apple", 10, True)
print(_tup, type(_tup)) # ('apple', 10, True) <class 'tuple'>
# 使用str()
_str = str(_tup)
print(_str, type(_str)) # ('apple', 10, True) <class 'str'>
# 使用列表推导的方式生成字符串
_str2 = ', '.join([str(item) for item in _tup]) # 用“, ”分割
print(_str2, type(_str2)) # apple, 10, True <class 'str'>
需要注意的是，转换后的字符串会保留元组的原始结构，包括圆括号和逗号。这是因为 str() 函数将元组视为一个整体进行转换。
参考：https://blog.51cto.com/u_16213414/7220752
字典是一种可变的容器，可以存储任意类型的数据
字典中的每个数据都是用"键" (key) 进行索引，而不像序列可以用下标进行索引
字典中的数据没有先后关系，字典的存储是无序的
字典是python中唯一的映射类型，**采用键值对（key-value）**的形式存储数据。key必须是不可变类型，如：数字、字符串、元组。
字典的表示方式是以{} 括起来，以冒号(:)分割的键值对，各键值对之间用逗号分隔开
字典的键一般是唯一的，如果重复最后的一个键值对会替换前面的
字典的内置方法&函数，总结：
dic.clear() # 清空字典
dic.pop(key) # 移除键，同时返回此键所对应的值
dic…popitem() # 随机删除一组键值对，同时返回对应的值
dic.copy() # 返回字典dic的副本，只复制一层（浅拷贝)
dic.update(dic1) # 将字典dic1合并到dic中，如果键相同，则此键的值取dic1的值作为新值
dic.get(key, default) # 返回键key所对应的值，如果没有此键则返回default
dic.keys() # 返回可迭代的dict_keys集合对象
dic.values() # 返回可迭代的dict_values值对象
dic.items() # 返回可迭代的dict_items对象
cmp(dict1, dict2) # 比较两个字典元素
len(dict) # 计算字典元素个数，即键的总数
str(dict) # 输出字典可打印的字符串表示
type(variable) # 返回输入的变量类型，如果变量是字典就返回字典类型
参考：https://blog.csdn.net/weixin_45014379/article/details/125641819
# 创建空字典：
d = {} # 空字典
d = dict() # 空字典
# 创建非空的字典：
dic1 = {'name': 'cgk', 'age': 20, 'sex': 'male'}
dic2 = dict((('name', 'cgk'),))
dic4 = {'name': 'cgk', 'age': '20', 'hobby': 'girl'}
# 通过键查找
print(dic4['name'], type(dic4['name'])) # cgk <class 'str'>
# 打印全部值
print(dic4.values(), type(dic4.values())) # dict_values(['cgk', '20', 'girl']) <class 'dict_values'>
# 打印全部键
print(dic4.keys(), type(dic4.keys())) # dict_keys(['name', 'age', 'hobby']) <class 'dict_keys'>
# 打印全部键值对
print(dic4.items(), type(dic4.items())) # dict_items([('name', 'cgk'), ('age', '20'), ('hobby', 'girl')]) <class 'dict_items'>
# 打印全部键，转成列表形式
print(list(dic4.keys()), type(list(dic4.keys()))) # ['name', 'age', 'hobby'] <class 'list'>
# 判断是否存在
print('name' in dic4) # True
print('name' not in dic4) # False
#增
dic1 = {'name': 'cgk'}
dic1['age'] = '20'
print(dic1)
#键存在，不改动，返回字典中相对应的键对应的值
a = dic1.setdefault('age', 30)
print(a)
print(dic1)
#键不存在，在字典中增加新的键值对，并返回相应的值
b = dic1.setdefault('hobby', 'girl')
print(b)
print(dic1)
# 修改字典对应键的值
dic4 = {'name': 'cgk', 'age': '20', 'hobby': 'girl'}
dic4['age'] = 30 #更新
dic4['school'] = '北大' #添加
print(dic4)
# 向字典添加新内容的方法是增加新的键/值对——updat
dic4 = {'name': 'cgk', 'age': '20', 'hobby': 'girl'}
dic5 = {1: "1", 'age': "30"}
dic4.update(dic5) #把dic5加进dic4里面，如果有重复的键，则覆盖
print(dic4)
dic5 = {'name': 'cgk', 'age': '20', 'hobby': 'girl', 'school': '北大'}
del dic5['name'] #删除键是name的条目
print(dic5)
red = dic5.pop('hobby') #通过pop删除键是hoppy的条目，并返回删除的值
print(red)
print(dic5)
dic5.clear() #清空字典
print(dic5)
del dic5 #直接删除字典
# d.copy()
# 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典
# 嵌套
#嵌套
av_catalog = {
"欧美": {
"www.111.com": ["免费的,高清的", "质量一般"],
"www.222.com": ["免费的,清晰", "质量还行"],
"333.com": ["自拍,图片", "资源不多,更新慢"],
"444.com": ["质量很高,good", "收费,白嫖绕路"]
},
"日韩": {
"555.com": ["质量很差,不喜欢", "收费"]
},
"大陆": {
"666.com": ["免费,好人一生平安", "服务器在国外,慢"]
}
}
av_catalog["大陆"]["666.com"][1] += ",可以用爬虫爬下来" #修改
print(av_catalog["大陆"]["666.com"]) #['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
# sorted(dict)
#返回一个有序的包含字典所有key的列表
dic = {5: '555', 2: '222', 4: '444'}
print(sorted(dic)) #默认根据键排序 [2, 4, 5]
print(sorted(dic.values())) #根据值排序 ['222', '444', '555']
print(sorted(dic.items())) #根据键排序 [(2, '222'), (4, '444'), (5, '555')]
# 字典的遍历
dic = {'zhangsan': {'age': 11, 'sex': '男'},
'李四': {'age': 22, 'sex': '男'},
'wangwu': {'age': 33, 'sex': '女'}
}
#方法一：
for i in dic:
print(i) #默认遍历打印键
print(i, dic[i]) #打印键值对
#方法二：
for i in dic.items():
print(i) #打印键值对
for i, v in dic.items():
print(i, v) #打印键值对