列表类型内置方法

一、列表类型内置方法(list)

  1. 用途：多个爱好、多个武器、多种化妆品

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

  1. # my_boy_friend = list(['jason','tank','sean'])
  2. my_boy_friend = ['jason','tank','sean']
  3. print(f'{my_boy_friend}')
  4. ​
  5. #['jason','tank','sean']
  6.  = list('hello nick')
  7. print(f'{1}')
  8. ​
  9. #['h','e','l','l','o',' ','n','i','c','k']

  1. 常用操作+内置方法：优先掌握、需要掌握、其他操作

优先掌握：

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

  2. 切片

  3. 长度len

  4. 成员运算in和not in

  5. 追加append

  6. 删除del

  7. 循环

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

  1. name_list = ['nick','jason','tank','sean']
  2. name_list[] = 'nick young'
  3. # name_list[] = 'tank sb' #报错
  4. ​
  5. print(f'name_list[0]: {name_list[0]}')
  6. ​
  7. # name_list[] = nick young

2.切片

  1. name_list = ['nick','jason','tank','sean']
  2. print(f'{name_list[0:3:3]}') #注意顾头不顾尾
  3. print(f'{name_list[0:3:-1]}')
  4. print(f'{name_list[0:3:2]}')
  5. ​
  6. #['nick']
  7. #[]
  8. #['nick','tank']

3.长度

  1. name_list = ['nick','jason','sean','egon']
  2. print(f'len(name_list): {len(name_list)}')
  3. ​
  4. #

4.成员运算in和not in

  1. name_list = ['nick','jason','tank','sean']
  2. print(f"{'simon' in name_list}")
  3. print(f"{'jason' in name_list}")
  4. print(f"{'maya' not in name_list}")
  5. ​
  6. #False
  7. #True
  8. #True

5.追加值

  1. name_list = ['nick','jason','tank','sean']
  2. name_list.append('simon')
  3. print(f'name_list:{name_list}')
  4. ​
  5. #name_list:['nick','jason','tank','sean','simon']

6.删除

  1. name_list = ['nick','jason','tank','sean']
  2. del name_list[]
  3. print(f"{name_list}")
  4. ​
  5. # ['nick','jason','sean']

7.循环

  1. name_list = ['nick','jason','tank','sean']
  2. for name in name_list:
  3.     print(name)
  4.  
  5. #nick
  6. #jason
  7. #tank
  8. #sean

需要掌握：

  1. insert

  2. pop

  3. remove

  4. count

  5. index

  6. clear

  7. copy

  8. expend

  9. reverse

  10. sort

1.insert( )

  1. name_list = ['nick','jason','tank','sean']
  2. name_list.insert(1,'handsome')
  3. print(f"name_list:{name_list}")
  4. ​
  5. #name_list:['nick','handsome','jason','tank','sean']

2.pop( )

  1. name_list = ['nick','jason','tank','sean']
  2. print(f"{name.list.pop(1)}")
  3. print(f"{name_list}")
  4. ​
  5. #jason
  6. #['nick','tank','sean']

3.remove( )

  1. name_list  = ['nick','jason','tank','sean']
  2. print(f"{name_list.remove('nick')}")
  3. print(f"{name_list}")
  4. ​
  5. #None
  6. #['jason','tank','sean']

4.count( )

  1. name_list = ['nick','jason','tank','sean']
  2. print(f"{name_list.count('nick')}")
  3. ​
  4. #

5.index( )

  1. name_list = ['nick','jason','tank','sean']
  2. print(f"{name_list.index('nick')}")
  3. ​
  4. #

6.clear( )

  1. name_list = ['nick','jason','tank','sean']
  2. name_list.clear()
  3. print(f"{name.list}")
  4. ​
  5. #[]

7.copy( )

  1. name_list = ['nick','jason','tank','sean']
  2. print(f"{name_list.copy()}")
  3. ​
  4. #['nick','jason','tank','sean']

8.extend( )

  1. name_list = ['nick','jason','tank','sean']
  2. name_list2 = ['nick young']
  3. name_list.extend(name_list2)
  4. print(f"{name_list}")
  5. ​
  6. #['nick','jason','tank','sean','nick young']

