Python的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Set（集合）

Numbers（数字）

数字类型分为：整数，浮点数，复数

运算：

+ - * / 加减乘除 ** 平方

String（字符串）

　　字符串就是一系列字符，在Python中，用引号括起来的都是字符串，其中的引号可以使单引号，也可以是双引号。

 1. 创建字符串

"This is a string."'This is also a string.'

2.基本操作方法

#重复输出字符串print('hello'*2)#切片，通过索引获取字符串中字符print('helloworld'[2:])#成员运算符，返回True或Falseprint('el' in 'hello')#格式字符串name = 'Hans'print('Hi,%s'%a)#字符串拼接，+号可以直接拼接（低效）a='123'b='abc'string=''.join([a,b])print(string)# 删除空白：string.rstrip()       #删除字符串末尾的空格string.lstrip()       #删除字符串开头的空格string.strip()        #删除字符串两端的空格

3.大小写操作

# 字符串大小写相关操作string.capitalize()         #把字符串的第一个字符大写string.title()              #所有单词首字母转换为大写string.swapcase()           #转换 string 中的大小写string.lower()              #转换 string 中的大写字符为小写string.upper()              #转换 string 中的小写字符为大写

4.字符串判断

string.isdigit()                                  #检测字符串是否只由数字组成string.isalpha()                                  #检测字符串是否只由字母组成string.isspace()                                  #检测字符串是否只由空格组成string.isalnum()                                  #检测字符串是否由字母和数字组成string.islower()                                  #检测字符串是否由小写字母组成string.isupper()                                  #检测字符串是否由大写字母组成string.isnumeric()                                #检测字符串是否只由数字组成,针对unicode对象string.isdecimal()                                #检查字符串是否只包含十进制字符,针对unicode对象string.istitle()                                  #检测字符串中所有的单词拼写首字母是否为大写string.endswith(obj, beg=0, end=len(string))      #判断字符串是否以指定后缀结尾string.startswith(obj, beg=0,end=len(string))     #检查字符串是否是以指定子字符串开头

# string.center(width)                                 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串# string.count(str, beg=0, end=len(string))            返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数# string.decode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'# string.encode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'# string.expandtabs(tabsize=8)                         把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。# string.find(str, beg=0, end=len(string))             检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1# string.index(str, beg=0, end=len(string))            跟find()方法一样，只不过如果str不在 string中会报一个异常.# string.join(seq)                                     以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串# string.ljust(width)                                  返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串# string.maketrans(intab, outtab])                     maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。# max(str)                                             返回字符串 str 中最大的字母。# min(str)                                             返回字符串 str 中最小的字母。# string.partition(str)                                有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.# string.replace(str1, str2,  num=string.count(str1))  把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.# string.rfind(str, beg=0,end=len(string) )            类似于 find()函数，不过是从右边开始查找.# string.rindex( str, beg=0,end=len(string))           类似于 index()，不过是从右边开始.# string.rjust(width)                                  返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串# string.rpartition(str)                               类似于 partition()函数,不过是从右边开始查找.# string.split(str="", num=string.count(str))          以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串# string.splitlines(num=string.count('\n'))            按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.# string.translate(str, del="")                        根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

5.同行显示

print ("Hello World!",end = "")print ("Hello World!",end = "")# end 控制段落最后# windows默认为 \r\n，Linux默认为 \n，mac默认为 \r

6.字符串拼接

name = 'Hans'age = '27'# 逗号拼接print ('my name is',name,'and I am',age,'years old')# 加号拼接print ('my name is'+name+'and I am'+age+'years old')# 占位符拼接（推荐使用）print ('my name is %s and I am %s years old'%(name,age))

List（列表）

列表的常用操作：增、删、改、查

1.创建列表

name = ['Hans','Jack','Tony','Peter']name1 = list(['Hans','Jack','Tony','Peter'])

2.增加

name = ['Hans','Jack','Tony','Peter']name.append('Joe')      #在列表末尾添加元素 ['Hans', 'Jack', 'Tony', 'Peter', 'Joe']name.insert(0, 'Ben')   #在列表中插入元素 ['Ben', 'Hans', 'Jack', 'Tony', 'Peter']

　　append()方法可以动态地创建列表，例如，创建一个空列表，在使用该方法添加元素

3.删除

name = ['Hans','Jack','Tony','Peter']name.remove('Hans') 　　#不知道索引，知道元素值时使用 ['Jack', 'Tony', 'Peter']n = name.pop(1)     　　#如果不加索引值，删除列表最后一个元素 ['Hans', 'Tony', 'Peter']print(n)            　　#删除的元素可以储存在变量以便继续使用 Jackdel name[2]         　　#通过元素在列表中的位置删除 ['Hans', 'Jack', 'Peter']name.clear()        　　#清空列表 []

　　remove()方法只删除第一个指定的元素，如果要删除的元素在列表中重复，则需要使用循环

4.修改

name = ['Hans','Jack','Tony','Peter']name[1] = 'Joe'             #对指定元素进行修改 ['Hans','Joe','Tony','Peter']name[1:3] = ['Joe', 'Ben']  #同时修改两个元素 ['Hans', 'Joe', 'Ben', 'Peter']

5.查询

name = ['Hans','Jack','Tony','Peter']name[1]         #取第二个元素 Jackname[1:]        #取到最后一个元素 ['Jack','Tony','Peter']name[1:-1]      #取到倒数第二个元素 ['Jack','Tony']name[0:-1:2]    #最后的2为步长,从左到右隔一个去取 ['Hans','Tony']name[3::-2]     #第4个元素开始从右到左隔一个去取 ['Peter', 'Jack']

