Python教程

Python学习笔记1-内置数据结构

本文主要是介绍Python学习笔记1-内置数据结构,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

变量:

存储一个对象的引用;由id()、type()、value组成

1.列表[list]:

python内置数据结构

本身由id()、type()、value组成,指向列表对象;

列表对象相当于数组,存储多个对象的引用;对象可以为多个不同数据类型;

  1. 列表的创建
    lst = [1,'2',1,'hello','world']
    lst = list([1,'2',1])
    
  2. 列表的特点

    元素有序、索引映射唯一数据(正序0开始,逆序-1开始)、存储重复数据、存储不同数据类型、根据需要动态分配和回收内存

  3. 列表的查询
    获取索引

    有相同元素,只返回第一个元素的索引;

    lst.index(1)
    

    指定索引区间[0,2)

    lst.index('2',0,2)
    
    获取单个元素

    正向0N-1,逆向-1-N;

    lst[0]=lst[-N]
    
    获取多个元素:切片

    [0,3)步长为2,步长为-1(逆着取,区间也逆过来,索引左大右小)

    lst[0:3:2]
    lst[::-1]
    

    首、尾(省略就能取到,无论正逆)

    lst[:3:2]
    lst[1::2]
    
    判断是否在列表中
    print('2' in lst)
    print(10 not in lst)
    
    列表的遍历

    迭代变量:字符串、列表…

    for 迭代变量 in lst
    
  4. 列表元素添加

    append()在末尾添加一个元素,列表对象不变(id不变),可以将列表作为元素添加进去

    extend()在末尾添加若干元素,列表对象不变(id不变),可以将列表添加进去(列表里的元素拿出来添加)

    insert()在任意位置添加一个元素,在索引1上添加90

    lst.insert(1,90)
    

    切片:在任意位置上添加若干元素

    在从lst的索引1开始替换(添加)lst3中的每个元素

    lst3=[True, False, 1]
    lst[1:]=lst3
    
  5. 列表元素和列表的删除

    remove()根据元素删除,一次只删一个元素,有重复就删第一个

    pop()根据索引移除元素,不指定就删除最后一个元素

    将list切片赋值给其他列表,也可用空列表赋给自身的切片

    clear()清空列表,列表对象还在

    del命令,删除列表对象

  6. 列表元素的修改

    索引:lst[2]=2,将索引更改其指向

    切片:lst[1:3]=11,22,33,44;在切片索引的位置,修改为更多个元素

  7. 列表元素的排序

    lst.sort(),默认从小到大,reverse=True则从大到小,在原列表上改(id不变)

    sorted(lst),内置函数,产生一个新列表,reverse=True则从大到小

  8. 列表生成式

    产生1~9各自平方的整数序列lst

    lst = [i*i for i in range(1,10)]
    

2.字典{dict}

python内置数据结构,和列表一样是一个可变序列(可以增删改,对象地址不变)

字典以键值对方式存储数据(元素是键值对),是无序的序列(第一个放未必第一个位置、其位置由hash工序决定(把键放到hash函数计算)所以要求*不可变序列(字符串)***)

  1. 字典的创建
    dic = {'a':1, 'b':2, 'c':3}
    dic = dict(d=4,e=5)
    dic = {}
    
  2. 字典值的获取

    利用键获取值。如果不存在[]会报错,get默认返回None(可以改返回值为99)

    dic['a']
    dic.get('a',99)
    
  3. 字典元素增、删、改

    判断key是否存在

    'a' in dic
    'b' not int dic
    

    删除指定键值对

    del dic['a']
    

    清空字典元素

    dic.clear()
    

    新增或修改

    dic['h']=5
    dic['a']=5
    
  4. 获取字典视图

    keys()获取所有key,返回dict_keys类型,列表[]

    values()获取所有value,返回dict_values类型,[]

    items()获取所有key,value对,返回dict_items类型,由元组组成的列表[( , ),( , )]

  5. 字典的特点

    key不允许重复(会覆盖),value可以重复,无法手动指定元素位置(hash自动计算)

    元素无序、key必须是不可变对象

    字典根据需要动态伸缩

    字典浪费较大内存,是空间换时间的 数据结构,查询速度很快

  6. 字典生成式

    将两个可迭代对象(字典、列表),按序将对应元素打包成一个个元组,返回由元组组成的列表(要进行list转换)

    items=['a','b','c']
    prices=[1,2,3]
    lst=zip(items,prices)#这个返回值显示看不来
    list(lst)#需要转换成列表,看到里面全是元组
    
    d = {item:price for item, price in zip(items, prices)}# 这个把元组按序取出来,并且循环按序赋给item:price;
    

