• 数据类型内置方法：列表/元组/集合

    目录

    list列表类型内置方法

    1. 作用:多个装备、多个爱好、多门课程，甚至是多个女朋友
    2. 定义方式:[]内用逗号隔开，可以有多个任意数据类型的元素
    friends_list = ['longzeluola'，'canglaoshi'，'qiaobenai'，'nick']
lis = list('abcd')

    1. 方法:

      1. 优先掌握

        1. 索引取值(正向取值+反向取值） 即可取又可存

          #list之索引取值
name_list={'nick','jason','tank','sean'}
name_list[0]='nick handsome'
#name_list[1000]='tank handsome'    #报错

print(f"name_list[0]:{name_list[0]}")

          name_list[0]:{name_list[0]}

        2. 切片

          #list之切片
name_list=['nick','jason','tank','jick']

print(name_list[0:3:2])                  ----->'nick','tank'

        3. 长度len

          #list之长度
name_list=['nick','jason','tank','jick']

print(len(name_list))                    ------>4

        4. append追加值

          # list之追加值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.append('tank handsome' )

print(name_list)      
           ------->['nick', 'jason', 'tank', 'jick', 'tank handsome']

        5. 成员运算in和not in

          # list之成员运算in和not in
name_list = ['nick', 'jason', 'tank', 'sean']

print('tank handsome' in name_list )      ----->Fslse
print('nick handsome' not in name_list)      ------>true

        6. for循环

          # list之循环
name_list = ['nick', 'jason', 'tank', 'sean']

for name in name_list:
    print(name)            
nick
jason
tank
jick

        7. 删除del

          # list之删除
name_list = ['nick', 'jason', 'tank', 'sean']
del name_list[2]

print(name_list)                ---->['nick', 'jason', 'jick']

      2. 需要掌握

        1. count计数

          # list之count()
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.count('tank'))        ------>1

        2. remove 如果删除对象不存在则报错，按照指定的元素删除

          # list之remove()
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.remove('tank'))     ------>        None
print(name_list)          ----->['nick', 'jason', 'sean']

        3. reverse 反转列表

          # list之reverse()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.reverse()

print(name_list)         ------>['sean', 'tank', 'jason', 'nick']

        4. pop 默认删除最后一个值，删除指定索引的值

          # list之pop()，pop()默认删除最后一个元素
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.pop(1))           ----->jason

print(name_list)            ----->['nick', 'tank', 'sean']

        5. insert 在索引前面加入一个值

          # list之insert()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.insert(1,'handsome')

print(name_list)    --->['nick', 'handsome', 'jason', 'tank', 'sean']

        6. sort 排序列表

          # list之sort()，使用sort列表的元素必须是同类型的
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.sort()

print(name_list)        --->['jason', 'nick', 'sean', 'tank']
name_list.sort(reverse=True)    
print(name_list)      ------->['tank', 'sean', 'nick', 'jason']

        7. index 获取指定元素的索引，但是只会获取第一次

          # list之index()
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.index('nick'))           ---->0

        8. copy 复制

          # list之copy()
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.copy())      --->['nick', 'jason', 'tank', 'sean']

        9. extend 扩展，把extend里的列表的元素添加到原列表中

          # list之extend()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list2=['nick handsome' ]
name_list.extend(name_list2)

print(name_list)  
               -->['nick', 'jason', 'tank', 'sean', 'nick handsome']

        10. clear 清除列表/清空列表

          # list之clear()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.clear()

print(name_list)      ------->[]

    2. 多个值or一个值 :多个值

    3. 有序or无序:有序

      hobby_list = ['read', 'run', 'girl']
print(f'first:{id(hobby_list)}')           --->4522187016
hobby_list[2] = ''
print(f'second:{id(hobby_list)}')         ---->4522187016

    4. 可变or不可变:可变数据类型

    元组类型内置方法

    1. 作用: 类似于列表，可以存不可以取
    2. 定义方式: 在()内可以有多个任意类型的值，逗号分隔元素
    friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick')
