列表数据类型内置方法
-
作用
描述多个值,比如爱好
-
定义方式
hobby_list = ['play', 'swimming', 'dancing', '666']
-
内置方法
优先掌握
-
索引取值
1. hobby_list = ['play', 'swimming', 'dancing', '666'] print(1, hobby_list[-1]) hobby_list[-1] = '233' # 索引修改 print(2, hobby_list[-1]) -
切片
print(hobby_list[:]) # ['play', 'swimming', 'dancing', '666'] print(hobby_list[::-1]) # 从右到左 # ['666', 'dancing', 'swimming', 'play'] -
长度
print(len(hobby_list)) -
in/not in
hobby_list = ['play', 'swimming', 'dancing', '666'] print('play' in hobby_list) # True -
for 循环
for hobby in hobby_list: print(hobby) -
del删除
del hobby_list[-1] print(hobby_list) -
append() # 追加
hobby_list = ['play', 'swimming', 'dancing', '666'] hobby_list.append('dapao-->piao') print(hobby_list)
-
需要掌握
-
count 计数
hobby_list = ['play', 'swimming', 'dancing', '666', 666, '666'] print(hobby_list.count('666')) -
extend 扩展列表
hobby_list.extend([1, 2, 3, 4])
print(hobby_list)
- clear 清除
hobby_list.clear()
print(hobby_list)
- copy 复制列表
hobby_list2 = hobby_list.copy()
hobby_list[-1] = '233'
print(hobby_list)
print(hobby_list2)
- pop 删除,默认删除最后一个
hobby_list.pop()
print(hobby_list)
hobby_list = ['play', 'swimming', 'dancing', 'play', '666', 666, '666']
print(hobby_list.index('play')) # 索引
print(hobby_list.index('play', 2, 4)) # 索引2-4内有没有该值
-
insert 插入
hobby_list.insert(0, '1') print(hobby_list) -
remove 移除
hobby_list.remove('1') print(hobby_list) -
reverse 反转
hobby_list.reverse()
print(hobby_list)
hobby_list = [1,2,434,5435,0,2304]
hobby_list = [['nick', 1000], ['jason', 500000], ['sean', 2000], ['tank', 10000]]
def func(i): # ['nick', 1000]
return i[1] # 1000,500000,2000,10000
hobby_list.sort(key=func)
hobby_list.sort(key=lambda i: i[1], reverse=True) #print(hobby_list)
-
存一个值还是多个值
多个值
-
有序or无序
有序
-
可变or不可变(重点)
可变
元组数据类型内置方法
-
定义方式
列表的中括号改成小括号lis = [1,2,3,4] tup = (1,2,3,4)元祖和列表一模一样,但是元祖无法修改,元祖在定义那一刻他的元素个数以及元素的值全部固定了
print(tup[1]) lis[1] = 5 print(lis) tup[1] = 5 print(tup) lis.append(5) print(lis) tup.早期永远一般用于减小内存占用,现在毫无用处,以后只要定义列表就行了
tup = (1,2,3,4) tup = tuple('lksjdkflj') print(tup.index(1)) print(tup.count(1))- 存一个值还是多个值
多个值 - 有序or无序
有序 - 可变or不可变(重点)
压根没有这一说
- 存一个值还是多个值
字典数据类型内置方法
1.用途：存多个值，但每一个值都有一个key与之对应，key对值有描述功能。多用于存的值表示的是不同的状态时，例如存的值有姓名、年龄、身高、体重、爱好。
2.定义：{}内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。
dic = {'a': 1, 'b': 2} # dic = dict({'a':1,'b':2})
print(f"dic: {dic}")
dic: {'a': 1, 'b': 2}
dic = dict(a=1, b=2, c=3)
print(f"dic: {dic}")
dic: {'a': 1, 'b': 2, 'c': 3}
dic = {1: 'a', 0: 'b'}
print(f"dic[0]: {dic[0]}") # 无法区分dic是列表，还是字典，并且key不再具有描述信息
dic[0]: b
dic = {[1,2]: 'a', 0: 'b'} # 报错
3.常用操作+内置方法：常用操作和内置方法分为优先掌握（今天必须得记住）、需要掌握（一周内记住）两个部分。
1.1 优先掌握(***)
- 按key存取值：可存可取
- 长度len
- 成员运算in和not in
- 删除del
- 键keys()、值values()、键值对items()
- 循环
1.按key存取值：可存可取
# 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
2.长度len
# dic之长度len
dic = {'a': 1, 'b': 2}
print(f"len(dic): {len(dic)}")
len(dic): 2
3.成员运算in和not in
# 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
4.删除
# dic之删除del
dic = {'a': 1, 'b': 2}
del dic['a']
print(f"dic.get('a'): {dic.get('a')}")
dic.get('a'): None
# dic之删除pop()
dic = {'a': 1, 'b': 2}
dic.pop('a') # 指定元素删除
print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")
dic.pop('b'): 2
dic.get('a'): None
# dic之删除popitem()
dic = {'a': 1, 'b': 2}
print(f"dic.popitem(): {dic.popitem()}") # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
dic.popitem(): ('b', 2)
5.键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)])
6.循环
# 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
1.2 需要掌握(**)
- get
- update
- fromkeys
- setdefault
1.get()
# 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
2.update()
# dic之update()
dic1 = {'a': 1, 'b': 2}
dic2 = {'c': 3}
dic1.update(dic2)
print(f"dic1: {dic1}")
dic1: {'a': 1, 'b': 2, 'c': 3}
3.fromkeys()
# dic之fromkeys()
dic = dict.fromkeys(['name', 'age', 'sex'], None)
print(f"dic: {dic}")
dic: {'name': None, 'age': None, 'sex': None}
4.setdefault()
# 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}
4.存一个值or多个值：多个值，值可以是多个类型，key必须是不可变类型，通常应该是不可变类型中的字符串类型
5.有序or无序：无序
dic = {'a': 1, 'b': 2}
print(f'first:{id(name)}')
dic['a'] = 3
print(f'second:{id(name)}')
first:4356627632
second:4356627632
6.可变or不可变：可变数据类型
集合数据类型内置方法
集合可以理解成一个集合体，学习Python的学生可以是一个集合体；学习Linux的学生可以是一个集合体。
pythoners = ['jason', 'nick', 'tank', 'sean']
linuxers = ['nick', 'egon', 'kevin']
# 即报名pythoners又报名linux的学生
py_li_list = []
for stu in pythoners:
if stu in linuxers:
py_li_list.append(stu)
print(f"pythoners and linuxers: {py_li_list}")
pythoners and linuxers: ['nick']
上述的列表方式求两个集合体的关系运算非常复杂，因此有了我们的集合数据类型。
1.用途：用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。
2.定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型。
s = {1, 2, 1, 'a'} # s = set({1,2,'a'})
print(f"s: {s}")
s: {1, 2, 'a'}
s = {1, 2, 1, 'a', 'c'}
for i in s:
print(i)
1
2
c
a
s = set('hello')
print(f"s: {s}")
s: {'e', 'o', 'h', 'l'}
3.常用操作+内置方法：常用操作和内置方法分为优先掌握（今天必须得记住）、需要掌握（一周内记住）两个部分。
1.1 优先掌握(***)
- 长度len
- 成员运算in和not in
- |并集、union
- &交集、intersection
- -差集、difference
- ^对称差集、symmetric_difference
- ==
- 父集：>、>= 、issuperset
- 子集：<、<= 、issubset
1.长度len
# set之长度len
s = {1, 2, 'a'}
print(f"len(s): {len(s)}")
len(s): 3
2.成员运算in和not in
# set之成员运算in和not in
s = {1, 2, 'a'}
print(f"1 in s: {1 in s}")
1 in s: True
3.|并集
# 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'}
4.&交集
# str之&交集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(f"pythoners&linuxers: {pythoners&linuxers}")
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")
pythoners&linuxers: {'nick'}
pythoners.intersection(linuxers): {'nick'}
5.-差集
# str之-差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(f"pythoners-linuxers: {pythoners-linuxers}")
print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")
pythoners-linuxers: {'tank', 'jason', 'sean'}
pythoners.difference(linuxers): {'tank', 'jason', 'sean'}
6.^对称差集
# str之^对称差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(f"pythoners^linuxers: {pythoners^linuxers}")
print(
f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")
pythoners^linuxers: {'egon', 'tank', 'kevin', 'jason', 'sean'}
pythoners.symmetric_difference(linuxers): {'egon', 'tank', 'kevin', 'jason', 'sean'}
7.==
# str之==
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javers = {'nick', 'egon', 'kevin'}
print(f"pythoners==linuxers: {pythoners==linuxers}")
print(f"javers==linuxers: {javers==linuxers}")
pythoners==linuxers: False
javers==linuxers: True
8.父集：>、>=
# str之父集：>、>=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}
print(f"pythoners>linuxers: {pythoners>linuxers}")
print(f"pythoners>=linuxers: {pythoners>=linuxers}")
print(f"pythoners>=javaers: {pythoners>=javaers}")
print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")
pythoners>linuxers: False
pythoners>=linuxers: False
pythoners>=javaers: True
pythoners.issuperset(javaers): True
9.子集：<、<=
# str之子集：<、<=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}
print(f"pythoners<linuxers: {pythoners<linuxers}")
print(f"pythoners<=linuxers: {pythoners<=linuxers}")
print(f"javaers.issubset(javaers): {javaers.issubset(javaers)}")
pythoners<linuxers: False
pythoners<=linuxers: False
javaers.issubset(javaers): True
1.2 需要掌握(**)
- add
- remove
- difference_update
- discard
- isdisjoint
1.add()
# set之add()
s = {1, 2, 'a'}
s.add(3)
print(s)
{1, 2, 3, 'a'}
2.remove()
# set之remove()
s = {1, 2, 'a'}
s.remove(1)
print(s)
{2, 'a'}
3.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'}
4.discard()
# set之discard()
s = {1, 2, 'a'}
# s.remove(3) # 报错
s.discard(3)
print(s)
{1, 2, 'a'}
5.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
4.存一个值or多个值：多个值，且值为不可变类型。
5.有序or无序：无序
s = {1, 2, 'a'}
print(f'first:{id(s)}')
s.add(3)
print(f'second:{id(s)}')
first:4480523848
second:4480523848
6.可变or不可变：可变数据类型