Python常规语法学习

关键词

del

作用：删除变量

a = 1 # 对象1被a引用，计数器为1
b = a # 对象1被b引用，计数器为2
c = a # 对象1被c引用，计数器为3
del a # 删除a，计数器为2
del b # 删除b，计数器为1
print(c) # 对象1仍存在
del c # 删除c，计数器为0，此时自动删除对象1

另外，注意 list 的坑：

li=[1,2,3,4,5]  # 列表本身不包含数据1,2,3,4,5，而是包含变量：li[0] li[1] li[2] li[3] li[4] 
first=li[0]     # 拷贝列表，也不会有数据对象的复制，而是创建新的变量引用
del li[0]
print(li)      # 输出[2, 3, 4, 5]
print(first)   # 输出

global

函数内部想要对外部变量进行操作并且没有传参：

x = 1
def f():
    global x
    x = 2
print(x)
>>> 2

try...except...else...final

用于错误提示，和C++中的switch有点像，只要第一个excep捕获到异常，后面的except就不再捕获，直接执行finally，如果无异常，就执行else和finally

try:
    a = 1 / 0
    b = t()
    b.aa()
except ZeroDivisionError:
    print('0')
except:
    print('unknown erro')
else:
    print("wtf???!!!")
finally:
    print("end")

常用方法

str.format()

替代以前的%进行字符串的格式化：

"{}{}{}".format("hack", "the", "world")
>>> hack the world

"1:{1} 2:{2} 3:{1}".format("a","b")  # 指定位置
>>> aba

"the function name is {.__name__}".format(sort) # 传入对象
>>> the function name is sort

"{:.2f}".format(3.1415926535) # 格式化数字
>>> 3.14

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	{:b}	1011	二进制
11	{:d}	11	十进制
11	{:o}	13	八进制
11	{:x}	b	十六进制
11	{:#x}	0xb	十六进制
11	{:#X}	0XB	十六进制

^, <, > `分别是居中、左对齐、右对齐，后面带宽度， `: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+` 表示在正数前显示 `+`，负数前显示 `-； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

zip()

将可迭代对象打包成元组，返回这些元组组成的对象：

a = [1,2,3]
b = [999,999,999,998]
c = list(zip(a,b)) # 注意zip只返回对象，需要手动list
print(c)
>>> [(1,999), (2,999), (3,999)]

函数

参数列表

必选参数

默认参数：arg=1

可变参数：*args（传入多个参数）

def func(*args):
    print(args) # 此时args已经自动变为tuple
func(a,b,c)

关键字参数：**kw（传入自命名的参数）

def func(**kw):
    print(kw) # 此时arge已经自动变为dict
func(A=1, B=2, C=3)

命名关键字参数：*，args （传入有命名限制的关键字参数，可以和默认参数结合）

def func(A, B, *, C=999, D=999):
    pass
func(1,2,C=3,D=4)

返回函数

Python中函数可以返回函数，这样操作可以使得函数命赋值时暂时不执行操作，调用的时候才进行操作：

def function(*args):
    def sum():
        ans = 0
        for n in args:
            and += n
        return ans
return sum

>>>   A = function(1,2,3,4,5)
>>> A()
15

装饰器（@的使用）

临时为一个函数动态增加一些功能

# 先定义一个装饰器（使用返回函数的知识）
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

# 开始使用, 下面代码相当于：now = log(now)，也就是now指向了wrapper，注意原来的now函数仍然存在，但是同名now变量指向新的函数，所以调用now()将执行wrapper()
@log
def now():
    print('01-30')

>>> now()
call now()
01-30

# 注意经过装饰器后函数now的__name__已经变为了wrapper，为了防止一些依赖函数签名的代码执行失败，需要在编写装饰器时使用functools.wraps(需要functool模块)，令wrapper.__name__ = func.__name__

# 完整装饰器如下：
import functools

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

# 好啦，来个更疯狂的：
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('call %s():' % (text,func.__name__) )
            return func(*args, **kw)
        return wrapper
    return decorator

# 使用
@log('hello!')
def now():
    #略

面向对象

__del__(self)

作用：类似析构函数，销毁引用

__call__(self, **args)

作用：使实例能够被调用

class ex():
    def __init__(self, a):
        self.a = a
    def __call__(self, b):
        self.a = b
    def show(self):
        print(self.a)

test = ex(1)
test(2)
test.show() # 输出为2

常用module

queue -- 安全的线程控制模块

应用背景：

​ Python内置GIL(Global Interperator Lock) 在代码执行IO操作（调用操作系统内建C代码）的时候GIL自动释放，也就是说此时会有别的线程开始工作，那么如果新入线程同样进行IO操作的话将会是一场灾难，虽然可以手动使用Lock进行控制将IO锁死，但是有更加方便的处理，就是queue模块，已经帮我们做好了着方面的工作

官方文档

常用class：

Queue(maxsize=0)：提供FIFLO队列

LifoQueue(maxsize=0)：提供LIFO队列

PriorityQueue(maxsize=0)：提供优先级队列，官方推荐数据输入格式为(priority_number, data)，将根据元组第一个元素进行优先级排序，每次弹出优先度最低的元组（注意弹出的是元组，务必加上获取数据的代码）

常用objects：

• qsize()
• empty()
• full()
• put(item, block=True, timeout=None)：block为真时，该线程在进行中时，队列将被阻塞，如果timeout设置，那么将在timeout秒后将阻塞解开（用于队满场景）
• put_nowait(item)：无阻塞线程，立即执行
• get(block=True, timeout=None)：block用于队空场景
• get_nowait()
• task_done()：这个很重要，当一个线程完成的时候务必加上用以告诉线程队列这个线程已经进行完毕，不然会无限挂死
• join(): 对主线程进行阻塞直到队列中的所有线程都已结束

相关问题：

• [多线程queue block问题](.\问题解决/多线程queue block问题)

numpy -- 矩阵科学运算模块

• 方便的索引取值用法

  x_vals = np.array([1,2,3,4,5,6,7,8,9,10])
  
  train_indices = np.random.choice(len(x_vals), round(len(x_vals) * 0.8), replace=False)
  test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))
  x_vals_train = x_vals[train_indices]
  x_vals_test = x_vals[test_indices]

  可以向一个 array（数据集） 中直接传入一个 array（索引） 用作批量选取数据

