Python

python相关的基础代码位于Gitee的 https://gitee.com/yangsx95/notes-python 中。

搭建Python环境

windows下的python环境

前往官网下载对应的python安装包，一路安装即可。

注意
在安装过程中会有选项，是否添加到环境变量中，勾选即可自动将python添加到环境变量中。

安装完成后，可以使用命令 python 检测是否安装成功。

如果你是用的是压缩版本，需要手动配置path环境变量，直接将根路径设置到Path中即可。

集成开发环境选择

使用文本编辑器开发，然后通过 python 文件名 来运行
Pycharm，Jetbrains，笔者正在使用的一款开发环境
Aptana Studio，基于Eclipse基础上进行插件集改支持python开发
使用IDEA或者Eclipse集成插件

检测python的版本

python -V #注意V大写
Python 3.6.2

Hello World

print("Hello World");

使用 python 命令打开shell交互式解释器，输入代码即可运行。

python命令参数：

选项参数-ddebug 解析时显示调试信息-O生成优化代码 .pyo 文件-S启动时不引入查找Python路径的位置-V输出Python版本号-X从 1.6版本之后基于内建的异常（仅仅用于字符串）已过时-c cmd执行 Python 脚本，并将运行结果作为 cmd 字符串file生成优化代码 .pyo 文件-h帮助

创建一个后缀为py的源码文件，使用python HelloWorld.py 运行python文件

交互式编程

我们可以在命令提示符中输入"Python"命令来启动Python解释器

脚本式编程

可以通过如下命令运行python脚本：

python hello.py

编码

Python3源码默认以UTF-8为编码，所有字符串都是Unicode字符串。如果要切换编码，可以在源文件中指定：

# -*- coding: cp-1252 -*-

标识符(变量命名规则)

不可使用保留字
首字符必须是字母或者下划线
其他字符可以有字母下划线和数字组成
大小写敏感

规则和Java相同

保留字

python提供了 keyword模块，可以列举出当前版本的所有保留字：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注释

单行注释： # sharp开头。

多行注释：多个 # 开头，或者使用 ''' ''' 或者 """ """

# 我是注释
'''
我是多行注释
'''
"""
我是多行注释
"""

可选的分号

在语句结束时，可以使用换行表示语句结束，可以替代分号。

行与缩进

python不需要大括号
使用缩进表示代码块
同一个代码块，缩进必须相同
如果缩进不同，会抛出错误： IndentationError: unindent does not match any outer indentation level

if True:
    print("Answer")
    print("True")
else:
    print("Answer")
    print("False")

代码组

缩进相同的一组语句构成一个代码块，我们称之 代码组。

if expression :
   suite
elif expression :
   suite
else :
   suite

多行语句

如果语句过长，我们可以使用反斜杠来实现多行语句：

total = item_one + \
        item_two + \
        item_three

如果语句包含 {}, [], () 则不需要反斜杠，比如如下数组：

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

同一行显示多个语句

一行使用多个语句，需要 ; 分号分割：

i: int = 100; j = 100; k:int = 100

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住： 空行也是程序代码的一部分。

使用import导入模块

导入整个模块 moduleA: import moduleA

导入模块 moduleA 的函数 funA： from moduleA import funA

导入模块 moduleA 的多个函数： from moduleA import funA, funB, funC

导入模块 moduleA 的所有函数: from moduleA import *

控制台输出与输入函数

#换行输出
print("输出")
#不换行输出，指定输出结尾为字符串空格
print("不换行输出", end=" ")
# 打印多个字符串
print ('The quick brown fox', 'jumps over', 'the lazy dog')
input("\n\n按下 enter 键后退出。") #输入

sys.argv 可以获取启动脚本时的输入参数，比如有如下 HelloWorld.py:

import sys
print(sys.argv)

使用命令 python HelloWorld.py name Lisi 运行，会打印：

['C:/Users/Feathers/PycharmProjects/learning/HelloWorld.py', 'name', 'Lisi']

变量和数据类型

变量

变量的定义和赋值：

# 变量的定义
# 定义变量a，类型为int。这里会判断赋值类型，从而确定变量类型
a = 1
# 定义变量b，类型为float。使用冒号空格指定类型
b: float = 10.0
c: complex = 10

