pythoncomprehensions_python

#开头&＃xff0c;注释

缩进的语句视为代码块

大小写敏感

数据类型和变量True 和 False 首字母大写

and、or 和 not

空值&＃xff1a;None

字符串格式化%%d 整数

%f 浮点数

%s 字符串

%x 十六进制整数

补位

>>>&＃39;%2d-%02d&＃39; % (3, 1)

&＃39; 3-01&＃39;

>>>&＃39;%.2f&＃39; % 3.1415926

&＃39;3.14&＃39;

数组&＃xff1a;list 和 tuplelist 数组len(list)得到长度

list[-2]获得倒数第二个元素

list.append(ele)往 list 中追加元素到末尾

list.insert(1, ele)&＃xff0c;把元素插入到指定的位置&＃xff0c;比如索引号为 1 的位置

list.pop()&＃xff0c;删除 list 末尾的元素&＃xff0c;用 pop()方法

list.pop(i)删除指定位置的元素&＃xff0c;用 pop(i)方法&＃xff0c;其中 i 是索引位置

元素的数据类型也可以不同&＃xff0c;L &＃61; [‘Apple’, 123, True]

tuple 数组&＃xff1a;classmates &＃61; (‘Michael’, ‘Bob’, ‘Tracy’)tuple 一旦初始化就不能修改&＃xff0c;代码更安全

条件判断和循环if elif else

for in

while

range()函数

>>>range(1,5) #代表从1到5(不包含5)

[1, 2, 3, 4]

>>>range(1,5,2) #代表从1到5&＃xff0c;间隔2(不包含5)

[1, 3]

>>>range(5) #代表从0到5(不包含5)

[0, 1, 2, 3, 4]

raw_inpit(str)读取的内容永远以字符串的形式返回

dict 和 setdict 就是 map&＃xff0c;用 key-value 的形式存储。

d &＃61; {&＃39;Michael&＃39;: 95, &＃39;Bob&＃39;: 75, &＃39;Tracy&＃39;: 85}

根据 key 获得 value[]&＃xff1a;一旦 key 不存在就会报错

get()函数&＃xff1a;如果 key 不存在&＃xff0c;可以返回 None&＃xff0c;或者自己指定的 value(作为第二个参数传入)

‘Thomas’ in d 如果不存在则返回 False

set 是一组 key 的集合&＃xff0c;但不存储 value&＃xff0c;key 不能重复。需要 list 作为输入

add(key)函数用来往里面添加元素&＃xff0c;自动忽略重复

remove(key)函数用来删除元素

&操作用来做交集

|操作用来做并集

函数类型检查 isinstance

可变参数 *

关键字参数 ** ,

参数定义的顺序必须

默认参数def power(x, n &＃61; 2):

s &＃61; 1

while n > 0:

n &＃61; n - 1

s &＃61; s * x

return s

定义默认参数要牢记一点&＃xff1a;默认参数必须指向不变对象&＃xff01;

可变参数a &＃61; [2, 3, 5]

def calc(*numbers):

sum &＃61; 0

for n in numbers:

sum &＃61; sum &＃43; n * n

return sum

calc(2, 3, 5) # 10

calc(*a) # 10

关键参数extra &＃61; {&＃39;city&＃39;: &＃39;Beijing&＃39;, &＃39;job&＃39;: &＃39;Engineer&＃39;}

def person(name, age, **kw):

print(&＃39;name:&＃39;, name, &＃39;age:&＃39;, age, &＃39;other:&＃39;, kw)

>>>person(&＃39;Michael&＃39;, 30)

# name: Michael age: 30 other: {}

>>>person(&＃39;Adam&＃39;, 45, gender &＃61; &＃39;M&＃39;, job &＃61; &＃39;Engineer&＃39;)

# name: Adam age: 45 other: {&＃39;gender&＃39;: &＃39;M&＃39;, &＃39;job&＃39;: &＃39;Engineer&＃39;}

>>>person(&＃39;Jack&＃39;, 24, city &＃61; extra[&＃39;city&＃39;], job &＃61; extra[&＃39;job&＃39;])

# name: Jack age: 24 other: {&＃39;city&＃39;: &＃39;Beijing&＃39;, &＃39;job&＃39;: &＃39;Engineer&＃39;}

>>>person(&＃39;Jack&＃39;, 24, **extra)

# name: Jack age: 24 other: {&＃39;city&＃39;: &＃39;Beijing&＃39;, &＃39;job&＃39;: &＃39;Engineer&＃39;}

kw 获得的 dict 是 extra 的一份拷贝&＃xff0c;对 kw 的改动不会影响到函数外的 extra。

命名关键字参数

*号 后面的参数被视为 命名关键字参数

def person(name, age, *, city &＃61; &＃39;shanghai&＃39;, job):

# 没有 city 和 job 字段或多了其他字段则会报错

print(name, age, city, job)

person(&＃39;Jack&＃39;, 24, city&＃61;&＃39;Beijing&＃39;, job&＃61;&＃39;Engineer&＃39;)

# Jack 24 Beijing Engineer

