容器数据类型内置方法

列表数据类型内置方法

  1. 作用

    描述多个值,比如爱好

  2. 定义方式

    hobby_list = ['play', 'swimming', 'dancing', '666']

  3. 内置方法

    优先掌握

    1. 索引取值

         1. hobby_list = ['play', 'swimming', 'dancing', '666']

  print(1, hobby_list[-1])
  hobby_list[-1] = '233'  # 索引修改
  print(2, hobby_list[-1])

    2. 切片

       print(hobby_list[:])  # ['play', 'swimming', 'dancing', '666']
 print(hobby_list[::-1])  # 从右到左  # ['666', 'dancing', 'swimming', 'play']

    3. 长度

      print(len(hobby_list))

    4. in/not in

      hobby_list = ['play', 'swimming', 'dancing', '666']
print('play' in hobby_list)  # True

    5. for 循环

      for hobby in hobby_list:
    print(hobby)

    6. del删除

      del hobby_list[-1]
print(hobby_list)

    7. append() # 追加

      hobby_list = ['play', 'swimming', 'dancing', '666']
hobby_list.append('dapao-->piao')
print(hobby_list)

需要掌握

  1. count 计数

       hobby_list = ['play', 'swimming', 'dancing', '666', 666, '666']
   print(hobby_list.count('666'))

  2. extend 扩展列表

   hobby_list.extend([1, 2, 3, 4])  
   print(hobby_list)
  1. clear 清除
   hobby_list.clear()  
   print(hobby_list)
  1. copy 复制列表
   hobby_list2 = hobby_list.copy() 
       hobby_list[-1] = '233'
   print(hobby_list)
   print(hobby_list2)
  1. 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内有没有该值

  1. insert 插入

    hobby_list.insert(0, '1')  
print(hobby_list)

  2. remove 移除

    hobby_list.remove('1')
print(hobby_list)

  3. 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)

  1. 存一个值还是多个值

    多个值

  2. 有序or无序

    有序

  3. 可变or不可变(重点)

    可变

元组数据类型内置方法

  1. 定义方式
    列表的中括号改成小括号

    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))
    1. 存一个值还是多个值
      多个值
    2. 有序or无序
      有序
    3. 可变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 优先掌握(***)

  1. 按key存取值：可存可取
  2. 长度len
  3. 成员运算in和not in
  4. 删除del
  5. 键keys()、值values()、键值对items()
  6. 循环

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 需要掌握(**)

  1. get
  2. update
  3. fromkeys
  4. 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 优先掌握(***)

  1. 长度len
  2. 成员运算in和not in
  3. |并集、union
  4. &交集、intersection
  5. -差集、difference
  6. ^对称差集、symmetric_difference
  7. ==
  8. 父集：>、>= 、issuperset
  9. 子集：<、<= 、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

集合类型内置运算-集合运算英文.jpg?x-oss-process=style/watermark

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 需要掌握(**)

  1. add
  2. remove
  3. difference_update
  4. discard
  5. 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不可变：可变数据类型

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/TMesh/p/11304833.html