扫码加入数据分析学习群

组合数据类型

（1）分类

序列：可变序列：列表[ ]； 不可变序列：字符串，range，元祖()；

集合：内部的存储遵从hash算法：没有重复值，查找更快{ },输出时有排列顺序

字典：一对对的存放，存放时遵从hash算法{ }，输出时有排列顺序

<列表和元祖的区别就是内容是否可修改>

（2）字符串

A．创建 s = '字符串'

可用””,’’,”’”’.三引号表示可以换行

字符串有转义符（如果字符串中出现转义符，可以用r或R来定义原始字符串，这样可以不让转义字符生效）

Eg:在语句中出现单引号，则对内引号进行转义或者用双引号代替总的字符串的引号

B．运算符

s+t 字符串连接 eg：’abc123’

s*n 重复输出字符 *n –>重复输出N次 eg:”abcabc”

s[i] 通过索引获取 s{i} 表示取第几位

[‘a’’b’’c’’d’] 每一个‘’中是一个位置 即 0 1, 2 3

s[i:j：k] 切片：从i到j,步长为k，包括i，但不包括j

例：s = 'string'

s[0] # 获取第一个元素 #s

s[-2] # 获取倒数第二个元素 #n

s[1:3] # 获取从偏移为1的字符一直到偏移为3的字符串，不包括偏移为3的字符串 "tr"

s[1:] # 获取从偏移为1的字符一直到字符串的最后一个字符（包括最后一个字符） "tring"

s[:3] 获取从偏移为0的字符一直到偏移为3的字符串，不包括偏移为3的字符串 "str"

s[:-1] 获取从偏移为0的字符一直到最后一个字符（不包括最后一个字符串） "strin"

s[:] 获取字符串从开始到结尾的所有元素 "string"

s[-3:-1] 获取偏移为-3到偏移为-1的字符，不包括偏移为-1的字符 "in"

s[-1:-3]和str[2:0] 获取的为空字符，系统不提示错误 ""

s[::2] 输出的结果为 "srn"à 步长为2 从0开始取到尾

s[-1:-5:-2] 从右往左，步长为2 "gi"—》倒着取，从右往左输出

s[::-1] 从结束以步长为1倒叙至开始

一般在取数过程中,会用到索引,切片和分割的连用

Eg(s[0:1][0:9:1].split( “” )) à 从起始位到某一位以步长为n进行取数和分割，输出为列表，用前面的[ ]取出

in和not in 判:1断子串是否在指定的字符串中 eg 'h' in 'hello' # True

C．函数

len(s) 求字符串的长度

max(s) 求字符串的最大值，字母会转换成ascii

min(s) 求字符串的最小值，字母会转换成ascii

D．方法

增：

1) 用分隔符拼接字符串：分隔符.join(字符串) –> 表示将分隔符插入字符串两两间

Eg：1234'.join('abcd') #a1234b1234c1234d –> 表示在后者两两之间中插入前者

2) 连接字符串：通过上面的运算符+ “1234abcd”

3) 复制字符串：通过上面的运算符* “abcabcabc”

删：

strip，lstrip 删除左边的，rstrip 删除右边的

s.strip([指定字符]) 删除字符串两边的指定字符，如果不指定默认是空格。

Eg：'#abc##'.strip('#') à abc

' abc '.strip() à abc

改：

1) 转换小写:s.lower()

2) 转换大写: s.upper()

3) 替换：replace(旧字符串，新字符串)

Eg:s.replace('g2','222')

查：index，find，count –> 知道字符找下标

1) 检测字符串是否包含子串：index和find；

区别是如果没有找到，find返回-1，index报错

'abc123'.index('c1') #2

'abc123'.find('c1') #2

'abc123'.find('c2') #-1 à 相当于报错

'abc123'.index('c2') #出错

2) 统计子串出现次数：count

'abc123abc'.count('b') #2

分割：

s.split(‘分隔符’)

检测：

startswith(prefix[,start[,end]]) #是否以prefix开头

