1、列表

1.1 列表定义

列表是有序可变元素的集合，元素可以是任意的数据类型。
表现方式：用一对中括号进行定义，元素和元素之间使用逗号隔开
列表用list 来表示

a = []  # 空列表
b = [1,2,3]
c= ['a','b','c']
d= [1,2,1.2,'a']
e = [1,'b',[1,2]]
print(a, type(a))
print(b, type(b))
print(c, type(c))
print(d, type(d))
print(e, type(e))

1.2 列表的拼接

+号和*号两个方式拼接（与字符串的拼接一样）

[1,2,3] + [4,5,6]  #  输出[1, 2, 3, 4, 5, 6]

[1,'2']* 3  #  输出[1, '2', 1, '2', 1, '2']

1.3 列表的索引和切片

语法与字符串的索引、切片是一样的
list[star:end:step]

• start 开始切片的索引，从头开始时可以省略
• end 结束切片的索引，从头开始时可以省略
• step 步长，每隔几个切一个 默认为1,当step为负数的时候，反向切片
  例子：

ls = [0,1,2,3,4,5,6,7,8,9]
ls[1::2] # 输出[1, 3, 5, 7, 9]

注意：与字符串不一样的是，列表还有嵌套，需要注意嵌套列表的取值

# 嵌套元素的取值
ls = [
    '心蓝',
    '170',
    '18',
    ['健身','meizi'],
    ['刘德华','张学友']
]
res = ls[-1][-1]    
print(res)# 输出'张学友'

1.4 列表的常用操作

增加元素

.append(el) ,在列表的末尾添加一个元素

因为列表中元素可以是任意的数据类型，所以el可以是任意字符类型

ls = [1,2,3]
ls.append(4)
prrint(ls)  # 输出ls的值是[1, 2, 3, 4]
ls.append([1,2,3])

.insert(index,el),在列表的指定索引index处插入元素el

ls = [1,2,3]
ls.insert(0, 'a')
prrint(ls)  # 输出ls的值是['a',1, 2, 3]

注意：
正向index=最后一个索引+1,可以在末尾添加一个字符
ls.insert(-1, 'a')，index=-1无法在最后插件字符串a

.extend(iterable),扩展列表，元素为传入的可迭代对象中的元素

ls = [1,2,3]
new_ls = [4,5,6]
ls.extend(new_ls)
prrint(ls)  # 输出ls的值是[1, 2, 3, 4, 5, 6]

删除元素

.pop(index=-1),删除指定索引的元素，并返回该元素，默认删除最后一个

ls = [1,2,3]
ls.pop()

.remove(value),从列表中删除第一个指定的值value，如果不存在value则报错

ls = [1,2,3,1]
ls.remove(1)
prrint(ls)  # 输出ls的值是[ 2, 3, 1]

.clear(),清空列表

ls = [1,2,3]
ls.clear()
prrint(ls)  # 输出ls的值是[ ]

修改元素

通过索引赋值修改元素

ls = [1, 2, 3]
ls[0]='a'
print(ls) # 输出ls的值是 ['a', 2, 3]

1.5 列表其他的方法

.count(value), 统计列表中value的出现次数

.index(value,start=0,stop=xxxxxx), 返回列表中指定值value的第一个索引，不存在则报错

ls = [1,2,3,1]
ls.index(1)
ls.index(1,1)

.reverse()，反转列表的顺序

ls = [1,2,3]
ls.reverse()
print(ls) # 输出ls的值是 [3, 2,1]

.sort(key=None, reverse=False),对列表进行排序

默认是从小到大，当reverse=True，从大到小
排序有前提：列表中的元素类型需要相同

ls = [3,2,1]
ls.sort()
print(ls) # 输出ls的值是 [1, 2,3]
ls.sort(reverse=True)
print(ls) # 输出ls的值是 [3, 2,1]

打印列表所有的方法
print(dir(list))
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', 
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', 
'__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', 
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', 
'__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 
'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

1.6字符串和列表的转换

s = 'hello world!'
ls = list(s)
print(ls) # 输出ls的值是['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!']

str.join(iterable) ，用str将iterable中的字符串元素进行拼接

''.join(ls)
print(ls) # 输出ls的值是'hello world!'
ls = ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!']
'-'.join(ls)
print(ls) # 输出ls的值是'h-e-l-l-o- -w-o-r-l-d-!'

2、元组

表示有序不可变元素的集合，元素可以是任意的数据类型，元组就是不可变的列表

2.1 元组定义

通过一对小括号进行定义，元素之间使用逗号隔开。

a = () # 空元组
b = ('a', 'b', 'c')
c = (1,2,3,'a')
d = (1,1.4,'a', [1,2])
e = (1,1,5,(1,2))
g = (1,)  # 单个元素元组定义时一定要多加一个逗号
h = 1,2 # 没有括号也是元组
print('h的类型为:',type(h))

把字符串拆分成元组
s = 'abc'
res = tuple(s) # ('a', 'b', 'c')

2.2元组的索引和切片

元组的索引和切片与字符串、列表的使用方法一致
元组的嵌套与列表的方式一致

tp1 = (1,2,(3,4,[1,2]))
tp1[2][2][0] # 输出的值是1

2.3元组的常用操作

不可变，不能修改，不能增加，不能删除，其他的操作与列表一致

print(dir(tuple))
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', 
'__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', 
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', 
'__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

2.4 元组的常用方法

count，index跟列表完全一致

2.5 len函数

获取对象中包含的元素的个数

s = 'abcde'
ls = [1, 2, 30, ['ab', 'world']
tp = (1,2,3)
len(s)
len(ls)
len(tp)

3.可变类型与不可变类型

内存机制分为可变与不可变两种。
不可变数据类型创建就不能修改，只能重新创建
通过内建函数hash可以对数据进行哈希运算，凡是不可hash的都是可变，

3.1数值，字符串，元组是不可变数据类型

3.2列表，集合，字典，是可变数据类型

拓展：哈希函数解释
将数据元素的关键字K作为自变量，通过一定的函数关系（称为哈希函数），计算出的值，即为该元素的存储地址。所以，只有元素的储存地址是唯一（不可变的数据类型）的时候，才可以进行哈希运算

hash('a')
输出-3269344633644372012

4. 赋值

id函数可以获取内存地址

a=1
id(a)  # 输出140714838398624

4.1不可变数据类型的赋值

image.png

运行a=a+1后，a=2，但是b还是等于1

4.2可变数据类型的赋值

image.png

.
运行ls[0]=2后，ls = [2,2,3]，ln= [2,2,3] 因为列表是可变的数据类型，改变ls[0]后，ls和ln都是指向原来的地址，所以ln会随之变成为[2,2,3]