列表的特点：可容纳多个元素(上限为2**63-1、9223372036854775807个)?

? ? ? ? ? ? ? ? ? ? ? 可以容纳不同类型的元素。

? ? ? ? ? ? ? ? ? ? ? 数据是有序存储的。

? ? ? ? ? ? ? ? ? ? ? 允许重复数据存在。

? ? ? ? ? ? ? ? ? ? ? 可以修改。

基本语法：?

# 字面量
[元素1,元素2,元素3,元素4, ...]

# 定义变量
变量名称 = [元素1,元素2,元素3,元素4, ...]

# 定义空列表
变量名称 = []
变量名称 = list()

# -*- codeing = utf-8 -*-
# @Time : 2022/10/14 15:18
# @Author : 可乐不加糖
# @File : list.py
# @Software: PyCharm
# 定义一个列表
name_list = ['可乐不加糖', 'Python', '我是程序员']
print(name_list)
print(type(name_list))

# 定义一个列表，元素为不同类型
name_list2 = ['可乐不加糖', 666, True]
print(name_list2)
print(type(name_list2))

# 定义一个嵌套列表
name_list3 = [[1, 2, 3], [1, 2, 3]]
print(name_list3)
print(type(name_list3))

?列表的下表索引

如图，列表中的每一个元素，都有位置下标索引，从前向后的方向，从0开始，依次递增。?

?语法：列表[标号]

?反向索引：

从后向前，从-1开始，依次递减。?

嵌套列表的下标索引：

语法：列表[标号][标号]?

# -*- codeing = utf-8 -*-
# @Time : 2022/10/14 15:18
# @Author : 可乐不加糖
# @File : list.py
# @Software: PyCharm
# 通过下标索引对应位置的数据
name_list = ['可乐不加糖', '我是程序员', 'python']
# 从前向后，从0开始，每次加1
print(name_list[0])
print(name_list[1])
print(name_list[2])

# 从后向前，从-1开始，每次-1
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])

# 取出嵌套列表的元素
name_list1 = [[1, 2, 3], [4, 5, 6]]
print(name_list1[0][0])
print(name_list1[0][1])
print(name_list1[0][2])
print(name_list1[1][0])
print(name_list1[1][1])
print(name_list1[1][2])

列表的常用操作?

1.查找某元素的下标

列表.index(元素)

name_list = ['可乐不加糖', '我是程序员', 'python']
print(name_list.index('python'))

2.修改特定位置的元素值

列表[下标] = 值

name_list = ['可乐不加糖', '我是程序员', 'python']
name_list[1] = 6
print(name_list)

3.插入元素

列表.insert(下标，元素)? ? ? ? 在指定位置，插入指定的元素

name_list = ['可乐不加糖', '我是程序员', 'python']
name_list.insert(0, 6)
print(name_list)

4.追加元素

列表.append(元素)? ? ? ? ? 将指定元素，追加到列表的尾部

name_list = ['可乐不加糖', '我是程序员', 'python']
name_list.append(6)
print(name_list)

列表.extend(其他数据容器)? ? ?将其他数据容器的内容取出，依次追加到列表尾部。

name_list = ['可乐不加糖', '我是程序员', 'python']
name_list1 = [1, 2, 3]
name_list.extend(name_list1)
print(name_list)

5.删除元素

del 列表[下标]?

name_list = ['可乐不加糖', '我是程序员', 'python']
del name_list[0]
print(name_list)

列表.pop(下标)?

name_list = ['可乐不加糖', '我是程序员', 'python']
a = name_list.pop(0)
print(f"通过pop方法取出元素后列表内容：{name_list},取出的元素是：{a}")

6.清空列表内容

列表.clear()

name_list = ['可乐不加糖', '我是程序员', 'python', '我是程序员', 'python']
name_list.clear()
print(name_list)

7.统计某元素在列表中的数量

列表.count(元素)

name_list = ['可乐不加糖', '我是程序员', 'python', '我是程序员', 'python']
print(name_list.count('我是程序员'))

8.统计列表中有多少个元素

len(列表)

name_list = ['可乐不加糖', '我是程序员', 'python', '我是程序员', 'python']
print(len(name_list))