endswith(suffix[,start[,end]]) #以suffix结尾

（3）列表

A.创建:

Lst = ['a', 1, True,1.0]

取值---用索引 lst[4]

设置值---lst[4] = 赋值

B. 函数

Len(),max(),min(),sum(lst)

C. 运算符

+ 不改变原列表

D.方法:

查：

list.index(x) 默认查第一个出现x的位置

list.count(x)

list.sort() –> 改变原来的list

list.sort()对列表中的元素进行从小到大排序

list.sort(reverse=true) 对列表中的元素进行从大到小排序

list.reverse()反转排列表中的元素---倒叙输出

增：

list.append(x) 末尾增加一个元素

list.extend([a,b]) 末尾增加多个原则

list.insert(i, x) 在指定位置插入一个元素 --.>在位置i上插入x

删：

list.clear() 清空元素，留下列表

del list 全部删除，列表元素都删除

list.remove(内容) 根据内容删除指定元素。列表中值为 x 的第一个元素。如果没有，就会返回一个错误。

list.pop([下标]) 根据下标删除指定元素。括号内不写，a.pop() 默认删除最后一个元素

改：

用切片索引：设置值---lst[4] = 赋值

拷贝：

Lst2=list.copy() 返回列表的一个浅拷贝。

Lst2=lst与copy的区别是：当lst发生改变，拷贝的lst2不改变，赋值的改变

E.列表推导式

[ i for x1 in <序列1>[…for xN in <序列N> if <条件表达式>]]

例1：

squares = [x**2 for x in range(10) if x!=5] #[0, 1, 4, 9, 16, 36, 49, 64, 81]

例2：

>>> matrix = [

[1, 2, 3, 4],

[5, 6, 7, 8],

[9, 10, 11, 12]

]

#下面交换行和列

>>> [[row[i] for row in matrix] for i in range(4)]

[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

（4）元组

列表是[ ]，元组是( )， 它基本用法同列表一样，但是元祖不可以修改，意味着增删改查都无法使用。

A.创建 --à 创建的方法非常多

t1 = ('a', 1, True,1.0)

t2 = 'a', 1, True,1.0 à 小括号可以省略

t5 = 1， à 表示只有一个元素

t3 = ([1, 3, 5],[2, 4, 6])

t5 = (42,) à必须加逗号

x,y,z = '1','2','3'

B,元组推导式

（i**2 for i in range(5)） - - > 显示为生成器，不显示结果

推导式用小括号，生成的结果是生成器。

C.元组与列表的相互转换

tuple(列表): 转成元组

list(元组)：转成列表

D. 元组与列表区别

元组内容不可变，列表可变。如果内容不需要改变，使用元组，更快更安全

（5）集合

A.创建 - - >按照hash算法，消除重复值

s = {'a','b','c'}

s = set('abc')

s = set(['a','b','c'])

s = set(a','b','c')

#空集合的创建

s = set()

注：不要用{}创建，这创建的结果是字典

B.数学运算符

s1 & s2 交集 对应方法是s1.intersection(s2)

s1 | s2 并集 对应方法是s1.union(s2)

s1 - s2 差集 对应方法是s1.difference(s2) 在s1中存在且不在s2中存在

s1 ^ s2 对称差(两变都不存在元素) 对应方法是s1.symmetric_difference (s2)

s1不在s2中出现的元素ands2不在s1中出现的元素

s1<=s2 s1是否是s2的子集 对应方法是s1.issubset(s2)

s1>=s2 s1是否是s2的超集 对应方法是s1.issuperset(s2)

s1|=s2 用s2更新s1 对应方法是s1.update(s2)

C.函数

hash(s) 哈希值 – 对某个数进行求余

D.方法

增 S.add(x) 增加元素

删 clear() 删除所有元素

remove(x)：删除x,不存在的元素，会报错

discard(x):删除x，不存在的元素，会什么都不操作，但是不会报错

改 update(新集合)—添加元素

E.集合推导式

"{i for i in range(5)}"