python3 学习笔记

时间 2019-12-09

原文原文链接

Python3 Study Notes

本人不多写 python 代码, 通常都是用 go 的, 去年时用 python 写过一些收集系统信息的工具, 当时是边看手册边写的. 现在又要用 python 来写一个生成 xlsx 的工具, 就又须要查看手册了, 至于为何不用 go 写? 那是由于 go 的库不兼容永中. 在这里不得不说, 虽然 go 很火, 可是一些库仍是不如 python 多, 不如 python 兼容性好.python

为了不之后再出这种事情, 此次就好好的了解下 python, 将它的用法按照本身对语言的理解分块记录下来. 要使用某种语言, 我的认为须要了解这些方面:linux

编码风格
变量的类型, 声明及使用方式
输入/输出
控制语句的写法
错误处理的用法
函数的用法, 还有语言支持的一些特性, python 中就有装饰器, lambda 语句等
对于面向对象语言还须要了解类的声明, 继承, 多态等的用法

还有一些就是此语言的一些特性, python 就还须要了解如下特性:express

模块的使用

下文就将按照这些内容来一一记录.编程

编码风格

变量名, 方法名和模块名建议小写, 单词以 _ 分割, 类名建议驼峰命名风格, 首字母大写, 私有类可用一个 _ 开头.
每行结尾尽可能不要添加 ;, 多行代码也不要写在一行
python 是以缩进来控制代码段的, 因此缩减建议使用 4 个空格
编码尽可能使用 utf-8, python 默认使用 ASCII, 因此要在文件的开头添加 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 来指定
python 有独一无二的注释方式: 文档字符串, 因此注释尽可能用文档字符串("""xxxx""")
若是一个类不从其余类继承, 就显示的从 object 类继承
使用 with 语句来管理文件, 如 open 或 close
添加 TODO 时, 尽可能在其后紧跟 (), 在里面写明做者名或 email 等其余标识信息, 而后紧跟一个 : 后面接着写要作的事情
每一个导入模块都占一行, 不要一行导入多个模块
尽可能定义一个 main 函数, 将主程序放入其中, 并在 "if <span class="underline"><span class="underline">name</span></span> = '__main__':" 成立时执行 =main, 这样被看成模块导入时就不会执行主程序

变量

Python 是动态语言, 变量的类型不固定, 根据值的类型而决定, 因此不用显示的声明变量，用的时候直接赋值便可，以下:数组

a = 1; // 此时是整型
print(a);
a = 'hello'; // 此时又为字符串类型

一般变量名所有大写的为常量, 空值用 None 表示.网络

以 _xxx 或 __xxx 命名的函数或变量是私有变量, 不能被其余模块直接引用app

基础类型

这里将整型, 浮点型, 布尔和字符串看做是基本类型, 整型和浮点型的使用就再也不介绍了, 布尔的值只能为 True/False, 而字符串的常见操做以下:编程语言