9.删除某元素在列表中的第一匹配项

列表.remove(元素)

name_list = ['可乐不加糖', '我是程序员', 'python', '我是程序员', 'python']
name_list.remove( '我是程序员')
print(name_list)

数据容器——元组(tuple)?

python中元组类型允许存储多个值但是不能改变。即在元组中存储的数据是不可变的。

创建一个元组之后，你可以将元组当作一个单独的对象去使用，也可以引用元组中任何一个单独的值。

创建元组

python使用括号将数据值集合起来表示元组。

?Python中有很多方法创建一个元组：通过使用括号创建一个空的元组、在赋值表达式中，在一个值后面添加一个逗号、在赋值表达式中，使用逗号分隔多个值、使用python内建的函数tuple()，并且指定一个可迭代的值(如列表)

# -*- codeing = utf-8 -*-
# @Time : 2022/10/20 16:10
# @Author : 可乐不加糖
# @File : learn tuple.py
# @Software: PyCharm
'''
创建元组
'''
# 使用括号创建一个空的元组
tuple1 = ()
print(tuple1)
print(type(tuple1))
# 在赋值表达式中，在一个值后面添加一个逗号
tuple2 = 1,
print(tuple2)
print(type(tuple2))
# 在赋值表达式中，使用逗号分隔多个值
tuple3 = 1, 2, 3, 4, 5
print(tuple3)
print(type(tuple3))
# 使用python内建函数tuple()并且指定一个可迭代的值
list1 = [1, 2, 3, 4, 5]
print(list1)

tuple4 = tuple(list1)
print(tuple4)
print(type(tuple4))

注意：元组是不可变的！?

访问元组中的数据

我们使用索引来访问元组中的数据。

索引指向一个元组中的一个单独的数据值。

索引值从0开始(从左开始)，也可以从-1开始(从右边开始)。

# -*- codeing = utf-8 -*-
# @Time : 2022/10/20 16:35
# @Author : 可乐不加糖
# @File : fang_wen_yuanzu.py
# @Software: PyCharm
tuple1 = 1, 2, 3, 4, 5, 6
print(tuple1[0])
print(tuple1[-1])

还可以获取数据值的一个子集，python中使用这样的索引格式[i:j]，获取一个元组中数据值的连续的子集(所谓片)，i是起点索引值，j是终点索引值。?

# -*- codeing = utf-8 -*-
# @Time : 2022/10/20 16:35
# @Author : 可乐不加糖
# @File : fang_wen_yuanzu.py
# @Software: PyCharm
tuple1 = 1, 2, 3, 4, 5, 6
print(tuple1[0])
print(tuple1[-1])
tuple2 = tuple1[1:5]
print(tuple2)

一个注意：切片所定义的新元组中第一个值是起点索引值，但是结尾的值是终点索引值的前值。?

还有一种格式可以从元组中提取数据。[i:j:k]，i是起点索引值，j是终点索引值，k是步长。?

tuple3 = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
tuple4 = tuple3[1:9:2]
print(tuple4)

?使用元组

因为元组是不可变的，所以Python中没有任何函数可以操作元组在中的值。但是，有一些函数可以帮助我们获取元组中数据的信息。

比较操作符 in 在元组包含所指定的数据元素是会返回一个布尔值True。

也可以将not逻辑运算符和in比较符一起使用来对结果取反。

len()函数可以确定元组中有多少个元素。

min()、max()函数可以找到元组中最小和最大的值。

当然，min()函数和max()函数对存储字符串值的元组也有效。Python中使用ASCII比较来决定最大值和最小值。

# -*- codeing = utf-8 -*-
# @Time : 2022/10/20 18:38
# @Author : 可乐不加糖
# @File : use tuple.py
# @Software: PyCharm


# 检查元组是否包含某个值
tuple1 = 1, 2, 3, 4, 5, 6, 7
if 3 in tuple1:
    print("It's there!")
else:
    print("It's not there!")
if 8 in tuple1:
    print("It's there!")
else:
    print("It's not there!")
# 将not逻辑运算符与in比较符一起使用来对结果取反
if 3 not in tuple1:
    print("It's not there!")