# 定义多个变量，并赋值
d, e, f = "a", 1, 1.8

# 定义多个变量并赋相同的值
g = h = i = 2

变量的销毁：

# del var1[,var2[,var3[....,varN]]]]
del a, b, c
print(a) # NameError: name 'a' is not defined

创建过程

当我们写：a = ‘ABC’时，Python解释器干了两件事情：

在内存中创建了一个’ABC’的字符串；
在内存中创建了一个名为a的变量，并把它指向’ABC’。

和Java类似。

标准数据类型

在python3中，公有六种标准的数据类型:

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

其中，Number String Tuple 是 不可变数据

List Dictionary Set 是 可变数据

type函数：查询变量的类型

a, b, c, d = 1, 1.0, 3e5j, "str"
print(type(a), type(b), type(c), type(d))
# <class 'int'> <class 'float'> <class 'complex'> <class 'str'>

instance函数：判断变量类型

print(isinstance(a, int)) // 会认为字类是一种父类类型
# True

None

用 None 表示。None不能理解为0，相当于其他语言中的NULL。

print(type(None)) # <class 'NoneType'>

Number

int 长整形
float 浮点型
bool 布尔类型
complex 复数类型

int

在 python3中没有短整型，只有长整形，长整形使用int来表示。

各个进制的表示形式：

进制表示对应十进制的值转换为此进制的方式二进制0b1004bin(任意进制数)八进制0o10064oct(任意进制数)十六进制0x100256hex(任意进制数)

float

浮点数就是小数： 1.2, 2.50， -0.58 等

对于很小的浮点数，使用e替代10,即 1.29e3 就是 1290

整数永远是精确的而浮点数永远会有四舍五入的误差。
整数与浮点数运算为浮点数。

bool

一个布尔值只有 True、 False 两种值，在内部中使用1 和 0 存储。

所以，bool类型也是Number类型，也可以进行数值运算。

print(50 + True) # 51

短路运算：布尔值可以用 and、 or 和 not 运算，分别对应与、或、非，并且是短路运算符。

注意：Python把 0、 空字符串‘和 None 看成 False，其他数值和非空字符串都看成 True

String

字符串是以 '' 或""括起来的任意文本，比如 'abc'， "xyz" 等等。请注意， '' 或 "" 本身只是一种表示方式，不是字符串的一部分，因此，字符串 'abc' 只有a，b，c这3个字符。

如果字符串本身包含 ',比如我们要表示字符串 I’m OK ，这时，可以用" "括起来表示： "I'm OK"
类似的，如果字符串包含 "，我们就可以用 ' ' 括起来表示： 'Learn "Python" in imooc'
如果既包含 "",又包含 '',可以使用 \ 转义字符。

注意：python字符串不可变

String在Python中公有三种表现形式：

s1 = '字符串1'
s2 = "字符串2"
s3 = '''字符串3
我是多行文本字符串
'''

字符串截取

字符串和java一样，是从第0个下表开始的。

s = 'abcdefg'
print(s[0:3]) # abc 输出前三个字符
print(s[0:-1]) # abcdef 输出第一个到倒数第二个字符
print(s[0]) # a 输出第0个字符
print(s[1:]) # bcdefg 输出第一个字符到最后一个字符
print(s[-2:]) # fg 输出最后两个字符

字符串连接操作

print (str + "TEST") # 连接字符串

不转移标识

python字符串中如果想禁用转义字符，可以使用如下方式:

s = r"\测试"
print(s) # \测试
# 同样适用于 ' 和 '''

其他

print (str * 2)      # 输出字符串两次

List

List是一种有序集合，可以添加和删除其中的元素
Python 是一种动态语言，所以List集合中的元素的类型可以不相同：例如， [10,"Python","test",17.7]

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59] #定义一个List集合
print list # 输出该集合
 ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]

空list： list = []

按照索引来访问list

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
print list[3]  #根据索引获取元素，不可越界IndexError
88

倒叙访问list，-1索引表示倒数第一个元素，-2表示倒数第二个元素，以此类推

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
print list[-3]  #根据索引获取元素，不可越界IndexError
88