9.reverse( )

  1. name_list = ['nick','jason','tank','sean']
  2. name_list.reverse()
  3. print(f"{name_list}")
  4. ​
  5. #['sean','tank','jason','nick']

10.sort( ) 注意：sort列表的元素必须是同一类型的

  1. name_list = ['nick','jason','tank','sean']
  2. name_list.sort()
  3. print(f"{name_list}")
  4. ​
  5. name_list.sort(reverse=True)
  6. print(f"{name_list}")
  7. ​
  8. #['jason','nick','sean','tank']
  9. #['tank','sean','nick','jason']

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

  2. 有序 or 无序：有序

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

  1. hobby_list = ['read','run','girl']
  2. print(f'first:{id(hobby_list)}')
  3. hobby_list[2] = ''
  4. print(f'second:{id(hobby_list)')
  5. ​
  6. #first:587887567432
  7. #second:587887567432

元组类型内置方法

一、元组类型内置方法（tuple）

  1. 用途：多个装备、多个化妆品、多门课程

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

  1. my_boy_friend = ('jason','tank','sean')
  2. print(f'{my_boy_friend}')
  3. ​
  4. #('jason','tank','sean')
  5. name_str = ('egon') #(只是普通包含的意思)
  6. name_tuple = ('egon',)
  7. print(f'type(name_str):{type(name_str)}')
  8. print(f'type(name_tuple):{type(name_tuple)}')
  9. ​
  10. #type(name_str): <class 'str'>
  11. #type(name_tuple): <class 'tuple'>

  1. 常用操作+内置方法：优先掌握、需要掌握和了解

优先掌握：

  1. 索引取值

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

  3. 长度len

  4. 成员运算in和not in

  5. 循环

  6. count

  7. index

1.索引取值

  1. name_tuple = ('nick', 'jason', 'tank', 'sean')
  2. # name_tuple[0] = 'nick handsom'  # 报错
  3. print(f"name_tuple[0]: {name_tuple[0]}")
  4. ​
  5. #name_tuple[0]: nick

2.切片

  1. name_tuple = ('nick', 'jason', 'tank', 'sean')
  2. print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
  3. ​
  4. name_tuple[1:3:2]: ('jason',)

3.长度

  1. name_tuple = ('nick','jason','tank','sean')
  2. print(f'{len(name_tuple)}')
  3. ​
  4. #