else:
    print("It's there!")
# 获取元组中的数量
a = len(tuple1)
print(f'元组中数据数量有{a}个')
# 找出元组中的最小值和最大值
print(f'元组中最小值为{min(tuple1)}')
print(f'元组中最大值为{max(tuple1)}')

连接元组

虽然不能改变元组，但可以连接两个或者多个元组来创建一个新的元组。?

# 连接元组
tuple2 = 1, 2, 3, 4
tuple3 = '可乐不加糖', '程序员', 'Python'
tuple4 = tuple2 + tuple3
print(tuple4)

?在脚本中使用列表和元组

列表和元组在Python脚本中用途非常广泛。只有将数据装入列表或者元组里面，你就可以使用很多Python中的函数来处理这些数据的信息，这将会使数学计算容易很多。

?遍历一个列表和元组

为了实现遍历操作，可以使用for语句。

# -*- codeing = utf-8 -*-
# @Time : 2022/10/20 19:24
# @Author : 可乐不加糖
# @File : traverse.py
# @Software: PyCharm

# 遍历一个列表
list_01 = [1, 2, 3, 4, 5, 6, 7]
for i in list_01:
    print(i)
# 遍历一个元组
tuple_01 = tuple(list_01)
for x in tuple_01:
    print(x)

变量i和x是每一次for语句的迭代中指向列表和元组中的值。print语句显示了在每一次迭代中变量i和x当前的值。

排序和倒序

sort()函数可以对列表中的值进行排序。

reverse()函数可以反转列表中存储的元素顺序。

?sort()函数会使排序后的顺序替换列表中之前的元素的顺序，这会改变数据元素的索引位置。

# 排序列表
list_01.sort()
print(list_01)
list_02 = ['abc', 'wer', 'gth', 'kilk']
list_02.sort()
print(list_02)
# 反转列表
list_02.reverse()
print(list_02)

?sorted()返回一个排过序的列表，不会改变原始列表。

reversed()返回一个反转过的列表，但是它不会返回列表本身，而是返回一个可迭代的对象，并且不能被直接访问，但可以用for循环遍历。

# 用sorted()函数排序列表
list_03 = [0, 4, 5, 2, 1, 9]
a = sorted(list_03)
print(list_03)
print(a)
print(list_03)
# 用reversed()反转列表
b = reversed(list_03)
print(list_03)
print(b)
print(list_03)
for x in b:
    print(x)

使用列表解析创建列表

?创建列表的第四种方法：使用列表解析。

使用列表解析是一种通过处理其他列表或者元组中的值来创建列表的简介方法。

基本格式：

[expression for variable in list]

也可以在列表解析中使用字符串及其函数和值。

# 使用列表解析创建列表
list1 = [1, 2, 3, 4, 5, 6]
list2 = [x*2 for x in list1]
print(list2)

tuple1 = 'abc', 'def', 'xyz'
list3 = [x.upper() for x in tuple1]
print(list3)

range类型

?还有一个可以包含多个数据元素的Python数据类型。range数据类型包含了一个不可变的序列，它像元组一样工作但是更容易创建。

注意：在python 2中，函数range()会以标准列表数据类型创建一个数字序列。Python 3改变了这个行为，把range数据类型从list数据类型分离出来。

?格式：range(start, stop, step)

start和step是可选的，如果没有指定他们，Python会默认start是0，step是1。

range1 = range(5)
# 尝试打印变量range1时，Python返回了range对象，显示了start和stop
print(range1)

print(range1[2])
for x in range1:
    print(x)

数据容器——字典

字典是一个简单的结构，也被叫做关联数组。字典中的每一个数据被称为元素、条目或者记录。每一个元素被划分成两部分，一部分叫做值，存储有效数据；另一部叫做键，键是不可变的，它在字典中被用来对值进行索引，并且仅能关联到一个特定的值，因此，字典元素的另外一个名字是键/值对。

创建字典

在python中创建和使用一个字典是非常简单的。比如：dictionary_name = {}?

student = {}
print(type(student))

填充字典

?填充字典，即向字典中添加键和与其关联的值。

语法：

dictionary_name = {key1:value1, key2:value2,key3:value3. . .}

