一. 整型（int）
int('...') -----int 只能转纯数字的字符串，一旦字符串中有的数字不是整型，就会报错。
进制转换：
1.任意进制转为十进制：
-----int 中第二个参数是几，那么就表示第一个参数是几进制,然后再转换为十进制
int('0110',2) ---------- 将二进制 ‘0110’ 转换为 十进制
int('26',8) -----------将八进制‘26’转换为 十进制
int(‘c’,16) ----------将十六进制‘c’转换为 十进制。 十六进制：0-9，A-F
2.将十进制转为任意进制：
bin(12) -------- 将十进制‘12’转换为 二进制。打印出来的 0b.... ，0b后面的数字为二进制
oct(12) -------- 将十进制‘12’转换为 八进制。打印出来的 0o....， 0o后面的数字为八进制
hex(12)-------- 将十进制 ‘12’ 转换为 十六进制。打印出来的 0x....，0x表示后面的数字为十六进制
二.浮点型（float）:
数字中含有小数点的一般都为浮点型。
三.可变类型与不可变类型:
可变类型：即使变量的值有所改变，但其 id 任然不变的，为可变类型。列表
不可变类型：一旦变量的值发生改变，其 id 一定便的情况，为不可变类型。int,字符串类型
四.字符串类型：（'...' ,''.... '','''.....''',单引号或是双引号，三引号）
1.按索引取值，可以正向取值，也可以反向取值。但是只能取值：
a = 'abcde'
a[3]----------取值 d
a[-1]--------取值 e
2.切片: 从大的字符串中切下来一部分小的字符串：
小特点：顾头不顾尾
步长：假如步长是n的话，那就隔 n-1 个数取一个值.
切片取值默认是从左到右的。
a = 'abcde'
a[2:3] ------取的片段为 c ----默认步长为1-----隔的个数为零
a ='abcde'
a[0:4:2] -----取的片段为 ac ------ 步长为2----隔的个数为1个
3.长度len: 统计字符串中字符的个数
a = 'abcd'
len(a) ------------- 4个
4. 成员运算 in 和 not in : 查看某个字符串是否存在于一个大的字符串中。
a = 'hello,andy'
print('an' in a) -------True
print('b' in a) ---------False
a = 'hello'
print('andy' not in a) ------- True
print('he' not in a) ------- False
5.strip : 去除字符串首尾两端的字符。strip() 默认去除字符串两边的空格。
lstrip : 去除字符串左边的字符。
rstrip : 去除字符串右边的字符。
name = '###andy###'
print(name.strip('#')) ------------------ andy
print(name.lstrip('#')) ------------------ andy###
print(name.rstrip('#')) ----------------- ###andy
6.split :切分。针对按照某种分隔符组成的字符串进行切分，切下来的是列表。
它是从左往右切分的。
rsplit: 从右往左切分成列表 。如果没有指定切分，它的效果跟split 是相同的。
name = 'andy is big|a os'
print(name.split('|')) -------- ['andy is big','a os']
print(name.split('a')) -------- [' ','ndy is big|', ' os']
print(name.split('a',2))-------['','ndy is big|',' os'] ---- 指定切分：其中2，是左往右切分2个 'a'
print(name.rsplit('a',1)) -------['andy is big|',' os'] -----指定切分： 其中 1，是指定切分从右到左的1个’a‘.
7.lower : 小写 ，upper: 大写
name = 'AndY'
print(name.lower()) -------'andy'
name = 'AndY'
print(name.upper())-------'ANDY'
.captalize 字符串中首字母大写
name = 'kEn'
print(name.captalize())------ Ken
.swapcase 大小写互换位置
name = 'KeNdGy'
print(name.swapcase())------kEnDgY
8.startswith 开头-----判断字符串中字符的开头
endswith 结尾-----判断字符串中字符的结尾
name = 'andy'
print(name.startswith('a')) ------ True
print(name.endswith('i')) ------- False
9.format 占位.有以下三种方法 ： （推荐使用该功能）
第一种：按位置占位，原理同%s,%d占位相同。
d = 'my {} name {} age {}'.format('hh','andy','18',)
print(d) ------my hh name andy age 18
第二种：按照索引占位。
d = 'my {0} name {0} age {2}'.format('hh','andy','18',)
print(d) --------my hh name hh age 18
第三种：对号入座式占位。
d = 'my {name1} name {name1} age {age}'.format(name1 = 'hh',name2 = 'andy',age = '18',)
print(d)-----my hh name hh age 18
10 .join :拼接，跟容器中的每个单个元素进行拼接，成为一个字符串。
l = ['a','b','c']
res = '#'.join(l)
print(res) -------a#b#c
11.replace：替换.将旧字符串中的字符替换成新的字符。
str = 'andy is big ,age is 18'
l =str.replace('andy','ruby')
print(l) ----------ruby is big ,age is 18
12.isdigit: 判断是否为数字.通常用这个就可以满足需求。 isnumeric() ---- 可以识别中文数字，罗马数字，只要是数字都识别
isdecimal()---只能识别阿拉伯数字
age = 18
age.isdigit() -----True
age = 'andy'
age.isdigit() ---- False
五.需要了解的内置方法：
1.find 查找.当查找的字符不在字符串中时，会返回 -1.但不会报错，可继续运行程序
rfind == find
s = 'abcdef'
print(s.find('c')) -------2. 返回是c字符所在的索引值
s = 'abcdef'
print(s.find('c',0,3))------2.通过索引可以来限制范围
s = 'abcdef'
print(s.find('g')) ------ -1.这是错误的，但不会中止程序运行.
2.index 索引，当指定的字符不在字符串里时，就报错。
rindex 从右往左开始索引取值
index == rindex
s = 'abcdef'
print(index('c')) -------2.返回的是索引值.
s = 'abcdef'
print(rindex('c')) ------2 从右往左返回索引值
s = 'abcdef'
print(index('c',0,3)) --------2,返回所传字符的所在范围内的索引值.
s = 'abcdef'
print(index('g')）--------报错
3.count 计数 统计字符在字符串中出现的频率
s = 'abcdefdg'
print(s.count('d')) ---------- 2.
4.center 居中
name = 'ken'
print(name.center(9,'#')) -------###ken###
5.ljust 居左
name = 'ken'
print(name.ljust(3,'#'))------ken###
6.rjust 居右
name = ' ken'
print(name.rjust(3,'#')) ------###ken
7.zfill 填充
name = 'ken'
print(name.zfill(3))----000ken
8.expandtabs 扩展
s1 = 'a bc'
print(s1.expandtabs(10)) -----a bc
9.title 字符串中每个单词首字母大写.
name = 'hello ken'
print(name.title()）------ Hello Ken
六.列表类型：
1.append 尾部追加,将被添加的数据当作列表的一个元素
l = [1,2,3,4,5]
l.append(6)
print(l)-----[1,2,3,4,5,6]
2.insert 插入 可以在列表中的任意位置插入
l = [1,2,3,4,5]
l.insert(1，26)
print(l) ---- [1,26,2,3,4,5]
3.extend 扩展
l = [1,2,3,4,5]
l1 = [3,2,3,45,]
l.extend(l1)
print(l)---------[1,2,3,4,5,3,2,3,45]
4.del 删除 针对所有数据类型
l =[1,2,3]
del l[0]
print(l) -------[2,3]
5.pop 尾部弹出, 可以按照索引弹出元素
l = [1,2,3,4]
l.pop()
print(l) ----- [1,2,3]
6.remove 指定要删除元素的值
l = [1,2,3,4]
l.remove(2)
print(l) ------[1,3,4]
7.reverse 将列表反转
l = [1,2,3,4,5,6]
l.reverse ---------[6,5,4,3,2,1]
8.clear 清除，将列表清除，返回的值的None,也就是不会返回值
9.sort 排序 ， 将列表内排序，从小到大的方式
10.索引，切片，长度len, 成员运算 in
---------------------------------------------------------------
二，元组（tuple）常用方法：
跟列表类似，只是表现的花括号变为小括号，能存多个值，是有序的
1.索引取值 ：正反都可以取值，只能取值
2.长度len, 成员运算 in , 切片 顾头不顾尾，步长。
3.for 循环 取值。
------------------------------------------------------
三，字典（dic）常用方法及内置方法
定义方式：在{}内用逗号分隔开多 个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型
1.按照 key 取值，可存可取
赋值语句当key不存在的情况下，会新增一个键值对*****
2.长度len 统计键值对的个数
3.成员运算，in ，not in。 在字典里只能判断key值
4.del 删除， 只能删除到key值,不能选择value直接删除
5.pop 弹出，在字典里选择key值，弹出的只是value，
6.定义字典的三种方式：
1.第一种：
d1 = {'name':'jason','password':123}
2.第二种：
d1 = {name = 'andy',pwd = 123}
3.第三种：
d1 = [['name','andy','age','18']]
d= {}
for k,v in d1:
d[k] = v --------{'name':'andy','age':'18'}
7.键keys()，取字典里的key值
值values()， 取字典里的value值
**********
键值对items() 取字典里的键值对，可以看作列表套元组， [(1,2)], 元组里的第一个元素为key,第二个元素为value
8.get() 根据key获取value
get 1.当你查找的key不在字典里时，不会报错。
2.可以传第二个参数，当key 不存在的时候，会返回第二个参数的信息。
9.fromkeys() 快速创建一个字典
l = ['name','age']
print(dict.fromkeys(l,123)) ------{'name': 123,'age':123}
10.popitem() 尾部弹出键值对
11.setdefault 当键不存在的情况下，新增一个键值对 并且将新增的键值对的值返回
d = {'name': 123,'hobby':123}
d.setdefault('age',18)------ {'name': 123,'age':123,'age':18}
12.update 更新，有相同key就更新为最新的value值，
如果没有相同键值对，就会更新字典，将新的键值对加进字典里。
d = {'name': 123,'age':123}
d.uppdate(age=18)
print(d)-------------{'name': 123,'age':18}
d = {'name': 123,'age':123}
d.uppdate(hobby=18)
print(d)-------------{'name': 123,'age':123,'hooby':18}
13.for 循环
d = {'name': 123,'age':123}
for i in d:
print(d) ----------name
age
for 循环取键值对然后解压赋值：
d = {'name': 123,'age':123}
for i,v in d.items:
print(i,v) ----------name 123
age 123
-----------------------------------------------------------
四.集合（set） 一般用于集合与集合之间做比较，不涉及单个元素
集合用花括号表示，可以包含多个元素，用逗号分隔，无键值对。定义空集合只能用 set---- d = set({})
1.集合的元素遵循的三个原则：
1.每个元素必须是不可变类型
可变：不可hash
不可变：可hash
2.没有重复的元素，集合里自动将重复的元素去除
3.无序的
2.长度len，集合中元素的个数
3.add 增加 将容器类型增加到集合中，也是当做单个元素传入的
4.成员运算 in 和not in
5.| 合集 两个集合，合并为同一个集合
6.& 交集 两个集合，相同部分组成一个集合
7.- 差集 两个集合相减，去除集合内的相同元素，并保留只保留第一个集合。
8.^对称差集 两个集合，不同部分组成一个集合
9.== 判断 两个集合是否相同。
10.父集： >,>= 符号前的集合是否包含符号后面的集合
11.子集：<,<= 符号前的集合是否在符号后面的集合里
12..
remove #删除的元素不存在则报错
discard #删除的元素不存在不会报错