os -- 操作系统调用模块

常用操作系统函数

• os.environ

  一个dictionary 包含环境变量的映射关系

• os.name

  显示当前使用的平台

• os.sep

  显示当前平台下路径分隔符

• os.linesep

  给出当前平台使用的行终止符

• os.remove('filename')

  删除一个文件

• os.rename("oldname","newname")

  重命名文件

• os.getcwd()

  显示当前python脚本工作路径

• os.chdir(dir)

  改变当前目录，注意windows下用到转义

• os.listdir('dirname')

  返回指定目录下的所有文件和目录名

• os.makedirs('dirname/dirname')

  可生成多层递规目录

• os.rmdir('dirname')

  删除单级目录

• os.getlogin()

  得到用户登录名称

• os.getenv(‘key’)

  得到环境变量配置

• os.putenv(‘key’)

  设置环境变量

• os.system()

  运行shell命令，注意：这里是打开一个新的shell，运行命令，当命令结束后，关闭shell。

os.path 提供的纯路径操作

函数

说明

• os.path.abspath()

  获取绝对路径 os.path.abspath("1.txt") == os.path.join(os.getcwd(),"1.txt")

• os.path.split()

  用于分开一个目录名称中的目录部分和文件名称部分。

• os.pardir

  表示当前平台下上一级目录的字符 ..

• os.path.join(path, name)

  连接目录和文件名。

• os.path.basename(path)

  返回文件名

• os.path.dirname(path)

  返回文件路径

• os.path.getctime("/root/1.txt")

  返回1.txt的ctime(创建时间)时间戳

• os.path.exists(os.getcwd())

  判断文件是否存在

• os.path.isfile(os.getcwd())

  判断是否是文件名，1是0否

• os.path.isdir('c:\Python\temp')

  判断是否是目录，1是0否

• os.path.islink('/home/111.sql')

  是否是符号连接，windows下不可用

• os.path.ismout(os.getcwd())

  是否是文件系统安装点，windows下不可用

• os.path.samefile(os.getcwd(), '/home')

  看看两个文件名是不是指的是同一个文件

• os.walk(top, topdown=True,onerror=None)

  能够把给定的目录下的所有目录和文件遍历出来。

  1、参数top表示需要遍历的顶级目录的路径。

  2、参数topdown的默认值是“True”表示首先返回顶级目录下的文件，然后再遍历子目录中的文件。当topdown的值为"False"时，表示先遍历子目录中的文件，然后再返回顶级目录下的文件。

  3、参数onerror默认值为"None"，表示忽略文件遍历时的错误。如果不为空，则提供一个自定义函数提示错误信息后继续遍历或抛出异常中止遍历。

  返回值：函数返回一个元组，含有三个元素。这三个元素分别是：每次遍历的路径名、路径下子目录列表、目录下文件列表。

