Python3的关键字有：
and, as, assert, break, class, continue, def, del,
elif, else, except, False, finally, for, from, global,
if, import, in, is, lambda, None, nonlocal, not, or, pass,
raise, return, True, try, while, with, yield
列表和元组
#列表是可变的，元组是不可变的，列表用中括号表示，元组用圆括号表示
x = [1,2,3,4,5,6,7,8,9,10]
a = [3, 'ss', 447, 3.14, 'test'] #可以存任何类型
#访问最后三个元素8,9,10
x[7:10] #索引1是第一个元素的编号，索引2是剩下部分第一个元素编号
3[0] #第一个元素下标从0开始
x[2:100] #最后一个一个索引可以超过数组边界
x[-1] #表示最后一个元素
x[-3:] #倒数三个元素8,9,10
x[0:10:1] #最后一个索引表示步长为1，结果是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
x[0:10:2] #结果是[1, 3, 5, 7, 9]
x[0:10:3] #结果是[1, 4, 7, 10]
y=[1,2,3] + [4,5,6] #列表的相加。如果x=[1,2,3]这样的操作不会改变x，只是创建了副本
[1,2,3] + 'hello' #列表不能和字符串相加，这样会报错
'python' * 5 #结果 'pythonpythonpythonpythonpython'
[12] * 4 #结果 [12, 12, 12, 12]
3 in x #in 运算符检查一个元素是否在列表中，结果True
'x' in x #结果False
len(x) #结果为10，len是求长度
max(x) #结果为10，最大值
min(x) #结果为1，最小值
y=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'ss', 'sdfsdf']
len(y) #结果为12
max(y) #报错，整数不能和字符串一起运算
list('hello') #结果['h', 'e', 'l', 'l', 'o'] ，但是不可以用于整数
del x[2] #删除列表x 中第三个元素
#分片赋值
name=list('perl')
name[1:]=list('ython') #此时name为['P','y','t','h','o','n']
name.append(4) #用于在列表末尾增加新对象，但是不能用于元组，因为元组不可变
name.append('n') #可以增加各种类型
name.count('n') #结果为2，计算这个值再列表中出现的次数
name.extend(a) #将另外一个列表增加到末尾如果a是[1,2]，则name为
#['p', 'y', 't', 'h', 'o', 'n', 'n', 1, 2]
name.index('n')
name.index("hehe") #找出某个元素在列表中第一次出现的位置，第一个元素下标为0
x.insert(3,"hehe") #结果[1, 2, 3, 'hehe', 4, 5, 6, 7, 8, 9, 10]
x.pop() #弹出最后一个元素，也就是10
x.append(x.pop()) #可以组合两个函数调用
x.remove('hehe') #删除一个元素
x.reverse() #将列表中的元素反向存放，会改变列表内容而不是返回副本
x.sort() #按字段排序列表，会改变列表的内容而不是返回副本
#注意不能同时排序数字(整数和浮点数)和字符串
x = (1,2,3) #用圆括号表示为元组(tuple)是不可改变的
y = tuple([1,2,3]) #将列表变成元组
y[1] #访问元组的第二个元素
dir(x) #打印出元组中所有可以使用的函数
dir(y) #打印出列表中所有可以使用的函数
字典
#和元素列表不同，字典是用大括号表示的
item=[('name','gumby'),('age',42)]
x=dict(item) #需要注意的是，这里的()内，也就是元组里面只能有2个元素
{'name': 'gumby', 'age': 42}
'name' in x #检查某个key是否在字典中
del x['age'] #删除键为age的项
x['name'] #返回关联到键name上的值
x[100]='hehe' #将一组新的键值对关联到x上，这里的key可以随意使用
x.clear() #清空字典x
#copy只是潜拷贝
a={'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
b=a.copy()
a['username']='mlh' #此时a 为{'username': 'mlh', 'machines': ['foo', 'bar', 'baz']}
a['machines'].remove('bar') #此时a 为{'username': 'mlh', 'machines': ['foo', 'baz']
#b为 {'username': 'admin', 'machines': ['foo', 'baz']
{}.fromkeys(['a1','????']) #fromkeys只是返回一个新的键值对，不会影响原始的字典内容
a.fromkeys(['a1','????']) #这样做对a 不会产生影响，a不会新增内容
#返回的结果为 fromkeys(['a1','????'])
a.fromkeys(['a2','????'],'unknow') #结果为 {'a2': 'unknow', '????': 'unknow'}
a.get('aa') #获取key对应的值，如果这个key不存在则返回空
a.get('aa','N/A') #如果可以不存在则返回'N/A'，如果用a['aa']key不存在则报错
a.items() #返回当前字典的所有键值对
a.keys() #返回当前字典的键集合
a.values() #返回当前字典的值集合
a.pop('aa') #根据给定的键返回值，并将这个键值对从字典中移除
b.setdefault('name','N/A') #如果name不存在，则设置name为N/A，此时返回N/A
b['name']='gumby'
b.setdefault('name','N/A') #此时返回gumby
a.update(b) #将字典b的内容增加到a 中
字符串
#格式化字符串
format="hello %s %s enough for ya?"
values=("world",'hot')
print(format % values) #结果 hello world hot enough for ya?
a.find('aa') #在一个较长的字符串中查找子字符串，若没找到
#返回-1；否则返回下标(从0开始)
a.find('aa',10) #从指定的位置开始查找
dir='','usr','bin','env' #内容为 ('', 'usr', 'bin', 'env')
'/'.join(dir) #结果为 '/usr/bin/env'
a="1+2+3+4+5"
a.split('+') #结果为 ['1', '2', '3', '4', '5']
a.replace('+','@') #结果为 '1@2@3@4@5'
a.lower() #转换为小写
a.upper() #转换为大写
len(a) #字符串长度
dir(a) #所有的字符串相关函数可以通过dir获得
基本的转换说明符包括以下部分
1) %字符：标记转换说明符的开始
2) 转换标志(可选)：-表示左对齐；+表示在转换值之前要加上正负号；""(空白字符)表示正数之前保留空格，
0表示转换值若位数不够则用0填充
3) 最小字段宽度(可选)：转换后的字符串至少应该具有该值指定的宽度。如果是* ，则宽度会从值元组中
读出
4) 点(.) 后跟精度值(可选)：如果转换的是实数，精度值就表示出现在小数点后的位数。如果转换的是
字符串，那么该数字就表示最大字段宽度。如果是* ，那么精度将会从元组中读出
5) 转换类型
| 转换类型 | 含义 |
| d，i | 带符号的十进制数 |
| o | 不带符号的八进制 |
| u | 不带符号的十进制 |
| x | 不带符号的十六进制(小写) |
| X | 不带符号的十六进制(大写) |
| e | 科学计数法表示的浮点数(小写) |
| E | 科学计数法表示的浮点数(大写) |
| f，F | 十进制浮点数 |
| g | 如果指数大于-4或小于精度则和e相同，其他情况与f相同 |
| G | 如果指数大于-4或小于精度值则和E相同，其他情况与F相同 |
| C | 单字符(接受整数或者单字符串) |
| r | 字符串(使用repr转换任意Python对象) |
| s | 字符串(使用str转换任意Python对象) |
条件，循环和其他语句
name='gumby'
print("hi "+name) #结果为hi gumby
import somemodule
from somemodule import somefunction
from somemodule import somefunction, antherfunction, otherfunction
import math #导入数学模块
math.pow(10,2) #使用pow()函数
import math from pow #只导入指定的函数
pow(10,2) #这样可以省略模块名称
#如果两个模块都有open函数可以使用别名
module1.open()
module2.open()
import math as foobar
foobar.sqrt(4) #结果为2
#序列解包
x,y,z = 1, 2, 3 #此时x为1，y为2，z为3
x, y = y, x #此时x为2，y为1，可以支持更多的变量
value = 1, 2, 3
x,y,z = value #此时x为1，y为2，z为3
#链式赋值
x = y = somefunction()
x = somefunction()
y = x
#增量赋值
x += 1
x *= 2
#python中 False None 0 "" () [] {} 都认为是假，其他都是真
False + True + 44 #结果为45
False == 0 #结果为True
True == 1 #结果为True
True - 3 #结果为-2
#判断语句
if name.endswith("gun"): #注意python没有{}语句，都是靠缩进的，if内的语句块需要缩进
print("hehe") #最终会打印hehe，
#if elif else
num = int(input('num'))
if num>0 :
print('num is positive')
elif num<0 :
print('num is negative')
else :
print('num is zero')
比较运算符
| 表达式 | 描述 |
| x is y | x和y是同一个对象 |
| x is no y | x和y是不同对象 |
| x in y | x是y容器(如序列)的成员 |
| x not in y | x不是y容器(如序列)的成员 |
其他运算符
x == y x < y x > y x>= y x <= y x != y 不推荐使用 x <> y
条件和循环语句
'foo'=='foo' #结果为True
'foo' == 'bar' #结果为False
x = y = [1,2,3]
z = [1,2,3]
x == y #结果为True
x == z #结果为True
#is 运算符判断的是同一性，而不是相等性
x is y #结果为True
x is z #结果为False
"alpha" < "beta" #结果为True
#结果为True
'FnOrd'.lower() == ''Fnord'.lower()
[1,2] < [2,1] #结果为True
[2,[1,4]] < [2,[1,5] #结果为True
#断言，assert后面可以不用跟'age must be realistic'这段解释
age=-1
assert 0 < age < 100 'age must be realistic'
File "<stdin>", line 1
assert 0 < age < 100 'age must be realistic'
#while循环
x=1
while x <=10 :
print(x)
x += 1
#for循环
world=['this', 'is', 'an', 'ex', 'parrot']
for word in words :
print(x)
#使用下标
strings='a+b+c+d+e+f+g'.split('+')
index=0
for s in strings :
if 'd' in s :
print(strings[index])
index+=1
#range函数
for i in range(0,10) :
print(i)
#反向遍历
for i in range(10,1,-2) :
print(i)
#break的用法
from math import sqrt
for n range(99,0,-1) :
root=sqrt(n)
if root == int(root) :
print(n)
break
#continue的用法，打印基数
for i in range(1,10) :
if(i%2 == 0) :
continue
print(i)
#循环外面可以增加一个else
for math import sqrt
for n in range(99,1,-1) :
root = sqrt(n)
if root == int(root)
print(n)
break
else :
print("Didn't find it!")
[x*x for x in range(10)] #结果为 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[x*x for x in range(10) if x%3==0] #结果为[0, 9, 36, 81]
[(x,y) for x in range(3) for y in range(3)]
#结果为[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
#也可以使用如下方式
for x in range(3) :
for y in range(3) :
result.append((x,y))
#pass
if name == 'ralph auldus melish' :
print('welcome')
elif name == 'Enid' :
pass #如果不写pass只是空着就会报错，python不允许有空语句
else if name == 'bill gates' :
print('access denied')
#del
a='hello'
b='world'
a=b #此时'hello'就会被回收了
a=None #类似同样的效果，'hello'也会被回收
del a #b还是为'world'，a的删除不影响b
#exec
name='hello'
exec('print(name)') #相当于动态执行代码print(name)
from math import sqrt
exec 'sqrt=1'
sqrt(4) #sqrt会变成变量名而不是函数，所以这样执行就会出错
from math import sqrt
scope={}
exec 'sqrt = 1' in scope
sqrt(4) #将sqrt变量名放到定义好的scope名称空间中后续代码就正常了
#eval 和exec类似，但是eval有返回值
a=eval("input('input')")
scope={}
scope['x']=2
scope['y']=3
eval('x*y',scope)
抽象
#定义一个可以接受参数的函数，斐波那契数列
def fibs(num) :
result = [0,1]
for i in range(num-2) :
result.append(result[-2] + result[-1])
return result
#函数可以返回序列，元素，字典
def foo():
rerurn [1,2,3,4]
#在函数中改变参数值不影响原始的值，也就是类似传递引用的值跟C和java类似
def bar(str):
str='aa'
#收集参数，有点像java中的可变参数
def print_params(*params):
print params
print_params('testing') #结果testing
print_params(1,2,3) #结果(1,2,3)
def print_params2(title, *params):
print title
print params
print_params('Params:',1,2,3) #结果Params:\n (1,2,3)
#收集关键字参数
def print_params_4(x,y,z=3, *pospar, **keypar):
print x,y,z
print pospar
print keypar
print_params_4(1,2,3,4,5,6,7,foo=1,bar=2)
#结果
1 2 3
(5,6,7)
{'foo':1, 'bar':2}
print_params_4(1,2)
#结果
1 2 3
()
{}
#反转过程
def add(x,y):return x+y
params=(1,2)
add(*params) #结果为3
def with_stars(**kwds):
print kwds['name'], 'is', kwds['age'],'years old'
def without_stars(kwds):
print kwds['name'], 'is', kwds['age'], 'years old'
args={'name':'Mr gumby', 'age':42}
with_stars(**args)
without_stars(args)
#结果都为 Mr gumby is 42 years old
#作用域
x=1
socpe=vars() #这里的var是()是内建的函数
scope['x']
#每个函数调用都会创建一个新的作用域
globals() #返回全局变量的字典，类似vars()
locals() #返回句柄变量的字典
#使用global 来申明一个变量为全局的
x=1
def change_global():
global x
x += 1
change_global() #x将变为2
#函数的嵌套，也就是函数里面包含函数，外层函数将会返回里层的函数也就是函数本身被返回了
#但并没有被调用
def multiplier(factor):
def multiplyByFactor(number):
return number*factor
return multiplyByFactor
double=multiplier(2)
double(5) #结果为10
triple=multiplier(3)
triple(3) #结果为9
multiplier(5)(4) #结果为20
#类似multiplyByFactor函数存储子封闭作用域的行为叫做闭包(closure)
#外部作用域变量一般来说是不能进行重新绑定的，python3中 nonlocal关键字被引入，他和global关键字的使用方式类似，可以让用户对外部作用域(但并非全局作用域)的变量进行赋值
异常
| 异常 | 描述 |
| NameError | 尝试访问一个没有申明的变量 |
| ZeroDivisionError | 除数为0 |
| SyntaxError | 语法错误 |
| IndexError | 索引超出序列范围 |
| KeyError | 请求一个不存在的字典关键字 |
| IOError | 输入输出错误（比如你要读的文件不存在） |
| AttributeError | 尝试访问未知的对象属性 |
| ValueError | 传给函数的参数类型不正确，比如给int()函数传入字符串形 |
#抛出异常
raise Exception
#自定义异常
class MyException(Exception):pass
#异常的捕获
try:
1/0
except:
print('number can't be zero!')
#完成的异常结构
try:
#......
#一些逻辑
except (TypeError,ZeroDivisionError) as e:
#
else:
#如果没有触发except，则会执行else语句
finally:
#finally子句一定会被执行
#使用sys模块中的函数
try:
1/0
except:
import sys
tuple = sys.exc_info()
tuple
#结果
(<class 'ZeroDivisionError'>, ZeroDivisionError('division by zero',), <traceback object at 0x00C90A58>)
#如果异常在函数内没有被处理则会继续往上抛
def faulty():
raise Exception('something is wrong')
def ignore_excepttion():
faulty()
def handle_exception():
try:
faulty()
except:
print('exception handled')
#结果
ignore_excepttion()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in ignore_excepttion
File "<stdin>", line 2, in faulty
Exception: something is wrong
handle_exception()
exception handled
参考