容器类型的操作

容器类型的操作

容器类型的变量可以存储多个数据，非容器的变量只能存储一个数据

列表的定义

列表是可变序列，元素是可以被修改的

列表定义的格式: 变量名 = [数据1, 数据2 ,,,,,,,]
使用type可以查询数据类型
直接使用print可以打印列表结构

内容：

元素 ： 列表中的数据。 元素间用 逗号 间隔
列表中的元素还可以是一个列表、元组或者字典：
列表索引和切片方法 同 字符串相同
列表用 [] 表示， 可以存放多个数据 ， 数据类型不必统一

列表的转换

list（）函数可以将字符串，元组，range对象转换为列表

list("python")

# 结果
['p', 'y', 't', 'h', 'o', 'n']

列表的查询

索引查询

与字符串的操作里的索引一样，不多赘述

列表中 没有 rindex（）find（） 这个方法

列表的修改

列表的增加

append

直接在源列表中修改

append 在列表末尾追加数据（一个）

追加列表之类的，会将列表识别成为一个str

list类型在使用append 方法时不会产生新的列表,而是在原有列表上进行修改

num_list.append(5)		# 示例
append 追加的数据,默认追加到列表末尾,追加完成后在原有数据上修改

extend

直接在源列表中修改

extend 追加数据序列（多个）

格式: 列表1.extend(数据序列)

追加数据序列时会将所有数据拆成一个个的再放入列表中

a = [1,2,3]
b = [4, 5, 6]
a.extend(b)   # 将b的所有元素添加到a

列表算数运算

如果是两个列表的话，利用加法可以使两个两个列表变成一个列表

使用乘法运算的话，可以使列表里的数据重复指定次数

加法运算

nums1 = [100, 200, 300]
nums2 = [10, 20, 30, 40]
result = nums1 + nums2
print(result)
# 运行结果
[100, 200, 300, 10, 20, 30, 40]

乘法运算

print(nums1 * 3) 
# 运行结果
[100, 200, 300, 100, 200, 300, 100, 200, 300]

insert

insert 插入

格式:列表.insert(要插入位置的索引, 要插入的对象)
# 插入后被插入的数据变为输入的索引，而原本该位置后的说有数据索引 +1
# 再使用该函数进行数据插入后，会导致索引混乱，所以除非所有的索引的引用都修改完成，否则不要调用该函数
# 在实际开发中append（）函数比insert（）插入数据更加安全

append（）函数在进行追加的时候如果追加的元素为列表时，则会将该列表当作一个元素进行追加

extend（）函数会将多个元素进行拆分后再进行追加

所以追加多个元素的时候使用extend（）函数

统计出现次数

count

统计元素出现的次数

a  = [2, 1, 2]
a.count(2).print      # 输出统计次数    

index

指定元素第一次出现的索引位置

a  = [2, 1, 2]
a.index(2).print  

列表元素的删除

del

del() 函数

该函数可以删除列表，元素

# 通过索引获取当前元素,并删除
del list1[2]			# 通过del删除元素时，索引必须能找到元素，不能为不存在的元素
del list1				# 删除名字为list1的列表

pop

pop() 删除指定索引的元素，并且返回该元素 # 再实际开发中可以再删除后赋值给变量进行保存

被删除元素的下标索引必须要存在，删除后，该元素后的索引统一向左移动一位

pop（）使用时也会造成索引变换索引在调用时要确保所有的索引引用都已经更改

不给pop（）传递参数默认删除最后一位

a = [1,2,3,4,5]
a.pop()  # 默认删除最后一个
a.pop(0)  # 删除索引为0的数据

remove

remove()

删除指定的元素（从左到右第一次出现的元素）

该函数并不会返回被删除的内容，删除不存在的内容的时候会进行报错

a = [1,2,1,2,]
a.remove(1)

# 运算结果
[2, 1, 2]

clear

clear（）清空指定列表

a = [1, 3, 4, 6]
a.clear()   # 清空所有元素

索引修改

通过索引查找指定位置的数据进行修改，该元素的位置必须时存在的

不能通过索引修改多个值

列表的反转

reverse

列表反转后，索引的位置倒置，不会产生新的列表

列表的排序

sort

reverse = True # 降序

reberse = Flase # 升序

sort 是对云游的数据进行了排序，不会产生新的列表，默认的规则是升序

list2.sort()

如果想对列表进行降序，可以选择对列表进行倒置再排序

list2.sort()
list2.reverse()

也可以直接进行倒序

list2.sort(reverse=True) 

reverse

将列表中的所有顺序颠倒，产生新列表

b = [1,3,5,2,4]
b.reverse()

sorted

将列表中的元素从小到大排序(不会修改原列表中元素的顺序，而是创建一个新的列表)

从小到大

sorted(容器)  

从大到小

