Python 序列

1.列表_特点_内存分析

     a.序列结构：字符串、列表、元组、字典、集合

     b.存入任意数目的元素；并且里面可混放，例如整数和字符串；列表大小可变；

2.创建列表的4种方式_推导式创建列表

     a.基本语法创建：

>>> a=[20,50,"ac"]
>>> a
[20, 50, 'ac']
>>> a[0]
20
>>> c=[]
>>> c.append(50)
>>> c
[50]

     b.list()创建：可以将任何可迭代数据转化为列表，但是当转list内是字符串的转化出来的也只是单个的字符

>>> a=list()    #创建一个空的列表对象
>>> a
[]
>>> a=list("qwe")
>>> a
['q', 'w', 'e']
>>> a=list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#以下语句为以上语句的分步骤；
>>> range(0,10)
range(0, 10)
>>> a=range(10)
>>> type(a)
<class 'range'>
>>> list(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a=list("ab,xx")
>>> a
['a', 'b', ',', 'x', 'x']

    c. range（）创建整数列表：语法格式为：range([start],end,[step]) 如range(3,15,2)  起始数字（不选则默认为0），结尾数字（这是必选），步长（不选          则默认为1）

>>> list(range(0,10,1))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(3,16,2))
[3, 5, 7, 9, 11, 13, 15]
>>> list(range(20,13,-1))
[20, 19, 18, 17, 16, 15, 14]

     d.推导式生成列表

>>> a=[x*2 for x in range(5)]
>>> a
[0, 2, 4, 6, 8]
>>> a=[x*2 for x in range(100) if x%9==0]
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

3.列表_元素的5种添加方式_效率问题

      a.append()方法：在尾部添加元素

      b.+运算符操作：不适合操作大量元素；操作后a的地址将会发生变化；

>>> a=[10,20]
>>> a
[10, 20]
>>> a+=[30]
>>> a
[10, 20, 30]

   c.extend()方法：将目标列表里的所有元素添加到本列表的尾部，属于原地操作，不创建新对象

 

>>> c=[10,20]
>>> id(c)
9573680
>>> c.extend([120])
>>> id(c)
9573680
>>> c
[10, 20, 120]

     d.insert() 插入元素：可以 指定元素插入到列表的任意位置；不适合大量元素时使用；类似移动函数：remove(), pop(), del();

>>> c=[10,20,120]
>>> c.insert(2,100)  #2表示在第二个位置进行插入；
>>> c
[10, 20, 100, 120]

   e.乘法扩展： 生成一个新列表，新列表元素使原列表元素多次重复；

>>> a=[10,20]
>>> a*2
[10, 20, 10, 20]

   
4.列表_元素删除的三种方式_删除本质是数组元素拷贝

  a.del删除 ：删除列表指定位置的元素；本质为数组的拷贝

>>> a=[10,20,30]
>>> del a[1]
>>> a
[10, 30]

  b.pop() 方法 ：删除并返回指定位置的元素，如果未指定位置则默认操作列表的最后一个元素；

>>> a=[10,20]
>>> a.pop()
20
>>> a
[10]
>>> a.pop(0)
10
>>> a
[]

   c.remove()方法：删除首次出现的指定元素，若不存在该元素则抛出异常；

 

>>> a=[10,20,20,30]
>>> a.remove(20)
>>> a
[10, 20, 30]
>>> a.remove(50)   #不存在50，则抛出异常
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    a.remove(50)
ValueError: list.remove(x): x not in list

5.列表_元素的访问_元素出现次数统计_成员资格判断

     a.用index（）获得指定元素在列表中首次出现的索引；

     b.用count()获得元素在列表中出现的次数

     c.用len()返回列表长度

     d.成员资格判断：in 如果元素在列表里，返回True;

6.列表_切片slice操作

    

>>> a=[10,20,30,50]
>>> a[:] #提取所有内容
[10, 20, 30, 50]
>>> a[1:3:1]
[20, 30]
>>> a[1::2]
[20, 50]

7.列表_排序_revered逆序_max_min_sum

   a. 直接修改原列表： a.sort（） # 默认升序排列；a. sort（reverse=True） #降序排列； import random   random.shuffle(a) #打乱顺序；

   b.建新列表的排序： 通过内置函数   sorted（a）进行排序，返回新列表，不对原列表做出修改；

>>> a=[10,20,40,30]
>>> sorted(a)
[10, 20, 30, 40]
>>> a
[10, 20, 40, 30]
>>> a.sort()
>>> a
[10, 20, 30, 40]
>>> a
[10, 20, 30, 40]
>>> a.sort(reverse=True)
>>> a
[40, 30, 20, 10]

   c.reversed() 返回迭代器； 迭代器只能用一次，时间换空间；

>>> a=[10,30,50,20]
>>> c=reversed(a)
>>> c
<list_reverseiterator object at 0x036A9130>
>>> list(c)
[20, 50, 30, 10]
>>> list(c)
[]
>>> #迭代器只能用一次；

   d.   max(a)；min();sum() 函数；适合数值型，不适合其他类型的列表