如果函数定义中已经有了一个可变参数&＃xff0c;后面跟着的命名关键字参数就不再需要一个特殊分隔符 * 了&＃xff1a;

def person(name, age, *args, city, job):

print(name, age, args, city, job)

person(&＃39;张三&＃39;, 12, 213, city&＃61;&＃39;北京&＃39;, job&＃61;&＃39;frontEnd&＃39;)

# 张三 12 (12, 213) 北京 frontEnd

如果没有 可变参数&＃xff0c;就必须加一个 * 作为特殊分隔符。如果缺少*&＃xff0c;Python 解释器将无法识别 位置参数 和 命名关键字参数

参数组合

在 Python 中定义函数&＃xff0c;可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数&＃xff0c;这 5 种参数都可以组合使用。

但是请注意&＃xff0c;参数定义的顺序必须是&＃xff1a;

必选参数

默认参数 x &＃61; 5

可变参数 *num

命名关键字参数 **ak

关键字参数 * (如存在可变参数则不需声明)

定义空函数def nop():

pass

pass 可以用来作为占位符

高级特性

切片(Slice )>>>L &＃61; [&＃39;Michael&＃39;, &＃39;Sarah&＃39;, &＃39;Tracy&＃39;, &＃39;Bob&＃39;, &＃39;Jack&＃39;]

>>>L[0:3]

[&＃39;Michael&＃39;, &＃39;Sarah&＃39;, &＃39;Tracy&＃39;]

L[0:3] 表示&＃xff0c;从索引 0 开始取&＃xff0c;直到索引 3 为止&＃xff0c;但不包括索引 3。即索引 0&＃xff0c;1&＃xff0c;2&＃xff0c;正好是 3 个元素。

如果第一个索引是 0&＃xff0c;还可以省略。

L[-1] 取倒数第一个元素&＃xff0c;也支持倒数切片&＃xff1a;L(-2:)

只写[:] 就可以原样复制一个 list

L[:10:2] 表示前十个元素&＃xff0c;每两个取一个&＃xff1a;[0,2,4,6,8]

L[:10:2] 前 10 个数&＃xff0c;每两个取一个

L[::5] 所有数&＃xff0c;每 5 个取一个&＃xff1a;

tuple 也可以用切片&＃xff0c;操作结果也是 tuple

字符串也支持切片

迭代(Iteration)只要是可迭代对象(list&＃xff0c;tuple&＃xff0c;dict&＃xff0c;set&＃xff0c;字符串)都可以用 for…in…迭代

默认情况下&＃xff0c;dict 迭代的是 key。如果要迭代 value&＃xff0c;可以用 for value in d.itervalues()

如果要同时迭代 key 和 value&＃xff0c;可以用 for k, v in d.iteritems()。

判断一个对象是否是可迭代对象&＃xff1a;

from collections import Iterable

isinstance(&＃39;abc&＃39;, Iterable) # str是否可迭代 True

isinstance([1,2,3], Iterable) # list是否可迭代 True

isinstance(123, Iterable) # 整数是否可迭代 False

拥有下标的循环&＃xff1a;

for i, value in enumerate([&＃39;A&＃39;, &＃39;B&＃39;, &＃39;C&＃39;]):

print i, value

for 循环同时引用两个变量&＃xff1a;

for x, y in [(1, 1), (2, 4), (3, 9)]:

print x, y

列表生成式(List Comprehensions)[x * x for x in range(1, 11)] &＃61;> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

加上判断&＃xff1a;[x * x for x in range(1, 11) if x % 2 &＃61;&＃61; 0] &＃61;> [4, 16, 36, 64, 100]

两层循环(可以用来生成全排列)&＃xff1a;[m &＃43; n for m in ‘ABC’ for n in ‘XYZ’] &＃61;> [‘AX’, ‘AY’, ‘AZ’, ‘BX’, ‘BY’, ‘BZ’, ‘CX’, ‘CY’, ‘CZ’]

生成器(Generator)在 Python 中&＃xff0c;这种一边循环一边计算的机制&＃xff0c;称为生成器&＃xff1a;generator。

生成器里面装了用来生成一个 list 的算法&＃xff0c;这样就不必创建完整的 list&＃xff0c;从而大量的节省空间。

如何创建 generator把列表生成的 [] 改成 ()

函数内使用 yield

g &＃61; (x * x for x in range(3))

g.next() # 0

g.next() # 1

g.next() # 4

g.next() # StopIteration

for n in g:

print n

定义 generator 的另一种方法&＃xff0c;yield&＃xff1a;

def fib(max):

n, a, b &＃61; 0, 0, 1

while n

yield b

a, b &＃61; b, a &＃43; b

n &＃61; n &＃43; 1

return &＃39;done&＃39;

如果一个函数定义中包含 yield 关键字&＃xff0c;那么这个函数就不再是一个普通函数&＃xff0c;而是一个 generator

可以直接使用 for 循环来迭代, 但是那样获取不到返回值, 必须使用捕获 StopIteration 错误, 返回值包含在 StopIteration 的 value 中&＃xff1a;

