变量：

存储一个对象的引用；由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)
   

   获取单个元素

   正向0_{N-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')