8.列表_二维列表_表格数据的存储和读取

    

>>> a=[
	["al",18,3000],
	["we",19,7000]
      ]
>>> a
[['al', 18, 3000], ['we', 19, 7000]]
>>> a[0]
['al', 18, 3000]
>>> a[0][1]
18
>>> for m in range(2):
	    for n in range(3):
		    print(a[m][n],end="\t")
	    print()

	
al	18	3000	
we	19	7000	

9.元组_特点_创建的两种方式_tuple()要点

     a.元组 tuple :不可变序列，不可修改元组中的元素（对比列表：列表是可变序列）

     b.元组的创建：1.用（）创建 （对比：列表用【】创建）（注：如果元组里只有一个元素，创建的时候在末尾加逗号，否则                                    被识别为整型）；

                              2.通过tuple（）创建元组，tuple(可迭代对象)；

>>> a=(20,)
>>> type(a)
<class 'tuple'>
>>> a=(20)
>>> type(a)
<class 'int'>
>>> b=tuple()
>>> b=tuple("abs")
>>> b
('a', 'b', 's')
>>> b=tuple(range(3))
>>> b
(0, 1, 2)
>>> b=tuple([1,2,3])
>>> b
(1, 2, 3)
>>> #以上是将列表转元组；
>>> del b
>>> b
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    b
NameError: name 'b' is not defined
>>> #以上是删除元组；

10.元组_元素访问_计数方法_切片操作_成员资格判断_zip()

   

>>> a=(19,25,3,12)
>>> a[0]
19
>>> a[1]=10
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    a[1]=10
TypeError: 'tuple' object does not support item assignment
>>> #表示元组元素不可修改；
>>> a[1:3]
(25, 3)
>>> a[::-1]
(12, 3, 25, 19)
>>> sorted(a)   
[3, 12, 19, 25]
>>> #生成的是列表；
>>> b=(1,2,3)
>>> a+b  #拼接
(19, 25, 3, 12, 1, 2, 3)
>>> a
(19, 25, 3, 12)
>>> b
(1, 2, 3)
>>> zip(a,b)  
<zip object at 0x041AED00>
>>> d=zip(a,b)
>>> list(d)
[(19, 1), (25, 2), (3, 3)]

11.元组_生成器推导式创建元组_总结

    <注> 元组生成器推导式用小括号，列表推导式直接生成列表对象，生成器推导式生成的不适列表也不是元组，是一个生成器对象，可通过生成器对象将其转化成列表或者是元组；或者用生成器对象的__next__() <注>有两个下划线 方法遍历，或者直接作为迭代器对象来使用；生成器只能创建一次；

>>> s=(x*2 for x in range(5))
>>> s
<generator object <genexpr> at 0x041B1BF0>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> list(s)
[]
>>> s=(x*2 for x in range(5))
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4
>>> s.__next__()
6
>>> s.__next__()
8
>>> s.__next__()
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    s.__next__()
StopIteration

 

    元组的总结：

    1.元组的核心特点：不可变序列；列表是可变序列

    2.元组的访问和处理速度比列表快；

   3.与整数和数字串一样，元组可以作为字典的键，列表则永远不可能作为字典的键来使用；

12.字典_特点_4种创建方式_普通_dict_zip_formkeys

    a.字典：是“键值对”的无序可变序列；（对比：列表是通过“下标数字”来找到对应的对象，字典是通过“键对象”找到对应的“值对象”）

      <注>键只能是 整数、字符串、浮点数、元组；列表、字典、集合这些可变对象不能作为”键“；键不能重复，否则会覆盖；； ”值“可以是任意数据，并且可以重复；

字典的创建：

>>> a={"name":"lall","age":18}
>>> b=dict(name="www",age=19)
>>> c=dict([("name","uu"),("age",22)])
>>> #zip()创建字典对象
>>> k=["name","age"]
>>> v=["qq",56]
>>> d=dict(zip(k,v))
>>> d
{'name': 'qq', 'age': 56}
>>> a
{'name': 'lall', 'age': 18}
>>> b
{'name': 'www', 'age': 19}
>>> c
{'name': 'uu', 'age': 22}
>>> a.get("name")
'lall'
>>> c.get("age")
22
>>> r=dict.fromkeys(["lili","age"])
>>> r
{'lili': None, 'age': None}

 

13.字典_元素的访问_键的访问_值的访问_键值对的访问

    #通过a.items 返回所有的键值对；可以通过 a.keys返回所有的键；a.values 列出所有的值；len（a）列出键值对个数； 通过in 判断某个键是否存在；

>>> b=dict(name="www",age=19)
>>> b["name"]
'www'
>>> b.get("name")
'www'
>>> b.get("ee","不存在")
'不存在'
>>> #设置键不存在时，返回一个特定的值或者字符串；
>>> b.items()
dict_items([('name', 'www'), ('age', 19)])
>>> #通过items 返回所有的键值对；可以通过 key 返回所有的键；value 列出所有的值；len（）列出键值对个数
>>> b.keys()
dict_keys(['name', 'age'])
>>> b.values()
dict_values(['www', 19])
>>> len(b)
2
>>> "name" in b
True