在填充之前你不需要创建一个空字典，可以使用一条命令创建并填充它，在使用命令填充字典时，python会自动创建字典。

字典是无序的。

# 创建字典
student = {}
print(type(student))
# 填充字典
teacher = {'20101': '张三', '20102': '李四', '20103': '刘六'}
print(teacher)
# 一次向字典中填充一对键值
teacher['20104'] = '王七'
print(teacher)

注意:键不能是一个列表。

? ? ? ? 键必须是一个不可变的对象。

? ? ? ? 键可以是一个字符串。

? ? ? ? 键可以是一个数字。（整数或者浮点数）?

? ? ? ? ?键可以是一个元组。

? ? ? ? 键只能属于一个值。

想要获取字典里的一个值，用:

dictionary_name = [key]

print(teacher['20104'])

如果你在字典里面查找一个不存在的键，会得到一个KeyError异常。我们可以使用get操作，来避免键不存在时出现错误异常。

基本语法：database_name.get(key, default)?

当get操作找到一个键时，返回所关联的值；当get操作没有找到键时，返回作为默认值的字符串。

print(teacher.get('20103', '没找到'))
print(teacher.get('3020', '没找到'))

循环获取字典中的值。先使用keys操作获取字典键的列表，dictionary_name.keys()。将它赋值给一个变量，用for循环遍历字典。?

# for循环遍历字典
key_list = teacher.keys()
print(key_list)
for key in key_list:
    print(key, end=' ')
    print(teacher[key])

?给字典排序

?在字典中，元素都是无序的。我们可以用sorted()函数来解决这个问题。不能使用sort()函数，因为字典键不是列表，你不能对它使用列表的操作。

# 使用排过序的键列表遍历字典
# 创建并且填充字典
student1 = {'03': '可乐', '02': '雪碧', '00': '奶茶', '01': '牛奶'}
print(student1)
print(type(student))
# keys操作获取字典键的列表
key_list_01 = student1.keys()
print(type(key_list_01))
# 用sorted()函数对字典键列表进行排序
key_list_01 = sorted(key_list_01)
# 注意在排序后，key_list_o1改变了数据类型，从dict_keys变成了list
print(type(key_list_01))
for x in key_list_01:
    print(x, end=' ')
    print(student1[x])

运行结果：

更新字典

字典中键是不可变的，但是，我们可以更新一个键关联的值。如果这个键不存在，一个新的键/值对会被创建。因此，我们可以使用这个方法更新字典，也可以添加一个新的元素。

语法：database_name[key] = value?

我们也可以从字典中删除一个键/值对。语法：

del dictionary_name = [key]

如果要删除的键/值对不存在，del操作会抛出一个错误异常，因此，在删除一个键/值对前，我们可以先使用if语句确认它是否存在。

# 创建并填充字典
student = {'0101': 'jack', '0102': 'ros', '0103': 'jim'}
print(student)
# 更新一个字典元素
student['0101'] = 'gak'
print(student)
# 如果这个键不存在，就会新创建一个键/值对
student['0104'] = 'xim'
print(student)
# 删除键/值对
del student['0101']
print(student)
# 使用if语句确认键是否存在
if '0102' in student:
    del student['0102']
print(student)

管理字典

student0 = {'1': 'dwqd'}
print(student0)
# len()返回字典中元素的个数
print(len(student0))
# dict_name.keys返回字典的所有键
print(student0.keys())
# dict_name.values返回字典的所有值
print(student0.values())
# dict_name.items返回一个元组包含字典的键值对
print(student0.items())
# dict_name.clear()清空字典
print(student0.clear())
student2 = {'0101': 'jim', '0102': 'mxa', '0103': 'lsd'}
# dict_name.update(other_dict_name),比较两个字典，将dict中没有但otherdict有的元素添加到dict中。
# 最后将dict中匹配otherdict的键/值对更新到otherdict中。
student0.update(student2)
print(student0)
print(student2)

数据容器——集合

集合是由一组元素组成。并且集合中的元素是无序的；每一个元素是唯一的。

集合中的元素是可变的。还有一种集合类型叫frozenset。frozenset是不可变的。它的值在本质上是被冻结的。