向List尾部添加元素使用 list.append() 方法

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
list.append("Jack")
print list
['Adam', 95.5, 'Lisa', 85, 'Bart', 59, 'Jack']

向List指定位置添加元素使用 list.insert() 方法

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
list.insert(0,"Jack")
list
['Jack', 'Adam', 95.5, 'Lisa', 85, 'Bart', 59]

从list中删除元素使用 list.pop() 方法，该方法返回被删除的元素

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
list.pop() #不指定参数，默认删除尾元素
59
list
['Adam', 95.5, 'Lisa', 85, 'Bart']
list.pop(0) #指定参数，删除指定索引处的元素
'Adam'
list
[95.5, 'Lisa', 85, 'Bart']

替换元素

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
list[0] = "Jack"
list
['Jack', 95.5, 'Lisa', 85, 'Bart', 59]
list[-1] = 60
list
['Jack', 95.5, 'Lisa', 85, 'Bart', 60]

Tuple

元组，和List非常相似，但一旦创建了，Tuple就无法修改了

tuple = ('Adam', 95.5, 'Lisa', 85, 'Bart', 59) #和List不同 使用了（）代替了[]
print tuple
('Adam', 95.5, 'Lisa', 85, 'Bart', 59)
print tuple[-1]
59
print tuple[2]
Lisa

空Tuple： tuple = ()

单元素Tuple

tuple = ("d")  #解释器默认将()解释为强制类型转换 这样代码就成了 tuple = "d"
tuple
'd'
tuple = ("d",) #多加一个，避免歧义
tuple
('d',)

可变Tuple

tuple = ("d","dsds",["dsfds",25])
list = tuple[-1]
list.append("555555")
tuple
('d', 'dsds', ['dsfds', 25, '555555'])

Dict：

_字典，字典中的字可以根据对应的信息查到，Dict类似

一种键值对类型_

Dict的特点

Dict的查找速度与元素数量无关，查找速度快，而List会随着元素数量的增加速度也会变慢
Dict相对于其他集合占用空间大，而List恰恰相反
Dict是无序的打印顺序不是创建顺序，不可以用dict存储有序集合
他的元素key，是不可变的，字符串，浮点数，整型都可以作为dict的key

创建dict

>>> d = {
...     'a':1,
...     'b':2
... }
print d
{'a': 1, 'b': 2}
#len()函数可以用来计算集合的长度
len(d)
2

根据key获取value
第一种方法：


# 判断是否有这个key，避免KeyError
if 'b' in d:
...     print d['b']
...
2

第二种方法

#使用dict的get()方法，根据key获得value，如果不存在该key，则返回None
print d.get('d')
None

更新Dict
```
d['b'] = 22
print d
{'a': 1, 'b': 22}
```
遍历Dict，注意，只能取到value的数值
```
for key in d:
...     print key
...
a
b
```

Set

set的特点：

没有重复
无序性
内部结构和Dict类似，但是不存储value，所以查询速度也很快
对象不可变，可用于存储常量

创建Set

调用set()方法，并传入一个List

>>> s = set(['a','b', 'c'])
>>> print s
set(['a', 'c', 'b'])#该set元素无序

传入含有重复元素的List，会自动去除重复元素
```
s = set(['a','b', 'c','a','a'])
print s
set(['a', 'c', 'b'])
```
访问Set
```
'a' in s
True
'A' in s
False
```
遍历Set
```
for  x  in s:
...     print x
...
a
b
```

添加元素

s.add('c')#如果add的元素在set中已经存在，则什么也不做
print s
set(['a', 'c', 'b'])

删除元素

s.remove('a')#如果remove的元素不存在，则会报错KeyError
print s
set(['c', 'b'])

运算符

算术运算符

运算符描述实例+加 – 两个对象相加a + b 输出结果 31–减 – 得到负数或是一个数减去另一个数a – b 输出结果 -11*乘 – 两个数相乘或是返回一个被重复若干次的字符串a * b 输出结果 210/除 – x 除以 yb / a 输出结果 2.1%取模 – 返回除法的余数b % a 输出结果 1**幂 – 返回x的y次幂a**b 为10的21次方//取整除 – 返回商的整数部分9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