3.元组(tuple)

python内置数据结构,不可变序列(和字符串一样没有增删改,对象地址会变),和列表很像,用的是()

  1. 元组的创建

    使用小括号创建可以省略小括号,但对于单元素的元素不可以这样

    仅有一个元素的元组必须加小括号逗号**(如果没有逗号,仍然会被误认为元素本身的数据类型)

    t = ('a','b',1)# 可以不写(),直接赋值默认为元组
    t = tuple(('a','b',1))
    t = ()
    t = tuple()
    
  2. 为什么设计元组为不可变序列

    变量内数据不可修改,避免因修改数据导致的错误

    在多任务环境下,同时操作对象,不需要加锁(可以看,不可以动)

    元组中存储的是对象的引用

    引用不允许更改,只能指向原来的那个对象(例如指向列表,可以再这个列表面操作,但是不能指向其他列表或变量等

  3. 元组的遍历
    for item in t:
        print(item)
    

4.集合{set}

python提供的内置数据结构,可变类型序列(和列表、字典一样),是没有value的字典(用hash函数计算位置,无序的,不允许重复

  1. 集合的创建
    s={1,2,3,4,5,5}# 集合元素不允许重复,重复的只保存1个
    s=set([1,2,3,4,5,5])#set转换列表、元组
    s8 = {}# 这无法定义空集合,这是字典dict
    s8 = set()# 这是空集合,类型是set
    
  2. 集合相关操作
    1. 元素的判断

      in,not in

    2. 新增集合元素

      add()一次添加一个元素

      update()一次添加若干元素(可以把列表、元组、集合里的元素拆开放进去)

    3. 删除集合元素

      remove()一次删除一个指定元素,不存在抛出KeyError异常

      discard()一次删除一个指定元素,不存在不抛出异常

      pop()一次删除一个任意元素

      clear()清空集合元素

  3. 集合间的关系
    1. 相等

      元素相同,==或者!=

    2. 子集
      s1.issubset(s2)# s2是s1的子集与否
      
    3. 超集

      issuperset()

    4. 交集

      isdisjoint()

  4. 集合的数据操作
    1. 交集

      intersection()

      &

    2. 并集

      union()

      |

    3. 差集
      s1.difference(s2)		#s1集合-交集
      
    4. 对称差集
      symmetric_difference()	# 并集-交集
      

      ^

  5. 集合的生成式
    {i*i for i in range(1,5)}
    

列表、元组、字典、集合总结

数据结构是否可变是否重复是否有序定义符号
列表list可变可以[]
元组tuple不可变可以()
字典dict可变key不可,value可{key:value}
集合set可变不可{}

字符串

python基本数据类型,不可变的字符序列

  1. 字符串驻留机制

    仅保存一份相同不可变字符串,不同的值放在字符串的驻留池。因此对相同的字符串只保留一份拷贝,后续创建不会开辟新空间,直接把该字符串地址赋给新变量。

    a,b,c都指向’python’这个内存空间。

    a='python'
    b="python"
    c='''python'''
    
    1. 驻留机制的几种情况

      ①符合**标识符(字符、数字、下划线)**的字符串、

      ②字符串长度为0或1

      ③只在编译(解释器)时进行驻留(例如基本运算),而非运行时(例如函数)、

      ④[-5,256]之间的整数数字(不是字符串)

      可以用a=sys.inter(b)强制驻留

      Pycharm会对字符串做优化处理,让内容相同的驻留

    2. 驻留机制优却点

      python中一切皆对象,创建对象和销毁对象消耗时间、内存,从字符串池拿来实用,提升效率节约内存。

      字符串的 拼接、修改 比较影响性能,建议直接用.join()方法,

      join方法先计算字符串长度,再拷贝,只new一次对象,效率比+高

  2. 字符串的常用操作
    1. 字符串的查询

      index()查找子串第一次出现位置,不存在抛异常

      rindex()查找子串最后一次出现位置,不存在抛异常

      find()查找子串第一次出现位置,不存在不抛异常返回-1

      rfind()查找子串最后一次出现位置,不存在不抛异常返回-1

    2. 字符串的大小写转换

      以下,都产生新的字符串对象(不可变序列,用了函数所以不满足驻留条件)

      uper()所有变大写

      lower()所有变小写

      swapcase() 大写变小写,小写变大写

      capitalize()开头字母大写,其余小写

      title()每个单词的开头大写,其余小写

    3. 字符串内容对齐

      center()居中对齐,参数一宽度,参数2填充符(默认空格)。宽度小于原字符串的,返回原字符。

      ljust()左对齐,

      rjust()右对齐,

      zfill()右对齐,左边用0填充。只有参数1。对负数字符串,0添加在**-**之后

    4. 字符串劈分

      split()左边开始劈分,sep指定分隔符(默认空格),maxsplit指定最大劈分次数(其余字串单独作为一部分),返回列表

      rsplit()从右边开始劈分

    5. 字符串判断

      isidentifier()是否合法标识符

      isspace()是否空白字符组成(回车、换行、水平制表等等)

      isalpha()是否只由字母组成

      isdecimal()是否只十进制数字组成(罗马数字不算)

      isnumeric()是否只数字组成(罗马、汉字都算)

      isalnum()是否只有数字、字母组成(中文算字母)

    6. 字符串替换与合并

      replace()参数1被替代的子串,参数2替换的子串,参数3最大替换次数。替换后,原字符串不发生变化。

      s = 'hello,python'
      s.replace('python', 'java')# 用java替换s中的python
      
      s1 = 'hello,python,python,python'
      s1.replace('python','java',2)# 用java替换s1中python,替换2次
      

      join()将列表或元组中的字符串合并成一个。如果要合并一个字符串,会把它当作字符序列

      lst = ['hello', 'java']
      '|'.join(lst) # 用|连接lst里的字符串
      
  3. 字符串的比较

    比较规则:从左往右按字符依次比较,如果不满足就不继续比较了

    比较原理:字符原始值ord(‘a’)<ord(‘b’),原始值对应字符chr(98)=‘b’。中文也有对应的ASCII码

  4. 字符串的切片

    字符串是不可变类型,不能增、删、改。

  5. 格式化字符串

    比如填写申请表,空格处是我们填写的内容,这里是可以变化的。拼接操作会浪费空间,因此格式化字符串就行。

    1. 格式化字符三种方式

      %占位符:%s字符串,%d或%i整数,%f浮点数

      name = 'zjj'
      age = 18
      '我叫%s,几年%d岁' % (name, age)# 用 %
      

      {}占位符:{0}第0个位置,{1}第一个位置

      name = 'zjj'
      age = 18
      '我叫{0},几年{1}岁'.format(name, age) # 用.format
      

      f-string

      f'我叫{name},今年{age}岁'
      
    2. 字符宽度、精度

      %10d,宽度10字符

      %.3f,保留三位小数

      %10.3f,宽度10,3位小数

      {0:.3},保留三位有效数(0代表占位符位置,可以省略)# 冒号后加格式要求

      {0:.3f},保留三位小数

      {0:10.3f},宽度10,3位小数

  6. 字符串的编码解码转换

    不同计算机,str在内存中的表示方式不同(A:Unicode,编码后,byte字节传输,B解码并显示)

    编码:字符串转为二进制数据(bytes)

    解码:bytes类型数据转换为字符串类型

    s='天涯共此时'
    byte = s.encode(encoding='GBK') # 一个中文俩字符
    string = byte.decode(encoding='GBK') # 编码解码的格式要相同
    
    byte = s.encode(encoding='UTF-8')# 一个中文仨字符
    string = byte.decode(encoding='UTF-8')
    
这篇关于Python学习笔记1-内置数据结构的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!