g &＃61; fib(6)

while True:

try:

x &＃61; next(g)

print(&＃39;g:&＃39;, x)

except StopIteration as e:

print(&＃39;Generator return value:&＃39;, e.value)

break

# g: 1

# ...

# Generator return value: done

Generator 的执行顺序

generator 函数在每次调用 next()时时候执行到 yield 语句返回&＃xff0c;再次执行时从上次返回的 yield 语句处继续执行。

def odd():

print(&＃39;step 1&＃39;)

yield 1

print(&＃39;step 2&＃39;)

yield(3)

print(&＃39;step 3&＃39;)

yield(5)

o &＃61; odd()

>>>next(o)

# step 1

# 返回值 1

>>>next(o)

# step 2

# 返回值 3

>>>next(o)

# step 3

# 返回值 5

迭代器凡是可作用于 for 循环的对象都是 Iterable 类型&＃xff1b;

凡是可作用于 next()函数的对象都是 Iterator 类型&＃xff0c;它们表示一个惰性计算的序列&＃xff1b;

list &＃61;> []、dict &＃61;> {}、str &＃61; ‘aaa’ 是 Iterable 但不是 Iterator

非 Iterator 可以通过 iter() 函数获得一个该对象。

模块mycompany

├─ __init__.py

├─ abc.py

└─ xyz.py

引入了包以后&＃xff0c;只要顶层的包名不与别人冲突&＃xff0c;那所有模块都不会与别人冲突。现在&＃xff0c;abc.py 模块的名字就变成了 mycompany.abc&＃xff0c;类似的&＃xff0c;xyz.py 的模块名变成了 mycompany.xyz。

每一个包目录下面都 必须有一个 __init__.py 的文件&＃xff0c;否则&＃xff0c;Python 就把这个目录当成普通目录&＃xff0c;而不是一个包。__init.py__ 可以是空文件&＃xff0c;也可以有 Python 代码&＃xff0c;因为__init.py__ 本身就是一个模块&＃xff0c;而它的模块名就是 mycompany。

类似的&＃xff0c;可以有多级目录&＃xff0c;组成多级层次的包结构。比如如下的目录结构&＃xff1a;

mycompany

├─ web

│ ├─ __init__.py

│ ├─ utils.py

│ └─ www.py

├─ __init__.py

├─ abc.py

└─ xyz.py

文件 www.py 的模块名就是 mycompany.web.www&＃xff0c;两个文件 utils.py 的模块名分别是 mycompany.utils 和 mycompany.web.utils。

模块是一组 Python 代码的集合&＃xff0c;可以使用其他模块&＃xff0c;也可以被其他模块使用。

创建自己的模块时&＃xff0c;要注意&＃xff1a;模块名要遵循 Python 变量命名规范&＃xff0c;不要使用中文、特殊字符&＃xff1b;

模块名不要和系统模块名冲突&＃xff0c;最好先查看系统是否已存在该模块&＃xff0c;检查方法是在 Python 交互环境执行 import abc&＃xff0c;若成功则说明系统存在此模块。

模块模板#!/usr/bin/env python3 # 可以让这个hello.py文件直接在Unix/Linux/Mac上运行

# -*- coding: utf-8 -*- # 文件本身使用标准UTF-8编码&＃xff1b;

&＃39; a test module &＃39; # 任何模块代码的第一行字符串都被视为模块的文档注释&＃xff1b;

__author__ &＃61; &＃39;Michael Liao&＃39; # 把作者写进去&＃xff0c;这样当你公开源代码后别人就可以瞻仰你的大名

# 以上就是Python模块的标准文件模板

import sys

def test():

args &＃61; sys.argv

if len(args)&＃61;&＃61;1:

print(&＃39;Hello, world!&＃39;)

elif len(args)&＃61;&＃61;2:

print(&＃39;Hello, %s!&＃39; % args[1])

else:

print(&＃39;Too many arguments!&＃39;)

# 当我们在 命令行运行 hello 模块文件时&＃xff0c;Python 解释器把一个特殊变量 __name__ 置为 __main__

# 也就是下面的这个 if 只有用命令行运行才会执行

if __name__&＃61;&＃61;&＃39;__main__&＃39;:

test()

作用域

类似__xxx__这样的变量是特殊变量&＃xff0c;可以被直接引用&＃xff0c;但是有特殊用途&＃xff0c;我们自己的变量一般不要用这种变量名&＃xff1b;

类似_xxx 和 __xxx__ 这样的函数或变量就是非公开的(private)&＃xff0c;不应该被直接引用

private 函数或变量不应该被别人引用&＃xff0c;那它们有什么用呢&＃xff1f;请看例子&＃xff1a;

def _private_1(name):

return &＃39;Hello, %s&＃39; % name

def _private_2(name):

return &＃39;Hi, %s&＃39; % name

def greeting(name):

if len(name) > 3:

return _private_1(name)

else:

return _private_2(name)

外部不需要引用的函数全部定义成 private&＃xff0c;只有外部需要引用的函数才定义为 public

面向对象编程

未完待续…