每天一点动力——python基础（一）

前言

    记录一下复习python的过程，有不对的地方欢迎在评论区批评指正，感谢！！

一、python3和python2部分区别

注：这里这是列出python2和python3的部分区别，更多区别等研究过后再加进来。

1.print函数

    在python3中，print语句没有了，取而代之的是print（）函数

# 以下三种方法是等价的
# python2
print "hello world!"
# python3
print ("hello world!")	# print后有空格
print("hello world!")	# print后没有空格

2.Unicode编码

    字符串编码问题一直是字符串操作中的一个大问题，尤其是在读写文件的时候（我的研究方向是KBQA，经常会遇到字符串编码问题），稍有不慎，程序就会报错，所以在这里把字符串编码问题记录一下（可能会有错误或遗漏，还是欢迎各位批评指正）。

这一部分还没有完全摸透，先把菜鸟教程上写的拿过来。

     Python 2 有 ASCII str() 类型，unicode() 是单独的，不是 byte 类型。
现在， 在 Python 3，我们最终有了 Unicode (utf-8) 字符串，以及一个字节类：byte 和 bytearrays。由于 Python3.X 源码文件默认使用utf-8编码，这就使得以下代码是合法的：

>>> 中国 = 'china' 
>>>print(中国) 
china

# python2
>>> str = "我爱北京天安门"
>>> str
'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8'
>>> str = u"我爱北京天安门"
>>> str
u'\u6211\u7231\u5317\u4eac\u5929\u5b89\u95e8'

# python3
>>> str = "我爱北京天安门"
>>> str
'我爱北京天安门'

3.除法运算

    python中的除法有两个运算符：/ 和 //。
    “/” 除法
    python2中，“/”，整数相除的结果是一个整数，把小数部分完全忽略掉；浮点数除法会保留小数部分得到一个浮点数的结果；
    python3中，“/”，整数之间的除法也是一个浮点数。

# python2
>>> 1 / 2
0
>>> 1.0 / 2.0
0.5

# python3
>>> 1/2
0.5
>>> 1.0/2.0
0.5

    “//” 除法
    这种除法叫做floor除法，会对除法的结果自动进行一个floor操作，在python2和python3中是一致的。

# python2、python3
>>> 1 // 2
0
>>> 1.0 // 2.0
0.0
>>> -1 // 2
-1

注意：这里并不是直接舍弃小数部分，而是做了一个floor操作，即向下取整，如果想只截取整数部分，就用math模块中的trunc()函数

