zoukankan      html  css  js  c++  java

  • Python进阶（二）

    列表类型内置方法

    一、作用

    描述多个值，比如爱好

    二、定义方式

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

    三、内置方法

    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', 'run', 'swimming', 'dancing']
print(hobby_list[::2])

# ['read', 'swimming']

      3. 长度len

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

# 4

      4. 成员运算in和not in

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

# True
# True

      5. 追加append

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

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

      6. 删除del

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

# ['read', 'run', 'dancing']

      7. 循环

        hobby_list = ['read', 'run', 'swimming', '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', 'read', 'swimming', 'dancing']

      2. pop

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

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

# swimming
# dancing

      3. remove

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

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

# ['run', 'dancing', 'swimming', 'read']

      4. count

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

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

# 1

      5. index

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

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

# 0

      6. clear

        clear()用来清空列表

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

# []

      7. copy

        copy()用来复制列表

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

# ['run', 'read', 'dancing', 'swimming']

      8. extend

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

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

# ['run', 'read', 'dancing', 'swimming', 'music']

      9. reverse

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

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

# ['swimming', 'dancing', 'read', 'run']

      10. sort

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

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

# ['dancing', 'read', 'run', 'swimming']

    四、存一个值还是多个值

    多个值

    五、有序or无序

    有序

    六、可变or不可变

    可变

    元组类型内置方法

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

    一、作用

    描述多个值，比如爱好

    二、定义方式

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

    三、内置方法

    1. 优先掌握

      1. 索引取值

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

# lisi

      2. 切片

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

# ('zhangsan', 'wangwu')

      3. 长度len

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

# 4

      4. 成员运算in和not in

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

# True
# True

      5. 循环

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

# zhangsan
# lisi
# wangwu
# zhaoliu

      6. count

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

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

# 1

      7. index

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

        name_tuple = ('zhangsan', 'lisi', 'wangwu', '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', 'age': 18, 'sex': 'male'}
print('name' in dict)
print('hobby' not in dict)

# True
# True

      4. 删除del

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

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

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

        dict = {'name': 'lisi', 'age': 18, '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', 'age': 18, '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', 'age': 18, 'sex': 'male'}

      3. fromkeys

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

        dic = dict.fromkeys(['name', 'age', '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', 'age': 18, 'sex': 'male'}

    四、存一个值还是多个值

    多个值

    五、有序or无序

    无序

    六、可变or不可变

    可变

    集合类型内置方法

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

    一、作用

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

    二、定义方式

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

    三、内置方法

    1. 优先掌握

      1. 长度len

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

# 3

      2. 成员运算in和not in

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

# True

      3. 并集 | 、union

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

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

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

      4. 交集 & 、intersection

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

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

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

      5. 差集 - 、difference

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

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

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

      6. 对称差集 ^、symmetric_difference

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

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

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

      7. ==

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

# False
# True

      8. 父集：>、>=、issuperset

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

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

# False
# False
# True
# True

      9. 子集：<、<=、issubset

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

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

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

      1. add

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

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

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

      2. remove

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

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

# {'zhangsan', 'lisi'}

      3. difference_update

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

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

# {'wangwu', 'zhangsan'}

      4. discard

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

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

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

      5. isdisjoint

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

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

# False

    四、存一个值还是多个值

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

    五、有序or无序

    无序

    六、可变or不可变

    不可变
  • 相关阅读:
    王爽汇编实验（八）
    王爽汇编实验（七）
    王爽汇编实验(六)
    王爽汇编实验(五）
    计算机操作系统锁机制.
    网页搜索框里显示字段鼠标点击后就隐藏的方法
    织梦删掉会员空间，保留开放会员（禁止注册）的方法
    织梦DEDECMS后台验证码错误不能正常验证的3种可能原因和解决
    织梦DEDECMS后台验证码错误不能正常验证的3种可能原因和解决
    织梦怎么对某些字段信息隐藏，登录后可查看
  • 原文地址：https://www.cnblogs.com/yunluo/p/11305943.html
Copyright © 2011-2022 走看看