Python的安装配置及编辑器的使用

Anaconda介绍

Anaconda是一种主流的工具包，第三方资源包丰富，不仅内嵌 Python，还包括了 Numpy、Pandas、SciPy、
Scikit-learn、Matplotlib、NLTK 等科学计算的主流模块以及两款不同风格的编辑器 Jupyter
和 Spyder。

Python的基础语法

编码设置

编码注释一般放在第一或第二行（第一行一般是shebang）

方法一 冒号形式

这种带冒号的方法，在大多数编译器中都能被正确识别。

1
2
#!/usr/bin/python 
# -*- coding: <编码名称> -*-

方法二 等号形式

1
2
#!/usr/bin/python 
# coding=<编码名称>

方法三 vim形式

1
2
#!/usr/bin/python 
# vim: set fileencoding=<编码名称> :

标识符

  • 第一个字符必须是字母表中字母或下划线 _ 。
  • 标识符的其他的部分由字母、数字和下划线组成。
  • 标识符对大小写敏感。

在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

python保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字

1
2
import keyword
print(keyword.kwlist)

注释

单行注释

使用#号

1
# 这是单行注释

多行注释

使用’’'或”""

1
2
3
4
5
6
7
8
9
10
11
12
# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""

行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 ** 来实现多行语句，例如：

1
2
3
total = item_one + \
        item_two + \
        item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \，例如：

1
2
total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

Python2 与 Python3 print 不换行

Python 3.x

在 Python 3.x 中，我们可以在 print() 函数中添加 end=”” 参数，这样就可以实现不换行效果。

在 Python3 中， print 函数的参数 end 默认值为 **”\n”，即end=”\n”，表示换行，给 end 赋值为空, 即end=””**，就不会换行了，例如：

1
print('hello world',end="")

Python 2.x

在 Python 2.x中， 可以使用逗号 , 来实现不换行效果：

1
print 'hello world' ,

Python2.x 与 Python3.x 兼容模式

如果 Python2.x 版本想使用 Python3.x 的 print 函数，可以导入 future 包，该包禁用 Python2.x 的 print 语句，采用 Python3.x 的 print 函数。以下代码在 Python2.x 与 Python3.x 都能正确执行：

1
from __future__ import print_function

import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。

  • 将整个模块(somemodule)导入，格式为： import somemodule
  • 从某个模块中导入某个函数,格式为： from somemodule import somefunction
  • 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
  • 将某个模块中的全部函数导入，格式为： from somemodule import *

命令行参数

在命令行中运行某程序时，携带的参数

基本数据类型

内置的 type() 函数可以用来查询变量所指的对象类型。

多个变量赋值

1
2
a = b = c = 1
a, b, c = 1, 2, "c"

数字型Number

python中数字有四种类型：整数、布尔型、浮点数和复数。

  • int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
  • bool (布尔), 如 True。
  • float (浮点数), 如 1.23、3E-2
  • complex (复数), 如 1 + 2j、 1.1 + 2.2j

使用isinstance()函数判断是否为int型

isinstance 和 type 的区别在于：

  • type()不会认为子类是一种父类类型。
  • isinstance()会认为子类是一种父类类型。

字符串String

  • Python 中单引号 ‘ 和双引号 “ 使用完全相同。
  • 使用三引号(‘’’ 或 “””)可以指定一个多行字符串。
  • 转义符 \。
  • 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r”this is a line with \n” 则 \n 会显示，并不是换行。
  • 按字面意义级联字符串，如 “this “ “is “ “string” 会被自动转换为 this is string。
  • 字符串可以用 + 运算符连接在一起，用 ***** 运算符重复。
  • Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
  • Python 中的字符串不能改变。
  • Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
  • 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
1
2
3
4
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
str='123456789'
 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)             # 输出字符串两次
print(str + '你好')         # 连接字符串

print('------------------------------')
print('hello\nworld')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nworld')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

列表型List

列表可以完成大多数集合类的数据结构实现。

列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

切片表达式

1
2
3
变量[头下标:尾下标]
#完整的切片表达式
变量[头下表:尾下标:步长]  #object[start_index : end_index : step]

step为1时，表示从左往右截取（默认）；

step为-1时，表示从右往左截取。

List 内置了有很多方法，例如 append()、pop() 等等

集合Set

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合。

1
2
3
parame = {value01,value02,...}
#或者
parame = set(iteration) #其中，iteration 就表示字符串、列表、元组、range 对象等可迭代对象。

注意：创建一个空集合必须用 set() 而不是 **{ }**，因为 { } 是用来创建一个空字典。

字典Dictionary

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

  1. 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
  2. 键(key)必须使用不可变类型。
  3. 在同一个字典中，键(key)必须是唯一的。

可以使用大括号**{ }**或 **dict()**函数创建字典。

1
2
3
#构造函数 dict() 可以直接从键值对序列中构建字典
dict([('key1':value1),('key2',value2),...]) 
dict(key1=value1,key2=value2,...) 
1
2
3
#Python推导式
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

**{x: x*2 for x in (2, 4, 6)}* 该代码使用的是字典推导式，更多推导式内容可以参考：Python 推导式。