比较运算符

运算符描述实例==等于 – 比较对象是否相等(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。

赋值运算符

运算符描述实例=简单的赋值运算符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

位运算符

运算符描述实例&按位与运算符：参与运算的两个值,如果两个相应位都为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

逻辑运算符（短路）

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

成员运算符

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

身份运算符

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

is 比较引用的地址，==比较值。

运算符优先级

运算符描述**指数 (最高优先级)~ + –按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)\* / % //乘，除，取模和取整除+ –加法减法>> <<右移，左移运算符&位 ‘AND’^ |位运算符<= < > >=比较运算符<> == !=等于运算符= %= /= //= -= += *= **=赋值运算符is is not身份运算符in not in成员运算符and or not逻辑运算符

条件判断和循环

Python 代码缩进规则

具有相同缩进的行代码，将被视作一个代码块。

if 条件语句

>>> if score == 100:
...     print "you score is very good"
... elif score > 80:
...     print "you score is good",score
... else:
...     print "not good"
...
you score is good 85

for循环语句

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
>>> for child in list:  #child的含义：依次取出list中的元素并赋值给child，让child做出处理（在缩进的代码块中）
...     print child
...
Adam
95.5
Lisa
85
Bart
59

遍历tuple类似。

while循环

n = 10
x = 1
while x < n:
       print x
        x = x+1

拥有break和continue。

支持多重循环

for x in ['a','b','c']:
...     for y in ['1','2','3']:
...             print x + y

输出结果为

a1、a2、a3、b1、b2、b3、c1、c2、c3

函数

查看帮助信息

官方文档地址：行内式链接
使用 help(abs) 查看abs函数的帮助信息

定义一个函数

def my_abs(x):
...     if x >= 0:
...             return x
...     else:
...             return -x

注意：return None 等同于 return 等同于无return语句

函数返回多值，比如坐标的x,y,z

数学函数:

abs(x) 绝对值函数

type(x) 类型函数

round(x) 四舍五入函数

内建函数

使用dir( builtins) 函数查看python中的内建函数

使用help(abs) 查看内建函数abs的信息(非内建函数无法使用此命令)

模块

类似于头文件

使用import math 导入math模块,使用math下的函数

一个完整的python文件就是一个模块,math模块的文件就是math.py

导入多个模块,模块间用逗号分开

导入指定的模块属性:from Module1 import ModuleElement

包package

一个层次文件的目录结构

比如:import AAA.CCC.c1导入AAA的子包BBB下的c1模块或者 : from AAA.CCC.c1 import funct() 直接导入函数

上一页与webpack整合下一页BuildTools

最后更新于9个月前

这有帮助吗？

>>> import keyword >>> keyword.kwlist ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

#换行输出 print("输出") #不换行输出，指定输出结尾为字符串空格 print("不换行输出", end=" ") # 打印多个字符串 print ('The quick brown fox', 'jumps over', 'the lazy dog') input("\n\n按下 enter 键后退出。") #输入

# 变量的定义 # 定义变量a，类型为int。这里会判断赋值类型，从而确定变量类型 a = 1 # 定义变量b，类型为float。使用冒号空格指定类型 b: float = 10.0 c: complex = 10 # 定义多个变量，并赋值 d, e, f = "a", 1, 1.8 # 定义多个变量并赋相同的值 g = h = i = 2

s = 'abcdefg' print(s[0:3]) # abc 输出前三个字符 print(s[0:-1]) # abcdef 输出第一个到倒数第二个字符 print(s[0]) # a 输出第0个字符 print(s[1:]) # bcdefg 输出第一个字符到最后一个字符 print(s[-2:]) # fg 输出最后两个字符

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59] list.pop() #不指定参数，默认删除尾元素 59 list ['Adam', 95.5, 'Lisa', 85, 'Bart'] list.pop(0) #指定参数，删除指定索引处的元素 'Adam' list [95.5, 'Lisa', 85, 'Bart']

list = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59] >>> for child in list: #child的含义：依次取出list中的元素并赋值给child，让child做出处理（在缩进的代码块中） ... print child ... Adam 95.5 Lisa 85 Bart 59