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

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

列表类型的内置方法

用途：用于存放多个值
定义：[]中用逗号分隔多个元素，这些元素可以是任意类型的值
方法：
优先掌握：
1. 按照索引取值
```
list=[1,2,3,4,5,6,7]
print(list[2]) # 3
print(list[-2])  #6
```
1. 切片
```
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]
```
1. 长度len
```
print(len(list)) #7
```
1. 成员运算 in 和 not in
```
print(10 not in list) #True
print(9 in list) #False
```
1. 追加append（在列表最后加入一个值）
```
list.append(100)
print(list)  #[1, 2, 3, 4, 5, 6, 7, 100]
```
1. 删除del
```
del list[2]
print(list) #[1, 2, 4, 5, 6, 7, 100]
```
1. 循环
```
for i in list:
print(i)
```
需要掌握
1. insert 在索引前面插入一个值
```
list=[1,2,3,4,5,6,7]
list.insert(4,100) #[1, 2, 4, 5, 100, 6, 7, 100]
```
1. pop 删除指定索引的值,默认删除最后一个值
```
list.pop()
list.pop(-3) #[1, 2, 4, 5, 6, 7]
```
1. remove 按照指定的元素删除,如果删除的对象不存在则报错
```
list.remove(2)
```
1. count 获取指定元素的个数
```
list.count(1)
```
1. index 获取指定元素的索引,但是只会获取第一次的索引
```
list.index(6)
```
1. clear 清空列表
```
list.clear()
```
1. copy 复制列表
```
list2=list.copy()
```
1. extend 扩展,把extend括号里面的列表的元素添加到原列表中
```
list.extend(['a','b','c'])
```
1. reverse 反转列表
```
list2=list.recerse()
```
1. sort 排序列表
```
lilst3=list.sort()
```
存储一个值or多个值:多个值
有序or无序:有序
可变or不可变:可变

元祖的内置方法

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

方法

索引取值

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

切片

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

长度

print(tuple.len())

成员运算

print('4' in tuple)

循环

for i in tuple:
    print i

count 获取指定元素的个数

print(tuple.count('c'))

index 获取指定元素的索引

print(tuple.count('b'))

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

字典的内置方法

作用:当列表存有很多值的时候,列表会显得很乱,所以有了字典
定义方式:{}内衣逗号分隔开多个键值对 key:value的值,key一般具有描述性意义所以为字符串,value可以为任意类型的数据
方法
优先掌握
1. 按key取值:可存可取
```
dict={'name':'zhujian','age':20,'hobby':['read','run','swimming']
print(dict['name'])
```
1. 长度len
```
print(len(dict))
```
1. 成员运算:比较的是key而非value
```
print('age' in dict)
```
1. 删除del 删除key
```
del dict['hobby']
```
1. 键keys()值values()键值对items(),取出的所有值当成列表
```
print(dict.keys())
print(dict.values())
print(dict.items())
```
1. 循环
```
for k,v in dict:
    print(k,v)
```
需要掌握
1. get:取值,如果键不存在,返回None,不会报错;如果键不存在,额可以给定默认值
```
print(dict.get('height', 170))
```
1. update 有就更新,没有则添加
```
dict2={'weight':130,'height':170}
dict.upfate(dict2)
```
1. fromkeys 默认吧给定列表内的元素取出来当成key,然后使用一个默认value新建一个字典
```
dict3 = dic.fromkeys(['a','b','c'],123)
print(dict3) # {'a':123,'b':123,'c':123}
```
1. setdefault 如果字典中有该key的话,则key的对应值不变,如果没有,则增加
```
dict.setdefault('country','china')
```
存储一个值or多个值:多个值
有序or无序:无序
可变or不可变:可变

集合的内置方法

作用:存储多个值,集合内的元素不能重复,多用于集合间的关系运算
定义方式:{}内以逗号分隔开多个元素,这个元素必须是不可变类型

方法:
优先掌握

去重

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

长度len

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

成员运算

print('wangdapao' in pythoner)

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

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

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

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

- 差集 diffence(属于第一个集合但不属于第二个集合)

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

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

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

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

print(pythoner == linuxer)

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

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

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

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

需要掌握

add 添加元素

s.add('a')

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

s.remove('a')

difference_update

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

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

s.discarf('a')

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

pythoner.isdisjiont(linuxer)

存储一个值or多个值:多个值
有序or无序:无序
可变or不可变:可变

数据类型的总结

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

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

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

浅拷贝和深拷贝(只针对可变类型)
拷贝:如果l2是l1的拷贝对象,l1发生改变则l2也会发生改变,因为l1是可变类型,可变类型
值变id不变
浅拷贝:如果l2是l1的浅拷贝对象,l1内部的不可变对象发生改变,则l2不变;如果l1内部的可变对象发生改变,则l2随着改变
深拷贝:如果l2是l1的深拷贝对象,l1内部的不可变对象发生改变,则l2不变;如果l1内部的可变对象发生改变,l2也不会改变

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