python comprehensions_Python_基础

Run

源代码

Python源代码的文件以"py"为扩展名，由Python程序解释，不需要编译

命令：python 文件

字节代码

Python源文件经过编译后生成的扩展名为"pyc"的文件

编译方法：

import py_compile

py_compile.compile("url") # url编译的文件的路径

编译后的文件为：xxx.cpython-36.pyc

优化代码

经过优化的源文件，扩展名为".pyo"

命令：pyhont -O -m py_comile 编译的文件

编译后的文件为：xxx.cpython-36.opt-1.pyc

Type

int, float, str, bool, NoneType

tuple, list, dict, set

Lists

list = []

list[i:j] # 返回列表的子集

list[-1] # 访问的最后一个元素

list[:-1] # 只返回最后一个元素

list[i] = val

list[i:j] = otherlist # replace ith to jth element with otherlist

del list[i:j]

list.append(item)

list.extend(list)

list.insert(0, item)

list.pop()

list.remove(i)

list1 + list2 # 结合两个列表

set(list) # 从列表中删除重复元素

list.reverse()

list.count(item)

sum(list)

list.sort()

zip(list1, list2)

sorted(list)

",".join(list)

Dict

dict.keys()

dict.values()

"key" in dict

dict["key"] # throws KeyError

dict.get("key")

dict.setdefault("key", 1)

Iteration

for item in ["a", "b", "c"]:

for i in range(4): # 0 到 3

for i in range(4, 8): # 4 到 7

for key, val in dict.items():

String

str[0:4]

len(str)

string.replace("-", " ")

",".join(list)

"hi {0}".format('j')

str.find(",")

str.index(",")

str.count(",")

str.split(",")

str.lower()

str.upper()

str.title()

str.lstrip()

str.rstrip()

str.strip()

str.islower()

len() # 求序列长度

+ # 连接2个序列

* # 重复序列元素

in # 判断元素是否在序列中

max() # 返回最大值

min() # 返回最小值

Set

集合Set于列表，元组类似，可以存储多个数据，但是，这些数据是不重复的。

集合对象支持union(联合), intersection(交集), difference(差集)和sysmmetric_difference(对称差集)等数学运算

>>> x = set('abcd')

>>> x

{'c', 'a', 'b', 'd'}

>>> type(x)

>>> y = set(['h','e','l','l','o'])

>>> y

{'h', 'e', 'o', 'l'}

>>> z = set('spam')

>>> z

{'s', 'a', 'm', 'p'}

>>> y&z # 交集

set()

>>> x&z # 交集

{'a'}

>>> x|y # 并集

{'a', 'e', 'd', 'l', 'c', 'h', 'o', 'b'}

>>> x-y # 差集

{'c', 'a', 'b', 'd'}

>>> x^z # 对称差集(在x或z中，但不会同时出现在二者中)

{'m', 'd', 's', 'c', 'b', 'p'}

Casting

int(str)

float(str)

str(int)

str(float)

bool(1)

Comprehensions

[fn(i) for i in list] # .map

map(fn, list) # .map, 返回的迭代

filter(fn, list) # .filter, 返回的迭代

[fn(i) for i in list if i > 0] # .filter.map

Regex

import re

re.match(r'^[aeiou]', str)

re.sub(r'^[aeiou]', '?', str)

re.sub(r'(xyz)', r'\1', str)

expr = re.compile(r'^...$')

expr.match(...)

expr.sub(...)

Function

定义函数

使用关键字:def。 依次写出函数名, 括号, 参数, 语句结束符 :。然后，在缩进块中编写函数体，函数的返回值用return语句返回

def my_abs (x):

if x >= 0:

return x

else:

return -x

空函数

定义一个什么也不做的空函数，使用pass语句

def nop ()

pass

空函数的作用：提供占位符

参数

默认参数一定要用不可变对象(基本变量类型和tuple), 如果是可变对象，程序运行时会有逻辑错误。

定义可变参数和关键字参数的使用：

*args是可变参数，args接收的是一个tuple

**kw是关键字参数，kw接收的是一个dict

调用函数时如何传入可变参数和关键字参数：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数作用：为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数

返回值

函数执行完毕也没有return语句时，自动return None

函数可以同时返回多个值，但其实就是一个tuple

匿名函数

lamdba 参数:函数体

匿名函数自动具有返回值

Characteristic

区分大小写

语句结尾使用:

Tab符

if的各种假

Flase: '', None, 0, -0.0, 0.0 [], {}, (), Flase

==与is

is是比较两个引用是否指向了同一个对象(引用比较)

==是比较两个对象是否相等

a = 2

b = 2

a is b # True, 为True的原因是[-5, 256]

c = 500

d = 500

c is d # False

python解释器为了优化速度，会把[-5, 256]之间的数据提前存放到小整数对象池中，程序中要使用到[-5, 256]之间范围的数据，就不会重新创建一份，都是指向对象池中的同一份数据，除了这个区间之外的数据，每次使用时解释器都会重新申请一块内存，用来存储数据。

深拷贝和浅拷贝

浅拷贝：对于一个对象的顶层拷贝(拷贝了引用，并没有拷贝内容)

深拷贝：重新申请内存存储复制的数据.

import copy

a = [1, 2, 3]

b = a # 浅拷贝

c = copy.deepcopy(a) # 深拷贝

区别copy和deepcopy:

deepcopy：所有的内容都重新申请内存，依次拷贝

copy: 外层重新申请内存

拷贝元组的特点：

都是相同引用地址(元组是不可变类型,拷贝之后还是相同地址)