• day 08总结（内置方法）

    一、列表类型内置方法

    1. 作用：描述多个值,比如兴趣爱好。

    2. 定义：[]内可以有多个任意类型的值，逗号分隔元素。

      hobby_list = ['play', 'swimming', 'dancing']
my_friend = ['tbb','bill','tom']

    3. 内置方法：优先掌握、需要掌握。

      3.1优先掌握

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

        my_friend = ['tbb','bill','tom']
my_friend[0] = 'TBB'
print(my_friend[0])

        TBB

      2. 切片

        my_friend = ['tbb','bill','tom']
print(my_friend[0::2])

        ['tbb', 'tom']

      3. 长度

        my_friend = ['tbb','bill','tom']
print(len(my_friend))

        3

      4. 成员运算in和not in

        my_friend = ['tbb','bill','tom']
print('Tbb' in my_friend)
print('frank' in my_friend)

        False
True

      5. 追加值

        my_friend = ['tbb','bill','tom']
my_friend.append('frank')
print(my_friend)

        ['tbb','bill','tom','frank']

      6. 删除

        my_friend = ['tbb','bill','tom']
del my_friend[1]
print(my_friend)

        ['tbb','tom']

      7. 循环

        my_friend = ['tbb','bill','tom']
for name in my_friend:
    print(name)


        tbb
bill
tom

      3.2需要掌握

      1. insert()将指定对象插入列表的指定位置。

        my_friend = ['tbb','bill','tom']
my_friend.insert(1,'frank')
print(my_friend)

        ['tbb', 'frank', 'bill', 'tom']

        2.pop()默认删除最后一个元素

        my_friend = ['tbb','bill','tom']
print(my_friend.pop(0))
print(my_friend)


        tbb
['bill', 'tom']
        1. remove()移除列表中某个值的第一个匹配项
        my_friend = ['tbb','bill','tom','frank']
my_friend.remove('frank')
print(my_friend)

        ['tbb', 'bill', 'tom']

        1. count()统计出现次数
        my_friend = ['tbb','bill','tom','frank']
print(my_friend.count('frank'))

        1

        1. index()查找索引
        my_friend = ['tbb','bill','tom','frank']
print(my_friend.index('tom'))

        3

        1. clear()清除
        my_friend = ['tbb','bill','tom','frank']
my_friend.clear()
print(my_friend)

        []

        1. copy()复制
        my_friend = ['tbb','bill','tom','frank']
print(my_friend.copy())

        ['tbb', 'bill', 'tom', 'frank']

        1. extend()在列表末尾一次性追加另一个序列中的多个值
        my_friend = ['tbb','bill','tom','frank']
my_friend2 = ['byebye']
my_friend.extend(my_friend2)
print(my_friend)

        ['tbb', 'bill', 'tom', 'frank', 'byebye']

        1. reverse()反转
        my_friend = ['tbb','bill','tom','frank']
my_friend.reverse()
print(my_friend)

        ['frank', 'tom', 'bill', 'tbb']

        1. sort()用于对原列表进行排序
        my_friend = ['tbb','bill','tom','frank']
my_friend.sort()
print(my_friend)

        ['bill', 'frank', 'tbb', 'tom']

    4. 存一个值or多个值：多个值

    5. 有序or无序：有序

      hobby_list = ['read', 'run', 'girl']
print(id(hobby_list))
hobby_list[2] = ''
print(id(hobby_list))  


      2352832078472
2352832078472

    6. 可变or不可变：可变数据类型

    二、元组类型内置方法(了解)

    ​ 元组是不可变的列表，即元组的值不可更改，因此元组一般只用于只存不取的需求。也因此元组可以被列表取代掉，所以元组相比较列表使用的很少。元组相比较列表的优点为：列表的值修改后，列表的结构将会发生改变，而元组只需要存储，因此列表在某种程度上而言需要占用更多的内存。但是目前工业上内存已经不是问题了，所以工业上元组一般不会使用。

    1.作用

    描述多个值,比如兴趣爱好。

    2.定义

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

    3.内置方法

    1. 1索引取值
    name_tuple = ('tbb', 'bill', 'tom', 'frank')
print(name_tuple[2])

    tom

    1. 2切片（顾头不顾尾，步长）
    name_tuple = ('tbb', 'bill', 'tom', 'frank')
print(name_tuple[0:3:2])

    ('tbb', 'tom')

    1. 3长度
    name_tuple = ('tbb', 'bill', 'tom', 'frank')
print(len(name_tuple))

    4

    1. 4成员运算
    name_tuple = ('tbb', 'bill', 'tom', 'frank')
print('tom' in name_tuple)

    True

    1. 5循环
    name_tuple = ('tbb', 'bill', 'tom', 'frank')
for name in name_tuple:
    print(name)


    tbb
bill
tom
frank
    1. 6count()
    name_tuple = ('tbb', 'bill', 'tom', 'frank')
print(name_tuple.count('bill'))

    1

    1. 7index()
    name_tuple = ('tbb', 'bill', 'tom', 'frank')