元组Tuple

与列表和字符串一样，元组也是序列的一种，使用()定义，元组与列表不同的是元组中的值不能改变，字符串和元组都具有不可变性。

文件File

文件可以永久保存数据，数据分析中最普遍的是对 txt、csv、excel 等文件进行读写处理。下面分别以上述类型文件为例，掌握在 Python 中如何读取这些类型文件。

txt

1
2
3
4
5
6
#读取
fp=open('news.txt')
a=fp.read()
fp.close()
print(a) 
#写入

csv

1
2
3
4
5
6
7
8
import pandas as pd
#读取
pd.set_option('display.max_colwidth', 50) 
#设置列的宽度
train=pd.read_csv("doubanpd.csv", encoding='gbk')
#encoding='gbk'表示对中文进行解码
print(train['reviews'].head())
#写入

excel

1
2
3
4
5
6
7
8
9
import pandas as pd
#读取
#列名与数据对齐显示
pd.set_option('display.unicode.ambiguous_as_wide', True) 
pd.set_option('display.unicode.east_asian_width', True) 
x=pd.read_excel('mtpl.xls', 'Sheet1')
print(x.head()) 
#默认显示前 5 行
#写入

Python数据类型转换

Python 数据类型转换可以分为两种：

  • 隐式类型转换 - 自动完成
  • 显式类型转换 - 需要使用类型函数来转换

隐式类型转换

在进行运算时，会自动完成。如整型与浮点型计算会转换为浮点型。即较小的数据类型会转换为较大的数据类型。

显式类型转换

函数 描述
int(x[ ,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

Python 推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 支持各种数据结构的推导式：

  • 列表(list)推导式
  • 字典(dict)推导式
  • 集合(set)推导式
  • 元组(tuple)推导式

列表推导式

1
2
3
4
5
6
7
[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者 

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
1
2
3
4
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

字典推导式

1
2
3
4
5
6
7
{ key_expr: value_expr for value in collection }
{键表达式:键值表达式 for 变量 in 列表}

或者

{ key_expr: value_expr for value in collection if condition }
{键表达式:键值表达式 for 变量 in 列表 if 条件}
1
2
3
4
5
6
7
8
9
10
11
listdemo = ['Google','User', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'User': 6, 'Taobao': 6}
-------------------------------------------
>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

集合推导式

1
2
3
{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }
1
2
3
4
5
6
7
8
9
10
#计算数字 1,2,3 的平方数：
>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}
#判断不是 abc 的字母并输出：
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

元组推导式（生成器表达式）

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

1
2
3
(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 **[]**，另外元组推导式返回的结果是一个生成器对象。

1
2
3
4
5
6
7
#生成一个包含数字 1~9 的元组：
>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

Python3 解释器

交互式编程

脚本式编程

Python3 运算符

Python数值运算

运算符

以下假设变量 a=10，变量 b=21：

+ 加 - 两个对象相加 a + b 输出结果 30
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 - x除以y b / a 输出结果 2
% 取模 - 返回除法的余数 b % a 输出结果 0
** 幂 - 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000
// 取整除 - 返回商的整数部分（向下取整） >>> 9//2
4
>> -9//2
-5

Python比较运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 True。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。

Python赋值运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
:= 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。 在这个示例中，赋值表达式可以避免调用 len() 两次:if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011
运算符 描述 实例
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。**~x** 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由”<<”右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符 逻辑表达式 描述 实例
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔”或” - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 **id(x) != id(y)**。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

is 与 == 区别：

  • is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：

运算符 描述
(expressions...),[expressions...], {key: value...}, {expressions...} 圆括号的表达式
x[index], x[index:index], x(arguments...), x.attribute 读取，切片，调用，属性引用
await x await 表达式
** 乘方(指数)
+x, -x, ~x 正，负，按位非 NOT
*, @, /, //, % 乘，矩阵乘，除，整除，取余
+, - 加和减
<<, >> 移位
& 按位与 AND
^ 按位异或 XOR
` `
in,not in, is,is not, <, <=, >, >=, !=, == 比较运算，包括成员检测和标识号检测
not x 逻辑非 NOT
and 逻辑与 AND
or 逻辑或 OR
if -- else 条件表达式
lambda lambda 表达式
:= 赋值表达式

数字Number

数学函数

函数 返回值 ( 描述 )
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,…) 返回给定参数的最小值，参数可以为序列。
modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) x**y 运算后的值。
round(x [,n]) 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x) 返回数字x的平方根。

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

函数 描述
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
[randrange (start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random() 随机生成下一个实数，它在[0,1)范围内。
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

三角函数

Python包括以下三角函数：

函数 描述
acos(x) 返回x的反余弦弧度值。
asin(x) 返回x的反正弦弧度值。
atan(x) 返回x的反正切弧度值。
atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
cos(x) 返回x的弧度的余弦值。
hypot(x, y) 返回欧几里德范数 sqrt(xx + yy)。
sin(x) 返回的x弧度的正弦值。
tan(x) 返回x弧度的正切值。
degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x) 将角度转换为弧度

数学常量

常量 描述
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）。