Python语法总结

您所在的位置：网站首页 › python中的fun › Python语法总结

Python语法总结

#Python语法总结| 来源: 网络整理| 查看: 265

前言

脚本是一种很有用的东西，它可以帮助我们减少很多重复的劳动。脚本的选择也有很多：JavaScript(Node.js)、Python、PHP、Shell ...

今天花了几个小时浏览了一下Python语法，做了一些小笔记，以便日后快速浏览复习：

Python格式编码

Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。

解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 就行了。

#coding=utf-8 print "你好，世界";注释

单行注释采用 # 开头：

name = "Madisetti" # 这是一个注释

多行注释使用三个单引号(''')或三个双引号(""")：

''' 这是多行注释，使用单引号。这是多行注释，使用单引号。这是多行注释，使用单引号。 ''' """ 这是多行注释，使用双引号。这是多行注释，使用双引号。这是多行注释，使用双引号。 """行和缩进

Python 的代码块不使用大括号 {} 来控制类、函数以及其他逻辑判断，而是是用缩进来写模块；缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行，否则会报“IndentationError: unexpected indent”错误

Python的语句后可以加分号（;），也可以省略分号，主要通过换行来识别语句的结束。

多行语句：

Python语句中一般以新行作为为语句的结束符。但是我们可以使用斜杠（ \）将一行的语句分为多行显示

total = item_one + \ item_two + \ item_three

三引号可以由多行组成：''' 或 """

paragraph = """这是一个段落。包含了多个语句"""

语句中包含 [], {} 或 () 括号就不需要使用多行连接符：

days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']单行多条语句：

Python 可以同一行显示多条语句，方法是用分号 ; 分开，如：

>>> print 'hello';print 'runoob'; hello基本输入输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号：

# 换行输出 print x print y # 不换行输出 print x, print y,变量类型Python 标识符标识符：可以包括英文、数字以及下划线(_)，但不能以数字开头；区分大小写。以下划线开头的标识符是有特殊意义的：以单下划线开头： _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；以双下划线开头： __foo 代表类的私有成员；以双下划线开头和结尾： __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。Python 保留字符

Python 的关键字只包含小写字母

Numbers（数字）数字数据类是不可改变的数据类型，改变数字数据类型会分配一个新的对象int（有符号整型）long（长整型[也可以代表八进制和十六进制]）float（浮点型）complex（复数）可以使用del语句删除一些 Number 对象引用：del var1[,var2[,var3[....,varN]]]]。如：del var_a, var_b一些数值类型的实例：

数学常量：

String（字符串）

" " 或 ' '

python的字串列表有2种取值顺序:从左到右索引默认0开始的，最大范围是字符串长度少1从右到左索引默认-1开始的，最大范围是字符串开头截取子字符串： [头下标:尾下标]，如：s = 'ilovepython' , s[1:5]的结果是love加号（+）是字符串连接运算符，星号（*）是重复操作#!/usr/bin/python # -*- coding: UTF-8 -*- str = 'Hello World!' print str # 输出完整字符串 print str[0] # 输出字符串中的第一个字符 print str[2:5] # 输出字符串中第三个至第五个之间的字符串 print str[2:] # 输出从第三个字符开始的字符串 print str * 2 # 输出字符串两次 print str + "TEST" # 输出连接的字符串转义字符:

字符串运算符:

格式化字符串的输出:

print "My name is %s and weight is %d kg!" % ('Zara', 21)

以上实例输出结果：

My name is Zara and weight is 21 kg!

python字符串格式化符号:

List（列表）

使用[ ]。

#!/usr/bin/python # -*- coding: UTF-8 -*- list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john'] print list # 输出完整列表 print list[0] # 输出列表的第一个元素 print list[1:3] # 输出第二个至第三个的元素 print list[2:] # 输出从第三个开始至列表末尾的所有元素 print tinylist * 2 # 输出列表两次 print list + tinylist # 打印组合的列表

以上实例输出结果：

['runoob', 786, 2.23, 'john', 70.2] runoob [786, 2.23] [2.23, 'john', 70.2] [123, 'john', 123, 'john'] ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

修改列表元素：

list[2] = 1000 # 直接覆盖原值

可以使用 del 语句来删除列表的的元素：

list1 = ['physics', 'chemistry', 1997, 2000]; del list1[2];

列表脚本操作符：

Tuple（元组）

使用（）。

元组类似于List（列表），但是元组不能二次赋值，相当于只读列表。

#!/usr/bin/python # -*- coding: UTF-8 -*- tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] tuple[2] = 1000 # 元组中是非法应用 list[2] = 1000 # 列表中是合法应用

#!/usr/bin/python # -*- coding: UTF-8 -*- tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) tinytuple = (123, 'john') print tuple # 输出完整元组 print tuple[0] # 输出元组的第一个元素 print tuple[1:3] # 输出第二个至第三个的元素 print tuple[2:] # 输出从第三个开始至列表末尾的所有元素 print tinytuple * 2 # 输出元组两次 print tuple + tinytuple # 打印组合的元组

以上实例输出结果：

('runoob', 786, 2.23, 'john', 70.2) runoob (786, 2.23) (2.23, 'john', 70.2) (123, 'john', 123, 'john') ('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组：

tup = ('physics', 'chemistry', 1997, 2000); del tup;

元组操作：

Dictionary（字典）

使用{ }。

字典由索引 key 和它对应的值 value 组成。

键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行。

#!/usr/bin/python # -*- coding: UTF-8 -*- dict = {} dict['one'] = "This is one" dict[2] = "This is two" tinydict = {'name': 'john','code':6734, 'dept': 'sales'} print dict['one'] # 输出键为'one' 的值 print dict[2] # 输出键为 2 的值 print tinydict # 输出完整的字典 print tinydict.keys() # 输出所有键 print tinydict.values() # 输出所有值

输出结果为：

This is one This is two {'dept': 'sales', 'code': 6734, 'name': 'john'} ['dept', 'code', 'name'] ['sales', 6734, 'john']

修改字典元素：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; dict['Age'] = 8; # update existing entry dict['School'] = "DPS School"; # Add new entry

删除字典元素：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; del dict['Name']; # 删除键是'Name'的条目 dict.clear(); # 清空词典所有条目 del dict ; # 删除词典运算符

逻辑运算符：

假设变量 a 为 10, b为 20：

成员运算符：

身份运算符：

算术运算符：

比较运算符：

赋值运算符：

位运算符：

逻辑控制语句条件语句if 判断条件1: 执行语句1…… elif 判断条件2: 执行语句2…… elif 判断条件3: 执行语句3…… else: 执行语句4……循环语句

for：

# 遍历 fruits = ['banana', 'apple', 'mango'] for fruit in fruits: print '当前水果 :', fruit # 下标迭代 fruits = ['banana', 'apple', 'mango'] for index in range(len(fruits)): print '当前水果 :', fruits[index] # for 循环嵌套 for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s)

while:

while 判断条件：执行语句…… # while 循环嵌套 while expression: while expression: statement(s) statement(s)

break：就像在C语言中，打破了最小封闭for或while循环

continue ：跳出本次循环

pass：空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

函数定义函数def functionname( parameters ): "函数_文档字符串" function_suite return [expression]

实例：

def printme( str ): "打印传入的字符串到标准显示设备上" print str return函数调用#!/usr/bin/python # -*- coding: UTF-8 -*- # 定义函数 def printme( str ): "打印任何传入的字符串" print str; return; # 调用函数 printme("我要调用用户自定义函数!"); printme("再次调用同一函数");匿名函数

python 使用 lambda 来创建匿名函数，lambda函数的语法只包含一个语句：

lambda [arg1 [,arg2,.....argn]]:expression

例子：

# 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2; # 调用sum函数 print "相加后的值为 : ", sum( 10, 20 )参数

必备参数：

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

#可写函数说明 def printme( str ): "打印任何传入的字符串" print str; return; #调用printme函数 printme("s");

关键字参数：

函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值

#可写函数说明 def printinfo( name, age ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" );

缺省参数:

调用函数时，缺省参数的值如果没有传入，则被认为是默认值

#可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" ); printinfo( name="miki" );

不定长参数：

一个函数能处理比当初声明时更多的参数。声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]

例子：

# 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print "输出: " print arg1 for var in vartuple: print var return; # 调用printinfo 函数 printinfo( 10 ); printinfo( 70, 60, 50 );

参数传递：

在 python 中，strings, tuples, 和 numbers 是不可更改（immutable）的对象，而 list,dict 等则是可以修改（mutable）的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。可变类型：类似 c++ 的引用传递，如列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

return 语句

返回单值：

# 可写函数说明 def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 return total; # 调用sum函数 total = sum( 10, 20 );

返回多值：

Python的函数返回多值其实就是返回一个tuple：

import math def move(x, y, step, angle): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny #效果与return (nx,ny)相同 print(move(100, 100, 60, math.pi / 6))

输出：

(151.96152422706632, 70.0)变量作用域

如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

Python 会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。因此，如果要给函数内的全局变量赋值，必须使用 global 语句。例如：

Money = 2000 def AddMoney(): # 想改正代码就取消以下注释: # global Money Money = Money + 1模块

module：一个 .py 文件就是个 module

模块能定义函数，类和变量，模块里也能包含可执行的代码。

重复执行模块

当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：

reload(module_name)

在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载 hello 模块，如下：

reload(hello)模块的引入import

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

1、当前目录

2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。

3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

在 Windows 系统，典型的 PYTHONPATH 如下：set PYTHONPATH=c:\python27\lib;

在 UNIX 系统，典型的 PYTHONPATH 如下：set PYTHONPATH=/usr/local/lib/python

import module1[, module2[,... moduleN]

在调用模块中的函数时，必须这样引用：

模块名.函数名

例子：

#!/usr/bin/python # -*- coding: UTF-8 -*- # 导入模块 import support # 现在可以调用模块里包含的函数了 support.print_func("Runoob")From…import

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：

from fib import fibonacci

把一个模块的所有内容全都导入到当前的命名空间：

from modname import *包

简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。

包中有很多模块（.py文件），可以直接通过 "包名.模块名"引用模块。

更多阅读：

Python包和类的基本用法：http://blog.csdn.net/liukang325/article/details/46724365

python中if __name__ == '__main__': 的解析： http://www.cnblogs.com/xuxm2007/archive/2010/08/04/1792463.html

类类定义class ClassName: '类的帮助信息' #类文档字符串 class_suite #类体

例子：

#!/usr/bin/python # -*- coding: UTF-8 -*- class Employee: '所有员工的基类' empCount = 0 def __init__(self, name, salary): self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): print "Total Employee %d" % Employee.empCount def displayEmployee(self): print "Name : ", self.name, ", Salary: ", self.salary创建实例对象"创建 Employee 类的第一个对象" emp1 = Employee("Zara", 2000) "创建 Employee 类的第二个对象" emp2 = Employee("Manni", 5000)访问属性emp1.displayEmployee() emp2.displayEmployee() print "Total Employee %d" % Employee.empCount

可以添加，删除，修改类的属性：

emp1.age = 7 # 添加一个 'age' 属性 emp1.age = 8 # 修改 'age' 属性 del emp1.age # 删除 'age' 属性

可以使用以下函数的方式来访问属性：

getattr(obj, name[, default]) : 访问对象的属性。hasattr(obj,name) : 检查是否存在一个属性。setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。delattr(obj, name) : 删除属性。hasattr(emp1, 'age') # 如果存在 'age' 属性返回 True。 getattr(emp1, 'age') # 返回 'age' 属性的值 setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8 delattr(empl, 'age') # 删除属性 'age'

类属性与方法：

类的私有属性：__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。类的方法：在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数类的私有方法：__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods

单下划线、双下划线、头尾双下划线说明：

__foo__: 定义的是特列方法，类似 __init__() 之类的。_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import * __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

Python内置类属性：

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）__doc__ :类的文档字符串__name__: 类名__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）#!/usr/bin/python # -*- coding: UTF-8 -*- class Employee: '所有员工的基类' empCount = 0 def __init__(self, name, salary): self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): print "Total Employee %d" % Employee.empCount def displayEmployee(self): print "Name : ", self.name, ", Salary: ", self.salary print "Employee.__doc__:", Employee.__doc__ print "Employee.__name__:", Employee.__name__ print "Employee.__module__:", Employee.__module__ print "Employee.__bases__:", Employee.__bases__ print "Employee.__dict__:", Employee.__dict__

执行以上代码输出结果如下：

Employee.__doc__: 所有员工的基类 Employee.__name__: Employee Employee.__module__: __main__ Employee.__bases__: () Employee.__dict__: {'__module__': '__main__', 'displayCount': , 'empCount': 0, 'displayEmployee': , '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': }类的继承

在python中继承中的一些特点：

1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。

2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

class SubClassName (ParentClass1[, ParentClass2, ...]): 'Optional class documentation string' class_suite

类判断：

issubclass() - 布尔函数：判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)isinstance(obj, Class) 布尔函数：如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

类重写：

#!/usr/bin/python # -*- coding: UTF-8 -*- class Parent: # 定义父类 def myMethod(self): print '调用父类方法' class Child(Parent): # 定义子类 def myMethod(self): print '调用子类方法' c = Child() # 子类实例 c.myMethod() # 子类调用重写方法

基础重载方法：

python对象销毁(垃圾回收)

Python 使用了引用计数这一简单技术来跟踪和回收垃圾：在 Python 内部记录着所有使用中的对象各有多少引用。一个内部跟踪变量，称为一个引用计数器。当对象被创建时，就创建了一个引用计数，当这个对象不再需要时，也就是说，这个对象的引用计数变为0 时，它被垃圾回收。但是回收不是"立即"的，由解释器在适当的时机，将垃圾对象占用的内存空间回收。

垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充，垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。在这种情况下，解释器会暂停下来，试图清理所有未引用的循环。

a = 40 # 创建对象 b = a # 增加引用，的计数 c = [b] # 增加引用. 的计数 del a # 减少引用的计数 b = 100 # 减少引用的计数 c[0] = -1 # 减少引用的计数异常python标准异常

BaseException、SystemExit、StandardError等

自定义异常class Networkerror(RuntimeError): def __init__(self, arg): self.args = arg

在你定义以上类后，你可以触发该异常，如下所示：

try: raise Networkerror("Bad hostname") except Networkerror,e: print e.args异常处理try: #运行别的代码 except ： #如果在try部份引发了'name'异常 except ，: #如果引发了'name'异常，获得附加的数据 else: #如果没有异常发生

try: 正常的操作 ...................... except(Exception1[, Exception2[,...ExceptionN]]]): 发生以上多个异常中的一个，执行这块代码 ...................... else: 如果没有异常执行这块代码 try: finally: #退出try时总会执行

例子：

#!/usr/bin/python # -*- coding: UTF-8 -*- try: fh = open("testfile", "w") fh.write("这是一个测试文件，用于测试异常!!") except IOError: print "Error: 没有找到文件或读取文件失败" else: print "内容写入文件成功" fh.close()应用

python函数库：（需要什么功能就google一下即可）

操作字符串、列表、元组、字典等时间文件I/O异步I/OFile 方法OS 文件/目录方法内置函数面向对象正则表达式MySQL网络编程（TCP/IP、HTTP...）SMTP多线程多进程XML解析JSONweb框架爬虫框架。。。

参考来源：Python 基础教程 | 菜鸟教程

【本文地址】

Python语法总结

Python语法总结

今日新闻

推荐新闻