1、字符串 ： '内容' 少量数据的存储
索引：就是下标就是从0开始
s = 'python自动化学习'
s1 = s[0]
print(s1) #通过索引找到元素
切片：就是一段，【0：4】顾头不顾尾
s = 'python自动化学习'
#通过切片查找python
s1 = s[0:6]
print(s1)
步长：跳着取
s = 'python自动化学习'
#通过跳着切片查找
s2 = s[:5:2] #0可以省略
print(s2)
反方向取值：必须加反向步长-1
s = 'python自动化学习'
#倒着取值必须加反向步长 -1
s3 = s[-1:-6:-1]
print(s3)
字符串操作方法：
.capitalize()首字母大写，其他小写
s = 'nxfxxy'
s1=s.capitalize() #新的字符串,
print(s1)
.upper()全部都大写
s = 'nxfxxy'
s1 = s.upper()
print(s1)
.lower()全部小写
s = 'nxfxxy'
s1 = s.lower()
print(s1)
小练习：
code = 'QeAr'.upper().lower()
you = input('>>plese:').upper().lower()
if you ==code:
print('yes')
else:
print('no')
.swapcase()大小写反转大变小，小变大
s = 'nxFxxy'
s1 = s.swapcase()
print(s1)
.title() 每个首字母大写，非字符隔开的每个单词
s = 'nxFxxy ycq q77*&bai'
a=s.title()
print(a) #非字母隔开首字母大写全部
.center（）居中,默认填充为None
s = 'nxFxxy'
a =s.center(20,'&')
print(a) #居中，长度自己设定
.startswith（）以什么开头
s = 'nxFxxy'
a = s.startswith('n')#以什么开头
print(a)
.endswith（）以什么结尾
s = 'nxFxxy'
a = s.endswith('y')#以什么结尾
print(a)
.strip() 去可以写填充，去除字母、除空格，制表符\t 换行符 非常有用
s = ' nxFxxy'
a = s.strip()
print(a)
.lstrip（）去左边
.rstrip（）去右边 #和上面的一样，不进行举例
.split() 字符串转换成列表 重要，设置切割次数
s = 'sss lll ddd ggg eee'
sq = s.split()
print(sq) #相当于字符串转换成列表
.join（）通过连接符连接之前的字符串，也可以对列表进行操作，吧列表转化为字符串，不能有非字符串的内容如数字
字符串：
s = 'sfnxFxxy'
sw = '+'.join(s)
print(sw) # s+f+n+x+F+x+x+y
列表：
ll =['xxx','ddd','222']
l2 = '-'.join(ll)
print(l2) # xxx-ddd-222
.replace（）用于替换
s = 'sfnxFxxy'
sq = s.replace('xx','TT')
print(sq) # sfnxFTTy
.find () 找字符串的索引如果有多个那就只找一个
s = 'sfnxFxxy'
sq = s.find('F')
print(sq) #4
.index() 如果找不到就报错不如find好使
s = 'sfnxFxxy'
sq = s.index('F')
print(sq) #4
.isdigit（）用于字符串转换成数字的判断是否有
i = '123a'
if i.isdigit():
i = int(i)
else:
print('输入错误')
.isalpha（）字符组成判断
i = 'sdf'
if i.isalpha():
i = str(i)
print('正确')
else:
print('输入错误')
.isalnum（）是否有字符和字母组成判断
公共方法：
.len（）查看长度
s= 'sdfsadfasdfasdfadsfadsfdsafewtr'
sq = len(s)
print(sq) #31
.count（）某个元素出现的次数
s= 'sdfsadfasdfasdfadsfadsfdsafewtr'
sq = s.count('s')
print(sq) #7
格式化输出：
.format
%s %d 占位符
res = '我叫{} 今年{}岁，爱好{}'.format('egon',18,'male')
print(res) #我叫egon 今年18岁，爱好male
res = '我叫{0} 今年{0}岁，爱好{0}'.format('egon',18,'male')
print(res)
res = '我叫{name} 今年{age}岁，爱好{hobby}'.format(name='egon',age=18,hobby='male')
print(res)
*2、数字 ：int 多用于计算 1 2 3 .。。
i = 3
i = 6
print(i.bit_length())
'''
二进制 十进制
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
'''
3、bool ： True False
4、list ： 【】列表，存放各种数据类型容器类型
索引：取出来之后就是字符串
切片 ： 之后的是列表
小练习：
li = [111,'alex',22,'wusir']
print(li[1])
print(li[:4:2])
增删改查、
增、
.append（）后面加
l = ['lxf','sdf','pp','sdf']
l.append('葫芦娃')
print(l)
insert 插入
l = ['lxf','sdf','pp','sdf']
l.insert(1,'天使')
print(l)
迭代添加：
l = ['lxf','sdf','pp','sdf']
l.extend('xxxx')
print(l)
看效果：['lxf', 'sdf', 'pp', 'sdf', 'x', 'x', 'x', 'x']
**删除：、
按照索引删除： pop
l = ['lxf','sdf','pp','sdf']
l.pop(0)
print(l)
按照元素删除、 remove
l = ['lxf','sdf','pp','sdf']
l.remove('pp')
print(l)
清空列表： clear
l = ['lxf','sdf','pp','sdf']
l.clear()
print(l)
删除列表 del
l = ['lxf','sdf','pp','sdf']
del l
print(l)
按照索引删除：
l = ['lxf','sdf','pp','sdf']
del l[3]
print(l)
按照切片删除：
l = ['lxf','sdf','pp','sdf']
del l[:3]
print(l)
**改：
按照索引改：**
l = ['lxf','sdf','pp','sdf']
l[0]='zookeeper'
print(l)
按照切片去改：
l = ['lxf','sdf','pp','sdf','df']
l[:2]='iopl'
print(l)
**查、:
按照索引查：
按照切片查： **
l = ['lxf','sdf','pp','sdf','df']
for i in l:
print(i)
其他方法：
计数count出现的次数
和长度：
l = [1,1,2,3,4,5,76,1,1,6]
print(l.count(1))
print(len(l))
#通过元素找索引
print(l.index(4))
l2 = [3,2,4,5,6,7,8,10,9]
l2.sort()#从小到大
print(l2)
l2.sort(reverse=True) #从大倒小
print(l2)
l2.reverse() #反方向排序
print(l2)
列表的嵌套：
ll = [1, 2, 'lxf', 'wusir',['oldboy', 'ycq', 99], 'taibai']
ll[2]= ll[2].upper()
print(ll)
ll[4].append('女神')
print(ll)
5、元祖 ： （）多种数据类型，只读列表，只限制子集的，孙子的可以改
tu = (1,2,True,[2,3,4],'alssx')
for i in tu:
print(i)
tu = (1,2,True,[2,3,4],'alssx')
#切片、索引
print(tu[2])
print(tu[:4])
6、字典 ：{} 键值对key value 大量数据，关联数据，查询快，二分查找
key是唯一的，必须是不可变的数据类型：(可hash )： str bool tuple int ：value 是 任意数据类型
数据分类型：
可变： dict list set
容器类型： list tuple dict set
不可变： 不可变的数据类型：(可hash )： str bool tuple int
dic = {'name':'taivai','age':21,'hobby':'girl','byc':[1,2,3]}
print(dic)
增删改查、
增、
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic['high'] = 180
print(dic)
如果有key在加入有责覆盖，无责添加
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic['name'] = 180
print(dic)
这个是有责不变，无责添加：
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic.setdefault('name',180)
print(dic)
删除：、4中方法
通过键删除，相当于list的索引
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic.pop('name')
print(dic)
清空字典：
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic.clear()
print(dic)
删除字典：
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
del dic['age']
print(dic)
删除最后一个3.6之后3.5 之前是随机删除
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic.popitem()
print(dic)
改、
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic['name']='ppp'
print(dic)
update：
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic2)
查、
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic['name']
print(dic)
推荐用这个，不报错
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
dic.get('name2')
print(dic)
#keys
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
#keys()可以转化成列表
print(dic.keys())
print(list(dic.keys()))
#values()
print(list(dic.values()))
#.tiems（）
print(list(dic.items()))
for i in dic.items():
print(i)
小练习题：：
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
for k,v in dic.items():
print(k,v)
#len（）查看长度
dic = {'name':'taivai','age':21,'hobby':'girl','alex':[1,2,3]}
#len
print(len(dic))
#fromkeys
dic1 = dict.fromkeys('abc',[1,2,3])
print(dic1)
备注：如果要是list当中是空的时候，如果要写入数据之后，那么将会给所有都变成写入的数据不会只有一个有
7、集合 ： 关系型数据的交集/并集/差集/子集。。列表的去重
无序不重复的数据类型，里面的元素必须是可哈希的，但是集合本身是不可hash
关系测试： 交集、子集、并集、差集
去重（列表去重）
增、
.add
ss = {'sss','bbb'}
ss.add('ddd')
print(ss)
.update
ss={'eee','eee','ddd'}
ss.update('abc')
print(ss)
删除、
.remove
ss={'eee','eee','ddd'}
ss.remove('ddd')
print(ss)
其他集合：
#交集
set1 = {1,2,3,4,5}
set2= {4,5,6,7,8}
print(set1 & set2)
#并集
print(set1 | set2)
#差集
print(set1 - set2 )
反交集
print(set1 ^ set2)
frozenset 不可变集合，让集合变成不可变的
s = frozenset('barry')
s1 = frozenset({1,2,3,4})
print(s,type(s))
print(s1,type(s1))
8、数据类型补充
#range 可制定数字列表
for i in range(1,10,2): #有步长
print(i)
注意：
不要改变、列表、字典的大小
如果元祖里面只有一个元素，并且没有逗号隔开，那么他的数据类型与该元素一致
小数据池：int: -5 ~ 256中相同的数全都指向一个内存地址
str: s = 'a'* 20 以内都是同一个内存地址，21就不可以了
深浅copy：
对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变 9、编码 ：
电信号01010101010101010
电脑：
a'siic码128
7位标识一个字节
升级到8位一个字节256 2的8次方
00000001 ===一个字符
万国码啊： unicode包括所有国家
16字节表示一个字符
00000001 00000001 ==一个字符 2的16次方
改变：4个字节表一个字符就是三十二次方
11111111 11111111 11111111 11111111 表示一个字节 2的32次方
资源浪费：
升级utf-8：最少用8位：
英文8位一个字节，00000001
欧洲16位两个字节，00000001 00000001
亚洲24位三个字节，00000001 00000001 00000001
python3下：
不同编码之间的二进制是不能互相识别的
pthon3x str 内部编码方式为unicode（内存）
但是，对于文件的存储、和传输不能用unicode
bytes类型：内部编码方式（内存）为非unicode
s1 = b'ffff'
print(s1,type(s1))
对于中文：