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)  转换类型

条件，循环和其他语句

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 == 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关键字的使用方式类似，可以让用户对外部作用域(但并非全局作用域)的变量进行赋值

更加抽象 

#定义一个类
class Person:  
    def setName(self,name):  
        self.name = name  
  
    def getName(self):  
        return self.name  
  
    def greet(self):  
        print("hello i'm "+self.name)


x = Person();
x.setName('aaa')
x.greet()

y = Person()
y.setName('bbb')
y.greet()
x.greet()
#结果
hello i'm aaa
hello i'm bbb
hello i'm aaa



class Service:
    def __inaccessible(self):
	print("bet you can't see me")

    def accessible(self):
	print("the secret message is:")
	self.__inaccessible()

s = Service()
#s.__inaccessible()
s.accessible()
help(Service)
#结果
the secret message is:
bet you can't see me
Help on class Service in module __main__:

class Service
 |  Methods defined here:
 |
 |  accessible(self)

异常

#抛出异常
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

参考

python中的range函数