Day 07 数据类型的内置方法(列表\字典\元祖\集合),深浅拷贝

目录

• 数据类型的内置方法(列表\字典\元祖\集合),深浅拷贝
  • • 列表类型的内置方法
    • 元祖的内置方法
    • 字典的内置方法
    • 集合的内置方法
    • 数据类型的总结
    • 浅拷贝和深拷贝(只针对可变类型),当拷贝对象中的不可变类型发生改变时,拷贝后的变量不会跟着拷贝对象改变

数据类型的内置方法(列表\字典\元祖\集合),深浅拷贝

列表类型的内置方法

1. 用途：用于存放多个值
2. 定义：[]中用逗号分隔多个元素，这些元素可以是任意类型的值
3. 方法：
   优先掌握：
   1. 按照索引取值

list=[1,2,3,4,5,6,7]
print(list[2]) # 3
print(list[-2]) #6
2. 切片 python
print(list[2:]) #[3, 4, 5, 6, 7]
print(list[2:5:2]) #[3, 5]
print(list[-2::-1]) #[6, 5, 4, 3, 2, 1]
3. 长度len python
print(len(list)) #7
4. 成员运算 in 和 not in python
print(10 not in list) #True
print(9 in list) #False
5. 追加append（在列表最后加入一个值） python
list.append(100)
print(list) #[1, 2, 3, 4, 5, 6, 7, 100]
6. 删除del python
del list[2]
print(list) #[1, 2, 4, 5, 6, 7, 100]
7. 循环 python
for i in list:
print(i)
```

需要掌握

1. insert 在索引前面插入一个值
```python
list=[1,2,3,4,5,6,7]
list.insert(4,100) #[1, 2, 4, 5, 100, 6, 7, 100]

```
2. pop 删除指定索引的值,默认删除最后一个值

```python
list.pop()
list.pop(-3) #[1, 2, 4, 5, 6, 7]
```
3. remove 按照指定的元素删除,如果删除的对象不存在则报错

```python
list.remove(2)
```
4. count 获取指定元素的个数

```python
list.count(1)
```
5. index 获取指定元素的索引,但是只会获取第一次的索引

```python
list.index(6)
```
6. clear 清空列表

```python
list.clear()
```
7. copy 复制列表
```python
list2=list.copy()
```

8. extend 扩展,把extend括号里面的列表的元素添加到原列表中

```python
list.extend(['a','b','c'])
```

9. reverse 反转列表

```python

list2=list.recerse()
```
10. sort 排序列表

```python

