Python: 数据类型、数字、字符串、列表、元组、字典、集合增删改查及切片
Python数据类型
1、Numbers（数字）：
1）整数（int）
通常被称为是整型或整数，可以是正整数或负整数，不带小数点。
> num2 = 1 > print(“num2–>”,num2,type(num2)) num2–> 1 <class ‘int’>
2）浮点数（float）
浮点型由整数部分与小数部分组成。
> num1 = 1.1 > print(“num1–>”,num1,type(num1)) num1–> 1.1 <class ‘float’>
3）布尔类型（bool）
布尔类型分为Ture和False
在Python3中True=1，False=0
> print(type(True)) True–> <class ‘bool’> > print(type(False)) False–> <class ‘bool’>
4）复数（complex）
复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
> aComplex = 1.56 + 1.2j > print(“aComplex–>”,type(aComplex)) aComplex–> <class ‘complex’>
5）String（字符串）：
字符串定义：
字符串可以用""或’'来定义
PS: 符号都是英文的符号
> str1 = ‘string_test1’ > print(type(str1)) <class ‘str’>
> str2 = “string_test2” > print(type(str2)) <class ‘str’>
比较字符串内容是否相同：
用"=="来比较两个字符串内的value值是否相同,返回值为布尔值
> print (“比较结果–>”,str1 == str2) 比较结果–> False #相同的话就返回True
is：比较两个字符串的id值。
print (“比较结果–>”,str1 is str2) 比较结果–> False #相同的话就返回True
比较字符串长度是否相等：
len():显示字符串的长度，返回数字整型然后进行长度的比较，返回值为布尔值。
> str1 = ‘string_test1’ > int1 = len(str1) > str2 = ‘string_test2’ > int2 =len(str2) > print(“比较结果–>”,int1 == int2) > 比较结果–> True #不相同的话就返回False
2、运算符、转义字符、占位符、内置函数
1）运算符：
常用的比较运算符:
>、<、> = 、< =、== 比较的规则为：从第一个字符开始比较，排序在前边的字母为小，当一个字符串全部字符和另一个字符串的前部分字符相同时，长度长的字符串为大。
常用的字符运算符：
+、*、[]、[:]、in、not in、r/R
+,字符串连接
> str3 = ‘love’ > str4 = ‘me’ > print(‘输出结果–>’,str3+str4) 输出结果–> loveme
*,重复输出字符串
> print(‘输出结果–>’,str3*3) 输出结果–> lovelovelove
[]，通过索引获取字符串中的字符
> print(‘输出结果–>’,str3[0]) 输出结果–> l #默认是从0开始起始
[:],截取字符串
> print(‘输出结果–>’,str3[2:]) 输出结果–> ve #截前不截后,[2:9:2]这个的意思是取某个字符串的第二个到第九个，步长为2（间隔2个）
> str4 = ‘123456789’ > print(‘输出结果–>’,str4[2:8:2]) 输出结果–> 357
in，成员运算符，检索字符串中是否包含给定的字符串，返回值为布尔值
> str3 = ‘love’ > result= “l” in str3 > print(‘比较结果–>’,result) 比较结果–> True
not in，成员运算符，检索字符串中是否包含给定的字符串，返回值为布尔值
> result= “l” not in str3 > print(‘比较结果–>’,result) 比较结果–> False
r和R，非转义原生字符，简单来说就是写啥打印出啥
> print(‘输出结果–>’,r’eric\n你好啊！’) 输出结果–> eric\n你好啊！
> print(‘输出结果–>’,R’eric\n你好啊！’) 输出结果–> eric\n你好啊！
2）转义字符：
| 转义字符 | 描述 |
|---|---|
| \（在行尾时） | 续行符 |
| \\ | 反斜杠符号(\) |
| \’ | 单引号(’) |
| \" | 双引号(") |
| \a | 响铃 (会发出滴的一声) |
| \b | 退格（删除\b前第一个字符串） |
| \e | 转义 |
| \000 | 空(代表空) |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符（TAB） |
| \r | 回车(取\r后的字符串) |
| \f | 换页 |
| \oyy | 八进制，yy代表的字符，例如: \o12 代表换行 |
| \xyy | 十六进制，yy代表的字符，例如: \ox0a 代表换行 |
| other | 其他的字符以普通格式输出 |
3）占位符：
在输出里占位的符号
| 占位符 | 转换 |
|---|---|
| %c | 字符 |
| %s | 通过str()字符串来格式化 |
| %i | 有符号十进制整数 |
| %d | 有符号十进制整数 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（大小写字母） |
| %X | 十六进制整数（大小写字母） |
| %e | 索引符号（小写“e”） |
| %E | 索引符号（大写“E”） |
| %f | 浮点实数 |
| %g | %f和%e的简写 |
| %G | %f和%E的简写 |
4）内置函数：
| 内置函数 | 描述 |
|---|---|
| string.capitalize() | 将字符串的第一个字符转换为大写 |
| string.center(width、fillchar) | 返回一个指定长度的宽度width居中的字符串，fillchar为填充的字符，默认为空格 |
| string.count(str) | 返回str在string里面出现的次数 |
| string.dencode(‘utf-8’) | 把str里面的内容编码 |
| string.decode(‘utf-8’) | 把str里面的内容解码 |
| string.isdigit() | 判断是否为数字 |
| string.isalpha() | 判断是否为字母 |
| string.lstrip() | 去除string左侧的空格 |
| string.rstrip() | 去除string右侧的空格 |
| string.strip() | 去除字符串前后的空格 |
| srting.splist() | 分割字符串并写入列表中 |
| ''.join(list) | 拼接list里面的元素 |
| string.lower() | 转换字符串中所有大写的为小写 |
| string.upper() | 转换字符串所有为大写 |
| string.title() | 转换字符串中所有第一个字符串为大写 |
| string.max(str) | 返回str中最大的字母 |
| string.min(str) | 返回str中最小的字母 |
| string.isupper() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是大写，返回值为True，否则False |
| string.islower | 如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是小写，返回值为True，否则False |
| string.istitle | 如果字符串是标题化则返回True，否则False |
| string.isnumeric | 如果字符串中全是数字字符，返回True，否则False |
| string.rfind | 从右侧检索（倒叙）想要查的字符串或者字符，并打印其位置数字，如果未查到返回-1 |
| string.find | 可以正序（左侧）查找到想要查到的字符串或者字符，并打印其位置数字，如果未查到返回-1 |
| string.replace | replace(old,new,[max]) max代表替换几次 |
| len(string) | 统计string的长度 |
3、List（列表）：
1）创建列表
list = [] #空列表
list = [“value”,154,‘a’] #列表中的内容可以是不同类型的
2）更新列表
列表是可以变更的类型
list = [“aaa”,“bbb”,111,222]
list[1] = “ccc” #将列表的第二个元素更改为"ccc"
3）查看列表内的指定元素
list[1] #查看列表的第二个元素
list[-1] #查看列表的倒数第一个元素
4）删除列表的元素
del list[1] #删除列表第二个元素
5）列表脚本操作符
列表对+ 和*的操作符与字符串相似。+号用于组合列表，*号用于重复列表。
如下表：
| Python表达式 | 结果 | 描述 |
|---|---|---|
| len([1,2,3]) | 3 | 长度 |
| [1,2,3]+[4,5,6] | [1,2,3,4,5,6] | 组合 |
| [“Python”]*4 | [‘Python’, ‘Python’, ‘Python’, ‘Python’] | 重复 |
| 3 in [1,2,3] | True | 判断元素是否存在于列表 |
| for i in [1,2,3]:print(i,end=’ ') | 1 2 3 | 迭代 |
列表切片截取：
> list1 = [1,2,3,4] > print(list1[1:4]) [2,3,4]
列表的拼接：
> list1 = [1,2,3,4] > print(list1 + [“a”,“b”,“c”]) [1, 2, 3, 4, ‘a’, ‘b’, ‘c’]
列表在末尾添加对象：
> list1 = [1,2,3,4] > list1.append(“aa”) > print(list1) [1, 2, 3, 4, ‘aa’]
统计某个str，在列表出现的次数：
> list1 = [1,2,3,3] > print(list1.count(3)) 2
向列表添加另外一个列表的内容：
> list1 = [1,2,3,3] > list2 = [‘a’,‘b’] > list1.extend(list2) > print(list1) [1, 2, 3, 3, ‘a’, ‘b’]
检索列表里指定的值的第一次匹配到的索引位置：
> list2 = [‘a’,‘b’] > print(“第一个匹配b的位置为：”,list2.index(“b”)) 第一个匹配b的位置为： 1
在列表指定位置插入对象：
> list2 = [‘a’,‘b’] > list2.insert(0,“w”) > print(list2) [‘w’, ‘a’, ‘b’]
移除列表中指定元素索引位置的对象：
#移除list2中的b > list2 = [‘a’,‘b’,‘c’] > list2.pop(1) > print(list2) [‘a’, ‘c’]
移除列表中指定元素第一个匹配到的对象：
#移除list2中的第一个a > list2 = [‘a’,‘b’,‘c’,‘a’] > list2.remove(‘a’) > print(list2) [‘b’, ‘c’, ‘a’]
反向排序列表的对象：
> list2 = [‘a’,‘b’,‘c’] > list2.reverse() > print(list2) [‘c’, ‘b’, ‘a’]
自定义列表输出降序还是升序：
#自定义列表对象降序输出 > list2 = [‘a’,‘d’,‘c’] > list2.sort(reverse=True) > print(list2) [‘d’, ‘c’, ‘a’]
#自定义列表对象升序输出 > list1 = [1,2,3,3] list2 = [‘a’,‘d’,‘c’] > list2.sort(reverse=False) > print(list2) [‘a’, ‘c’, ‘d’]
清空列表对象：
> list2 = [‘a’,‘d’,‘c’] > list2.clear() > print(“list2–>”,list2) list2–> []
复制列表对象：
> list2 = [‘a’,‘d’,‘c’] > list3 = list2.copy() > print(“list3:”,list3,“list2:”,list2) list3: [‘a’, ‘d’, ‘c’] list2:[‘a’, ‘d’, ‘c’]
4、Tuple（元组）：
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号来表示。
1）创建元组
创建空的元组：
> tup = （）#创建空元组 > print(“tup的内容：”,tup) tup的内容： ()
创建一个元组：
> tup1 = (‘aa’,‘bb’,‘cc’) > print(“tup1内容：”,tup1) tup1内容： (‘aa’, ‘bb’, ‘cc’)
注意：
> tup1 = (‘aa’,) #创建只有单个元素的元组的时候需要加个逗号,不然创建的是str > print(“tup1的类型为：”,type(tup1),“tup1的内容为：”,tup1) tup1的类型为： <class ‘tuple’> tup1的内容为： (‘aa’,)
2）查看元组
元组也可以用下表索引来查看元组中的值，和字符串、列表一样：
> tup1 = (‘aa’,‘bb’,‘cc’) > print(tup1[0]) tup1[0]的值： aa > print(tup1[0:3:1]) tup1[0:3:1]的值： (‘aa’, ‘bb’, ‘cc’)
3）修改元组
元组的元素值是不允许修改的，但是却可以进行连接组合。
> tup2 = (‘aa’,‘bb’,‘cc’) tup3 = (‘11’,‘22’) > print(‘合并结果为：’,tup2 + tup3) 合并结果为： (‘aa’, ‘bb’, ‘cc’, ‘11’, ‘22’) tup2 [0] = “c” #元组不允许修改元素内的值，这样操作会报错
4）删除元组
元组中的元素值是不允许删除的，但是可以用del来删除整个元组
> tup5 = (“aaa”,) > del tup5 print(tup) #这个时候会报错，因为tup被del删除了，不只是删除tup内的值，而是删除元组本身
5）元组运算符
与字符串一样，元组之间可以使用+号和*号进行运算。
6）元组内置函数
| 方法及描述 | 实例 |
|---|---|
| len(tuple) 计算元组中元素个数 | tup = (‘aa’,‘bb’) len(tup) #2 |
| max(tuple) 返回元组中最大的元素 | tup = (‘aa’,‘bb’) max(tup) #bb |
| min(tuple) 返回元组中最小的元素 | tup = (‘aa’,‘bb’) min(tup) #aa |
| tuple(list) 将列表转换为元组 | list=[‘11’,‘22’ tup=tuple(list)] |
5、Sets（集合）：
Python set是基本数据类型的一种集合类型，它有可变集合（set()）和不可变集合（frozenset）两种。集合是一个无序的，不重复的数据组合，主要作用为：去重（把一个列表变成集合，就自动去重了），测试两组数据的交集、差集、并集等。set里面可以是多种数据类型（但不能是列表，集合，字典，可以是元组）。
1）创建集合set
使用大括号或者set（）来创建集合。如果想要创建空集合，必须使用set()来创建。
空集合：
> set2 = set() > print(“set2的内容：”,set2,“set2的类型为：”,type(set2)) set2的内容： set() set2的类型为： <class ‘set’>
创建个集合：
> set1 = {‘aa’,‘cc’,‘bb’} > print(“set1的类型为：”,type(set1),“set1的内容：”,set1) set1的类型为： <class ‘set’> set1的内容： {‘bb’, ‘aa’, ‘cc’}
2）为集合添加元素
set1.add(“dd”)#在集合后边添加"dd"，如果添加的元素是重复的，则不会进行操作
> set1 = {‘aa’,‘cc’,‘bb’} > set1.add(‘dd’) > print(“set1的内容：”,set1) set1的内容： {‘dd’, ‘aa’, ‘cc’, ‘bb’}
3）更新集合
s.update(x) #x可以是列表，元组，字典等，x可以有多个，用逗号分开。但是x不能是单独的数字(添加多个数字字符或者字符串)
> listing = [‘ab’,12] > set3 = {1,“a”} > set3.update(listing) > print(“set3内容：”,set3,“set3类型：”,type(set3)) set3内容： {1, 12, ‘a’, ‘ab’} set3类型： <class ‘set’>
set2.update(1)#会被报错
set2.update(“sss”)#只会添加一个"s"
> set2.update(‘sss’) > print(“set2内容为：”,set2) set2内容为： {‘s’}
4）删除元素
seting.discard(“ab”)#删除s中的"ab"元素，如果"ab”不存在，不会进行操作，不报错。
> seting = {‘ab’,‘bc’,12} > seting.discard(‘ab’) > print(“seting的内容为：”,seting) seting的内容为： {‘bc’, 12}
seting.remove(“12”)#移除s中的"12"元素，如果“12“不存在，会报错。
> seting = {‘ab’,‘bc’,12} > seting.remove(12) > print(“seting的内容为：”,seting) seting的内容为： {‘ab’, ‘bc’}
seting.pop()#随机删除并返回集合seting中某个值，因为set是无序的，所以pop删除的只是随机的一个元素。
> seting = {‘ab’,‘bc’,12} > seting.pop() > print(“seting的内容为：”,seting) #随机删除一个元素
seting.clear（）#清空s中的所有元素
> seting = {‘ab’,‘bc’,12} > seting.clear() > print(“seting的内容为：”,seting) seting的内容为： set()
5）集合内置函数和实例
| 方法及描述 | 实例 |
|---|---|
| x in s | s={‘a’,‘b’} x=‘b’ print(x in s) #结果返回True |
| union() | c = s.union(x) #c的结果为s和x的并集,不改变s, x可以是列表,元组,字典 |
| intersection() | c = s.intersection(x) #c的结果为s和x的交集,不改变s, x可以是列表,元组,字典 |
| difference() | c = s.difference #c的值=集合s中而不再集合x中的元素的集合，不改变集合s，x也可以是列表，元组和字典 |
| symmetric_difference() | c = s.symmetric_difference() #c的值=s和集合x的对称差集，即只在其中一个集合中出现的元素，不改变集合s |
| issubset() | c = s.issubset(x) #判断集合s是否是集合x的子集,返回值为布尔值 |
| issuperset() | c = s.issuperset(x) #判断集合x是否是集合s的子集,返回值为布尔值 |
| isdisjoint() | c = s.isdisjoint(x) # 判断s和s1是否完全没有任何交集,返回值为布尔值 |
6）集合运算符：
s1 & s2 #求两个集合的交集 s1 | s2 #求两个集合的并集 s1 - s2 #求s1减去s2的差集 s1 ^ s2 #求两个集合的对称差集（对称差值：不包含同时存在两个集合的值）
6、Dictionaries（字典）：
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值（key=>value）对用冒号（：）分割，每个对之间用逗号（，）分割，整个字典包括在花括号中：
1）创建字典：
键必须是唯一的，但值则不必，值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
格式：dic = {key：value，key1：value1}
> dic = {“name”:“eric”,“pass”:123} > print(“dic的类型为：”,type(dic),“dic的内容为：”,dic) dic的类型为:<class ‘dict’> dic的内容为： {‘name’: ‘eric’, ‘pass’: 123}
2）访问字典里面的值：
根据键来查看值：
> dic = {“name”:“eric”,“pass”:123} > print(“name这个键对应的值为：”,dic[‘name’]) name这个键对应的值为： eric
3）更新字典：
1）根据键修改值：
> dic = {“name”:“eric”,“pass”:123} > dic[“name”] = “lucky” > print(“修改后的值为：”,dic) 修改后的值为： {‘name’: ‘lucky’, ‘pass’: 123}
2)添加新的元素（键值对）
> dic = {“name”:“eric”,“pass”:123} > dic[“age”] = 23 print(“添加后的值为：”,dic) 添加后的值为： {‘name’: ‘lucky’, ‘pass’: 123, ‘age’: 23}
4）删除字典元素：
1）删除指定的键
> dic = {“name”:“eric”,“pass”:123} > del dic[“pass”] > print(“删除后的值为：”,dic) 删除后的值为： {‘name’: ‘eric’}
2）删除所有的元素
> dic = {“name”:“eric”,“pass”:123} > dic.clear() > print(“clear后的值：”,dic) clear后的值： {}
3）删除字典
> dic = {“name”:“eric”,“pass”:123} > del dic NameError: name ‘dic’ is not defined
5、字典键的特性
字典值可以是任何的Python对象，既可以是标准的对象，也可以是用户定义的，但是键不行。
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住：
> dict = {‘age’:10,‘name’:“wang”,‘age’:18} > print(dict) {‘age’: 18,‘name’: ‘wang’}
2）键必须不可变，可以用数字、字符串或者元组，可变类型不能作为键，比如列表。
6、字典内置函数和方法
Python字典包含了以下内置函数：
| 函数 | 描述 |
|---|---|
| len(dict) | 计算字典元素个数，即键的个数 |
| str(dict) | 输出字典，可以打印成字符串格式 |
| clear() | 删除字典内所有元素 |
| c = dic.copy() | 返回一个字典的浅复制 |
| formkeys() | 创建一个新的字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| values() | 以列表返回字典中的所有值 |
| keys() | 以列表返回字典中的所有键 |
| pop(key[,default]) | 删除字典指定键key所对应的值，返回值为被删除的值。key值必须给出，否则，返回default |
| popitem() | 随机删除字典中的一对键和值(一般删除末尾对)。 |
| items() | 以列表返回可遍历的(键，值）元组数组 |
| key in dict | 如果键在字典dict里返回True,否则返回False |
| get(key) | 返回指定键的值，如果值不在字典中返回default值 (默认为none) |
注意：
fromkeys 方法只用来创建新字典，不负责保存。如果想要保存要把它赋值给其他的变量
> seq = (‘Google’, ‘Runoob’, ‘Taobao’) > dict = dict.fromkeys(seq) > print(“新字典为 : %s” % str(dict)) 新字典为 : {‘Google’: None, ‘Runoob’: None,‘Taobao’: None} dict = dict.fromkeys(seq, 10) > print (“新字典为 : %s” % str(dict)) 新字典为 : {‘Google’: 10, ‘Runoob’: 10, ‘Taobao’: 10}
pop()
> dic = {‘age’:10,‘name’:“wang”} > print(dic.pop(‘age’)) 删除的值为： 10 > print(dic) dic字典的内容还有： {‘name’: ‘wang’}
popitem()
> dic = {‘age’:10,‘name’:“wang”} > print(“删除的值为：”,dic.popitem()) 删除的值为：(‘name’, ‘wang’) > print(“dic字典的内容还有：”,dic) dic字典的内容还有： {‘age’: 10}
get()
> dic = {‘age’:10,‘name’:“wang”} print(“检索的结果为：”,dic.get(“a”)) “检索的结果为：”,None print(“检索的结果为：”,dic.get(“age”)) " 检索的结果为：",10
