python语法总结

 

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

 

 

 

 

 

更加抽象 

#定义一个类
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)

 

 

 

异常

异常	描述
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

 

 

 

 

 

参考

python中的range函数