print(name_tuple.index('tbb'))

    0

    4.存一个值or多个值

    一个值

    5.有序or无序

    有序

    6.可变or不可变

    不可变数据类型

    7.元组和列表的区别

    • 列表可变的原因是：索引所对应的值的内存地址是可以改变的.
    • 元组不可变得原因是：索引所对应的值的内存地址是不可以改变的，或者反过来说，只要索引对应值的内存地址没有改变，那么元组是始终没有改变的。

    三、字典类型内置方法

    1.作用

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

    2.定义

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

    3.内置方法：优先掌握，需要掌握

    3.1优先掌握

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

      dic = {'a': 1, 'b': 2}

print(dic['a'])

      1

    2. 长度len

      dic = {'a': 1, 'b': 2}

print(len(dic))

      2

    3. 成员运算in和not in

      dic = {'a': 1, 'b': 2}

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


      True
False

    4. del删除

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

      {'b': 2}

      dic = {'a': 1, 'b': 2}
dic.pop('a')
print(dic)

      {'b': 2}

    5. 键keys()、值values()、键值对items()以列表返回可遍历的(键, 值) 元组数组。

      dic = {'a': 1, 'b': 2}
print(dic.keys())
print(dic.values())
print(dic.items())


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

    6. 循环

      dic = {'a': 1, 'b': 2}
for k, v in dic.items():  
    print(k, v)


      a 1
b 2

    3.2需要掌握

    1. get()返回指定键的值，如果值不在字典中返回默认值。

      dic = {'a': 1, 'b': 2}
print(dic.get('a'))
print(dic.get('c'))


      1
None

    2. update()把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里

      dic = {'a': 1, 'b': 2}


      dic1 = {'a': 1, 'b': 2}
dic2 = {'c': 3}
dic1.update(dic2)
print(dic1)

      {'a': 1, 'b': 2, 'c': 3}

    3. fromkeys()用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

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

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

    4. setdefault():与get()类似，如果键不存在于字典中，将会添加键并将值设为默认值

      dic = {'a': 1, 'b': 2}
print(dic.setdefault('a',3))
print(dic)
print(dic.setdefault('c',3))
print(dic)


      1
{'a': 1, 'b': 2}
3
{'a': 1, 'b': 2, 'c': 3}

    4.存一个值or多个值

    多个值，值可以是多个类型，key必须是不可变类型，通常应该是不可变类型中的字符串类型

    5.有序or无序

    无序

    6.可变or不可变

    可变数据类型

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


    2875759947640
2875759947640

    四、集合类型内置方法(set)

    ​ 集合可以理解成一个集合体，学习Python的学生可以是一个集合体；学习Linux的学生可以是一个集合体。

    • 特点：1.去重 2. 乱序

    1.作用

    存储一大堆元素的东西，容器数据类型

    2.定义

    {}内用逗号分隔开多个元素，每个元素必须是不可变类型。

    s = {1, 2, 1, 'a'}  

print(s)

    {1, 2, 'a'}

    3.内置方法:优先掌握，需要掌握

    3.1优先掌握

    1. 长度len

      s = {1, 2, 'a'}

print(len(s))

      3

    2. 成员运算in和not in

      s = {1, 2, 'a'}

print(1 in s)

      True

    3. |并集

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(pythoners|linuxers)
print(pythoners.union(linuxers))


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

    4. &交集

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(pythoners&linuxers)
print(pythoners.intersection(linuxers))


      nick
nick

    5. -差集

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(pythoners-linuxers)
print(pythoners.difference(linuxers))


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

    6. ^对称差集

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(pythoners^linuxers)
print(pythoners.symmetric_difference(linuxers))

    7. ==

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javers = {'nick', 'egon', 'kevin'}

print(pythoners==linuxers)
print(javers==linuxers)


      False
True

    8. 父集：>、>=

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(pythoners>linuxers)
print(pythoners>=linuxers)
print(pythoners>=javaers)
print(pythoners.issuperset(javaers))


      False
False
True
True

    9. 子集：<、<=

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

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


      False
False
True

    3.2需要掌握

    1. add()

      s = {1, 2, 'a'}
s.add(3)

print(s)

      {1, 2, 3, 'a'}

    2. .remove()

      s = {1, 2, 'a'}
s.remove(1)

print(s)

      {2, 'a'}

    3. difference_update()用于移除两个集合中都存在的元素

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.difference_update(linuxers)

print(pythoners)

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

    4. discard()用于移除指定的集合元素。

      # set之discard()
s = {1, 2, 'a'}
# s.remove(3)  # 报错
s.discard(3)

print(s)

      {1, 2, 'a'}

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

      pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.isdisjoint(linuxers)

print(pythoners.isdisjoint(linuxers))

      False

    4.存一个值or多个值

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

    5.有序or无序

    无序

    6.可变or不可变

    可变数据类型
  • 相关阅读:
    linux挂载ntfs格式的U盘
    linux tar命令
    chown chmod chgrp chattr chroot usermod 命令简单分析
    UI/UE/ID/UED/UCD的区别（转）
    搭建 Docker Swarm 集群
    端口
    linux crontab 定时任务
    centos8 安装 docker
    history 用法大全
    PHP生成正则表达式的类
  • 原文地址：https://www.cnblogs.com/mgytz/p/11305005.html
Copyright © 2020-2023  润新知