list列表类型内置方法
- 作用:多个装备、多个爱好、多门课程,甚至是多个女朋友
- 定义方式:[]内用逗号隔开,可以有多个任意数据类型的元素
friends_list = ['longzeluola','canglaoshi','qiaobenai','nick']
lis = list('abcd')
- 方法:
-
优先掌握
- 索引取值(正向取值+反向取值) 即可取又可存
#list之索引取值 name_list={'nick','jason','tank','sean'} name_list[0]='nick handsome' #name_list[1000]='tank handsome' #报错 print(f"name_list[0]:{name_list[0]}")
name_list[0]:{name_list[0]}
- 切片
#list之切片 name_list=['nick','jason','tank','jick'] print(name_list[0:3:2]) ----->'nick','tank'
- 长度len
#list之长度 name_list=['nick','jason','tank','jick'] print(len(name_list)) ------>4
- append追加值
# list之追加值 name_list = ['nick', 'jason', 'tank', 'sean'] name_list.append('tank handsome' ) print(name_list) ------->['nick', 'jason', 'tank', 'jick', 'tank handsome']
- 成员运算in和not in
# list之成员运算in和not in name_list = ['nick', 'jason', 'tank', 'sean'] print('tank handsome' in name_list ) ----->Fslse print('nick handsome' not in name_list) ------>true
- for循环
# list之循环 name_list = ['nick', 'jason', 'tank', 'sean'] for name in name_list: print(name) nick jason tank jick
- 删除del
# list之删除 name_list = ['nick', 'jason', 'tank', 'sean'] del name_list[2] print(name_list) ---->['nick', 'jason', 'jick']
- 索引取值(正向取值+反向取值) 即可取又可存
- 需要掌握
- count计数
# list之count() name_list = ['nick', 'jason', 'tank', 'sean'] print(name_list.count('tank')) ------>1
- remove 如果删除对象不存在则报错,按照指定的元素删除
# list之remove() name_list = ['nick', 'jason', 'tank', 'sean'] print(name_list.remove('tank')) ------> None print(name_list) ----->['nick', 'jason', 'sean']
- reverse 反转列表
# list之reverse() name_list = ['nick', 'jason', 'tank', 'sean'] name_list.reverse() print(name_list) ------>['sean', 'tank', 'jason', 'nick']
- pop 默认删除最后一个值,删除指定索引的值
# list之pop(),pop()默认删除最后一个元素 name_list = ['nick', 'jason', 'tank', 'sean'] print(name_list.pop(1)) ----->jason print(name_list) ----->['nick', 'tank', 'sean']
- insert 在索引前面加入一个值
# list之insert() name_list = ['nick', 'jason', 'tank', 'sean'] name_list.insert(1,'handsome') print(name_list) --->['nick', 'handsome', 'jason', 'tank', 'sean']
- sort 排序列表
# list之sort(),使用sort列表的元素必须是同类型的 name_list = ['nick', 'jason', 'tank', 'sean'] name_list.sort() print(name_list) --->['jason', 'nick', 'sean', 'tank'] name_list.sort(reverse=True) print(name_list) ------->['tank', 'sean', 'nick', 'jason']
- index 获取指定元素的索引,但是只会获取第一次
# list之index() name_list = ['nick', 'jason', 'tank', 'sean'] print(name_list.index('nick')) ---->0
- copy 复制
# list之copy() name_list = ['nick', 'jason', 'tank', 'sean'] print(name_list.copy()) --->['nick', 'jason', 'tank', 'sean']
- extend 扩展,把extend里的列表的元素添加到原列表中
# list之extend() name_list = ['nick', 'jason', 'tank', 'sean'] name_list2=['nick handsome' ] name_list.extend(name_list2) print(name_list) -->['nick', 'jason', 'tank', 'sean', 'nick handsome']
- clear 清除列表/清空列表
# list之clear() name_list = ['nick', 'jason', 'tank', 'sean'] name_list.clear() print(name_list) ------->[]
- count计数
-
- 多个值or一个值 :多个值
- 有序or无序:有序
hobby_list = ['read', 'run', 'girl'] print(f'first:{id(hobby_list)}') --->4522187016 hobby_list[2] = '' print(f'second:{id(hobby_list)}') ---->4522187016
- 可变or不可变:可变数据类型
元组类型内置方法
- 作用: 类似于列表,可以存不可以取
- 定义方式: 在()内可以有多个任意类型的值,逗号分隔元素
friends_tuple = ('longzeluola','canglaoshi','qiaobenai','nick')
tup = tuple('abcd')
- 方法
- 索引取值(无法更改)
- 切片(顾头不顾尾,步长)
- 长度 len
- 成员运算 in 和not in
- for循环
- count
- index
- 多个值or一个值:多个值
- 有序or无序:有序
- 可变or不可变:无可变不可变这一说
列表可变的原因是:索引所对应的值的内存地址是可以改变的
元组不可变得原因是:索引所对应的值的内存地址是不可以改变的,或者反过来说,只要索引对应值的内存地址没有改变,那么元组是始终没有改变的。
字典类型内置方法
- 作用:当列表存在很多值的时候,列表会显得很乱,所以就有了字典。多用于存的值表示的是不同的状态时,例如存的值有姓名、年龄、身高、体重、爱好。
- 定义方式:{}内用逗号分隔开多个键值对key:value的值,value可以是任意数据类型,而key通常应该是字符串类型,但是key必须为不可变类型。
nick_info_dict = {
'name':'nick',
'height':180,
'weight':140,
'hobby_list':['read','run','music','fishing','programming','coding','debugging']
}
for k,v in nick_info_dict.items():
print(k,v)
name nick
height 180
weight 140
hobby_list [‘read‘, ‘run‘, ‘music‘, ‘fishing‘, ‘programming‘, ‘coding‘, ‘debugging‘]
- 方法
- 按键取值:可存可取
# dic之按key存取值 dic = {'a': 1, 'b': 2} print(f"first dic['a']: {dic['a']}") dic['a'] = 3 print(f"second dic['a']: {dic['a']}")
first dic[‘a‘]: 1
second dic[‘a‘]: 3 - 长度:
?``` print(len(dic))
- 键keys() / 值values()/ 键值对items()
# dic之键keys()、值values()、键值对items(),python2中取出的是列表(鸡蛋);python3中取出的是元组(鸡) dic = {'a': 1, 'b': 2} print(f"dic.keys(): {dic.keys()}") print(f"dic.values(): {dic.values()}") print(f"dic.items(): {dic.items()}")
dic.keys(): dict_keys([‘a‘, ‘b‘])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([(‘a‘, 1), (‘b‘, 2)]) - for循环
# dic之循环 # dic是无序的,但是python3采用了底层优化算法,所以看起来是有序的,但是python2中的字典是无序 dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4} for k, v in dic.items(): # items可以换成keys()、values() print(k, v)
a 1
b 2
c 3
d 4 - 成员运算in 和 not
# dic之成员运算in和not in dic = {'a': 1, 'b': 2} print(f"'a' in dic: {'a' in dic}") print(f"1 in dic: {1 in dic}")
‘a‘ in dic: True
1 in dic: False - 删除del
# dic之删除del dic = {'a': 1, 'b': 2} del dic['a'] print(f"dic.get('a'): {dic.get('a')}")
dic.get(‘a‘): None
- 需要掌握
1. fromkeys 来自键值,默认把给定列表内的元素取出来当成key,然后使用一个默认value新建一个字典# dic之fromkeys() dic = dict.fromkeys(['name', 'age', 'sex'], None) print(f"dic: {dic}")
dic: {‘name‘: None, ‘age‘: None, ‘sex‘: None}
2. setdefault 如果字典中有该key的话,则key对应的值不变:如果没有,则增加
```python
# dic之setdefault(),有指定key不会改变值;无指定key则改变值
dic = {'a': 1, 'b': 2}
print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
print(f"dic: {dic}")
print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
print(f"dic: {dic}")
```
dic.setdefault('a'): 1
dic: {'a': 1, 'b': 2}
dic.setdefault('c'): 3
dic: {'a': 1, 'b': 2, 'c': 3}
3. get 如果键不存在,返回不会报错,可以给默认值
```python
# dic之get()
dic = {'a': 1, 'b': 2}
print(f"dic.get('a'): {dic.get('a')}")
print(f"dic.get('c'): {dic.get('c')}")
```
dic.get('a'): 1
dic.get('c'): None
4. update 有就更新,没有就添加
```python
# dic之update()
dic1 = {'a': 1, 'b': 2}
dic2 = {'c': 3}
dic1.update(dic2)
print(f"dic1: {dic1}")
```
dic1: {'a': 1, 'b': 2, 'c': 3}
- 多个值or一个值:多个值,值可以是多个类型,key必须是不可变类型,通常应该是不可变类型中的字符串类型
- 有序or无序:无序
- 可变or不可变:可变数据类型
集合类型内置方法
- 作用:存多个值,为了集合之间做运算,由于集合内的元素无序且集合元素不可重复,因此集合可以去重,但是去重后的集合会打乱原来元素的顺序。
- 定义方式:{}内用逗号分隔开多个元素,每个元素必须是不可变类型。
s = set()
s = {1,2,3,4,5,1}
- 方法:
- 优先掌握
- 去重
- 并集 | ,union
# str之|并集 pythoners = {'jason', 'nick', 'tank', 'sean'} linuxers = {'nick', 'egon', 'kevin'} print(f"pythoners|linuxers: {pythoners|linuxers}") print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")
pythoners|linuxers: {‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘nick‘, ‘sean‘}
pythoners.union(linuxers): {‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘nick‘, ‘sean‘} - 交集 & intersection
- 差集 -difference
- 对称差集 ^symmetric_difference
- 父集 > >=issuperset
- 子集 <&emsp;<=issubset
==
- 需要掌握
- add()
# set之add() s = {1, 2, 'a'} s.add(3) print(s)
{1, 2, 3, ‘a‘}
- difference_update
# str之difference_update() pythoners = {'jason', 'nick', 'tank', 'sean'} linuxers = {'nick', 'egon', 'kevin'} pythoners.difference_update(linuxers) print(f"pythoners.difference_update(linuxers): {pythoners}")
pythoners.difference_update(linuxers): {‘tank‘, ‘jason‘, ‘sean‘}
- isdisjoint 是否不联合
# set之isdisjoint(),集合没有共同的部分返回True,否则返回False pythoners = {'jason', 'nick', 'tank', 'sean'} linuxers = {'nick', 'egon', 'kevin'} pythoners.isdisjoint(linuxers) print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")
pythoners.isdisjoint(linuxers): False
- remove # 值不存在会报错
# set之remove() s = {1, 2, 'a'} s.remove(1) print(s)
{2, ‘a‘}
- discard # 放弃,删除,不会报错
# set之discard() s = {1, 2, 'a'} # s.remove(3) # 报错 s.discard(3) print(s)
{1, 2, ‘a‘}
- add()
- 优先掌握
- 多个值or一个值:多个值,且值为不可变类型
- 有序or无序:无序
- 可变or不可变:可变数据类型
数据类型总结
一个值 | 多个值 |
---|---|
整型/浮点型/字符串 | 列表/元祖/字典/集合/ |
有序 | 无序 |
---|---|
字符串/列表/元祖 | 字典/集合 |
可变 | 不可变 |
---|---|
列表/字典/集合 | 整型/浮点型/字符串 |
拷贝
- ==拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的==
l1 = ['a','b','c',['d','e','f']]
l2 = l1
l1.append('g')
print(l1) # ['a','b','c',['d','e','f'],'g']
print(l2) # ['a','b','c',['d','e','f'],'g']
如果l2是l1的拷贝对象,则l1内部的任何数据类型的元素变化,则l2内部的元素也会跟着改变,因为可变类型值变id不变
浅拷贝
import copy
l1 = ['a','b','c',['d','e','f']]
l2 = copy.copy(l1)
l1.append('g')
print(l1) # ['a','b','c',['d','e','f'],'g']
print(l2) # ['a','b','c',['d','e','f']]
l1[3].append('g')
print(l1) # ['a','b','c',['d','e','f','g'],'g']
print(l2) # ['a','b','c',['d','e','f','g']]
如果l2是l1的浅拷贝对象,则l1内的不可变元素发生了改变,l2不变;如果l1内的可变元素发生了改变,则l2会跟着改变
深拷贝
import copy
l1 = ['a','b','c',['d','e','f']]
l2 = copy.deepcopy(l1)
l1.append('g')
print(l1) # ['a','b','c',['d','e','f'],'g']
print(l2) # ['a','b','c',['d','e','f']]
l1[3].append('g')
print(l1) # ['a','b','c',['d','e','f','g'],'g']
print(l2) # ['a','b','c',['d','e','f']]
如果l2是l1的深拷贝对象,则l1内的不可变元素发生了改变,l2不变;如果l1内的可变元素发生了改变,l2也不会变,即l2永远不会因为l1的变化而变化
!
```
原文地址:https://www.cnblogs.com/gongjingyun123--/p/10920988.html