day7容器类型

1.recode

列表(list) - 有序(可以使用下标进行取值),可变(支持增删改)
[12,1,3]
列表元素的要求,任何类型的数据都可以作为列表元素(普通字面量,变量,函数返回值等等)

获取单个元素,获取部分元素(切片:会产生一个新的子列表),遍历列表

相关运算: + , * , == , !=, in/not , len() , list(必须是序列),max(列表中的元素都是一样的),min(列表中的元素都是一样的)

== - 判断两个数据的值是否相等
is - 判断地址是否相等
1.python存储数据赋值时,如果存储的对象时数字和字符串,不会直接开辟空间,而是先去字符串和数字的缓存去查找是否已经存过对应的数据
如果存了,直接将之前的数据对应的地址赋值给变量
如果没有存储才会在缓存区开辟空间存储数据
其他类型的数据都是直接开辟空间存储数据,然后将地址返回
2.容器类型中的元素不是直接存的值,而是元素值对应的地址
注意:当其他类型在存值时,都是字符串和数字拼接的,所以还是遵循第一条,先去缓存区查找对应的值,如果没有,就要重新在缓存区开辟空间
如:

list1 = [1, 2, 3]
list2 = [1, 2, 3]
print('元素的值对应的地址比较:', list1[0] is list2[0])  # True

== - 判断两个数据的值是否相等 :
如:
list1 = [1,2,3]
list2 = list1
print(list1 == list2) # True :值相同
is - 判断地址是否相等
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 is list2) # False
list3 = list2
print(list2 is list3) # True
示例图:

is与==的区别

2.列表相关方法

__author = 'LL'

2018/11/13 10:20

PyCharm

1.列表赋值

现象一

list1 = [1, 2, 3]

list2 = list1 # 将list1的地址赋值给了list2,所以无论谁操作这个列表,都会对列表进行改变

list1.append(100)

print(list2) # [1, 2, 3, 100]

现象二

list1 = [1, 2, 3]

list2 = list1[:] # 切片会产生新的列表,就会产生新的地址,所以在后续操作中,两个列表就不会相互影响

list1.append(100)

print(list2) # [1, 2, 3]

"""
a.直接使用一个列表变量给另一个列表变量赋值,赋的是地址.
赋完值过后,对其中一个列表进行增删改,会影响另一个列表.(原理:两个列表的内存地址相同)
b.如果赋值时赋的是列表的切片或者拷贝,会产生新的地址,然后使用新的地址赋值.
赋完值后,对其中一个列表进行增删改,两个列表相互不再影响(原理:两个列表的内存地址不同)
"""

2.关于列表的方法

2.1.列表.count(元素) - 获取指定元素在列表中出现的次数

a = [1, 2, 3, 4, 1, 2, 1]
print(a.count(1))  # 3

2.2.列表.extend(序列) - 将序列中所有的元素都添加到列表中

a = ['a', 1]
a.extend(['a', 1])
a.extend('abcdefg')
print(a)  # ['a', 1, 'a', 1, 'a', 'b', 'c', 'd', 'e', 'f', 'g']

3.列表.index(元素) - 获取指定元素对应的下标索引
注意:
1.如果元素有重复的,则只返回第一个
2.如果元素不存在会报一个错,报的(ValueError)

num = [1, 2, 3, 4, 3, 5, 3, 4, 2]
print(num.index(3))  # 2

4.列表.reverse() - 反向列表(将列表元素倒序)

a = [1, 3, 2, 5, 99, 0]
a.reverse()
print(a)  # [0, 99, 5, 2, 3, 1]

5.列表.sort() - 列表排序(默认是升序排序)
列表.sort(reverse=True) - 列表排序(降序)
注意:
1.列表中所有元素类型必须一样
2.列表中的元素必须支持大小比较

a = [1, 3, 2, 5, 99, 0]
a.sort()
print(a)  # [0, 1, 2, 3, 5, 99]
a.sort(reverse=True)
print(a)  # [99, 5, 3, 2, 1, 0]
b = ['a', 'b', '1', 'z', 'zz']
b.sort()
print(b)  # ['1', 'a', 'b', 'z', 'zz']
print(ord(b[-2]))  # 122
print(chr(122))  # z

6.列表.clear() - 清空列表