• os.path.walk(top, func, arg)

  1、参数top表示需要遍历的目录路径。

  2、参数func表示回调函数，即对遍历路径进行处理的函数。所谓回调函数，是作为某个函数的参数使用，当某个时间触发时，程序将调用定义好的回调函数处理某个任务。注意：walk的回调函数必须提供三个参数：第1个参数为os.path.walk的参数arg，第2个参数表示目录dirname，第3个参数表示文件列表names。注意：os.path.walk的回调函数中的文件列表不和os.walk()那样将子目录和文件分开，而是混为了一谈，需要在回调函数中判断是文件还是子目录。

  3、参数arg是传递给回调函数的元组，为回调函数提供处理参数，arg可以为空。回调函数的第1个参数就是用来接收这个传入的元组的。

  过程：以top为根的目录树中的每一个目录(包含top自身，如果它是一个目录)，以参数(arg, dirname, names)调用回调函数funct。参数dirname指定访问的目录，参数names列出在目录中的文件(从os.listdir(dirname)中得到)。回调函数可以修改names改变dirname下面访问的目录的设置，例如，避免访问树的某一部分。(由names关联的对象必须在合适的位置被修改，使用del或slice指派。)注意：符号连接到目录不被作为一个子目录处理，并且因此walk()将不访问它们。访问连接的目录必须以os.path.islink(file)和os.path.isdir(file)标识它们，并且必须调用walk()。

  区别：os.path.walk()与os.walk()产生的文件名列表并不相同。os.walk()产生目录树下的目录路径和文件路径，而os.path.walk()只产生文件路径（是子目录与文件的混合列表）。

json -- 标准数据存储模块

JSON 函数

使用 JSON 函数需要导入 json 库：import json。

函数	描述
json.dumps	将 Python 对象编码成 JSON 字符串
json.loads	将已编码的 JSON 字符串解码为 Python 对象

---

json.dumps

json.dumps 用于将 Python 对象编码成 JSON 字符串。

语法

json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)

实例

以下实例将数组编码为 JSON 格式数据：

#!/usr/bin/python
import json

data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]

json = json.dumps(data)
print json

以上代码执行结果为：

[{"a": 1, "c": 3, "b": 2, "e": 5, "d": 4}]

使用参数让 JSON 数据格式化输出：

>>> import json
>>> print json.dumps({'a': 'Runoob', 'b': 7}, sort_keys=True, indent=4, separators=(',', ': '))
{
    "a": "Runoob",
    "b": 7
}

python 原始类型向 json 类型的转化对照表：

Python	JSON
dict	object
list, tuple	array
str, unicode	string
int, long, float	number
True	true
False	false
None	null

---

json.loads

json.loads 用于解码 JSON 数据。该函数返回 Python 字段的数据类型。

语法

json.loads(s[, encoding[, cls[, object_hook[, parse_float[, parse_int[, parse_constant[, object_pairs_hook[, **kw]]]]]]]])

实例

以下实例展示了Python 如何解码 JSON 对象：

#!/usr/bin/python
import json

jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

text = json.loads(jsonData)
print text

以上代码执行结果为：

{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

json 类型转换到 python 的类型对照表：

JSON	Python
object	dict
array	list
string	unicode
number (int)	int, long
number (real)	float
true	True
false	False
null	None

更多内容参考：https://docs.python.org/2/library/json.html。

---

使用第三方库：Demjson

Demjson 是 python 的第三方模块库，可用于编码和解码 JSON 数据，包含了 JSONLint 的格式化及校验功能。

Github 地址：https://github.com/dmeranda/demjson

官方地址：http://deron.meranda.us/python/demjson/

环境配置

在使用 Demjson 编码或解码 JSON 数据前，我们需要先安装 Demjson 模块。本教程我们会下载 Demjson 并安装：

$ tar -xvzf demjson-2.2.3.tar.gz
$ cd demjson-2.2.3
$ python setup.py install

更多安装介绍查看：http://deron.meranda.us/python/demjson/**install**

JSON 函数

函数	描述
encode	将 Python 对象编码成 JSON 字符串
decode	将已编码的 JSON 字符串解码为 Python 对象

---

encode

Python encode() 函数用于将 Python 对象编码成 JSON 字符串。

语法

demjson.encode(self, obj, nest_level=0)

实例

以下实例将数组编码为 JSON 格式数据：

#!/usr/bin/python
import demjson

data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]

json = demjson.encode(data)
print json

以上代码执行结果为：

[{"a":1,"b":2,"c":3,"d":4,"e":5}]

---

decode

Python 可以使用 demjson.decode() 函数解码 JSON 数据。该函数返回 Python 字段的数据类型。

语法

demjson.decode(self, txt)

实例

以下实例展示了Python 如何解码 JSON 对象：

#!/usr/bin/python
import demjson

json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

text = demjson.decode(json)
print  text

以上代码执行结果为：

{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}