6.其他操作

6.1 sort() 对列表进行永久性排序

letter = ['c','a','d','b']letter.sort()               #对列表进行永久性排序 ['a', 'b', 'c', 'd']letter.sort(reverse=True)   #反向排序 ['d', 'c', 'b', 'a']

6.2 sorted() 对列表进行临时性排序

letter = ['c','a','d','b']print(sorted(letter))               #对列表进行临时性排序 ['a', 'b', 'c', 'd']print(sorted(letter,reverse=True))  #临时性反向排序 ['d', 'c', 'b', 'a']print(letter)                       #['c', 'a', 'd', 'b']

6.3 reverse() 反转列表元素的排列顺序

letter = ['c','a','d','b']letter.reverse()　　　　#['b', 'd', 'a', 'c']

6.4 更多方法

count      #统计某个元素在列表中出现的次数：extend     #可以在列表的末尾一次性追加另一个序列中的多个值index      #方法用于从列表中找出某个值第一个匹配项的索引位置

Tuple（元组）

　　元组被称为只读列表，即数据可以被查询，但不能被修改，所以，列表的切片操作同样适用于元组，元组写在小括号()里，元素之间用逗号隔开，虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

　　构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组tup2 = (20,) # 一个元素，需要在元素后添加逗号

作用：

　　1.对于一些数据我们不想被修改，可以使用元组；

　　2.另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在。 

Dictionary（字典）

描述

　　字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。

　　特点：

　　　　　　1.无序

　　　　　　2.键唯一

1.创建字典

dic = {'name':'alex'}dic1 = dict((('name','alex'),))

2.增加

# 方法一dic1 = {'name':'alex'}dic1['age'] = 18 #通过赋值方式增加print(dic1)# 方法二dic1.setdefault('age',34) #键存在，不改动print(dic1)#键存在，不改动，返回字典中相应的键对应的值ret = dic1.setdefault('age',34) print(ret) #返回值为18#键不存在，在字典中增加新的键值对，并返回相对应的值ret1 = dic1.setdefault('hobby','girl') print(ret1) # 返回值为'girl'

3.删除

dic5 = {'name': 'alex', 'age': 18}#方法一：del dic5['name']    #del方法：删除键值对print(dic5)#方法二：dic5.clear()    #.clear方法：将字典内容清空print(dic5)#方法三：res = dic5.pop('age')   #pop方法：根据Key删除键值对print(dic5)print(res)  #返回值：返回删除的键值对#方法四：a = dic5.popitem()  #随机删除某组键值对，并以元组方式返回print(a,dic5)

4.修改

dic3 = {'name':'alex','age':18,'hobby':'girl'}dic3['age'] = 55print(dic3)#将dic4字典中的键值对更新到dic3中，如果键值重复，则覆盖dic3 = {'name': 'alex', 'age': 18}dic4 = {'sex': 'male', 'hobby': 'girl', 'age': 36}dic3.update(dic4)print(dic3)

5.查询

dic3 = {'name':'alex','age':18,'hobby':'girl'}dic3['name'] #通过键查找值list(dic3.keys()) #查找字典中所有的键list(dic3.values()) #查找字典中所有的值list(dic3.items()) #查找字典中所有的键值对

6.其他操作

　　6.1 dict.fromkeys

d1=dict.fromkeys(['host1','host2','host3'],'Mac')print(d1) d1['host1']='xiaomi'print(d1)#######d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])print(d2)d2['host1'][0]='xiaomi'print(d2)

　　6.2 d.copy() 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典

　　6.3 字典的嵌套

　　6.4 sorted(dict) : 返回一个有序的包含字典所有key的列表

dic={5:'555',2:'222',4:'444'}print(sorted(dic))          #对键排序并返回print(sorted(dic.values())) #对值排序并返回print(sorted(dic.items()))  #对键值对排序并返回

　　6.5 字典的遍历

dic5={'name': 'alex', 'age': 18} for i in dic5:    print(i,dic5[i]) for items in dic5.items():    print(items)for keys,values in dic5.items():    print(keys,values)

Set（集合）

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

s = set([3,5,9,10])      #创建一个数值集合    t = set("Hello")         #创建一个唯一字符的集合  a = t | s          # t 和 s的并集    b = t & s          # t 和 s的交集    c = t – s          # 求差集（项在t中，但不在s中）    d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）         基本操作：    t.add('x')            # 添加一项    s.update([10,37,42])  # 在s中添加多项         使用remove()可以删除一项：    t.remove('H')      len(s)  set 的长度    x in s  测试 x 是否是 s 的成员    x not in s  测试 x 是否不是 s 的成员    s.issubset(t)  s <= t  测试是否 s 中的每一个元素都在 t 中    s.issuperset(t)  s >= t  测试是否 t 中的每一个元素都在 s 中    s.union(t)  s | t  返回一个新的 set 包含 s 和 t 中的每一个元素    s.intersection(t)  s & t  返回一个新的 set 包含 s 和 t 中的公共元素    s.difference(t)  s - t  返回一个新的 set 包含 s 中有但是 t 中没有的元素    s.symmetric_difference(t)  s ^ t  返回一个新的 set 包含 s 和 t 中不重复的元素    s.copy()  返回 set “s”的一个浅复制