Python 学习笔记

Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。
解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 # coding=utf-8 就行了

#!/usr/bin/python
# -*- coding: UTF-8 -*-
print( "你好，世界" )

Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。
以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。
Python 可以同一行显示多条语句，方法是用分号 ; 分开

在 Python 的代码块中必须使用相同数目的行首缩进空格数。
建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用

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

total = item_one + \
        item_two + \
        item_three

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

'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

Python 中的变量赋值不需要类型声明。

str = 'Hello World!' print str # 输出完整字符串 print str[0] # 输出字符串中的第一个字符 print str[2:5] # 输出字符串中第三个至第六个之间的字符串 print str[2:] # 输出从第三个字符开始的字符串 print str * 2 # 输出字符串两次 print str + "TEST" # 输出连接的字符串

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
元组是不允许更新的。而列表是允许更新的

int(x [,base])    将x转换为一个整数
long(x [,base] )    将x转换为一个长整数
float(x)    将x转换到一个浮点数
complex(real [,imag])    创建一个复数
str(x)    将对象 x 转换为字符串
repr(x)    将对象 x 转换为表达式字符串
eval(str)    用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)    将序列 s 转换为一个元组
list(s)    将序列 s 转换为一个列表
set(s)    转换为可变集合
dict(d)    创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)    转换为不可变集合
chr(x)    将一个整数转换为一个字符
unichr(x)    将一个整数转换为Unicode字符
ord(x)    将一个字符转换为它的整数值
hex(x)    将一个整数转换为一个十六进制字符串
oct(x)    将一个整数转换为一个八进制字符串

%    取模 - 返回除法的余数    b % a 输出结果 0
**    幂 - 返回x的y次幂    a**b 为10的20次方， 输出结果 100000000000000000000
//    取整除 - 返回商的整数部分（向下取整）    >>> 9//2
4
>>> -9//2
-5

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
运算符    逻辑表达式    描述    实例
and    x and y    布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。    (a and b) 返回 20。
or    x or y    布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。    (a or b) 返回 10。
not    not x    布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。    not(a and b) 返回 False

Python成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
运算符    描述    实例
in    如果在指定的序列中找到值返回 True，否则返回 False。    x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in    如果在指定的序列中没有找到值返回 True，否则返回 False。    x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

Python身份运算符
身份运算符用于比较两个对象的存储单元
运算符    描述    实例
is    is 是判断两个标识符是不是引用自一个对象    x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not    is not 是判断两个标识符是不是引用自不同对象    x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

s 与 == 区别：
is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。

 

if 判断条件：
    执行语句……
else：
    执行语句……

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

while 判断条件(condition)：
    执行语句(statements)……

for iterating_var in sequence:
   statements(s)

for letter in 'Python':
 # 第一个实例
print '当前字母 :', letter
fruits = ['banana', 'apple', 'mango']
for fruit in fruits:
# 第二个实例
print '当前水果 :', fruit

fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print '当前水果 :', fruits[index]

在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
for num in range(10,20):
# 迭代 10 到 20 之间的数字
for i in range(2,num):
# 根据因子迭代
    if num%i == 0:
    # 确定第一个因子
         j=num/i
        # 计算第二个因子
        print '%d 等于 %d * %d' % (num,i,j)
        break
# 跳出当前循环
else:
 # 循环的 else 部分
     print num, '是一个质数'

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

匿名函数
python 使用 lambda 来创建匿名函数。
* lambda只是一个表达式，函数体比def简单很多。
* lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
* lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
* 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda arg1, arg2: arg1 + arg2

import 语句
模块的引入
模块定义好后，我们可以使用 import 语句来引入模块，语法如下：
import module1[, module2[,... moduleN]]
比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：
模块名.函数名

from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
from modname import name1[, name2[, ... nameN]]
例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：
from fib import fibonacci

搜索路径
当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
* 1、当前目录
* 2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
* 3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

dir()函数
dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 导入内置math模块
import math
 
content = dir(math)
 
print content;
以上实例输出结果：
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
'sqrt', 'tan', 'tanh']

globals() 和 locals() 函数
根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

reload() 函数
当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：
reload(module_name)
在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载 hello 模块，如下：
reload(hello)

Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__init__.py 用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、__init__.py 文件，test.py 为测试调用包的代码，目录结构如下：

test.py
package_runoob
|-- __init__.py
|-- runoob1.py
|-- runoob2.py

类的继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
继承语法
class 派生类名(基类名)
    ...
在python中继承中的一些特点：
* 1、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。详细说明可查看： python 子类继承父类构造函数说明。
* 2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
* 3、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：
class SubClassName (ParentClass1[, ParentClass2, ...]):

class Parent:
# 定义父类
parentAttr = 100
def __init__(self):
print "调用父类构造函数"
def parentMethod(self):
print '调用父类方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父类属性 :", Parent.parentAttr
class Child(Parent):
# 定义子类
def __init__(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法'
c = Child()
# 实例化子类
c.childMethod()
 # 调用子类的方法
c.parentMethod()
# 调用父类方法
c.setAttr(200)
# 再次调用父类的方法 - 设置属性值
c.getAttr()

基础重载方法
下表列出了一些通用的功能，你可以在自己的类重写：
序号    方法, 描述 & 简单的调用
1    __init__ ( self [,args...] )
构造函数
简单的调用方法: obj = className(args)
2    __del__( self )
析构方法, 删除一个对象
简单的调用方法 : del obj
3    __repr__( self )
转化为供解释器读取的形式
简单的调用方法 : repr(obj)
4    __str__( self )
用于将值转化为适于人阅读的形式
简单的调用方法 : str(obj)
5    __cmp__ ( self, x )
对象比较
简单的调用方法 : cmp(obj, x)

运算符重载
Python同样支持运算符重载，实例如下：
实例
#!/usr/bin/python class Vector: def __init__(self, a, b): self.a = a self.b = b def __str__(self): return 'Vector (%d, %d)' % (self.a, self.b) def __add__(self,other): return Vector(self.a + other.a, self.b + other.b) v1 = Vector(2,10) v2 = Vector(5,-2) print v1 + v2

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

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