加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 （https://www.lidatong.com.cn/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 编程开发 > Python > 正文

Python进阶（二）

发布时间：2020-12-20 12:47:11 所属栏目：Python 来源：网络整理
导读：列表类型内置方法 一、作用 描述多个值，比如爱好 二、定义方式 列表用[]表示，[]内可以有多个任意类型的值，逗号分隔元素 三、内置方法 优先掌握 按索引取值（正向取值+反向取值），即可存也可取 hobby_list = ['read','run','swimming']print(hobby_list[1

列表类型内置方法

一、作用

描述多个值，比如爱好

二、定义方式

列表用[]表示，[]内可以有多个任意类型的值，逗号分隔元素

三、内置方法

  1. 优先掌握

    1. 按索引取值（正向取值+反向取值），即可存也可取

      hobby_list = ['read','run','swimming']
print(hobby_list[1])
hobby_list[-1] = 'dancing'
print(hobby_list[-1])

# run
# dancing

    2. 切片

      hobby_list = ['read','swimming','dancing']
print(hobby_list[::2])

# ['read','swimming']

    3. 长度len

      hobby_list = ['read','dancing']
print(len(hobby_list))

# 4

    4. 成员运算in和not in

      hobby_list = ['read','dancing']
print('run' in hobby_list)
print('唱' not in hobby_list)

# True
# True

    5. 追加append

      hobby_list = ['read','dancing']
hobby_list.append('666')
print(hobby_list)

# ['read','dancing','666']

    6. 删除del

      hobby_list = ['read','dancing']
del hobby_list[2]
print(hobby_list)

# ['read','dancing']

    7. 循环

      hobby_list = ['read','dancing']
for hobby in hobby_list:
    print(hobby)

# read
# run
# swimming
# dancing
  2. 需要掌握

    1. insert

      insert()将指定的对象插入指定的列表索引位置

      hobby_list = ['run','read','dancing']
hobby_list.insert(2,'swimming')
print(hobby_list)

# ['run','dancing']

    2. pop

      pop()用于删除列表中的一个元素，默认删除最后一个元素

      hobby_list = ['run','swimming']
print(hobby_list.pop())
print(hobby_list.pop(2))

# swimming
# dancing

    3. remove

      remove()用于移除列表中某个值的第一个匹配项

      hobby_list = ['run','read']
hobby_list.remove('read')
print(hobby_list)

# ['run','read']

    4. count

      count()用于统计某个元素在列表中出现的次数

      hobby_list = ['run','swimming']
print(hobby_list.count('run'))

# 1

    5. index

      index()从列表中找出某个值第一个匹配项的索引位置

      hobby_list = ['run','run']
print(hobby_list.index('run'))

# 0

    6. clear

      clear()用来清空列表

      hobby_list = ['run','swimming']
hobby_list.clear()
print(hobby_list)

# []

    7. copy

      copy()用来复制列表

      hobby_list = ['run','swimming']
print(hobby_list.copy())

# ['run','swimming']

    8. extend

      extend()用新列表扩展原来的旧列表

      hobby_list = ['run','swimming']
hobby_list2 = ['music']
hobby_list.extend(hobby_list2)
print(hobby_list)

# ['run','music']

    9. reverse

      reverse()用于反转列表中的元素

      hobby_list = ['run','swimming']
hobby_list.reverse()
print(hobby_list)

# ['swimming','run']

    10. sort

      sort()用来对原列表进行排序，但列表中的元素必须是同类型的，reverser = True是降序，reverser = False是升序（默认）

      hobby_list = ['run','swimming']
hobby_list.sort()
print(hobby_list)

# ['dancing','swimming']

四、存一个值还是多个值

多个值

五、有序or无序

有序

六、可变or不可变

可变

元组类型内置方法

元组与列表类似，但是元组的元素不能修改，因此元组一般只用于只存不取的需求，也因此元组可以被列表取代掉。元组在定义的那一刻，他的元素个数和元素的值以及全部固定死了

一、作用

描述多个值，比如爱好

二、定义方式

元组用()表示，()内可以有多个任意类型的值，逗号分隔元素

三、内置方法

  1. 优先掌握

    1. 索引取值

      name_tuple = ('zhangsan','lisi','wangwu','zhaoliu')
print(name_tuple[1])

# lisi

    2. 切片

      name_tuple = ('zhangsan','zhaoliu')
print(name_tuple[0::2])

# ('zhangsan','wangwu')

    3. 长度len

      name_tuple = ('zhangsan','zhaoliu')
print(len(name_tuple))

# 4

    4. 成员运算in和not in

      name_tuple = ('zhangsan','zhaoliu')
print('lisi' in name_tuple)
print('sunqi' not in name_tuple)

# True
# True

    5. 循环

      name_tuple = ('zhangsan','zhaoliu')
for name in name_tuple:
    print(name)

# zhangsan
# lisi
# wangwu
# zhaoliu

    6. count

      count()用于统计某个元素在元组中出现的次数

      name_tuple = ('zhangsan','zhaoliu')
print(name_tuple.count('lisi'))

# 1

    7. index

      index()从元组中找出某个值第一个匹配项的索引位置

      name_tuple = ('zhangsan','zhaoliu')
print(name_tuple.index('wangwu'))

# 2

四、存一个值还是多个值

多个值

五、有序or无序

有序

六、可变or不可变

没有可变不可变的说法

字典类型内置方法

一、作用

描述多个值，但每一个值都有一个key与之对应，key对值有描述作用。

二、定义方式

字典用{}表示，{}内用逗号隔开多个元素，每个元素都是key: value的形式，key通常是字符串类型，但key必须是不可变的数据类型，value可以是任意的数据类型

三、内置方法

  1. 优先掌握

    1. 按key存取值：可存可取

      dict = {'name': 'lisi','age': 18}
print(dict['age'])
dict['age'] = 20
print(dict['age'])

# 18
# 20

    2. 长度len

      dict = {'name': 'lisi','age': 18,'sex': 'male'}
print(len(dict))

# 3

    3. 成员运算in和not in

      dict = {'name': 'lisi','sex': 'male'}
print('name' in dict)
print('hobby' not in dict)

# True
# True

    4. 删除del

      dict = {'name': 'lisi','sex': 'male'}
del dict
print(dict)

# 执行del操作后字典不存在

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

      dict = {'name': 'lisi','sex': 'male'}
print(dict.keys())
print(dict.values())
print(dict.items())

# ict_keys(['name','age','sex']) # 取出字典中的键
# dict_values(['lisi',18,'male'])   # 取出字典中的值
# dict_items([('name','lisi'),('age',18),('sex','male')]) # 取出字典中的键值对

    6. 循环

      dict = {'name': 'lisi','sex': 'male'}
for k,v in dict.items(): #items可以换成keys()、values()
    print(k,v)

# name lisi
# age 18
# sex male
  2. 需要掌握

    1. get

      get()用来返回指定键的值，如果字典中没有值就返回None

      dict = {'name': 'lisi','age': 18}
print(dict.get('name'))
print(dict.get('sex'))

# lisi
# None

    2. update

      update()用来把字典2中的键值对更新到字典1中

      dict1 = {'name': 'lisi','age': 18}
dict2 = {'sex': 'male'}
dict1.update(dict2)
print(dict1)

# {'name': 'lisi','sex': 'male'}

    3. fromkeys

      fromkeys()用于创建一个新字典

      dic = dict.fromkeys(['name','sex'],None)
print(dic)

# {'name': None,'age': None,'sex': None}

    4. setdefault

      setdefault()类似于get()，但使用setdefault()时，如果键不在字典里，会创建一个键并将值设为None

      dict = {'name': 'lisi','age': 18}
dict.setdefault('sex','male')
print(dict)

# {'name': 'lisi','sex': 'male'}

四、存一个值还是多个值

多个值

五、有序or无序

无序

六、可变or不可变

可变

集合类型内置方法

集合（set）是一个无序的不重复的元素序列

一、作用

用于关系运算的集合体，因为集合内的元素无序且集合元素不可重复，因此集合可以去重，但去重后的集合会打乱原来元素的顺序。

二、定义方式

集合可以用{}和set()创建，但是空集合只能用set()，因为{}是用来创建一个空字典的，{}内用逗号隔开多个元素，每个元素必须是不可变类型

三、内置方法

  1. 优先掌握

    1. 长度len

      pythons = {'zhangsan','wangwu'}
print(len(pythons))

# 3

    2. 成员运算in和not in

      pythons = {'zhangsan','wangwu'}
print('lisi' in pythons)

# True

    3. 并集 | 、union

      union()方法返回包含了所有集合的元素

      pythons = {'zhangsan','wangwu'}
linuxs = {'lisi','zhaoliu'}
print(pythons | linuxs)
print(pythons.union(linuxs))

# {'zhangsan','zhaoliu','wangwu'}
# {'zhangsan','wangwu'}

    4. 交集 & 、intersection

      intersection()方法返回两个集合都包含的元素

      pythons = {'zhangsan','zhaoliu'}
print(pythons & linuxs)
print(pythons.intersection(linuxs))

# {'lisi'}
# {'lisi'}

    5. 差集 - 、difference

      difference()返回集合的差集，即包含在第一个集合中，但不包含在第二个集合中

      pythons = {'zhangsan','zhaoliu'}
print(pythons - linuxs)
print(pythons.difference(linuxs))

# {'zhangsan','wangwu'}

    6. 对称差集 ^、symmetric_difference

      symmetric_difference()移除两个集合中都存在的元素

      pythons = {'zhangsan','zhaoliu'}
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

# {'zhaoliu','zhangsan'}
# {'zhaoliu','zhangsan'}

    7. ==

      pythons = {'zhangsan','zhaoliu'}
javas = {'lisi','zhaoliu'}
print(pythons == linuxs)
print(linuxs == javas)

# False
# True

    8. 父集：>、>=、issuperset

      issuprtset()方法用于判断指定集合中的所有元素是否都包含在圆石的集合，是就返回True，不是就返回False

      pythons = {'zhangsan','wangwu'}
print(pythons > linuxs)
print(pythons >= linuxs)
print(pythons >= javas)
print(pythons.issuperset(javas))

# False
# False
# True
# True

    9. 子集：<、<=、issubset

      判断集合的所有元素是否都包含在指定集合中，如果是返回True，不是返回False

      pythons = {'zhangsan','wangwu'}
print(pythons < linuxs)
print(pythons <= linuxs)
print(javas.issubset(pythons))

# False
# False
# True
  2. 需要掌握

    1. add

      add()方法用来给集合添加元素

      pythons = {'zhangsan','wangwu'}
pythons.add('sunqi')
print(pythons)

# {'wangwu','zhangsan','sunqi','lisi'}

    2. remove

      remove()用来移除集合中指定的元素

      pythons = {'zhangsan','wangwu'}
pythons.remove('wangwu')
print(pythons)

# {'zhangsan','lisi'}

    3. difference_update

      difference_update()用来移除两个集合中都存在的元素，与difference()方法一样

      pythons = {'zhangsan','zhaoliu'}
pythons.difference_update(linuxs)
print(pythons)

# {'wangwu','zhangsan'}

    4. discard

      discard()用来移除指定的集合元素，不同于remove()，remove()方法在移除一个不存在的元素时会发生错误，但discard()方法不会

      pythons = {'zhangsan','wangwu'}
pythons.discard('zhaoliu')
print(pythons)

# {'lisi','zhangsan'}

    5. isdisjoint

      isdisjoint()用来判断两个集合是否包含相同的元素，如果没有返回True，否则返回False

      pythons = {'zhangsan','zhaoliu'}
print(pythons.isdisjoint(linuxs))

# False

四、存一个值还是多个值

多个值，且值为不可变类型

五、有序or无序

无序

六、可变or不可变

不可变

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
    相关内容
      推荐文章
        站长推荐
        热点阅读

          【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

          建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

          Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同