lilst3=list.sort()
```
4. 存储一个值or多个值:多个值
5. 有序or无序:有序
6. 可变or不可变:可变

元祖的内置方法

1. 作用:类似于列表,但是元祖只能取不能更改
2. 定义方式:()内用逗号隔开任意数据类型的元素
3. 方法
   1. 索引取值

   tuple=('a','b','c','d','e')
   print(tuple[2])
   

   2. 切片

   print(tuple[2:])
   print(tuple[1:5:2])
   

   3. 长度

   print(tuple.len())
   

   4. 成员运算

   print('4' in tuple)
   

   5. 循环

   for i in tuple:
   	print i
   

   6. count 获取指定元素的个数

   print(tuple.count('c'))
   

   7. index 获取指定元素的索引

   print(tuple.count('b'))
   

4. 存储一个值or多个值:多个值
5. 有序or无序:有序
6. 可变or不可变:不存在可变不可变这个说法

字典的内置方法

1. 作用:当列表存有很多值的时候,列表会显得很乱,所以有了字典

2. 定义方式:{}内衣逗号分隔开多个键值对 key:value的值,key一般具有描述性意义所以为字符串,value可以为任意类型的数据

3. 方法
   优先掌握

   1. 按key取值:可存可取

   dict={'name':'zhujian','age':20,'hobby':['read','run','swimming']
   print(dict['name'])
   

   2. 长度len

   print(len(dict))
   

   3. 成员运算:比较的是key而非value

   print('age' in dict)
   

   4. 删除del 删除key

   del dict['hobby']
   

   5. 键keys()值values()键值对items(),取出的所有值当成列表

   print(dict.keys())
   print(dict.values())
   print(dict.items())
   

   6. 循环

   for k,v in dict:
   	print(k,v)
   

   需要掌握

   1. get:取值,如果键不存在,返回None,不会报错;如果键不存在,额可以给定默认值

   print(dict.get('height', 170))
   

   2. update 有就更新,没有则添加

   dict2={'weight':130,'height':170}
   dict.upfate(dict2)
   

   3. fromkeys 默认吧给定列表内的元素取出来当成key,然后使用一个默认value新建一个字典

   dict3 = dic.fromkeys(['a','b','c'],123)
   print(dict3) # {'a':123,'b':123,'c':123}
   

   4. setdefault 如果字典中有该key的话,则key的对应值不变,如果没有,则增加

   dict.setdefault('country','china')
   

4. 存储一个值or多个值:多个值

5. 有序or无序:无序

6. 可变or不可变:可变

集合的内置方法

1. 作用:存储多个值,集合内的元素不能重复,多用于集合间的关系运算

2. 定义方式:{}内以逗号 分隔开多个元素,这个元素必须是不可变类型

3. 方法:
   优先掌握

   1. 去重

   l1 = [1, 2, 1, 2, 3, 5, 100, 0, -1000]
   s=set(l1)
   

   2. 长度len

   pythoner = {'fanping', 'wangdapao', 'wangwu', 'zhaoliu', 'zhangsan', 'wangba'}
   linuxer = {'ruiixng', 'lisi', 'wangba', 'wangdapao'}
   print(len(pythoner))
   

   3. 成员运算

   print('wangdapao' in pythoner)
   

   4. | 并集 union(两个集合的所有元素,并且没有重复)

   print(pythoner | linuxer)
   print(pythoner.union(linuxer))
   

   5. & 交集 intersection(两个集合中相同的元素)

   print(pythoner & linuxer)
   print(pythoner.intersection(linuxer))
   

   6. • 差集 diffence(属于第一个集合但不属于第二个集合)

   print(pythoner - linuxer)
   print(pythoner.difference(linuxer))
   

   7. ^ 对称差集 symmetric_diffence(两个几个的并集并且去除他们相同的元素)

   print(pythoner ^ linuxer)
   print(pythoner.symmetric_difference(linuxer))
   

   8. == 判断两个集合是否完全相同

   print(pythoner == linuxer)
   

   9. 父集 > >= issuperset(判断第二个集合中的元素是否都在第一个集合中)

   print(pythoner > linuxer)
   print(pythoner.issuperset(linuxer))
   

   10. 子集 < <= issubset(判断第一个集合中的元素是否都在第二个集合中)

   print(pythoner < linuxer)
   print(pythoner.issubset(linuxer))
   

   需要掌握

   1. add 添加元素

   s.add('a')
   

   2. remove 移除元素,如果不存在会报错

   s.remove('a')
   

   3. difference_update

   pythoner = {'fanping', 'wangdapao', 'wangwu', 'zhaoliu', 'zhangsan', 'wangba'}
   linuxer = {'ruiixng', 'lisi', 'wangba', 'wangdapao'}
   pythoner.difference_update(linuxer)
   

   4. discard 移除元素,如果不存在也不会报错

   s.discarf('a')
   

   5. isdisjiont 判断集合有没有共同的部分,如果没有返回True,否则返回False

   pythoner.isdisjiont(linuxer)
   

4. 存储一个值or多个值:多个值

5. 有序or无序:无序

6. 可变or不可变:可变

数据类型的总结

存一个值还是多个值
一个值:整型/浮点型/字符串
多个值:列表/元祖/字典/集合

有序or 无序
有序:字符串/列表/元祖
无序:字典/集合

可变or 不可变
可变:列表/字典/集合
不可变:整型/浮点型/字符串

浅拷贝和深拷贝(只针对可变类型),当拷贝对象中的不可变类型发生改变时,拷贝后的变量不会跟着拷贝对象改变

拷贝:如果l2是l1的拷贝对象,l1发生改变则l2也会发生改变,因为l1是可变类型,可变类型
值变id不变(拷贝是指两个列表指向同一个内存地址)

浅拷贝:如果l2是l1的浅拷贝对象,l1内部的不可变对象发生改变,则l2不变;如果l1内部的可变对象发生改变,则l2随着改变(浅拷贝是指l2新开辟了一个内存空间并复制了l1的索引,当拷贝对象中的可变类型发生变化时,由于id不变,l2仍使用原来的索引,所以l2也会跟着变动)

深拷贝:如果l2是l1的深拷贝对象,l1内部的不可变对象发生改变,则l2不变;如果l1内部的可变对象发生改变,l2也不会改变(深拷贝是指l2新开辟一个内存空间并复制了l1中的不可变类型的索引,可变类型的索引是新建的内存空间,所以无论拷贝对象如何变化,与l2都没有关系)