sorted(容器, reverse=True) 

列表的求和

a = [1, 3, 5, 7]
print(a)     # 输出a所有数值的综合

map函数

将每个元素都被调用的函数当作条件执行一遍

实例 ：

 def square(x) :            # 计算平方数
     return x ** 2
     
 map(square, [1,2,3,4,5])   
# 调用自己定义的square 让每个列表中的元素都成为函数中被传入的值
# 返回的值会组成一个新对象

map函数返回的对象不能直接输出，但是可以用list转换为列表

 def square(x) :            # 计算平方数
     return x ** 2
     
a =  map(square, [1,2,3,4,5]) 
print(list(a))

列表的遍历

遍历列表有两个方法

while循环

for循环

列表的嵌套

再一个列表中包含其他列表元素

嵌套列表的遍历输出

使用嵌套遍历

如果当前的列表内的数据不都是子列表,有其他数据类型的数据,则不能直接使用循环嵌套,需要先进行类型判断

两个列表比较大小

两个列表比较大小， 比较的是第一对不相等的元素的大小

两个列表比较大小的时候，数据类型必须相同， 如果第一对数据的的大小相等，比较第二对数据

判断列表是否存在指定元素

in

判断数据是否存在于列表中，如果存在则是返回True 不存在返回Flase

nums = [10, 20, 55, 100, 5]
print(20 in nums)  # True

print([10, 20] in nums)    # True

not in

与in刚好相反

判断列表中是否不存在指定的数据

nums = [10, 20, 55, 100, 5]
print(20 not in nums)  # Flase

元组

元组是不可变的的列表

元组的定义

如果定义的时候没有歧义，可以直接省略（）

元组:可以储存多个数据,但是元组内的数据不能被修改(元定义后只能被查询)
元组的定义:变量 = (数据1, 数据2, 数据3......)
t1 = (100, 200, 300, 500)
t1 = 100, 200, 300, 500

查询数据类型：type(tuple1)

如果元组中只有一个元素怎么办? 在单一元素后添加逗号
如果小括号包裹单一元素数据不添加逗号,则小括号的意义是提升算术运算符优先级
在定义元素或者传值时,元组的括号可以省略

元组的操作

元组不能进行修改，只能查看或者重新定义一个元组

元组的索引

# 查询
# 通过索引进行查询
# 查询方法和列表一致
# 正向索引,从0开始,从左至右依次递增
# 负向索引,从-1开始,从右至左依次递减

字典

字典的定义

字典:储存多个数据,以键值对形式存储,方便快速存取

字典的键要见名知意

字典定义格式: 变量 = {键1:值1, 键2:值2…}

使用print打印可以显示字典中的所有数据

# 空字典定义方法
dict2 = {}

实例

直接定义字典

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

dict函数

将 其他形式的数据转换成为字典

my_dict = dict(name='John', age=30, city='New York')

字典推导式

用最少的代码将字典写完

my_dict = {key: value for key, value in [('name', 'John'), ('age', 30), ('city', 'New York')]}

逐个添加

my_dict = {}   # 定义一个空的集合
my_dict['name'] = 'John'    # key = name    value = john
my_dict['age'] = 30
my_dict['city'] = 'New York'

见名知意的重要性
# 需求: 使用字典保存一个人的信息  xiaoming  18   男  001
# 保存方式一:
dict4 = {'name': 'xiaoming', 'age': 18, 'gender': '男', '学号': '001'}
print(dict4)
# 字典的优势是快速存取,注意命名键的时候要见名知意,并且易于记忆
# 字典占用空间远大于列表,使用字典存储数据本来就是牺牲空间确保时间,所以要尽量利用字典快速存取的特性,而不要想空间的节省

定义字典时 ,不能有重复的键,否则后定义的键值对会覆盖先定义的， 字典中键是唯一的但是值可以随意重复

字典的修改

字典新增

规则：使用新的键= 值

如果是要新增一个值，则该值的key或者说键就必须没有再字典中存在，不然就是修改该key对应的值

字典的拼接

update

如果update中添加的键已经存在则修改原有的值

dict1.update({'id': '001', 'color': 'yellow', 'name': 'rose'})

字典的删除

Del

要删除一个dict（值）必须要找到对应的key，字典中key和dict是成对出现的，删除任意一个，两个都会消失

del dict1['age']

clear（）

清空字典

将字典的所有内容都进行清空

pop

print(dict2.pop('name'))

删除后会对删除后的内容进行返回

popitem

随机删除但是一般都是最后一个

dict2.popitem()

删除后将对删除的内容以元组方式返回

字典中值的修改

dict1 = {'name':'小明', 'age':18}

通过索引（key或者dict）修改字典中的键或者值

dict1['name'] = '小红'

update（）可以对指定的字段值进行修改

dict1.update({'name': '小绿'})

