核心数据结构

1.分类

• 序列类型数据：字符串、列表、元组
• 泛映射类型：字典（ 例如{'name' :'shark'} ）用name标识shark
• 集合：set（）
  在 Python中列表、元组、字典、集合都称为容器。

2.序列型的数据结构共有的特点：

从左到右索引分别为：

列表

1.列表的特性

• 列表的元素是可变的
  ->列表的元素可以是Python的任何类型的数据和对象，包括字符串、列表（又叫嵌套列表）、元组、字典、集合、函数、类
• 列表中的就有相同价值的元素允许出现多次
  [1,2,1,1,1,1,1] 而集合中元素就只能出现一次

2.创建列表

>>> li = []
>>> type(li)
<class 'list'>
>>> ll = ['@','a']
>>> ll
['@', 'a']
>>> type(ll)
<class 'list'>
>---------------------------------------
>>> list ("known")    #利用list（）转换字符串
['k', 'n', 'o', 'w', 'n']
>>> "www.baidu.com".split('.')    
 #利用split（）按照某些分隔符分隔成列表  ；split具体应用在上一个笔记
['www', 'baidu', 'com']

list（）把每个元素作为自己的一部分，包括空格
li = [['one', 'two', 'three'], [1, 2, 3]] ；列表可以嵌套

3.列表的基本操作

取值

li_f = [ 'insert', 'append','extend', 'remove', 'pop', 'sort', 'sorted']
li_f[0]   # insert
没有嵌套的可以按照索引号取值

l2 = [['one', 'two', 'three'], [1, 2, 3]]
l2[0][1]  # two
嵌套的可以li_f [0][0]取值

切片

s = [ 'insert', 'append','extend', 'remove', 'pop', 'sort', 'sorted']

• s[:] #获取所有的内容
• 切片反转 s[: : -1] #就像第一个拿-1； 第二个-2 ；第三个-3；...

in判断元素是否在数列中

li=["shark",1]
1 in li #在列表的元素的id和整个列表的id是不一样的

一些重要的列表处理方法

append（）

向列表的最后位置，添加一个元素，只接收一个

>>> li =["ad","shd","s","s","s",11]
>>> li.append('a')
>>> li
['ad', 'shd', 's', 's', 's', 11, 'a']

insert（）

向原列表的指定位置插入一个元素，接受两个参数，一个是索引号一个是要插入的元素。

>>> li
['ad', 'shd', 's', 's', 's', 11, 'a']
>>> li.insert(0,'b')       #先索引号后列表，一定要放索引号
>>> li
['b', 'ad', 'shd', 's', 's', 's', 11, 'a']

extend（）

把一个列表类型中的每一个元素追加到原列表中，接收的参数是一个序列类型的数据（）

>>>a=['qf','yangge']
>>> li =["11",2]
>>> li.extend(a)         #会自主接受到后面
>>> li
['11', 2, 'qf', 'yangge']

remove（）#不存在则报错

移除列表中某个指定的元素,没有返回值，并且假如有多个相同值的元素存在，每次只会移除排在最前面的那个元素；会改变列表本身（只能删除一个,但是不能不写）

>>> li
['11', 2, 'qf', 'yangge']
>>> li.remove('qf')
>>> li
['11', 2, 'yangge']
>>> 
KeyboardInterrupt
>>> li.remove(2)
>>> li
['11', 'yangge']

pop()

也是删除一个元素，但是会把这个元素返回，接受0或一个参数，参数是索引号

>>> li
['11', 2, 'qf', 'yangge']
>>> li.pop()          ##什么参数都不接收的时候返回最后一个
'yangge'                        
>>> li
['11', 2, 'qf']                   #这个返回的参数可以接收
>>> li.pop(0)
'11'
>>> li.pop("qf")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer

' '.join()把列表中的元素拼接起来，返回的是字符串类型

>>> li =['a','b']
>>> s =''.join(li)      #''是设置拼接的`字符的`，为空则无间隙的拼接；有没有发现它和前面的接收数列的方式不一样
>>> print(s)
ab

index()

返回指定元素的索引号，即找出元素在列表中排第几个

li=['s','e',1,1,3]
>>> idx =li.index(1)        #输入的是列表的元素,输出的是第一个匹配到的元素
>>> idx
2

* count() 是列表的内置方法，可以统计出相同值的元素在列表中总共出现都少次.

>>> obj=[2, 4, 23, 34, 100]
>>> num = obj.count(4)        ##要统计输入的当然是元素啦
>>> num
1

sort()

• 要求排列的列表中的元素。必须是同一类型的