集合基础

创建集合

为了创建一个空的集合，我们可以使用内建的set函数，

语法：set_name = set()

# 创建空的集合
set_one = set()
print(type(set_one))

填充集合

向集合中添加一个元素，我们可以使用.add操作。

语法：set_name.add (element)

# 向集合中添加元素
set_one.add('123')
print(set_one)

我们还可以使用一个命令创建和填充一个集合。

语法：set_name ([element1, element2, element3, . . .elementn])?

# 创建并填充集合
set_two = set([123, 1234, 12345])
print(set_two)

集合中的元素可以是整数、浮点数、字符串、列表和元组等。

从集合获取信息

集合的主要价值是数学中的集合理论。通过集合可以很容易的确定哪个特定的元素在多个集合中、一个集合与另一个集合如何不同、一个元素在一组集合中是否唯一等。

我们可以使用if语句检查一个元素是否是一个集合的成员。

# 检查一个元素是否是一个集合的成员
a = 123
if a in set_two:
    print(a, "zai")
else:
    print(a, "no")

并集

并集是两个集合的所有元素合并创建的第三个集合。

创建并集的语法：

set_union = set_name1.union(set_name2)

记住，不能用+操作符创建并集。集合操作.union是将集合的成员合并到一起，但是集合中每一个元素都是唯一的。即使合并前某个元素在两个集合中都存在，但是在并集中只会出现一次。

# 创建集合
set_student = set(['raz', 'jas', 'dld'])
print(set_student)
set_student1 = set(['rfd', 'kil', 'dld'])
print(set_student1)
# 合并集合
set_union_student = set_student.union(set_student1)

print(set_union_student)

?交集

交集是包含在两个集合中都有的元素。

进行交集的语法：set_inter = set_name1.intersection(set_name2)

set_student = set(['raz', 'jas', 'dld'])
print(set_student)
set_student1 = set(['rfd', 'kil', 'dld'])
print(set_student1)
# 交集
set_inter_student = set_student.intersection(set_student1)
print(set_inter_student)

差集

差集又叫补集。是一个集合中包含在第一个集合中但是不在第二个集合中的元素。本质上，从第一个集合中减掉第二个集合，剩下的就是差集。

语法：set_dif = set_name1.difference(name2)

# 创建集合
set_student = set(['raz', 'jas', 'dld'])
print(set_student)
set_student1 = set(['rfd', 'kil', 'dld'])
print(set_student1)
# 差集
set_dif_student = set_student.difference(set_student1)
print(set_dif_student)

对称差集

仅包含存在于一个集合的元素。

语法：set_symdif = set_name1.symmetric_difference(set_name2)?

>>> set_student = set(['kk','ll','lk'])
>>> set_student1 = set(['ll','oo','pp'])
>>> set_symdif_student = set_student.symmetric_difference(set_student1)
>>> print(set_student)
{'lk', 'll', 'kk'}
>>> print(set_student1)
{'ll', 'pp', 'oo'}
>>> print(set_symdif_student)
{'oo', 'kk', 'lk', 'pp'}
>>>

通过上面的例子，不难发现，对称集合会包含所有set_student和set_student1中的元素，除了'll'之外。因为'll'同时在两个集合中，它将会从对称集合中被排除掉。?

遍历集合

因为集合本身可以被用来迭代，所以使用循环从集合中获取元素值非常容易的。?
# 创建集合
set_student = set(['raz', 'jas', 'dld'])
# 遍历集合
for x in set_student:
    print(x)
?

修改一个集合

修改一个集合并不是修改集合中某个元素，因为集合没有索引功能。所谓修改一个集合，是对这个集合进行一系列添加或者删除操作。?

添加操作：

语法：set_name.update([element1,element2,......])?

删除操作：

(1)remove

语法：set_name.remove([element])

(2)discard

语法：set_name.discard([element])

# 创建集合
set_name = set()
print(set_name)
print(type(set_name))
# 添加操作
set_name.update(['kk', 'll', 'pp'])
print(set_name)
# 使用remove删除元素
set_name.remove('kk')
print(set_name)
# 使用discard删除元素
set_name.discard('ll')
print(set_name)