字典的查询

key

直接使用key查询对应的值

不存在则会报错 KeyError: ‘apple’

print(dict1[key])

get

dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
print(dict1['apple'])
# 报错内容			KeyError: 'apple'

如果使用get（）函数时查找的key不存在则不会报错只会输出 None

print(dict1.get('name'))

如果要查找的key不存在则可以自己定义默认返回值

#格式 字典.get(要查询的键, 查询的键不存在时返回的数据)
print(dict1.get('apple', '小刚'))

keys

返回当前字典的所有key

print(dict1.keys()) 
# keys返回的内容不是列表,而是dict_keys,该数据类型不能直接使用索引查询数据,但是可以进行for遍历
# 也不能使用索引查询

values

返回当前字典所有的值

print(dict1.values())
# dict_values不能使用索引查询,但是可以迭代

items

返回当前字典所有的 key-dict 以元组的形式展示

dict1 = {"a": 10, "b": 20, "c": 30, "d": 40}
print(dict1.iteam())
# dict_items不能使用索引查询,但是可以迭代
# 运行结果
dict_items([('a', 10), ('b', 20), ('c', 30), ('d', 40)])

字典的循环遍历

key

dict1 = {"a": 10, "b": 20, "c": 30, "d": 40}
for i in dict1.keys():
    print(i)

dict

dict1 = {"a": 10, "b": 20, "c": 30, "d": 40}
for i in dict1.values():
    print(i)

key-dict

dict1 = {"a": 10, "b": 20, "c": 30, "d": 40}
for i in dict1.items():
    print(i)

key-dict 一起输出

for i in dict1:
    print(i, dict1[i])
# 原理 遍历出key 通过key 获得对应key的dict

for key, value in dict1.items():
    print(key, value )
# 原理： 遍历，输出两种不同的值
# 如果需要被遍历的组合有三种不同的东西 前面用与接收的变量也可以是三个
# 举例：文件操作中的路径遍历  有文件名，路径，绝对路径  可以用三个变量分别接收不同的内容

集合

集合的定义

集合: 集合是一个无序,不重复的数据序列
无序: 程序员无法控制其排不顺序,  程序员无法使用索引查找或修改数据
不重复:没有办法在字典中放入相同的值,会自动去重,类似于字典的键

无序性

在调用或者使用时会自动根据哈希值进行排序

set1 = {1, 2, 5, 6, 3, 4}
# 程序员无法利用其顺序,有顺序也无用
# 了解:在集合中会使用数据的值计算哈希值,根据哈希值顺序进行排序
print(set1)  # {1, 2, 3, 4, 5, 6}

不重复

有重复时自动去重

# 不重复
set2 = {1, 2, 3, 4, 5, 6, 7, 2, 3}
# set会自动去重
print(set2)  # {1, 2, 3, 4, 5, 6, 7}

空集合的定义

# 定义空集合
set3 = set()
# {} 是定义空字典的
print(set3)

可以被集合存储的数据

# 基础数据类型 int  float  bool  字符串 都可以用集合储存
set4 = {1, 12.3, True, 0, False, ''}
print(set4)

列表 字典 集合,不能放入集合中,作为元素出现

不能作为集合元素的数据类型,同样不能作为字典的键出现

元组类型可以放入集合内储存

集合的修改

集合的增加

add

在使用add命令后,不会产生新的数据,而是原集合中进行修改

update

update（） 的内部只能填写容器类型（数据序列）

set1.update([6, 7])

集合的删除

remove

删除不存在的内容则会报错

set1.remove(3)

pop

set1.pop()

discard

set1.remove(13)

集合的遍历

set1 = {1, 2, 3, 4}

遍历的顺序不定

for

for i in set1:
    print(i)

数据的判断

返回bool值

存在

print(4 in set1) 

不存在

print(4 not in set1) 

on

定义空集合

set3 = set()

{} 是定义空字典的

print(set3)

## 可以被集合存储的数据

```python
# 基础数据类型 int  float  bool  字符串 都可以用集合储存
set4 = {1, 12.3, True, 0, False, ''}
print(set4)

列表 字典 集合,不能放入集合中,作为元素出现

不能作为集合元素的数据类型,同样不能作为字典的键出现

元组类型可以放入集合内储存

集合的修改

集合的增加

add

在使用add命令后,不会产生新的数据,而是原集合中进行修改

update

update（） 的内部只能填写容器类型（数据序列）

set1.update([6, 7])

集合的删除

remove

删除不存在的内容则会报错

set1.remove(3)

pop

set1.pop()

discard

set1.remove(13)

集合的遍历

set1 = {1, 2, 3, 4}

遍历的顺序不定

for

for i in set1:
    print(i)

数据的判断

返回bool值

存在

print(4 in set1) 

不存在

print(4 not in set1)