tup = tuple('abcd')

    1. 方法

      1. 索引取值(无法更改)

      2. 切片（顾头不顾尾，步长）

      3. 长度 len

      4. 成员运算 in 和not in

      5. for循环

      6. count

      7. index

    2. 多个值or一个值:多个值

    3. 有序or无序:有序

    4. 可变or不可变:无可变不可变这一说

      列表可变的原因是：索引所对应的值的内存地址是可以改变的

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

    字典类型内置方法

    1. 作用:当列表存在很多值的时候，列表会显得很乱，所以就有了字典。多用于存的值表示的是不同的状态时，例如存的值有姓名、年龄、身高、体重、爱好。
    2. 定义方式:{}内用逗号分隔开多个键值对key：value的值，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。
    nick_info_dict = {
'name':'nick'，
'height':180，
'weight':140，
'hobby_list':['read'，'run'，'music'，'fishing'，'programming'，'coding'，'debugging']
}

for k，v in nick_info_dict.items():
	print(k，v)

    name nick
    height 180
    weight 140
    hobby_list ['read', 'run', 'music', 'fishing', 'programming', 'coding', 'debugging']

    1. 方法

    2. 按键取值：可存可取

      # 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

    3. 长度：

      ​```
print(len(dic))

    4. 键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)])

    5. for循环

      # 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

    6. 成员运算in 和 not

      # 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

    7. 删除del

      # dic之删除del
dic = {'a': 1, 'b': 2}
del dic['a']

print(f"dic.get('a'): {dic.get('a')}")

      dic.get('a'): None

    8. 需要掌握
      1. fromkeys 来自键值，默认把给定列表内的元素取出来当成key，然后使用一个默认value新建一个字典

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

print(f"dic: {dic}")

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

    2. setdefault    如果字典中有该key的话，则key对应的值不变：如果没有，则增加

   ```python
   # 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}

3. get 如果键不存在，返回不会报错，可以给默认值

   ```python
   # 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

4. update  有就更新，没有就添加

   ```python
   # dic之update()
   dic1 = {'a': 1, 'b': 2}
   dic2 = {'c': 3}
   dic1.update(dic2)
   
   print(f"dic1: {dic1}")
   ```

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

    1. 多个值or一个值:多个值,值可以是多个类型，key必须是不可变类型，通常应该是不可变类型中的字符串类型

    2. 有序or无序:无序

    3. 可变or不可变:可变数据类型

    集合类型内置方法

    1. 作用:存多个值，为了集合之间做运算，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。
    2. 定义方式:{}内用逗号分隔开多个元素，每个元素必须是不可变类型。
    s = set()

s = {1，2，3，4，5，1}
    1. 方法:
      1. 优先掌握

        1. 去重

        2. 并集 | ,union

          # 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'}

        3. 交集 & intersection

        4. 差集 -difference

        5. 对称差集 ^symmetric_difference

        6. 父集 >&emsp；>=issuperset

        7. 子集 <&emsp；<=issubset

        8. ==

      2. 需要掌握

        1. add（）

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

print(s)

          {1, 2, 3, 'a'}

        2. 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'}

        3. 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. remove # 值不存在会报错

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

print(s)

          {2, 'a'}

        5. discard # 放弃，删除，不会报错

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

print(s)

          {1, 2, 'a'}

    2. 多个值or一个值:多个值，且值为不可变类型
    3. 有序or无序:无序
    4. 可变or不可变:可变数据类型

    数据类型总结

    一个值 多个值
    整型/浮点型/字符串 列表/元祖/字典/集合/
    有序 无序
    字符串/列表/元祖 字典/集合
    可变 不可变
    列表/字典/集合 整型/浮点型/字符串

    拷贝

    • 拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的
    l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = l1

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']

    如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变

    浅拷贝

    import copy


l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

l1[3].append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']]

    如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变

    深拷贝

    import copy


l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

l1[3].append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

    如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化

    !
  • 相关阅读:
    归一化与标准化区别
    pytorch进行mnist识别实战
    pytorch实现学习率衰减
    RNN
    Python中9大时间序列预测模型
    InfluxDB基本概念
    如何在CentOS 7上使用InfluxDB分析系统指标(转载学习用)
    InfluxDB1.2.4部署（centos7）
    Centos7搭建influxdb+chronograf
    python通过SNMP协议收集服务器监控信息
  • 原文地址：https://www.cnblogs.com/gongjingyun123--/p/10920988.html
Copyright © 2020-2023  润新知