b = ['a', 'b', '1', 'z', 'zz']
b.clear()
print(b)  # []

注意:使用下面的清空列表,会额外的消耗资源,所以清空列表使用clear

b = ['a', 'b', '1', 'z', 'zz']
b = []
print(b)  # []

7.列表.copy() - 将列表中元素直接赋值一份产生一个新的列表.和列表[:]效果一样
注意:这儿的拷贝的是浅拷贝

a = [1, 2, 3]
b = a.copy()
print(a == b)
print(b is a)  # False

注意: id是查询内存地址的方法

print(id(b), id(a))  # 3153180430664 3153180411272

总结:列表直接赋值-如:
list1 = list2 ->直接将list2的地址赋给list1,所以他们值和地址都相同
list1 = [1,2,3];list2=[1,2,3] : 这里的list1与list2只有值相同,地址不同
num1 = num2->直接将num2的地址赋给num1,所以他们的值和地址都相同
num1=1;num2=1,虽然他们都是单个赋值,但是由于单个数字与字符存在缓存机制,声明时都是先到缓存中去找有没有这个值的地址,所以这里num1与num2的值和地址都相同

3.深浅拷贝

import copy

"""
1.copy.copy(对象) - 浅拷贝:直接拷贝元素的值(不管是地址还是元素值)产生一个新的地址
2.copy.deepcopy(对象) - 深拷贝:不会直接复制地址,而是将地址对应的值拷贝一份产生新的地址
"""
nums1 = [1, 2, 3]
nums2 = [10, 20, 30]
list1 = [nums1, nums2]
print('1.浅拷贝:')
list2 = list1.copy()
print('修改前:list1', list1)
print('修改前:list2', list2)
list1.append(111)
list1[0].append(1000)
print('修改后list1', list1)
print('修改后list2', list2)

nums1 = [1, 2, 3]
nums2 = [10, 20, 30]
list1 = [nums1, nums2]
print('2.深拷贝:')
list2 = copy.deepcopy(list1)
print('修改前:list1', list1)
print('修改前:list2', list2)
list1.append(111)
list1[0].append(1000)
print('修改后list1', list1)
print('修改后list2', list2)

结果:

1.浅拷贝:
修改前:list1 [[1, 2, 3], [10, 20, 30]]
修改前:list2 [[1, 2, 3], [10, 20, 30]]
修改后list1 [[1, 2, 3, 1000], [10, 20, 30], 111]
修改后list2 [[1, 2, 3, 1000], [10, 20, 30]]
2.深拷贝:
修改前:list1 [[1, 2, 3], [10, 20, 30]]
修改前:list2 [[1, 2, 3], [10, 20, 30]]
修改后list1 [[1, 2, 3, 1000], [10, 20, 30], 111]
修改后list2 [[1, 2, 3], [10, 20, 30]]

示例图:

浅拷贝

深拷贝

4.元组

4.1.什么是元组(tuple)

元组就是不可变的列表.(有序,不可变)
有序 - 可以通过下标获取元素
不可变 - 不支持增,删,改

4.2.元组的字面量:

使用小括号将多个元素括起来,多个元素之间用逗号隔开
a.只有一个元素的元组:在元素的后面必须加一个逗号

nums = [1, 2, 3]
tuple1 = (1, 2, nums)  # 元组中包含列表,是可以修改列表中的值的
tuple1[2][0] = 'a'
print(tuple1)  # (1, 2, ['a', 2, 3])
tuple2 = (10,)  # 只有一个元素的元组小括号里面加逗号才代表元组
print(type(tuple2))  # 

b.去掉小括号,直接将多个数据用逗号隔开,不加括号,也是元组类型

tuple3 = 1, 2, 3, 'abc'
print(type(tuple3))  # 

c.获取元组元素

tuple4 = (10, 20)
print(tuple4[0], tuple4[-1])  # 10 20
# 通过变量个数和元组元素个数保持一致来获取元组中的每个元素
x, y = tuple4
print(x, y)  # 10 20

# 通过在变量名前加*号,获取没有*号的变量获取的元素的剩下的部分,*号的内容以列表返回
tuple5 = ('LL', 100, 100, 60, 60)
name, *scores, number = tuple5  # 注意加*号,代表可以将序列剩余的所有元素新添到一个列表中,但是带*号的只能有一个(列表也可以)
print(name, scores, number)  # LL [100, 100, 60] 60