4.成员运算

  1. name_tuple = ('nick','jason','tank','sean')
  2. print(f'{"nick“ in name_tuple}")
  3.  
  4. #True    
  1.   

5.循环

  1. name_tuple = ('nick', 'jason', 'tank', 'sean')
  2. ​
  3. for name in name_tuple:
  4.     print(name)
  5.  
  6. #nick
  7. #jason
  8. #tank
  9. #sean

6.count( )

  1. name_tuple = ('nick', 'jason', 'tank', 'sean')
  2. print(f"{name_tuple.count('nick')}")
  3. ​
  4. #

7.index( )

  1. name_tuple = ('nick', 'jason', 'tank', 'sean')
  2. print(f"{name_tuple.index('nick')}")
  3. ​
  4. #

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

  2. 有序 or 无序：有序

  3. 可变 or 不可变：不可变

二、元组和列表的区别

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

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

注意：id（list[ ]）不同，可变；而id（tuple[ ]）相同，不可变。

字典类型内置方法

一、字典类型内置方法

  1. 用途：存多个值，以key：value的形式

  2. 定义：逗号隔开，以key：value的形式，value可以是任意类型数据，key通常是字符串类型，但是key必须为不可变类型

  3. 常用操作+内置方法

优先掌握：

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

  2. 长度len

  3. 成员运算in和not in

  4. 删除del

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

  6. 循环

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

  1. dic = {'a': 1, 'b': 2}
  2. print(f"first dic['a']: {dic['a']}")
  3. ​
  4. dic['a'] = 3
  5. print(f"second dic['a']: {dic['a']}")
  6. ​
  7. ​
  8. #
  9. #

2.长度len

  1. dic = {'a':1,'b':2}
  2. print(f'{len(dic)}')
  3. ​
  4. #

3.成员运算

  1. dic = {'a': 1, 'b': 2}
  2. print(f"'a' in dic: {'a' in dic}")
  3. print(f"1 in dic: {1 in dic}")
  4. ​
  5. #True
  6. #False

4.删除

  1. dic = {'a': 1, 'b': 2}
  2. del dic['a']
  3. print(f"{dic.get('a')}")
  4. ​
  5. #None
  6. ​
  7. #指定元素删除
  8. dic = {'a': 1, 'b': 2}
  9. dic.pop('a')
  10. print(f"{dic.pop('b')}")
  11. print(f"{dic.get('a')}")
  12. ​
  13. #
  14. #None
  15. ​
  16. #键值对删除并返回
  17. dic = {'a': 1, 'b': 2}
  18. print(f"{dic.popitem()}")
  19. ​
  20. #{'b',2}

5.keys/values/items

  1. dic = {'a': 1, 'b': 2}
  2. ​
  3. print(f"dic.keys(): {dic.keys()}")
  4. print(f"dic.values(): {dic.values()}")
  5. print(f"dic.items(): {dic.items()}")
  6. ​
  7. #dict_keys(['a', 'b'])
  8. #dict_values([1, 2])
  9. #dict_items([('a', 1), ('b', 2)])

6.循环

  1. dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  2. for k, v in dic.items():
  3. # items可以换成keys()\values()
  4.     print(k, v)
  5.  
  6. #a 1
  7. #b 2
  8. #c 3
  9. #d 4

需要掌握：

  1. get

  2. update

  3. fromkeys

  4. setdefault

1.get( )

  1. dic = {'a': 1, 'b': 2}
  2. ​
  3. print(f"{dic.get('a')}")
  4. print(f"{dic.get('c')}")
  5. ​
  6. #
  7. #None 
  1.    

2.update( )

  1. dic1 = {'a': 1, 'b': 2}
  2. dic2 = {'c': 3}
  3. dic1.update(dic2)
  4. ​
  5. print(f"dic1: {dic1}")
  6. ​
  7. #dic1: {'a': 1, 'b': 2, 'c': 3}

3.fromkeys

  1. dic = dict.fromkeys(['name', 'age', 'sex'], None)
  2. print(f"{dic}")
  3. ​
  4. #dic: {'name': None, 'age': None, 'sex': None}   
  1.  

4.setdefault

  1. dic = {'a': 1, 'b': 2}
  2. ​
  3. print(f"{dic.setdefault('a',3)}")
  4. print(f"{dic}")
  5. print(f"{dic.setdefault('c',3)}")
  6. print(f"{dic}")
  7. ​
  8. #
  9. #{'a': 1, 'b': 2}
  10. #
  11. #{'a': 1, 'b': 2, 'c': 3}

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

  2. 有序 or 无序：无序

  3. 可变 or 不可变：可变

集合类型内置方法

一、集合类型内置方法

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

2.定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型

  1. s = {1, 2, 1, 'a'}
  2. print(f'{s}')
  3. ​
  4. #{1,2,'a'}
  5. s = {1, 2, 1, 'a', 'c'}
  6. ​
  7. for i in s:
  8.     print(i)
  9.  
  10. #
  11. #
  12. #a
  13. #c
  14. s = set('hello')
  15. print(f"{s}")
  16. ​
  17. {'e','o','h','l'}

  1. 常用操作+内置方法：优先掌握，需要掌握，了解

优先掌握：

  1. 长度len

  2. 成员运算in和not in

  3. |并集、union

  4. &交集、intersection

  5. -差集、difference

  6. ^对称差集、symmetric_difference

  7. ==

  8. 父集：>、>= 、issuperset

  9. 子集：<、<= 、issubset

1.长度

  1. s = {1, 2, 'a'}
  2. print(f'{len(s)}')
  3. ​
  4. #

2.成员运算in or not in

  1. s = {1, 2, 'a'}
  2. print(f'{1 in s}')
  3. ​
  4. #True

3. 并集（|）

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. print(f"{pythoners|linuxers}")
  4. ​
  5. #{'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}

4.交集（&）

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. print(f"{pythoners&linuxers}")
  4. ​
  5. #{'nick'}

5.差集（-）

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. print(f"{pythoners-linuxers}")
  4. ​
  5. #{'tank', 'jason', 'sean'}

6.对称差集（^）

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. print(f"{pythoners^linuxers}")
  4. ​
  5. #{'egon', 'tank', 'kevin', 'jason', 'sean'}

7.==

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. javers = {'nick', 'egon', 'kevin'}
  4. ​
  5. print(f"{pythoners==linuxers}")
  6. print(f"{javers==linuxers}")
  7. ​
  8. #False
  9. #True

8.父集（>、>=）

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. javaers = {'jason', 'nick'}
  4. ​
  5. print(f"{pythoners>linuxers}")
  6. print(f"{pythoners>=linuxers}")
  7. print(f"{pythoners>=javaers}")
  8. print(f"{pythoners.issuperset(javaers)}")
  9. ​
  10. # False
  11. # False
  12. # True
  13. # True

9.子集（<、<=）

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. javaers = {'jason', 'nick'}
  4. ​
  5. print(f"{pythoners<linuxers}")
  6. print(f"{pythoners<=linuxers}")
  7. print(f"{javaers.issubset(javaers)}")
  8. ​
  9. # False
  10. # False
  11. # True

需要掌握：

  1. add

  2. remove

  3. difference_update

  4. discard

  5. isdisjoint

1.add( )

  1. s = {1, 2, 'a'}
  2. s.add(3)
  3. print(s)
  4. ​
  5. #{1, 2, 3, 'a'}

2.remove( )

  1. s = {1, 2, 'a'}
  2. s.remove(1)
  3. print(s)
  4. ​
  5. #{2, 'a'}

3.difference_update( )

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. pythoners.difference_update(linuxers)
  4. ​
  5. print(f"{pythoners}")
  6. ​
  7. #{'tank', 'jason', 'sean'}

4.discard( )

  1. s = {1, 2, 'a'}
  2. s.discard(3)  # s.remove(3)  # 报错
  3. print(s)
  4. ​
  5. #{1, 2, 'a'}

5.isdisjoint( )

  1. pythoners = {'jason', 'nick', 'tank', 'sean'}
  2. linuxers = {'nick', 'egon', 'kevin'}
  3. pythoners.isdisjoint(linuxers)
  4. ​
  5. print(f"{pythoners.isdisjoint(linuxers)}")
  6. ​
  7. # False

  1. 存一个值 or 多个值：多个值，值不可变

  2. 有序 or 无序：无序

  3. 可变 or 不可变：可变

【0805 | Day 8】Python进阶（二）的更多相关文章

  1. Python进阶(二)----函数参数,作用域

    Python进阶(二)----函数参数,作用域 一丶形参角度:*args,动态位置传参,**kwargs,动态关键字传参 *args: ​ 动态位置参数. 在函数定义时, * 将实参角度的位置参数聚合 ...

  2. python进阶(二) 多进程+协程

    我们大多数的时候使用多线程,以及多进程,但是python中由于GIL全局解释器锁的原因,python的多线程并没有真的实现 实际上,python在执行多线程的时候,是通过GIL锁,进行上下文切换线程执 ...

  3. Python进阶(二)

    高阶函数 1.把函数作为参数传入,这样的函数称为高阶函数,函数式编程就是指这种高度抽象的编程范式. 2.Python内建了map( )和reduce( ) 函数 map()函数接收两个参数,一个是函数 ...

  4. Python进阶二

    文章目录 函数参数1.位置传递2.名称传递 def f(a,b): f(1,2) f(b=2,a=1) 3.可选参数传递(可选参数必须放在最后)def f(a,b=1) ✔def f(b=1,a) ❌ ...

  5. Python进阶(十二)----re模块

    Python进阶(十二)----re模块 一丶re模块 ​ re模块是python将正则表达式封装之后的一个模块.正则表达式模式被编译成一系列的字节码,然后由用C编写的匹配引擎执行. #正则表达式: ...

  6. Python 面向对象进阶(二)

    1. 垃圾回收 小整数对象池 Python对小整数的定义是 [-5, 257),这些整数对象是提前建立好的; 在一个Python程序中,所有位于这个范围内的整数,使用的都是同一个对象; 单个字符共用对 ...

  7. 【python进阶】Garbage collection垃圾回收2

    前言 在上一篇文章[python进阶]Garbage collection垃圾回收1,我们讲述了Garbage collection(GC垃圾回收),画说Ruby与Python垃圾回收,Python中 ...

  8. Python进阶：全面解读高级特性之切片！

    导读:切片系列文章连续写了三篇,本文是对它们做的汇总.为什么要把序列文章合并呢?在此说明一下,本文绝不是简单地将它们做了合并,主要是修正了一些严重的错误(如自定义序列切片的部分),还对行文结构与章节衔 ...

  9. Python进阶：迭代器与迭代器切片

    2018-12-31 更新声明:切片系列文章本是分三篇写成,现已合并成一篇.合并后,修正了一些严重的错误(如自定义序列切片的部分),还对行文结构与章节衔接做了大量改动.原系列的单篇就不删除了,毕竟也是 ...

  10. Python进阶(三十五)-Fiddler命令行和HTTP断点调试

    Python进阶(三十五)-Fiddler命令行和HTTP断点调试 一． Fiddler内置命令   上一节(使用Fiddler进行抓包分析)中,介绍到,在web session(与我们通常所说的se ...

随机推荐

  1. 成功入职ByteDance，分享我的八面面经心得！

    今天正式入职了字节跳动.办公环境也很好,这边一栋楼都是办公区域.公司内部配备各种小零食.饮料,还有免费的咖啡.15楼还有健身房.而且公司包三餐来着.下午三点半左右还会有阿姨推着小车给大家送下午茶.听说 ...

  2. 【深入浅出-JVM】（序）

    本系列主要是让一个刚入门的 java 开发者,也能愉快的从零开始成为一个真正的 jvm 大神. 大纲 java 虚拟机的定义.总体架构.常用配置 垃圾回收算法.各类垃圾回收器 java 虚拟机对多线程 ...

  3. Centos7:yum安装MySQL5.7后如何设置root密码

    Centos下安装软件的方式很简单,只需要通过yum install xxx命令即可.第一步当然检查是否有mysql的yum源,命令:yum list|grep mysql-community[主要还 ...

  4. kafka介绍及安装配置（windows）

    Kafka介绍 Kafka是分布式的发布—订阅消息系统.它最初由LinkedIn(领英)公司发布,使用Scala和Java语言编写,与2010年12月份开源,成为Apache的顶级项目.Kafka是一 ...

  5. C语言指针专题——指针怎么就很灵活?

    最近在研读 C Primer pkus(第五版)中文版,老外写的还是很经典的,推荐给朋友们,购买地址:C primer plus 5版中文版购买 另外再推荐两本书: 1. 2017年9月全国计算机二级 ...

  6. 摄像头驱动的使能配置、V4L2编程接口的设计应用

    摄像头采集子系统 一.摄像头驱动的使能配置 摄像头软件驱动构架 摄像头采集系统由上图所示,硬件(摄像头) -> 驱动(Linux内核配置中,选择支持V4L2的驱动选项) -> V4L2接口 ...

  7. jdk安装错误1316，jdk-10.0.1

    打开注册表regedit ,定个位到 计算机\HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\ 把jdk,jre下面的目录删掉.即10.0.1 ,问题解决 参考: https ...

  8. Linux目录文件

    /binbin是binary的缩写.这个目录沿袭了UNIX系统的结构,存放着使用者最经常使用的命令.例如cp.ls.cat,等等. /boot这里存放的是启动Linux时使用的一些核心文件. /dev ...

  9. 小白学python-day04-运算符、while循环相关

    今天是day04.以下是学习总结. 但行努力,莫问前程. ----------------------------------------------------------------------- ...

  10. 数据库---T-SQL语句（一）

    一.T-SQL语句 1.创建表:create table Name(Code varchar(50),) 主键:primary key 自增长:auto_increment 外键关系:referenc ...