python的数据类型有字符串（str），字节串（bytes），整型（int），浮点型（float），元组（tuple），列表（list），字典（dict），集合（set）。字节串在进行字符编码时进行介绍。
（一） 字符串
定义：在单引号或者双引号或者三引号内，由一个或多个字符串在一起组成的字符串 name = "alex123456"
作用：姓名，性别，国籍，地址等描述信息；
用法：
1.按索引取值 ”顾头不顾尾“
正向取 ：name[3] ----"x"
反向取：name[-3] ----"4"
2.切片 ”顾头不顾尾“ 可以有三个参数，起始点，终止点，步长,注意反向步长的作用，可以把字符串倒过来
name[1:4:2] ---"lx"
name = "alex" name[ : : -1] ------"xela"
3.长度 len()
len(name)----10
4.分割（split()）,以某一字符将字符串分割成一个列表，有2个参数，字符可以是标点符号也可以是字母，另一个参数是从第几个标号符号或字符来分割
(以什么分割，分割后的结果就没有什么)
name = "alex,123456hello"
以逗号分隔： name.split(",") ------["alex", "123456hello"]
以字母分割： name.split("l") ------["a", "ex,123456hello"]
以第2个指定字母分割： name.split("l",2) ------["alex,123456he", "lo"]
5.去除空白 strip()，去掉字符串开头和结尾的空格和 。也可以有一个参数，指定去掉开头结尾的这个参数。
去除空白和换行： s= " 你好 " s.strip() ------s="你好"
去除指定字符： s = ***你好***“ s.strip(" * ") -----s="你好"
这个也成立 name="alex1214" name.strip("a") -----name="lex1314"
6.拼接 ” “. join()方法，将一个列表拼接成一个字符串，给join()传一个参数时，以此参数来连接列表里的内容
将列表拼接成字符串：” “.join( ["I", "am", "world"] ) ---------"Iamworld"
传递以恶搞参数： ” * "“.join( ["I", "am", "world"] ) ---------"I*am*world"
7.find() 方法 从左像右找
s = " hello world " s.find(" l ") ------2 从左边起第一个“ l "索引位为2
rfind() 从右边起找
s = " hello world " s.rfind(" l ") ------9 从右边起第一个“ l "索引位为2
找不到会返回-1，Index找不到会报错
8.index（）方法 可以有2个参数
s.index(" 0 ") -----4
s.index("0",3) 从第三个索引值开始找 ------4
9.replace 替换
”hello world".replace("world", "python") ------"hello python "
10.format() 字符串格式化
（1）百分号通配符来格式化 %s 表示字符串 %d 整型 %f 浮点型 %4f 保留四位小数
" %s %d %f " % (a, b, c)
(2) format()
a. 按位来对应： ” hello {0}，his age is {1}".format("alex, 12)
hello alex,his age is 12.
b. 按变量来对应：” hello {name}，his age is {age}".format(name="alex, age=12)
hello alex,his age is 12.
a中("alex, 12)不可换位置，而b中(name="alex, age=12)可以换位置
11.center()，ljust(), rjust() 2个参数，一个是字符宽度，一个是填充的字符
"hello".center(20，“*”) -----“*******hello********"
"hello".ljust(20，“*”) -----“hello***************"
"hello".rjust(20，“*”) -----“***************hello"
12.判断是否为数字 返回真假
”12“.is decimal()
”12“.isdigital() 十进制数，一般用这个就可以了
"12".isnumeric() 罗马数字 汉子数字用这个
13.isalpha() 判断字符串是否都为字母，必须都是菜返回真
”hello“.isalpha() ------- True
14.变大写
” hello, world".capitalize() H变大写
” hello, world".title() H和W变大写
” hello, world".upper() 整个字符串都变大写
15.变小写
” HELLO WORLD".lower() 都变小写
” HelLO WorLD".swapcase() 大小写互换
” hello, world".casefold() 都变小写，罗马大写也变小写
16.扩展定义tab键
” hello 、 world".expandtabs(20) 将 4个空格键改为20个空格
--------” hello, world“
17.zfill() 以参数补充定义的宽度
” hello, world".zfill(20)
-----“00000000hello, world”
18.startswith() endswith() 判断是否以给定参数开头结束，返回真假
True” hello, world".startswith(" h ") -------True
” hello, world".endswith(" d ") ------- True
19.translate() 一种映射关系，来编译成对应的字符
a = "abedabc"
IN = " abcde"
OUT = "12345"
trans_table = str.maketrans(IN, OUT)
a.translate(trans_table) ----------1254123
（二）列表 LIST
list [] 像一个清单
定义：[ ]内可以有任意类型的值，用逗号隔开
作用：多个同一类型的数据的存放，多个同学，多个爱好，多件衣服
1.创建
a.l = [1,2,3] ----[1,2,3] 中括号中什么都可以放，包括嵌套
b. l = list([1,2,3]) -----[1,2,3] list后用软括号也可以 l = list((1,2,3)) -----[1,2,3]
2.查找
a. 切片的方法 [] 注意反向步长
l = [1,2,3,4,5,6] l[ : : -1] --------[6,5,4,3,2,1]
取后2个元素 l[ -2: ]
b. index
3.增加
insert() 2个参数，第几位插入什么元素 l.insert(2,"a")-----[1,2,"a",3,4,5,6]
append() 追加都列表的最后一位 只能添加一个 l.append(7)-------[1,2,3,4,5,6,7]
extned() 扩展列表 可以增加多个元素，多个元素放在一个列表里 l.extend([8,9])
-------[1,2,3,4,5,6,7,8,9]
4.删除
pop() 通过位置删除
l.pop() 默认输出最后一个 ------[1,2,3,4,5,6,7,8]
l.pop(2) 指定删除索引为2的元素 -------[1,2,4,5,6,7,8]
remove() 通过内容删除 给定的参数为内容
l.remove(8) ------[1,2,3,4,5,6,7]
del 可以删除元素 也可以删除整个列表
del l[3] 删除元素3
del l 删除整个列表
5.改 赋值操作
通过索引重新赋值来改： l[0] = 9 ------[9,1,2,3,4,5,6,7,8,]
6.clear() 清空列表里面的值
l.clear() -----[]
7.count() 统计某个元素的个数
a = [1,2,3,4,2,3,1,2] a.count(2) ------3
8.sort() 从小到大排序
a = [1,3,5,7,2,9] a.sort() ------[1,2,3,5,7,9]
函数sorted也可以排序 sorted(a) ------[1,2,3,5,7,9]
sort(reverse=True) 从大到小排序
a = [1,3,5,7,2,9] a.sort(reverse=True) ------[9，7，5，3，2，1]
9.reverse() 把列表倒过来 不排序
a = [1,3,5,7,2,9] a.reverse() ------[9，2，7，5，3，1]
10.enumarate() 函数 给列表自动加索引
a=[1,2,3,4]
for i in enumarate(a)
print(a) # 会给a前加一个索引
0 1
1 2
2 3
3 4
（三）字典 dict
Python中唯一具有映射关系的数据类型，一对一，一对多，字典的查询效率要高于字典，无序
定义：位于{}中的多个键值对，键与值对之间用冒号隔开key-value,注意key必须是不可变类型，value可以是任意类型可以嵌套
作用：用于有映射关系的场景
1.创建
d = { "name" : ” alex"，“age":12}
2.查询
（1）通过键来查 d["name"] ------"alex"
（2）使用get方法查 d.get("name") ------"alex"
推荐使用2方法，使用方法一当给出的键找不到时会报错，而方法2不会，会返回None，不报错
（3）用循环遍历 打印出每一对键值对
3.增加：赋值来增
d["age"]=12
4.修改 ：通过对键对应的值重新赋值来修改
d["age"]=21
5.删除
pop.(key) 删除所传的key的value
d = { "name" : ” alex"，“age":12} d.pop("name") -------print(d) {“age" : 12}
d.pop("name")有返回值 是它对应的value
popitem() 随机删除一个
del del d.["name"] 删除以"name”为键的键值对
del d 删除整个字典
6.update（） 更新字典 括号内传一个字典，会更新旧的字典，旧字典和括号内传的字典有共同的键时，这个键在新字典中对应的值为括号内传的字典的键的值
即所谓的更新覆盖
d2 = {1:"小明“，”name":"egon"}
d.updeate(d2) ------{"name":"egon","age":12,1:"小明“}
（四）集合 set
集合是可变数据类型，但集合内的元素必须是不可变数据类型
定义：位于{}中的多个元素，用逗号隔开，遵循三个原则：集合内每个元素都是不可变数据类型；没有重复的元素。务虚
作用：去重；关系测试
注意：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
1.创建：
（1）s={1，3，”hello"}
（2）s=set([1，3，”hello"]) ------s={1，3，”hello"}
2.去重：天然去重
l = [1,2,3,2]
print(set(l)) -----{1,2,3}
3.关系测试
s1 = {1,2,"hello"} s2 = {1,2,("a", "b")}
（1）求交集 Intersection()
s1.intersection(s2) 也可以写成 s1 and s2
（2）求并集 union()
s1.union(s2 ) 也可以写成 s1 | s2
（3）求差集 difference 我有的 你没有
s1.difference(s2) ------- {"hello",3}
s2.difference(s1) ------- {("a","b")}
（3）求对称差集 symmetric_difference 两者并集中除去共同拥有的
s1.symmetric_difference(s2) 也可以这样表示 s1 ^ s2
s1与s2互换位置结果一样
（五）元组 tuple
同列表用法，不能修改
t = （1，2，3）
t.count()
t.index()