# 了解
tuple1 = (1, 2, 3)
list1 = ['aa', 'b', 'c']
print("列表解开:", *list1)  # 列表解开: aa b c
print("元组解开:", *tuple1)  # 元组解开: 1 2 3

"""

4.3.获取元组元素和获取列表元素一样如:for item in 元组: , for item in range(len(元组)):,

tuple1 = 1, 2, 3, 4, 1, 2
print(tuple1[1])
print(tuple1[1:3])  # (2, 3)

for item in tuple1:
    print(item)

4.4.相关运算和列表一样

+, * ,in/not in , len(),tuple(序列),max(),min()

print((1, 2) + ('a', 'b'))  # (1, 2, 'a', 'b')
print((1, 2) * 2)  # (1, 2, 1, 2)
print(1 in (1, 2))  # True
print(1 not in (1, 2))  # False
print((1, 2, 1, 1, 2).count(1))  # 3
print((1, 2, 1, 1, 2).index(2))  # 1 返回元素的索引位置,如果有重复则只返回一次,并且是最前面的索引

5. 认识字典

5.1.什么是字典(dict)

字典是python中内置的容器类数据类型, 可变 , 无序 .
字典的元素是键值对

5.2.字典的字面量:

由大括号括起来的,大括号里面是键值对,多个键值对由逗号隔开
键值对 - 键:值
键(key) - 不可变的(list不能,字典不能等等一切可变的数据都不能作为键); 唯一的.(一般使用字符串作为key值)
值(value) - 任何类型的数据

dict1 = {'Tom': 18, 'shanshan': 19, 'Shan': 20, (10, 20): 'hello'}
print(dict1)
for item in dict1.values():
    print(item)
dict2 = {'aa': 1, 'aa': 2, 'aa': 0}
print(dict2)  # {'aa': 0},只会打印一个,并且是键重复的最后一个,所以键是唯一的,重复没有意义

dict3 = {[1, 2]: 'a', 'a': 5}  # unhashable type: 'list',不能使用可变的数据作为键

注意:什么时候使用字典:
如果一个容器里面存储的数据是不同意义的(数据之间需要区分,比如说:成绩,姓名等),就使用字典

# 用一个变量来存储一个学生的信息:姓名,年龄,电话,成绩,学号
student = ['小明', 18, '13111856135', 99, '150015511089']
print(student)
student = {'name': '小明', 'age': 18, 'tel': '13111856135', 'score': 98}
print(student['name'])

6.字典的增删改查

6.1.查(获取字典的值)

a.获取单个值

字典[键(key)] - 获取字典中key对应的值(常用这种方式,如果key值不明确,就使用下面一种方法)
字典.get(key) - 获取字典中key对应的值(如果key不存在,不会报错,并且会返回一个默认值None)
None是python中的关键字,表示一个特殊值(空,没有)

d1 = {'name': '旺财', 'age': 3, 'color': 'white', 'type': '萨摩耶'}
print(d1['name'])  # 旺财
print(d1['color'])  # white
# key值不存在时,会报key值错误
# print(d1['sex'])  # KeyError: 'sex'
print(d1.get('type'))  # 萨摩耶
# .get取值时,如果key不存在,会返回一个None
print(d1.get('sex'))  # None

b.遍历

直接遍历字典拿到的是key值

d1 = {'name': '旺财', 'age': 3, 'color': 'white', 'type': '萨摩耶'}
for x in d1:
    print(x, ':', d1[x])

# 以下的操作不常用,因为会多次转化元组和列表,浪费资源
print(d1.items())  # dict_items([('name', '旺财'), ('color', 'white'), ('type', '萨摩耶'), ('age', 3)])
for key, value in d1.items():
    print(key, value)

6.2.增(添加键值对)

a.添加一个键值对 - 字典[key] = 值 - 当key不存在时,就是在字典中添加键值对,当key存在时,就是修改key对应的值

dic1 = {'a': 'hah'}
dic1['b'] = 'aha'  # key不存在就新加
dic1['a'] = '不添加'  # key存在就修改值
print(dic1)  # {'b': 'aha', 'a': '不添加'}

b.字典1.update(序列) - 将序列中的元素转化成键值对,然后再添加到字典1中.

当序列中的key值有重名的时候,会用序列中键值对对应的值,更新原字典的key对应的值
注意:序列除了字典外必须是这种类型(能够转化成字典的序列):[[1, 2], ['zz', 99], ['转化', '字典']](内部可以是元组,外部也可以是元组)

dic1 = {'a': 'hah', 'b': 200}
dic1.update({'aa': '希娜佳', 'bb': '德玛西亚', 'a': "更新"})
print(dic1)  # {'b': 200, 'aa': '希娜佳', 'bb': '德玛西亚', 'a': '更新'}

dic1.update([[1, 2], ['zz', 99], ['转化', '字典']])
print(dic1)
# {1: 2, 'aa': '希娜佳', 'zz': 99, 'bb': '德玛西亚', 'a': '更新', 'b': 200, '转化': '字典'}

6.3.改(修改key对应的值)

字典[key] = 值 - 当key存在时就是修改key对应的值

dic1 = {'a': 'hah', 'b': 200}
dic1['a'] = '修改后'
print(dic1)  # {'a': '修改后', 'b': 200}

6.4.删(删除键值对)

a.del 字典[key] - 删除字典中key对应的键值对(键值对是成对存在的,所以删除一个就会都删除)

dic1 = {'a': 'hah', 'b': 200}
del dic1['a']
print(dic1)  # {'b': 200}

b.字典.pop(key) - 取出字典中key对应的值(删除整个键值对)

dic1 = {'aa': '希娜佳', 'bb': '德玛西亚', 'a': "更新"}
pop_value = dic1.pop('bb')
print(dic1, pop_value)  # {'a': '更新', 'aa': '希娜佳'} 德玛西亚
dic1 = {'aa': '希娜佳', 'bb': '德玛西亚', 'a': "更新"}
# 随机删除一个键值对(返回值是元组)
pop_item = dic1.popitem()
print(dic1, pop_item)  # {'aa': '希娜佳', 'bb': '德玛西亚'} ('a', '更新')

7.字典相关的运算和方法

7.1.字典不支持+和*

in/not in,len(),dict(序列(序列的要求,为一个大的容器里面许多小的容器,小的容器必须只有两个元素,并且第一个元素必须不可变)),max(),min()
key in 字典 - 判断字典中国是否存在指定的key

dic1 = {'a': 1, 'b': 2}
print('a' in dic1)

7.2.clear

字典.clear() - 清空字典 (删除字典中所有的键值对)

dict1 = {'a': 100, 'b': 200}
print("clear前:", dict1)  # clear前: {'a': 100, 'b': 200}
dict1.clear()
print("clear后:", dict1)  # clear后: {}

3.copy

字典.copy() - 复制字典中所有的键值对,产生一个新的字典

dict1 = {'a': 100, 'b': 200}
dict2 = dict1.copy()  # 浅拷贝(会产生新的地址)
print(dict1 is dict2)  # False
dict1['a'] = 200
print(dict2)  # {'a': 100, 'b': 200}

7.4. fromkeys

dict(类型名).fromkeys(序列,值) - 这个方法是类方法
以序列中的元素作为key,值作为所有key对应的默认值,返回一个新的字典

dict1 = dict.fromkeys('abc', 'a')
print(dict1)  # {1: 'a', 2: 'a', 3: 'a'}

7.5.get

字典.get(key) - 获取key对应的值,如果key不存在,返回None
字典.get(key,value) - 获取key对应的值,如果key不存在,则返回指定的值

dict1 = {1: 'a', 2: 'b', 3: 'c'}
print(dict1.get(4))  # None
print(dict1.get(4, '不存在'))  # 不存在
# 注意:如果字典.get(key),这个key存在,则都只返回key值对应的值(value)

7.6.keys,values,items

字典.keys() - 获取字典所有的key
字典.values() - 获取字典所有的值
字典.items() - 获取字典所有键值对,以元组形式返回

dict1 = {1: 'a', 2: 'b', 3: 'c'}
print(dict1.keys())  # dict_keys([1, 2, 3]) - 返回值是序列,不是列表
print(dict1.values())  # dict_values(['a', 'b', 'c'])  - 返回值是序列,不是列表
print(dict1.items())  # dict_items([(1, 'a'), (2, 'b'), (3, 'c')]) - 返回值是序列,不是列表
for i, j in dict1.items():
    print(i, j)

7.7. setdefault

字典.setdefault(key , value) - 给字典添加键值对(注意:如果key值存在,不会改变字典)

dict1 = {1: 'a', 2: 'b', 3: 'c'}
dict1.setdefault('a', 555)
print(dict1)  # {1: 'a', 2: 'b', 3: 'c', 'a': 555}

8. 集合的基本操作

8.1.什么是集合(set)

a. 集合是python内置的一个容器类的数据类型,是可变的 , 无序的
b. 字面量 - 使用{}括起来,里面有多个元素,多个元素之间用逗号隔开,如:
{1,2,3}
c.元素 - 不是键值对; 必须是不可变的, 而且还是唯一的

set1 = {1, 2, 3, 'acb'}
print(set1, type(set1))  # 
print(isinstance(set1, set))  # True

list1 = [1, 2, 4, 5, 2, 5, 6, 4, 7]
list1 = list(set(list1))
print(list1)  # [1, 2, 4, 5, 6, 7]

set2 = {}
print(type(set2))  # 
set3 = set()
print(type(set3))  # 
print(set2, ':', set3)  # {} : set()

8.2. 集合的增删改查

a.查(获取集合元素)

注意:集合是不能获取单个元素的,只能通过遍历获取全部元素

set1 = set('hello wrod!')
print(set1)  # {'w', 'r', 'o', 'e', '!', 'l', ' ', 'h', 'd'}
for i in set1:
    print(i)

b.增(添加元素)

集合.add(元素) - 将指定的元素添加到集合中
集合.update(序列) - 将序列中的元素添加到集合

set1 = set('hello')
set1.add('ccc')
print(set1)  # {'l', 'o', 'h', 'ccc', 'e'}
set1.update([10, 20])
print(set1)  # {'h', 'l', 10, 'e', 'ccc', 20, 'o'}

c.删(删除元素)

集合.remove(元素) - 删除集合中指定的元素

set1 = {1, 200, 300, 50, 1000}
print(set1)  # {200, 1, 50, 300, 1000}
set1.remove(1000)
print(set1)  # {200, 1, 50, 300}

d.改 - 集合不能修改元素的值

e.集合支持的其他方法

in/not in, max , min , len , set()

set1 = {1, 2}
set2 = {3, 4}
print(3 in set2)  # True
print(2 not in set1)  # False
print(len(set1))  # 2
print(max(set2))  # 4
list1 = [1, 'a', 'c']
print(set(list1))  # {'c', 1, 'a'}

9. 集合的数学运算

python中的集合支持数学相关的集合运算

9.1.包含关系

集合1 >= 集合2 判断集合1中是否包含集合2(判断集合2是否是集合1的子集)
集合1 <= 集合2 判断集合2中是否包含集合1(判断集合1是否是集合2的子集)

print({1, 2, 3} >= {1, 2})  # True  注意:不是在比较大小,而是在判断是否是包含关系
print({1, 2, 3} <= {1, 2})  # False

9.2.求并集

集合1 | 集合2 - 将两个集合中的元素合并在一起产生一个新的集合

set1 = {1, 2, 3, 4, 5}
set2 = {6, 5, 4, 7, 8}
print('并集', set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}

3.求交集

集合1 & 集合2 - 使用两个集合中公共的元素,创建一个新的集合

set1 = {1, 2, 3, 4, 5}
set2 = {6, 5, 4, 7, 8}
print('交集', set1 & set2)  # {4, 5}

9.4.求差集

集合1 - 集合2 :将集合1中除了集合2中(相同的元素)剩下的元素组成一个新的集合

set1 = {1, 2, 3, 4, 5}
set2 = {6, 5, 4, 7, 8}
print('差集', set1 - set2)  # {1, 2, 3}

5.求补集

集合1 ^ 集合2 - 将两个集合中除了公共部分以外的元素组成一个新的集合

set1 = {1, 2, 3, 4, 5}
set2 = {6, 5, 4, 7, 8}
print('补集', set1 ^ set2)  # 补集 {1, 2, 3, 6, 7, 8}