# python3
>>> import math
>>> math.trunc(0.2546)
0
>>> math.trunc(-12.2546)
-12
>>> math.trunc(-1/2)
0
>>> math.trunc(-1//2)
-1

4.异常处理

    在python2时代，异常除了表示程序错误，还经常做一些普通控制结构应该做的事情，而在python3中，只有在发生错误的情况下，才能用异常捕获语句来处理来处理。

# 一个简单的异常处理
# python3
>>> try:
>>>    a = 10 / 0
>>>    print(a)
>>>except Exception as e:
>>>    print(e)
division by zero

    python2中捕获异常语法为：

except Exc,val

    而在python3中为：

except Exc as val

5.range()的区别

    python2中的range()返回的是一个列表，而python3中的range()返回的是一个迭代值，

# python2
>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

# python3
>>> range(1,10)
range(1, 10)
# 在python3中，range(1,10)是一个迭代器，用list()将其作用为一个列表
>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

6.八进制表示

直接看代码：

# python2
>>> 0o1000
512
>>> 01000
512

# python3中只有一种写法
>>> 0o1000		#(只有这一种写法)
512
>>> 01000
File "<ipython-input-9-449c15942124>", line 1
    01000
        ^
SyntaxError: invalid token

7.不等运算符

• python2中不等运算符两种写法：!=，<>
• python3中不等运算符一种写法：!=

8.其他区别

    由于我平时使用的都是python3，基本没接触过python2，以上这些都是从菜鸟教程学来的，python2.x和3.x的区别就先记录到这，后续遇见了会继续更新。

接下来的记录都以python3.x为主，我的python版本是3.7.4

二、基本数据类型

    相对于其他编程语言，python的变量不需要声明（不需要类似于int a之类的），每个变量在使用前必须赋值，变量赋值后变量才会被创建。变量赋值包括单个变量赋值和多个变量赋值：

# 单个变量赋值
a = 3
str_1 = "hello"
list_1 = []
……

# 多个变量赋值
a = b = c = 1	# 创建一个整型对象，值为1，然后从后往前以此赋值给c、b、a，三个变量赋同一个值
a,b,c = 1,2,3	# 将整型对象1,2,3分别赋值给a,b,c

# 其他诸如字符串、列表等赋值也是一样的

    python中有6个标准的基本数据类型，分别为：

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

第一遍学习python的时候，并没有特别在意这六个基本的数据类型（本人本科是数学专业，研究生才考的计算机，属于半路出家），觉得这些基本数据类型的使用方法在使用的时候直接查百度就行，但是在两年左右的学习NLP的过程中，发现频繁的查百度并不是一个长久之计，因为在此过程中，频繁的用到这六个标准的基本数据类型以及他们的使用方法，基本每个程序里都会遇到，所以在这里将这六类基本数据类型以及它们常用的使用方法记录下来，一方面是做一个整理，另一方面也是为了巩固一下自己的知识库。

1.数字

    python中的数字数据类型用于存储数值，数据类型是不允许改变的，如果改变数字数据类型的值，将重新分配内存空间。python支持三种不同的数值类型：

• 整型（int）：python中的整型是没有限制大小的，意思就是python中的整型不存在长整型、短整型之分（python2中有Long类型，而python3中没有大小限制）；
• 浮点型（float）：浮点型可以使用科学计数法表示，例2.5e2=2.5*10^^2=250
• 复数（complex）：复数中需要注意的是实部a和虚部b都是浮点型（a+bi或者complex(a,b)表示复数）

注：我在使用的过程中，整型和浮点型经常用到，而复数类型几乎没有涉及到。

    整数的四种表现形式：

• 二进制：以“0b”或“0B”开头；0b101、0B101
• 八进制：以“0o”或“0O”开头；0o1000、0O1000
• 十进制：正常显示；
• 十六进制：以“0x”或“0X”开头；0x1000、0X1000
• 0x1000或0X1000（同理：第二个是字符x，可以小写也可以大写）

注：在八进制和十六进制的表示中，python3必须要把第二个字符（o或x）写上，如果不写就会报错，而python2中八进制表示也可以去掉字符o。

    各进制之间的相互转换：

• bin（i）：将i转换为2进制，以“0b”开头。
• oct（i）：将i转换为8进制，以“0o”开头。
• int（i）：将i转换为10进制，正常显示。
• hex（i）：将i转换为16进制，以“0x”开头

1.1 数字类型的转化

    在操作数字类型时，经常会碰到数字类型的转化，如将float转化为int等，转化规则很简单：

• int(x) 将x转换为一个整数。

• float(x) 将x转换到一个浮点数。

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

注：我在使用过程中涉及较多的就是int和float之间的转换，还有str和int之间的转换，复数的转换很少涉及，所以暂时不知道复数的转换具体可以用在哪。

1.2 数字运算

    数字的运算无非就是加减乘除四则运算加上指数、对数等操作，具体的做法可以参考菜鸟教程-python3数字，在这里我就不一一介绍了，因为这个帖子是作为一个复习整理的帖子，主要是为了把平时容易忽略的、容易搞混的知识记下来，方便自己学习整理。
    在这里主要写以下几点：

• python中的除法运算。
      除法运算在第一节中的第三小节已经介绍过了，所以就不再记录，需要注意的是在使用过程中，一定要确认自己在除法运算中要的结果，到底是直接取整数部分还是向下取整还是要一个浮点数，然后选择合适的方法计算。（四则运算中，加减乘都是固定的，除法在python中需要重点关注一下。）
• 赋值“=”和等于“= =”
      注意：“=”在python中是赋值的意思，“==” 才是数学中的等于操作。

>>> a = 1		# 赋值
>>> b = 2		# 赋值
>>> c = a + b	# 赋值
>>> c == 3		# 等于
True

• 不同类型的数字运算时，会将整数转化为浮点数
      这一点需要重点注意一下（这个知识点至少我非常容易混淆，有时候不注意就会把结果计算错，尤其是在神经网络的前向计算中，经常会出现最终结果和自己预想的有一点差别），不同类型的数混合运算后人为运算的结果是整数时，python计算出的是浮点数，例如：

>>> 3*7/3.5
6.0

• 幂运算
      幂运算“**”：

>>> 3 ** 2
9

    不过我一般用的较多的是exp()函数，经常会在数据归一化前做一步exp()。

1.3 常用的数学函数

    常用的数学函数有很多，这里我就不一一记录，详细内容可以参考菜鸟教程-python3数字，这里只记录一下经常使用以及容易混淆的函数。

• 绝对值函数abs()和fabs()
      这两个函数都能计算数字的绝对值，不同的是abs()是python内置函数，可以运用在整型、浮点型和复数类型的数值中，而fabs()是math模块中的函数，只能作用于整型和浮点型数据：

>>> abs(-10)
10
>>> math.fabs(-10)
10.0
>>> abs(-10.2)
10.2
>>> math.fabs(-10.2)
10.2
>>> abs(complex(2,3))
3.605551275463989
>>> abs(2+6j)
6.324555320336759
>>> math.fabs(2+6j)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float

注：math.fabs()返回是是浮点数，即使作用的是整型，返回的也是浮点数（可以这样记：fabs()中的f就是float，不知道这样理解对不对），且不能作用于复数，abs()作用于复数时，返回的是复数的模。

• 向下取整函数floor
      math.floor()是返回数字的下舍整数，返回值是整数。//除法运算的时候也是向下取整，但不同的是//除法在遇到float类型的数据时，返回的结果也是float类型的，而floor()返回的结果是int型。

>>> 8 // 3
2
>>> math.floor(8 / 3)
2

>>> 8.0 // 3
2.0
>>> math.floor(8.0 / 3)
2

• math模块中的pi和e
      math中的pi和e分别代表圆周率π和常数e

>>> math.pi
3.141592653589793
>>> math.e
2.718281828459045

这两个常数是在math模块中

1.4 随机数函数

    在数据运算时，随机数可谓有着举足轻重的地位。神经网络中如LSTM的隐含层参数h_0、c_0就需要进行随机初始化（当然了，我在使用pytorch的时候，torch中已经提供了随机数函数）；在划分数据集的时候，为了使数据更加均衡，大多数时候往往需要将数据随机打乱然后再按一定比例抽取出train、dev、test，这时候就可以用到随机数函数。
    python中的随机数函数大多都在random这个模块中。

• choice()函数
  choice()函数返回的一个列表、元组或字符串的随机项

>>> import random
>>> random.choice(range(10))
2
>>> random.choice([1,2,3,4,5])
4
>>> random.choice((1,2,3,4,5))
3
>>> random.choice("sjdlaskjd")
'd'
>>>  

• randrange()函数
  randrange()函数返回一个等差数列集合中的随机数，在使用时，需要指定等差数列的起始值和结束值已经等差项（这个等差数列必须是递增的，起始值如果不指定则默认为0，等差项不指定则默认为1，结束值必须要指定）。

# 从 1-100 中选取一个奇数
>>> random.randrange(1, 100, 2)
31
# 从 0-99 选取一个随机数
>>> random.randrange(100)
8

• random()函数和uniform()函数
  random()随机生成一个实数，范围在0-1之间（这个方法也是我目前为止用过最大的随机数方法）。

>>> random.random()
0.0033405654731752943
>>> random.random()
0.8756213120776958

uniform()函数和random()函数类似，也是返回一个随机生成的实数，不同的是，random()生成实数的范围是0-1，而uniform()可以指定实数的范围，当然也可以实现random.random()方法的效果。

>>> random.uniform(1,7)
3.611152952225363
>>> random.uniform(0,1)
0.3372118863045026
>>> random.uniform(7,15)
11.55147918096392

• seed()函数
  随机数种子函数。一般情况下，随机数函数生成的随机数都是不固定的，但是在某些时候，我们需要将每次生成的随机数固定。比如在训练神经网络时，为了对比两组不同的参数之间的差别时，就需要设置随机数种子来约束随机数的生成。这个函数一般是在调用其他随机数函数之前调用。
  在pytorch中设置随机数种子方法如下：

import torch
torch.manual_seed(2)   #为CPU设置种子用于生成随机数，以使得结果是确定的 

torch.cuda.manual_seed(args.seed)	# 设置GPU随机数种子

到目前为止，我使用的随机数种子函数是在训练神经网络之前，目的是为了比较多组不同参数之间的效果（也就是所谓的对比实验）。

• shuffle()函数
  将序列所有元素随机排序。这个函数我一般在构建三个数据集以及DataLoader中用到，目的是使得数据分布更加均衡，这个函数的用处还是比较大的。

>>> lists = [1,2,3,4,5,6]
>>> random.shuffle(lists)
>>> lists
[5, 2, 4, 3, 6, 1]
>>> random.shuffle(lists)
>>> lists
[3, 1, 2, 4, 6, 5]

1.5 三角函数

    python中的三角函数没有歧义，只需调用即可。我用的最多的是cos函数，不过一般计算的是两个向量之间的cos值，所以大多数时候用的是numpy中的cos()和pytorch中的cos()。python中的三角函数可以参考菜鸟教程-python3数字

1.6 布尔数据

python中的布尔数值True和False分别对应0和1，可以用True或False进行数据运算：

>>> True+2
3
>>> False+3
3

有时候需要True、False之间相互转换：

#方法1：直接加0
>>> True + 0
1
>>> False + 0
0

# 方法2：使用类型转换
>>> int(True)
1
>>> int(False)
0

2.字符串

    在NLP中，不论什么任务，当拿到数据后做数据预处理时，做的最多的可能就是字符串的操作的。字符串是python中最常用的数据类型，可以用’’（单引号）或者""（双引号）来创建字符串，与其他语言稍有不同的是，python中不支持单字符类型，单个字符也是字符串。也就是说不存在类似于C中的char、string这种区别，只有字符串一种。与数字数据类型一样，使用字符串的时候直接创建即可：

str = "hello"

注：python中单引号和双引号没有任何区别

    python中字符串可以直接使用“+”进行拼接，访问字符串的时候可以使用类似访问列表元素的方法来访问：

>>> a = "hello"
>>> b = 'world'
>>> c = a + " " + b
>>> c
'hello world'
>>> c[2:6]
'llo '
>>> c[4]
'o'
>>>  

    其他的一些简单操作在这里就不进行记录了。

2.1 转义字符

    转义字符在字符串操作中经常会遇到，不过我认为学习转义字符没有什么技巧性，就是记住然后会用，至于其原理就不懂了。在这里把常用的转义字符列出来（按我平时用到的频率）。

转义字符	描述
\	续行符
\n	换行符
\t	横向制表符（tab键的作用）
\a	响铃
\b	退格(Backspace)
\000	空
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

2.2 三引号

    python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下：

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

注：我平时很少用到三引号，因为平时操作的时候都是操作文件（txt、csv等），所以很少会初始化一个篇幅较大的字符串，这里有写的不对的地方还请批评指正。

2.3 常用字符串操作函数

    通常情况下，字符串操作用的最多的就是字符串操作函数，因为我们需要对字符串进行多种操作，而python又提供了很多的函数，所以字符串操作起来就变得很方便了，在这里按我平时使用的频率将这些函数记录下来。

• strip()函数
  这个函数在做文本清洗的时候经常会用到，作用是用于去除字符串两边指定的字符（默认为所有的空字符，包括空格、\n、\t等）或字符序列，注意是只能删除头尾，不能删除中间。

>>> str1 = "    hello world    "
>>> str1
'    hello world    '
>>> str1.strip()
'hello world'
>>> str2 = "***hello world**"
>>> str2
'***hello world**'
>>> str2.strip("*")
'hello world'
>>> str3
'  hello world  \n\n'
>>> str3.strip()
'hello world'

我一般都是用这个函数去除文本数据两边的空格字符和换行字符。

• split()函数
  这个函数我一般用在分割字符串，函数的作用是通过指定的分隔符（默认为所有的空字符，包括空格、\n、\t等）对字符串进行切片，有两个参数，第二个参数一般用不到。

>>> txt = "Google#Runoob#Taobao#Facebook"
>>> txt.split("#")
['Google', 'Runoob', 'Taobao', 'Facebook']
>>> txt.split("#",2)
['Google', 'Runoob', 'Taobao#Facebook']
>>> txt.split("#",1)
['Google', 'Runoob#Taobao#Facebook']
>>>   

• len()函数
  计算字符串的长度，就不过多介绍了。

• max()和min()函数
  返回字符串中最大和最小的字符

注：字符串中同时有大写字符和小写字符时，返回的是小写字符中最大的字符和大写字符中最小的字符，其实就是按着ASCII码值来判断最大和最小。

>>> strs = "rIJInsdjaskl"
>>> max(strs)
's'
>>> min(strs)
'I'

• replace()函数
  这个函数在文本数据清洗的时候也经常用到，作用是用于替换字符串中的指定字符，一般可用于去除字符串中间的空格、特殊字符等（当然，用正则表达式也可以解决，不过诸如去除字符串中间的空格之类的任务，使用replace()函数就可以直接一步到位了，不需要再用复杂的正则表达式）。

>>> strs = "he llo  worl  d"
>>> strs
'he llo  worl  d'
>>> strs.replace(" ","")
'helloworld'

• join()函数
  这个函数我一般会用到拼接分词后的文本。此函数的作用是将序列中的元素以指定的字符连接生成一个新的字符串。
  语法：str.join(seq)，str是拼接序列的字符，seq是要拼接的序列

>>> s1 = "-"
>>> s2 = ""
>>> seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
>>> print (s1.join( seq ))
r-u-n-o-o-b
>>> print (s2.join( seq ))
runoob

• lower()、upper()、swapcase()
  lower()：将字符串中所有的大写字符转化为小写字符；
  upper():将字符串中所有的小写字符转化为大写字符；
  swapcase()：大写转化为小写，小写转化为大写。

>>> strs = "asdsaJDSJjdlsLKJSD"
>>> strs.upper()
'ASDSAJDSJJDLSLKJSD'
>>> strs.swapcase()
'ASDSAjdsjJDLSlkjsd'

其他函数在这里就不一一记录了，详细内容可以参考菜鸟教程-字符串。

3.列表

    序列是python中最基本的数据结构，序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
    python中有6个序列的内置类型：列表、元组、字符串、Unicode字符串、buffer对象和xrange对象，最常见的也是用的最多的是列表和元组。
    序列都可以进行以下操作：切片、索引、加、乘、检查成员，列表是最常见的python数据类型，列表中的数据项不需要具有相同的类型，换句话说，同一个列表中可以包含数字、字符串、列表等数据类型（列表中可以嵌套列表），创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

3.1 列表的增删改查

• 增（append()、extend()、insert()）
  列表中增加数据有多种方法，不同方法对应不同需求。

>>> list1 = [1,2,3,'a','b']
>>> list1
[1, 2, 3, 'a', 'b']

# append：在末尾添加新的对象，可以添加的对象有数字、字符串、列表、元组、字典、集合等python基本数据类型
# 相对来说，append用的是比较多的
>>> list1.append('c')
>>> list1
[1, 2, 3, 'a', 'b', 'c']
>>> list1.append([1,2])
>>> list1
[1, 2, 3, 'a', 'b', 'c', [1, 2]]
>>> list1.append((3,4))
>>> list1
[1, 2, 3, 'a', 'b', 'c', [1, 2], (3, 4)]
>>> list1.append({0:1})
>>> list1
[1, 2, 3, 'a', 'b', 'c', [1, 2], (3, 4), {0: 1}]

# extend：在列表末尾一次性追加另一个序列中多个值
# 注意这里不仅仅可以追加另一个列表中的值，只要是序列都可以进行追加
>>> list2 = [1,2,3]
>>> list2.extend([4,5,6])
>>> list2
[1, 2, 3, 4, 5, 6]
>>> list2.extend((7,8,9))
>>> list2
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#insert：将新的对象插入指定位置（同样可以插入多种数据类型）
>>> list3 = [1,2,3]
>>> list3.insert(1,5)
>>> list3
[1, 5, 2, 3]
>>> list3.insert(1,[1,2])
>>> list3
[1, [1, 2], 5, 2, 3]

• 删（pop()、remove（）、clear（）、del）
  同样，列表的删也有多种方法，分别对应不同需求

# pop()：按照下标索引删除指定值，并返回删除的值（这个方法是有返回值的），默认下标索引是-1，即列表最后一个元素
>>> list1 = [1,2,3,4,5,6]
>>> list1.pop()
6
>>> list1.pop(4)
5
>>> list1
[1, 2, 3, 4]

# remove()：按元素删除指定值，删除的是该值的第一个匹配项
>>> list2 = ['aa','bb','cc','aa','aa']
>>> list2.remove('aa')
>>> list2
['bb', 'cc', 'aa', 'aa']
>>> list2.remove('aa')
>>> list2
['bb', 'cc', 'aa']

# clear()：清空列表中的数据，（并没有删除列表，列表还在，只不过列表中的数据都清空了）
>>> list2.clear()
>>> list2
[]

# del()：两个功能。1、删除整个列表。2、按切片删除
# 删除整个列表，将列表本身也删除
>>> list3 = [1,2,3,4,5,6]
>>> list3
[1, 2, 3, 4, 5, 6]
>>> del list3
>>> list3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'list3' is not defined

# 按切片删除
>>> list3 = [1,2,3,4,5,6]
>>> del list3[1:4]
>>> list3
[1, 5, 6]

• 改
  列表修改元素比较简单，只需在指定索引位置对元素进行赋值即可：

>>> lists = [1,2,3,4,5]
>>> lists
[1, 2, 3, 4, 5]
>>> lists[2]=8
>>> lists
[1, 2, 8, 4, 5]

• 查
  列表查询即访问列表元素，可以进行单个元素访问，也可以通过切片的方式进行查询：

>>> lists = [1,2,3,4,5,6]
>>> lists[2]
3
>>> lists[2:4]
[3, 4]
>>>     

3.2 列表操作其他方法

    除了增删改查，在列表操作中还会遇到其他的方法：

• max(),min(),len()

# max()：返回列表元素最大值
>>> lists = [1,2,3,4,5,6]
>>> max(lists)
6

# min()：返回列表元素最小值
>>> min(lists)
1

# len()：返回列表长度
>>> len(lists)
6

• 获取对应元素的索引

>>> lists = [1,2,3,4,5,6]
>>>> lists.index(4)
3

• 反转列表

>>> lists = [1,2,3,4,5,6]
>>> lists.reverse()
>>> lists
[6, 5, 4, 3, 2, 1]

• 排序
  列表排序在列表操作中也会经常用到：

# sort()：对列表进行排序，没有返回值
# 有两个参数:

# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
>>> lists = [1,2,4,5,6,12,4,1]
>>> lists.sort()
>>> lists
[1, 1, 2, 4, 4, 5, 6, 12]
>>> lists.sort(reverse=True)
>>> lists
[12, 6, 5, 4, 4, 2, 1, 1]

4.元组

    python中元组与列表类似，也是一个序列数据类型，不同之处在于元组的元素不能修改。元组使用小括号，而列表使用中括号。

注：在创建元组时，即使元组中只有一个元素，也要加上逗号，否则会被当做操作符来计算。

4.1 元组的增删改查

    元组中的元素不能进行修改，即不能实现增和改的操作，但可以对元组进行拼接从而形成新的元组。

>>> tup1 = (12, 34.56)
>>> tup2 = ('abc', 'xyz')
>>>
 # 以下修改元组元素操作是非法的。
# tup1[0] = 100

 # 创建一个新的元组
 tup3 = tup1 + tup2
>>> print (tup3)
(12, 34.56, 'abc', 'xyz')

查
与列表一样，元组的查也可以通过查询单个元素以及切片查询：

>>> tup3[2]
'abc'
>>> tup3[0:2]
(12, 34.56)

删
元组中的值不允许修改，所以在删除元组时只能将元组全部删除：

>>> tup3
(12, 34.56, 'abc', 'xyz')

# 不能进行某个值的删除
>>> del tup3[2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>> del tup3
# 元组删除是将整个元组从内存中删除
>>> tip3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tip3' is not defined

4.2 元组的内置函数

• max(),min(),len(),tuple()

max(),min(),len()与列表中对应的函数功能是一样的，在这里就不做过多的介绍。
tuple()：
该函数的作用是将可迭代系列转化成元组，例如将列表转化成元组：

>>> lists = [1,2,3,4,5]
>>> type(lists)
<class 'list'>
>>> tup = tuple(lists)
>>> tup
(1, 2, 3, 4, 5)
>>> type(tup)

再次强调，元组中只有一个元素时，一定要加逗号，只有加了逗号，这个对象才是元组

>>> a = (2)
>>> type(a)
<class 'int'>
>>> a
2
>>> b = (2,)
>>> type(b)
<class 'tuple'>
>>> b

列表与元组最大的区别就是：列表中的值可以修改，而元组中的值不可以修改。

5.集合

    python中集合是一个无序的不重复的元素序列（数学中的集合不也是这样吗？只不过数学中的集合中的元素都是同一类型）。
    由于集合中的元素不能重复，所以可以使用集合进行去重操作。
    可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
    python中的集合需要注意以下几点：

• 创建空集合必须用set();
• 用“{}”创建集合时，不能包含字典、列表，但可以有元组；
• 如果想要在集合中包含列表，可以使用set()创建集合

一点小经验：在创建集合时，可以优先考虑set()，因为用“{}”创建集合的时候有很多局限性，稍不留神可能就会出错。

5.1 集合的"增删改查"

    上面提到，python有6种序列的内置类型，序列类型都可以进行切片，索引，检查成员等，而集合并不属于这6种序列，所以也没有切片、索引、检查集合成员这些功能，不过集合尤其独特的功能：交集、并集、差集等。集合作为一个无序的元素序列，当然也有添加元素和删除元素的功能。

• 添加元素
  python中可以实现集合添加元素的函数有两个：add()，update()。这两个函数都可以实现对集合进行添加元素操作，不过两个函数也是有一定区别的（否则的话直接整一个函数多好），首先来看这两个函数各自的功能：
  add()函数
  描述：add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

>>> sets = set(["hello","world"])
>>> sets
{'world', 'hello'}
>>> sets.add("welcome")
>>> sets
{'world', 'welcome', 'hello'}

update()函数
描述：update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

>>> set2 = set(["hello","world"])
>>> set2
{'world', 'hello'}
>>> set2.update("welcome")
>>> set2
{'w', 'o', 'm', 'hello', 'l', 'e', 'world', 'c'}

两个函数的区别
    上面的例子中，我特意使用了字符串，同样是在集合{hello,world}中添加“welcome”，不同的是，add()函数将“welcome”当成一个字符串加入到了集合中，而update()函数将"welcome"本身当成了一个集合，然后将该集合中的各个字符添加到集合中。
    其实从两个函数的定义中就能看出，add()函数接收了是一个元素，而update()函数接收的是一个元素或集合，上面例子中，同样是一个字符串“welcome”，add()将其当成一个元素，而update()将其当成了集合。

在使用集合添加元素时，一定要分清楚这两个函数，然后根据实际情况选择合适的函数。本文就在这踩过坑，当时的需求是用add，但是当时没搞清楚，用了update，结果可想而知。

不论是初学者也好，还是大牛也好，我认为基础一定要打好，因为很多函数的功能都类似，但都有本质区别，稍不留神，可能就会出错。

• 删除元素
  集合的四个删除元素的函数，pop(),remove(),discard(),clear()
  pop()函数
  pop()方法用于随机删除一个集合中的元素，并且返回删除的元素。

注：集合是无序的，会出现随机删除，要与列表中的pop()函数区分开。

>>> set2
{'w', 'o', 'm', 'hello', 'l', 'e', 'world', 'c'}
>>> set2.pop()
'w'

remove()函数
移除集合中指定的元素，当指定元素不存在时会报错。

>>> set2
{ 'o', 'm', 'hello', 'l', 'e', 'world', 'c'}
>>> set2.remove("o")
>>> set2
{'m', 'hello', 'l', 'e', 'world', 'c'}
>>> set2.remove("o")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'o'

discard()函数
移除集合中指定元素，当指定元素不存在时不会报错。

>>> set2
{'m', 'hello', 'l', 'e', 'world', 'c'}
>>> set2.discard("m")
>>> set2
{'hello', 'l', 'e', 'world', 'c'}
>>> set2.discard("m")
>>> set2
{'hello', 'l', 'e', 'world', 'c'}

remove()和discard()的区别：既然两个都是移除指定元素，那么两个函数有什么不同呢？
remove如果删除的元素不存在则会报错。
discard如果删除的元素不存在则不会报错。

clear()函数
移除集合中所有元素，但不删除集合。

>>> set2
{'hello', 'l', 'e', 'world', 'c'}
>>> set2.clear()
>>> set2
set()

5.2 集合的交、并、差

    除了元素的增删改查，集合还有着自己的运算：交集、并集、差集

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

我在做一些两个集合相似的时候会用到集合的这几个操作

当然，除了直接使用运算符计算，还可以通过函数来计算。

• difference() 返回多个集合的差集
• difference_update() 移除集合中的元素，该元素在指定的集合也存在。
• intersection() 返回集合的交集
• intersection_update() 删除集合中的元素，该元素在指定的集合中不存在。
• isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
• issubset() 判断指定集合是否为该方法参数集合的子集。
• issuperset() 判断该方法的参数集合是否为指定集合的子集
• symmetric_difference() 返回两个集合中不重复的元素集合。
• symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
• union() 返回两个集合的并集

这些函数的具体用法可以参考：菜鸟教程-集合

6.字典

    在我平时的使用过程中，字典被用到的频率是非常高的，甚至比集合和元组都高。
    字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 。
    我认为在字典中，最重要的应该就是Key和Value了，因为几乎所有的字典操作都是针对Key和Value来的。

在字典中，需要注意以下几点：

• 键（Key）必须是唯一的，但值（Value）可以不唯一；
• 值可以取任何数据类型，
• 键必须是不可变的，如字符串，数字或元组；
• 键不能是列表；
• 键和值成对存在；
• 字典内可以嵌套字典；

6.1 字典的增删改查

    字典的相关操作都是基本操作，所以就直接在代码中体现了。

# 创建字典
>>> dict1 = dict()
>>> dict1
{}
>>> dict1 = {0:'a','1':'b'}
>>> dict1
{0: 'a', '1': 'b'}

# 访问值
>>> dict1[0]
'a'
>>> dict1['1']
'b'
# 如果字典中没有所查询的键，这种获取值的方法就会报错
>>> dict1[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 1

# 可以使用dict.get()方法来取代这种获取值的方法
# 如果不存在，则使用default参数进行返回值的设置
>>> dict1.get(1,"no")		# 第二个参数是设置的default参数，如果字典中没有这个键，则返回这个默认值
'no'
>>> dict1.get(0)
'a'

# 修改字典，包括增和改，只需操作对应的键值对就可以
# 增加
>>> dict1["aa"]=12
>>> dict1
{0: 'a', '1': 'b', 'aa': 12}
# 修改
>>> dict1["aa"]="ysu"
>>> dict1
{0: 'a', '1': 'b', 'aa': 'ysu'}

# pop()方法
# Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
# pop(key，default)：key——要删除的键；default——如果没有 key，返回 default值
>>> dict1.pop(2,"aaa")
'aaa'
>>> dict1.pop(0,"aaa")
'a'
>>> dict1
{'1': 'b', 'aa': 'ysu'}
# popitem() 方法
# Python 字典 popitem() 方法随机返回并删除字典中的最后一对键和值。
# 如果字典已经为空，却调用了此方法，就报出KeyError异常。
# 所以要想使用这个方法，在使用前要先判断字典是否为空
# 该方法没有参数，这里就不做演示了
# 还可以使用del删除
# 但是del删除时，如果要删除的某个键不存在，或者字典为空，就会报错
# dict.clear()方法用来清空字典，但并不会删除字典，只是清空了字典中的内容

6.2 字典的其他操作

• 判断字典中的key是否存在
  两种方法：
  方法一：使用自带函数实现（注意：这个方法是python2中的函数，python3中这个函数已经废弃）
  python中字典属性方法中有一个has_key()方法可以用来判断key是否存在。
  方法二：key in dict（python3中的方法）

>>> dict1
{'1': 'b', 'aa': 'ysu'}
>>> '1' in dict1
True
>>> 45 in dict1
False

• dict.items()，dict.keys()
  Python 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组。

>>> dict1
{'1': 'b', 'aa': 'ysu'}
>>> dict1.items()
dict_items([('1', 'b'), ('aa', 'ysu')])
>>> for key,value in dict1.items():
...     print(key,value)
...
1 b
aa ysu

Python3 字典 keys() 方法返回一个可迭代对象，可以使用 list() 来转换为列表。（注意：Python2.x 是直接返回列表）

>>> dict1
{'1': 'b', 'aa': 'ysu'}
>>> dict1.keys()
dict_keys(['1', 'aa'])

• 其他函数
  字典的相关基本操作就记录到此，其他的方法可以参考菜鸟教程-字典。

    到此为止，本次主要记录了python2和3的一些区别以及六种基本数据类型：数字、字符串、列表、元组、集合、字典。如果有错误或遗漏的地方，还请批评指正，感激不尽。

写在最后

    本文是个人的一些学习笔记,如有侵权,请及时联系我进行删除,谢谢大家.