列表、元组、字典、集合类型内置方法

目录

• 列表类型内置方法
  • 作用
  • 定义方式
  • 方法
    • 索引取值（既可取也可以改）
    • 切片
    • 长度
    • 成员运算in和not in
    • 追加值
    • 删除
    • 循环
  • 多个值or一个值
  • 有序or无序
  • 可变or不可变
• 元祖类型内置方法
  • 作用
  • 定义方式
  • 方法
    • 索引取值（无法更改）
    • 切片（顾头不顾尾，步长）
    • 长度
    • 成员运算
    • for循环
    • count()
    • index()
  • 多个值or一个值
  • 有序or无序
  • 可变or不可变
• 字典类型内置方法
  • 作用
  • 定义方式
  • 方法
    • 按key取值：可存可取
    • 长度len
    • 成员运算in和not in
    • 删除
    • 键keys()、值values()、键值对items()
    • 循环
  • 多个值or一个值
  • 有序or无序
  • 可变or不可变
• 集合类型内置方法
  • 作用
  • 定义方式
  • 方法
    • 长度
    • 成员运算in和not in
    • |并集
    • &交集
    • -差集
    • ^对称差集
    • ==
    • 父集：>、>=
    • 子集：<、<=
  • 多个值or一个值
  • 有序or无序
  • 可变or不可变
• 布尔类型
• 数据类型总结
• 拷贝
• 浅拷贝
• 深拷贝

列表类型内置方法

作用

存储多个任意数据类型的元素

定义方式

“[ ]”内用逗号隔开多个任意数据类型的元素

hobby = ['run',1,2.3,'read','swimming','fishing']

方法

索引取值（既可取也可以改）

a = hobby[3]
hobby[0] = 'xiaoming'

print(a)
print(hobby)

read

['xiaoming',1,2.3,'read','swimming','fishing']

切片

name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list[0:3:2]: {name_list[0:3:2]}")

name_list[0:3:2]: ['nick', 'tank']

长度

print(len(name_list))

4

成员运算in和not in

print('xiaoming' in name_list)
print('xiaoming' not in name_list)

False

True

追加值

name_list.append('zhao')
print(name_list)

['nick', 'jason', 'tank', 'sean', 'zhao']

删除

del name_list[2]
print(name_list)

['nick', 'jason', 'sean']

循环

for name in name_list:
    print(name)

nick

jason

tank

sean

多个值or一个值

多个值

有序or无序

有序

可变or不可变

可变

元祖类型内置方法

作用

类似于列表，可以取不可以存

定义方式

friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick')
tup = tuple('abcd')

方法

索引取值（无法更改）

name_tuple = ('nick','jason','tank','sean')
print(name_tuple[0])

nick

切片（顾头不顾尾，步长）

print(name_tuple[1:3:2])

('jason',)

长度

print(len(name_tuple))

4

成员运算

print('nick' in name_tuple)

True

for循环

for name in name_tuple:
    print(name)

nick

jason

tank

sean

count()

print(name_tuple.count('nick'))

1

index()

print(name_tuple.index('nick'))

0

多个值or一个值

多个值

有序or无序

有序

可变or不可变

无可变和不可变之说

字典类型内置方法

作用

存多个值，但每一个值都有一个key与之对应，key对值有描述功能。多用于存的值表示的是不同的状态时，例如存的值有姓名、年龄、身高、体重、爱好。

值太多列表存容易，取麻烦时使用字典。

定义方式

’‘{ }“内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。

方法

按key取值：可存可取

dic = {'a':1,'b',2}
print(dic['a'])
dic['a'] = 3
print(dic('a'))

1

3

长度len

print(len(dic))

2

成员运算in和not in

print('a' in dic)
print(1 in dic)

True

False

删除

del dic['a']
print(dic.get('a'))

None

dic.pop('a')
print(dic.pop('b'))   # 随机删除指定的元素，打印删除的值
print(dic.get('a'))

2

None

priny(dic.popitem())  # 随机删除一个键值对，打印删除的值

('b',2)

键keys()、值values()、键值对items()

print(dic.keys())
print(dic.values())
print(dic.items())

dict_keys(['a','b'])

dict_values([1,2])

dict_items([('a',1),('b',2)])

循环

for k,v in dic.items():
    print(k,v)

a 1

b 2

多个值or一个值

多个值

有序or无序

无序

可变or不可变

可变

集合类型内置方法

作用

存多个值，为了集合之间做运算。

集合内元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。

定义方式

s = set()
s1 = {1,2,3,4,5}

方法

长度

s = {1,2,'a'}
print(len(s))

3

成员运算in和not in

print(1 in s)

True

|并集

pythoners = {'jason','nick','tank','sean'}
linuxers = {'nick','egon','kevin'}
print(pythoners|linuxers) # 对应方法pythoners.union(linuxers)

{'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}

&交集

print(pythoners&linuxers)   # 对应方法pythoners.intersection(linuxers)

{'nick'}

-差集

print(pythoners-linuxers)  # 对应方法pythoners.difference(linuxers)

{'tank', 'jason', 'sean'}

^对称差集

print(pythoners^linuxers)  # 对应方法pythoners.symmetric_difference(linuxers)

{'egon', 'tank', 'kevin', 'jason', 'sean'}

==

javers = {'nick','egon','kevin'}
print(pythoners==linuxers)
print(linuxers==javers)

False

True

父集：>、>=

java = {'jason','nick'}
print(pythoners>linuxers)
print(pythoners>=linuxers)
print(pythoners>=java)
print(pythoners.issuperset(java))

False

False

True

True

子集：<、<=

print(pythoners<linuxers)
print(pythoners<=linuxers)
print(java.issubset(java))

False

False

True

多个值or一个值

多个值

有序or无序

无序

可变or不可变

可变

布尔类型

一般用于判断，除了0/None/空/False自带布尔值为False，其他的数据类型自带布尔值为True

数据类型总结

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

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

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

拷贝

拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的

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的变化而变化