是列表的内置方法，对列表中元素进行排序。
默认是升序， 这个改变列表自身。不能输出给另一个变量名
还可以接收一个 reverse (反转) 参数, 其值可以是 True 和 False。
False 是升序，True 是降序。需要是同一种数据类型，比如都是字符串，或都是整型。

>>> li = [2,10,3,7]
>>> li.sort()
>>> li
[2, 3, 7, 10]
>>> 
>-------------------------------------------
l5 = [2, 4, 23, 34, 100]
l5.sort(reverse=True)   ##注意这个输入方法
print(l5)
# 输出：
[100, 34, 23, 4, 2] 

sorted()

就是排列好之后可以输出给另一个变量名，而不改变原来的列表

>>> li = [2,10,3,7]
>>> num = sorted(li)
>>> print(li)
[2, 10, 3, 7]
>>> print(num)
[2, 3, 7, 10]         ##这个是排列好的

4.引用赋值

In [192]: a
Out[192]: ['6', '5', '3', '1', '1']

In [193]: b = a

In [194]: b
Out[194]: ['6', '5', '3', '1', '1']

In [195]: a[-2]=2

In[196]:a
Out[196]:['6','5','3','2','1']
In[197]:b
Out[197]:['6','5','3','2','1']

可以看到，这种用等号将一个列表赋值给多个变量时，使用其中任意一个变量对列表的操作，结果都会同步到其他变量的值。(这和前面学到的只有一个元素的变量又不一样了，前面a='1' ;b=a;的时候a、b的inode号是不一样的，现在的列表里的a、b的inode号是一样的，有点像是列表的ab指向了一个存储空间一样)

在这种现象中，就像前面学到的变量的赋值，变量和列表本身之间的关系称作，变量对列表对象的引用，并没有创建一个新的列表。

如下面的代码所示

>>> s=1
>>> id(s)
139707815630400
>>> s=a
>>> id(a)
139707816272368
>------------------------------
和单个变量赋值不同，=的时候列表的id不变

>>> int_number = [1,2,3,4,5]
>>> int_i = int_number
>>> id(int_i)
139707648389280
>>> id(int_number)
139707648389280

如果你要改变两个列表的inode号那么就要深度的拷贝

In [110]: base_count = ['name',['money',100.00]]
#定义一个列表
In [111]: xmen = list(base_count)
#未深度拷贝
In [112]: xpan = base_count.copy()
#copy（）简单拷贝的语句
In [113]: xmen[1][1] = 20.00
#改变一个元素的值后
In [114]: xpan
Out[114]: ['name', ['money', 20.0]]   #另一个也会跟着改变
>------------------------------------------
import copy #导入模块
>>> import copy 
>>> base_count = ['name',['money',100.00]]
>>> xmen_new = copy.deepcopy(base_count)
>>> xpan_new = copy.deepcopy(base_count)
>>> xpan_new[1][1] = 50.00
>>> print(xmen_new)
['name', ['money', 100.0]]
>>> print(xpan_new)
['name', ['money', 50.0]]

元组

元组的特性

元组和列表一样，也是一种序列。
唯一的不同是，元组是相对不可变的。

空元组的创建

>>> t1=()
>>> type(t1)
<class 'tuple'>
>>> t2=,      #空元组串不能用逗号创建；只能用（）创建
  File "<stdin>", line 1
    t2=,
       ^
SyntaxError: invalid syntax

单元素的元组的创建

>>> v_tp = (3)           #除了空元组，其他都用逗号创建
>>> type(v_tp)
<class 'int'>
>>> only_ty = 3,
>>> type(only_ty)
<class 'tuple'>
>>> t2=2,3,4,[2,3],     ##用逗号创建
>>> type(t2)
<class 'tuple'>
>>> t3=(2,3,4,["dof","sdd"])      ##起到作用的是逗号而不是（）
>>> type(t3)
<class 'tuple'>

tuple（）可以对其他序列类型的数据转换为元组。但是要把它的输出赋给变量名；写python的脚本的时候要注意赋值呀

In [173]: s1 = 'car'

In [174]: li = [1,2,3]

In [175]: tuple(s1)
Out[175]: ('c', 'a', 'r')

In [176]: tuple(li)
Out[176]: (1, 2, 3)

In [177]: dl = [1,2,3,['a','b']]

In [178]: tuple(dl)
Out[178]: (1, 2, 3, ['a', 'b'])

>使用元组的理由

占用内存空间小
元组内的值不会被意外的修改

>>> dl = [1,2,3,['a','b']]
>>> d2=tuple(dl)
>>> d2
(1, 2, 3, ['a', 'b'])
>>> d2.remove('b')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'remove'
>>> d2.remove('1')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'remove'

可作为字典的键
函数的参数是以元组形式传递的:如print（）
命名元组有时候可以代替类的对象(面向对象的时候讲)