使用 """ 或 ''' 能够嵌入长字符串
字符串能够经过下标来索引, len 函数获取长度
使用 + 进行拼接操做
字符串对象还内置了不少方法提供了一些常见功能, 具体请查阅手册

另外它们之间的相互转换是经过 int(arg), float(arg), str(arg) 这些内置的方法来处理的.函数

列表

列表中能够包含不一样类型的数据, 如:工具

list = ["eggs", 1, 67.12];

经过 list(seq) 能够将一个序列转换为列表.

array 模块提供了固定类型的数据, 能够指定要转换的类型, 具体请查阅手册.

列表经过下标索引, len 函数获取大小.

列表对象经常使用的方法以下:

append(item): 附加元素
insert(idx, item): 插入元素
pop(idx): 删除指定位置的元素, 参数为空则删除最后一个元素

列表遍历:

for <variable> in <array>:
    // do

// 带下标
for idx, name in enumerate(<array>):
    // do

// 列表中多个元素
for x, y in [(1, 1), (2, 4), (3, 9)]:
    // do

// 用 zip 同时遍历多个数组
a = [1, 2];
b = [5, 6];
for av, bv in zip(a, b):
    // do av=1, bv=5

// 生成
[x * x for x in range(1, 11) if x % 2 == 0]

元组

元组(tuple) 是一个不可修改的列表, 元组中每一个元素的指向是不可更改的, 但指向里的内容是能够更改的, 如元组中包含一个数组:

t = ('1', 1, ["A", "B"]);
t[2][0] = "X";
t[2][1] = "Y";

字典

语法:

dict = {'<key>':<value>}

经常使用的对象方法:

get(key, value): 获取指定 key 的值, 若是不存在则返回 value, 若是 value 未指定则返回 None
pop(key): 删除指定的 key

使用字典须要注意如下几点:

字典中的 key 不能重复
字典中的 key 不可变, 因此只能用数字, 字符串和元组
字典的值则没有限制, 能够是任意对象

集合

集合与字典相似, 是一组 key 的集合, 但不存储 value, 没有重复的 key.

要建立一个集合, 须要传入一个数组, 重复的元素会被自动过滤.

遍历:

for <key> in <dict>:
    // do

// 带下标
for idx, name in dict.items():
    // do

s = set([1, 2, 3 ,3]); // s: {1,2,3}

经常使用的对象方法:

add(key): 添加 key
remove(key): 删除 key

global 关键字

global 关键字用于声明变量的做用域, 用法以下:

# 全局变量
a = 1

def test():
    # 若下面这行注释掉, 则下面的 a 是局部变量, 'Global' 处的输出仍是全局变量 1
    # 若下面这行取消注释, 则下面的 a 是全局变量, 'Gloabl' 出的输出是 5
    # global a
    a = 5
    print("In test:", a)

# Global
print("Global:", a)

输出, global a 注释掉时:

In test: 5
Global: 1

输出, global a 取消注释时:

In test: 5
Global: 5

上面的只是基础，想要更好的使用变量，还须要了解如下内容：

类型对象的方法
python 中每种类型都是对象, 都提供了一些内置方法, 如字符串类型的 replace() 等
变量的内存分配
变量只是值的引用, 具体的内存分配是在值的这一边, 有些类型的值是不可变的, 这些是须要深刻了解的
结构体

python 中没有结构体, 可使用下列方式实现:
- 使用 struct 模块来实现, 须要了解与 c 中类型的格式对照, 建立时须要指定结构体的成员类型
- 使用类来实现, 在类的构造函数 __init__ 中定义结构体成员

输入/输出

输入

使用 raw_input(prompt) 能够接受控制台的输入

输出

使用 print() 能够打印内容到控制台, 格式化输出:

n = 1;
s = "Joy";
print("The %d student's name is %s" % (n, s));

也可使用 format 来格式化, 它会用传入的参数依次替换字符串内的占位符 {0}、{1}…… :

// {3:.1f} 表示保留一位小数
s = "The {0} student's name is {1}, score: {3:.1f}".format(1, "Joy", 87.75);
print(s);

控制语句

控制语句中可使用 break, continue, pass 关键字, break 与 continue 的做用与其余语言中的同样, pass 则是一个空语句, 不作任何事情, 通常是为了保持结构的完整性, 常被用来占位, 代表以后会实现.

注意: python 中没有 goto 和 switch.

IF

语法:

if <condition>:
elif <condition>:
else:

FOR

for <variable> in <array>:
    // do
else:

else 可选

WHILE

while <condition>:
    // do
else:

else 可选

错误处理

语法:

try:
    // do
except <error type> as e:
   // do
except <error type> as e:
else:
   // no error
finally:
   // do

若是 finally 存在, 则不管有没有异常都会执行, else 则在 except 都没进入时才执行.

函数

语法:

def func(arg1, arg2=value, arg3=value):
    // do
    return ret1, ret2

# 不定长参数
def func(arg1, *vartuple):
   "打印全部参数"
   print(arg1)
   for var in vartuple:
       print(var)
   return

定义函数时能够给参数指定默认值, 这样在调用时就能够不传入这些参数, 没有默认值的参数是必需要传入的.

定义默认参数要牢记一点：默认参数必须指向不变对象(数, 字符串, 元组)！

参数前加了 * 的变量会存放全部未命名的变量.

__name__ 是函数对象的一个属性, 能够拿到此函数的名称

Lambda

使用关键字 lambda, 就能够建立短小的匿名函式, 如:

# 语法
lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 10) # 20
print(sum(10, 20) # 30

特色:

lambda 只是一个表达式, 函数体比 def 简单的多, 近能封装有限的逻辑进去
lambda 函数拥有本身的命名空间, 而且不能访问自有参数以外或全局命名的参数
lambda 函数虽然间短, 但不等同于 内联函数

装饰器

当须要加强某个函数的功能时, 但有不但愿修改函数, 此时可使用装饰器. 如添加日志功能:

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def test():
    print("Test")

经过 @ 语法就给函数 test 添加了日志功能

模块

模块就是一个 python 文件, 使用 import 导入模块, 调用模块中的方法时就必须以 <module>.<func> 来调用.

from <module> import <func1>,<func2>... 语句是从模块中导入指定的函数, from <module> import * 则将模块中的全部方法都导入

导入一个模块时的路径搜索顺序以下:

先从当前目录查找是否有此模块
若是当前目录没有, 就从 PYTHONPATH 定义的目录下查找
若是都找不到, 就查看默认路径, linux 下通常是 /usr/lib/python

搜索路径定义在 sys.path 中, 能够用 append 函数来添加指定目录, 如项目中模块再也不同一个目录就能够添加 path 来导入

包

python 中的包就是一个分层次的目录, 定义了一个由模块及子包组成的环境.

包简单来讲就是一个目录, 目录中必须包含一个 __init__.py, 该文件能够为空, 目的使用来标识这个目录是一个包, 一个简单的例子以下:

如存在目录 package_test , 此目录下有 __init__.py, foo1.py, foo2.py 等文件

foo1.py 文件:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def foo1():
    print("Foo1 test")

foo2.py 文件:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def foo2():
    print("Foo2 test")

调用:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from package_test.foo1 import foo1
from package_test.foo2 import foo2

if __name__ == "__main__":
    foo1()
    foo2()

类

python 是一门面向对象语言, 因此建立类和对象是很容易的, 先简单介绍下面向对象的一些基本特征:

类: 用来描述具备相同属性和方法的对象的集合, 定义了每一个对象共有的属性和方法, 对象是类的实例
数据成员: 类中的变量, 用于处理类及对象的相关的数据
私有成员: 只能在类的内部方法中访问的成员
受保护成员: 只能由本类或子类访问的成员
公有成员: 全局的, 类内部, 外部和子类都能访问的成员
方法: 类中定义的函数
方法重写: 若是从父类继承的方法不知足需求, 能够对其从新实现, 这个过程就叫重写
操做符重载: 自定义某些操做符的功能, 如 + 操做符, 指明2个对象的数据如何相加
继承: 从一个父类派生出一个子类
多态: 若是多个对象都继承子一个父类, 经过传入一个父类变量来调用某个方法时, 若是此时传入的是子类的对象, 则会调用这个子类中实现的方法(方法已被重写)

类的建立

python 中类建立的语法以下:

# 建立一个类
class Human:
    # 类变量
    var1 = 0 # 公有成员
    _var2 = 0 # 受保护成员
    __var3 = 0 # 私有成员

    # 构造函数, 里面能够定义实例变量, 这些变量只有在这个函数调用后才能使用, 子类若是重写了构造函数, 则不能使用这些变量
    def __init__(self, arg1, arg2...):
        self.arg1 = arg1
        self._arg2 = arg2
        self.__arg3 = arg3

    # 类方法
    def foo(self):
        print("Var1:", var1)
        print("Arg1:", self.arg1)

"""
动态类型的语言在建立实例后, 能够给实例绑定任何的属性和方法, 但这些绑定只对当前实例有效
若是要对因此实例生效, 能够在建立实例前给动态的给类绑定
"""

# 动态的给类绑定属性和方法, 这些属性和方法全部实例均可用
Human.school = ''
# 实例化
h = Human(arg1, arg2...)
print(h.school)
# 方法调用
h.foo()
# 动态的给实例绑定属性和方法, 这些属性和方法只能该实例可用
h.parent = 'Big Joy'
# 类的销毁
del h

类的实例化是经过调用构造函数完成的, __init__ 函数中定义了实例化时须要的参数.

类中以一个 _ 开头命令的变量或方法叫作受保护成员, 以二个 _ 开头命名的叫作私有成员, 以 __ 开头并以 __ 结尾的为系统定义的, 通常是内置的成员.

使用 del 则可销毁一个类实例.

类内置了如下属性:

__dict__: 类的数据属性组成的字典
__doc__: 类的文档
__name__: 类名
__module__: 类定义所在的模块名
__bases__: 类继承的全部父类的元组

类的继承

语法以下:

class SubName(Parent1, Parent2...):
    pass

一个子类能够继承多个父类, 使用 isintance(obj, type) 能够判断一个对象的类型, 使用 issubclass(sub, parent) 能够判断是否为另外一个类的子类.

方法重写

若是父类的方法不能知足子类的需求, 子类就可重写此方法, 在使用子类对象调用此方法时会调用重写后的方法.

运算符重载 也是方法的重写, 只不过是对一些内置方法进行重写.

下面列出一些基本的内置方法:

__init__(self, [, args…]): 构造函数, 用户实例化对象
__del__(self): 析构函数, 用于删除对象
__repr__(self): 转化为供解释器读取的形式
__str__(self): 用于将值转化为适于人阅读的形式
__cmp__(self, obj): 对象比较
__add__(self, obj): '+' 对象相加
__sub__(self, obj): '-' 对象相减
__eq__(self, obj): '==' 对象是否相等
__gt__(self, obj): '>' 对象是否小于
__lt__(self, obj): '<' 对象是否小于
__iadd__(self, obj): '+=' 对象相加

更多的内置方法请查阅手册

以上就介绍完了 python 的基础知识, 按照上面的内容就可以写出 python 程序了, 固然前提是你不是一个小白, 至少熟悉一门编程语言.

但 python 还有不少高级知识则须要你自行使用学习了, 如文件操做, 进程和线程, 网络编程, 图形编程等等. 本文的目的只是让你明白 python 程序应该怎么写, 怎么把你用其余语言写的程序转换成 python 语言的, 更多高级的特性只能靠你本身学习尝试.