14.字典_元素的添加_修改_删除

   a.给字典新增键值对，如果字典中已经存在改键，则覆盖旧键；

>>> b=dict(name="www",age=19)
>>> b["sex"]="man"
>>> b
{'name': 'www', 'age': 19, 'sex': 'man'}
>>> b["name"]="lishen"
>>> b
{'name': 'lishen', 'age': 19, 'sex': 'man'}

  b.使用update()   （使用 a.update(b),b覆盖a）将新字典上所有的键值对添加到旧字典中，若有重复，则覆盖；

#接上一条程序
>>> c=dict(name="meng",fufu=17)
>>> b.update(c)
>>> b
{'name': 'meng', 'age': 19, 'sex': 'man', 'fufu': 17}

 c.用del() 删除字典中的元素；clear() 删除所有键值对；pop() 删除指定键值对，并返回对应的值对象；

#接上面的程序
>>> del(b["name"])
>>> b
{'age': 19, 'sex': 'man', 'fufu': 17}
>>> b.pop("age")
19
>>> b
{'sex': 'man', 'fufu': 17}
>>> b.clear()
>>> b
{}

   d. 使用popitem() 随机删除和返回该键值对；

>>> c.popitem ()
('fufu', 17)
>>> c
{'name': 'meng'}

15.字典_序列解包用于列表元组字典

作用：方便地对多个变量赋值

>>> x,y,z=(10,20,30)
>>> x
10
>>> (x,y,z)=(10,20,30)
>>> x
10
>>> [x,y,z]=[10,20,30]
>>> x
10
>>> a=dict(name="lili",age=15)
>>> q,w=a   #用q,w去接收a 的键；
>>> q
'name'
>>> w
'age'
>>> s,d=a.values() 
>>> s
'lili'
>>> d
15

16.字典_复杂表格数据存储_列表和字典综合嵌套

>>> r1={"name":"li","age":12,"city":"北京"}	
>>> r2={"name":"liu","age":21,"city":"成都"}	
>>> tb=(r1,r2)
>>> tb[1].get("city")
'成都'
>>> for i in range(2):
	print(tb[i].get("name"),tb[i].get("age"),tb[i].get("city"))

li 12 北京
liu 21 成都

17.字典_核心底层原理_内存分析_存储键值对过程

   a.字典对象的核心：散列表，散列表是一个稀疏数组，数组的每个单元叫做bucket；通过偏移量来读取指定的bucket;

      通过hash（）函数计算出他的散列值，将散列值转化成二进制，根据散列表的长度，算出是2的a次幂，从散列值右边取a个值，算出应该存放的位置，如果此位置已经填入键值，则再往左数a位，从这a为找对应存放位置；如果散列表已经存到三分之二，则扩容；

18.字典_核心底层原理_内存分析_查找值对象过程

与上一条同理，找a值，然后取出对象，如果取出的不是想要的，再往后取三位，直到找到需要的值；如果两个散列值相同，则返回；

用法总结：

  1.   键必须可散列

    （1）数字、字符串、元组都是可散列的

     （2）自定义对象需要支持下面三点

               a.支持hash()函数

               b.支持通过__eq__() 方法检测相等性

               c.若 a==b 为真，则hash(a)==hash(b)也为真

  2.字典在内存中的开销巨大，典型空间换时间

 3.键查询速度快

  4.不要遍历字典序的同时，对字典进行修改，可能会导致扩容，导致散列表中的键的次序发生变化

19.集合_特点_创建和删除_交集并集差集运算

a. 集合：无序性；不可重复性；底层是字典实现；所有元素都是字典中的“键对象”

b. 用add() 方法添加新元素；

c. 使用set（）函数，将列表、元组等可迭代对象转化为集合，若存在重复性，则取一个；

d.使用remove() 函数删除指定函数

e. 使用clear() 函数清空整个集合

>>> a={1,2,5}
>>> a
{1, 2, 5}
>>> a.add(6)
>>> a
{1, 2, 5, 6}
>>> c=[1,2,2,3,4,5]
>>> c
[1, 2, 2, 3, 4, 5]
>>> set(c)
{1, 2, 3, 4, 5}
>>> c.remove(3)
>>> c
[1, 2, 2, 4, 5]
>>> c.clear()
>>> c
[]

 f.集合的相关操作：并交差等运算；并集：| 或者 a.union(b) ;交集：&或者 a.intersection(b) ; 差集：-或者a.difference(b);

>>> a={"a",2,1}
>>> b={1,"c",7}
>>> a|b
{1, 2, 7, 'c', 'a'}
>>> a.union(b)
{1, 2, 7, 'c', 'a'}
>>> a&b
{1}
>>> a-b
{'a', 2}
>>> a.intersection(b)
{1}
>>> a.difference(b)
{'a', 2}