列表，字典，元组，集合,字符串，数字类型

列表

从0开始，可取'-'

添加元素

list.append() 在list # 末尾增加一个元素
list.insert（n,'4'） #在指定位置添加元素，如果指定的下标不存在，那么就是在末尾添加
list.extend(list2) #合并两个list list2中仍有元素

查看元素

print(list[n]) #使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符
print(list.count(xx)) #查看某个元素在这个列表里的个数，如果改元素不存在，那么返回0
print(list.index(xx))#找到这个元素的小标，如果有多个，返回第一个，如果找一个不存在的元素会报错

删除元素

list.pop() #删最后一个元素
list.pop(n)#指定下标，删除指定的元素，如果删除一个不存在的元素会报错
list.remove(xx) #删除list 里面的一个元素，有多个相同的元素，删除第一个
print(list.pop()) #有返回值
print(list.remove()) #无返回值
del list[n] #删除指定下标对应的元素
del list #删除整个列表， list删除后无法访问

排序和反转

list.reverse()将列表反转
list.sort()排序，默认升序
list.sort(reverse=True) 降序排列
注：list 中有字符串，数字时不能排序，排序针对同类型

内置方法

1、len(list)：列表元素个数
2、max(list)：返回列表元素最大值
3、min(list)：返回列表元素最小值
4、list(seq)：将元组转换为列表
5、enumerate 用法（打印元素对应的下标）

切片

name[n:m] 切片是不包含后面那个元素的值（顾头不顾尾）
name[:m] 如果切片前面一个值缺省的话，从开头开始取
name[n:] 如果切片后面的值缺省的话，取到末尾
name[:] 如果全部缺省，取全部
name[n:m：s] s：步长 隔多少个元素取一次
步长是正数，从左往右取
步长是负数，从右往左取
注：切片同样适用于字符串，字符串也有下标

列表知识补充

列表是一个有序的对象集合
一个对象在另外一个对象中吗？用 in 来检查

从列表中删除对象 remove
remove:取一个对象值作为唯一参数。remove方***从列表中删除指定数据值的第一次出现。
如果在列表中找到了这个数据值，就会从列表中删除包含这个值的对象（同时列表的大小减一）。如果在列表中没有找 到这个数据值，会报错

从列表中弹出对象 pop
pop:取一个可选的索引值（indexof）作为参数。pop方法根据对象的索引值从现有列表删除和返回一个对象。
如果调用pop时没有指定索引值，将删除和返回列表中的最后一个对象。如果指定了一个索引值，则会删除和返回那个 位置上的对象。
如果列表为空或者调用pop时指定了一个不存在的索引值，会报错。

用对象扩展列表 extend
extend:取一个对象列表作为唯一参数。extend方法接收第二个列表，将其中的各个对象增加到现有列表。如果要将 两个列表合并为一个列表，这个方法就非常有用。

在列表中插入一个对象 insert/append
insert:取一个索引值和一个对象作为参数。insert 方法将一个对象插入到现有列表中指定索引值的前面。
这样就可以将对象插入到现有列表的开头，或者插入到列表中的任何位置。要把对象插入到列表末尾，用append 。用法 num.insert(2,"abc")

如何复制一个数据结构？不要使用赋值操作符复制列表；应当使用copy方法。
赋值操作都指向同一个数据，如果修改一个列表，另一个也会改变；如果想让另一个变量引用一个现有列表，可以使用 赋值操作（=）
copy:list2 = list1.copy() ；如果想建立现有列表中对象的副本，用他们初始化一个新列表，就一定要使用copy 方法

列表切片的使用【start:stop:step】不包含stop 索引值
step 为正数时，从右至左；step 为负数时，从左至右

字典

字典也被称作关联数组或哈希表
键必须独一无二，但值则不必。
值可以取任何数据类型，但必须是不可变的，如字符串，数组或元组。

取值

print(d['key']) 如果写了不存在的值会报错
print(d.get('key')) 如果写了不存在的值，返回None
print(d.get('key','not find ')) 如果找不到存在的值，返回 “not find”

print(d.keys()) #获取所有的key 值
print(d.values()) #获取所有的value 值

if 'key' in d: #判断key是否存在
    print('key')

for k,v in d.items(): #遍历字典
    print(k,v)

修改

d['key'] = value key # 存在即修改，key不存在即新增
d.setdefault('key',value) # 只能新增

删除

d.pop('key') # 必须要传值，因为字典是无序的
d.popitem() # 随机删除一个
del d['key']
d.clear() # 清空字典

扩展

