目录

元组内置方法

什么是元组tuple（了解）：只可取 不可更改 的列表,元组一创建就被写死了

  • 作用：占用内存小,元组一创建就被写死了

  • 定义方式：()内用逗号隔开多个元素（可以为任意数据类型）

lt = list([1,2,3])
tup = tuple((1, 2, 3))
print(tup, type(tup))

如果元组只有一个元素，必须得加逗号

tup1 = (1,)
print(tup1, type(tup1))
  • 使用方法
1. 索引取值
print(tup[0])

2. 索引切片
print(tup[0:3])

3. for循环
for i in tup:
    print(i)
    
4. 成员运算
print(0 in tup)

5. len长度
print(len(tup))

6. index获取元素索引
print(tup.index(1))

7. count 计数
print(tup.count(2))

  • 有序or无序：有序

  • 可变or不可变: 压根不存这一说

字典内置方法

  • 作用: 存储多个数据，对每个数据具有描述

  • 定义方式：{}内用逗号隔开多个键key(具有描述意义，不能为可变数据类型):值value（任意数据类型）对

散列表（哈希表）

dic = {'name': 1}
print(dic)

可以以数字为变量名

dic = {0: '功能1', 1: '功能2'}
print(dic)

dic = {[1, 2]: 'a'}  # 可变==不可哈希，不可变==可哈希
print(dic)

dic = {(1,2):'a'}
print(dic)
  • 使用方法：

优先掌握

1、按key取值/按key修改值
dic = {'a': 1, 'b': 2, 'c': 3}

print(dic['a'])

dic['b'] = 4

print(dic)

2. 添加值,没有就添加，有就修改
dic['d'] = 4
print(dic)

3. for循环
for i in dic:
    print(i)

4. 成员运算
print('a' in dic)

5. len长度
print(len(dic))

6. keys/values/items
print(dic.keys())  # 看成列表
print(dic.values())  # 获取所有值

print(dic.items())
for i in dic.items():
    print(i)
for kasdfsad, vsdfsdf in dic.items():  # 解压缩
    print(kasdfsad, vsdfsdf)

需要掌握

1、get:获取
s = 'e'
print(dic[s])  # KeyError: Nonetype --> s是None，并不是你想象的e
print(dic.get('b', 1))  # 字典中没有返回None,可以给定一个默认值

2、update : 更新，等同于list里的extend
dic1 = {'a': 1, 'c': 2}
dic2 = {'b': 1, 'd': 2}
dic1.update(dic2)
print(dic1)

fromkeys
print(dict.fromkeys(dict.fromkeys([1, 2, 3, 4])))  # 默认给None

3、setdefault  # 字典有这个key，就不修改，没有则增加
dic.setdefault('j', 2)
dic.setdefault('a', 2)
print(dic)

4. 有序or无序：无序

5. 可变or不可变：可变
dic = {'a': 1}
print(id(dic))
dic['b'] = 2
print(id(dic))

集合内置方法

集合：交集/并集/补集/差集

  • 作用 ： 1。进行上述运算 2. 去重 3.乱序 ---》基于散列表实现的

  • 定义方式： {}内以逗号隔开多个元素（不能可为变数据类型）

空字典

s = {}  # 空字典
print(type(s))
s = set()  # 空集合  # 上面定义了一个相同的变量但是从未使用，你又定义了这个变量
print(type(s))

s = {'a', 'a', 'a', 1, 'v', 2, 2, 'c', 3, 3, 6}#对于数字而言，不会乱序；但是对于其他，就乱序
print(s)

打印结果：1, 2, 3, 'a', 6, 'v', 'c'}
  • 使用方法
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

并集
print(pythoners | linuxers)

交集
print(pythoners & linuxers)

差集
print(pythoners - linuxers)

补集
print(pythoners ^ linuxers)

添加：add

pythoners.add('oscar')#添加到字典中
print(pythoners)

pythoners.remove('oscar1')  # 移除，没有报错
print(pythoners)

pythoners.discard('oscar1')  # 抛弃，没有不报错
print(pythoners)

pythoners.pop()  # 随机删除一个
print(pythoners)

  • 有序or无序: 无序

  • 可变or不可变：可变

set = {1, 2, 3}
print(id(set))
set.add(4)
print(id(set))

散列表（哈希表）

  • 定义：

散列表（Hash table，也叫哈希表），是根据关键码值(Key和value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

  • 冲突：

对不同的关键字可能得到同一散列地址，即k1≠k2，而f(k1)=f(k2)，这种现象称为冲突（英语：Collision）。具有相同函数值的关键字对该散列函数来说称做同义词。综上所述，根据散列函数f(k)和处理冲突的方法将一组关键字映射到一个有限的连续的地址集（区间）上，并以关键字在地址集中的“像”作为记录在表中的存储位置，这种表便称为散列表，这一映射过程称为散列造表或散列，所得的存储位置称散列地址。

个人理解：与列表不同的是，哈希表的索引是Key，直接通过Key值访问value，而不同于列表，通过整数[0,∞)[0,\infty)[0,∞)作为索引存储值。

首先对key做了哈希处理(能对所有数据类型都可以哈希处理)：梅森旋转算法（生成伪随机数）--> 通过哈希处理对于每个key他都可以生成一个序列（永不重复，相同的东西进入哈希处理，结果相同）

使用哈希函数对刚刚生成的序列（纯数字）,对纯数字除9取余（0，1，2，3，4，5，6，7，8）

深浅拷贝

可变/不可变

可变： 值变id不变
lt = [1, 2, 3, 4]
lt.append(5)
print(lt)

不可变：值变id变化
s = 'nick'
s += ' handsome'
print(s)
  • 拷贝(赋值)
当y为x的拷贝对象，如果x为不可变类型，x变化y不变；如果x为可变类型，x变化y也变。
x = 10 # 赋值
y = x  # 即是赋值又是拷贝

lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = lt1

当lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变(*****)
  • 浅拷贝 (表示的一种现象)
lt1 = [1, 2, 3]
lt2 = copy.copy(lt1)  # lt2叫做lt1的浅拷贝对象

当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化，lt2不变；lt1内部的可变元素变化，lt2变
  • 深拷贝
lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = copy.deepcopy(lt1)

当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变

主要内容

当lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变(*****)

当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化，lt2不变；lt1内部的可变元素变化，lt2变(******)

当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变(*****)

拷贝/浅拷贝/深拷贝 --> 只针对可变数据类型

s1 = 'nick'
s2 = copy.copy(s1)  # 无论s2是指向s1指向的值nick，还是自己新开辟内存空间

内置方法中的copy方法都是浅拷贝的copy，也就是说如果你的列表里面有可变数据类型，那就不要使用.copy方法

lt = [1,2,3,[1,]]
lt2 = copy.deepcopy(lt)

数据类型总结

按存值个数分类

存一个值：整型/浮点型/字符串
存多个值：列表/元组/字典/集合

按有序or无序分类
有序：字符串/列表/元组（序列类型）
无序：字典/集合

按可变or不可变分类
可变：列表/字典/集合
不可变：整型/浮点型/字符串/元组

深浅拷贝（只针对可变数据类型） --. 用一定用不到，面试很大概率会问，这不是python独有的，而是一种语言独有的