print(dict.items()) # 输出一个list格式（非真正意义上的list）
print(list(dict.items())) # 把字典的key 和 value 转成一个多维list

元组

用小括号括起来的，用逗号隔开，若只有一个元素，后面也需要加逗号

查

tup = (1,2,3)
tup[0] # 1
tup[-1] # 3

改

tup1 = (1,2)
tup2 = (3,4)
tup3 = tup1 + tup2
tup3 # (1,2,3,4)

tup = (1,2,3,[5,6]) # 可以对元组里的列表的值进行修改

删

del tup

元组运算符

len() 计算元组的长度，如 len(1,2,3) = 3
连接 将多个元组连接到一块，如 ：tuple1 = (1,2,3,4,5)；tuple2 = (6,7,8,9,10)； tuple3 = tuple1 + tuple2=(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
查询 x in (x,y.z) 返回值是True

拓展

max(tuple) :返回元组中元素最大值。
min(tuple) : 返回元组中元素最小值。
tuple(list) : 将列表转换为元组

集合

s = set() # 定义空集合

赋值

s.add()
s = {'a','b','c','d'}

------------------------------------------

s.add('ijk') #注意add 与 update 的区别
print(s)
输出结果： {'d', 'ijk', 'c', 'b', 'a'}

 ------------------------------------------

s.update()
s.update('fgh')
print(s)
输出结果：{'f', 'b', 'g', 'd', 'a', 'c', 'h'}

 ------------------------------------------

s = set()
s = set('cheeseshop')
print(s)
输出结果：
{'s', 'e', 'p', 'h', 'o', 'c'}

删除

s.remove()
s = set('cheeseshop')
s.remove('er') # 删除不存在的会报错
s.remove('e')

s.pop() #随机删除一个

s.discard('er') #如果删除的元素存在，删除，不存在不做处理

del s # 删除集合

集合的常用操作

s -= set('copy') 等价于 s = s - set('copy')

 取交集

s.intersection(s1) 等价于 s & s1

 取并集

s.union(s1) 等价于 s | s1

 取差集

s.difference(s1) 等价于 s - s1

 取对称差集

s.symmetric_difference(s1) 等价于 s^s1 取既不存在于s ,也不存在于s1中的元素

 示例如下：

s = set('hi')
t = set('hello')
print(s.symmetric_difference(t))

输出结果：
{'e', 'i', 'l', 'o'}

字符串

去掉空格和特殊符号

name.strip() # 去掉空格和换行符
name.strip('xx') # 去掉某个字符串
name.lstrip() # 去掉左边的空格和换行符
name.rstrip() # 去掉右边的空格和换行符

字符串的搜索和替换

name.count('x') # 查找某个字符在字符串里面出现的次数
name.center(n,'-') # 把字符串放中间，两边用- 补齐
name.find('x') # 找到这个字符返回下标，多个时返回第一个；不存在的字符返回-1
name.index('x') # 找到这个字符返回下标，多个时返回第一个；不存在的字符报错
name.replace(oldstr, newstr) # 字符串替换
name.format（） # 字符串格式化
name.format_map(d) # 字符串格式化，传进去的是一个字典

内置方法

name.capitalize() # 首字母大写
S.startswith(prefix[,start[,end]]) #是否以prefix开头
S.endswith(suffix[,start[,end]]) #以suffix结尾
S.isalnum() #是否全是字母和数字，并至少有一个字符
S.isalpha() #是否全是字母，并至少有一个字符
S.isdigit() #是否全是数字，并至少有一个字符
S.isspace() #是否全是空白字符，并至少有一个字符
S.islower() #S中的字母是否全是小写
S.isupper() #S中的字母是否便是大写
S.istitle() #S是否是首字母大写的

分割

name.split() # 默认是按照空格分割
name.split(',') # 按照逗号分割

连接字符串

‘，’.join(str) 用逗号连接slit 变成一个字符串，str 可以是字符，列表，字典（可迭代的对象）
int 类型不能被连接

切片

str = '0123456789′
print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的全部字符
print str[6:] #截取第七个字符到结尾
print str[:-3] #截取从头开始到倒数第三个字符之前
print str[2] #截取第三个字符
print str[-1] #截取倒数第一个字符
print str[::-1] #创造一个与原字符串顺序相反的字符串
print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print str[-3:] #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取

内置模块

import string

string.ascii_uppercase # 所有大写字母
string.ascii_lowercase # 所有小写字母
string.ascii_letters # 所有字母
string.digits # 所有数字

数字类型

整型int和浮点型float
# 浮点型保留小数位：
x = 3.1415926保留3位小数
print（round（x,3））