python解释器在语法上不支持_Python语法

*** 环境

安装： brew install python3

python解释器：

开启：python

退出： exit()

执行文件： python xxx.py

输入：input()

eg: input(), input("please input somethong...")

输出：print()

eg: print("aaa"), print("aaa", "bbb") 逗号自动转为空格

*** 基础

python是动态强类型语言：运行时类型才被确定，类型校验严格，不支持隐式转换

"#": 键作为注释

":": 表示接下来的是代码块

缩进表示在同一个代码块

约定四个空格表示缩进，不推荐Tab

鸭子类型：类似于协议，只需要实现方法就可以，不需继承等

常用代码块

# 条件判断

if True:

# something

# s...

elif True:

# ...

else:

# other

# 循环

for a in b:

#...

while True:

# ...

for else # for循环中没有break就会执行else内容，条件不满足判断

while else #同上

try else # 没有exception会执行else代码段

常用变量

字符串：

b'ABC' #bytes类型

"" 或'', \转义符， 换行相同

格式化： 'Hello, %s' % 'world' 说明： %s等表示格式， %分割

eg: "name is %s age is %d" % ("shijian", 18)

'{0}, {1}, {0}'.format("first", "last") # 通过format格式化

"hellow" + "world," + name

ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符

encode('ascii') # 'utf-8' .decode('ascii') # 二进制类型的解码

encode('utf-8',errors='ignore') # ignore, replace(默认字符串)、

len('ABC') # 长度

Chardet工具包：用来猜测文本的可能编码方式

split(sep, maxsplit) #分割，$0不填默认是空格，$1分割次数

replace(old, new[, count]) #count选填

strip[chars] # 移除指定字符，默认移除空格，只能移除开始和结尾分部分，对中间无效

join(array1) # 将数组转换为字符串，";".join(["a", "b","c"]) = "a;b;c"

HereDoc：所见即所得文本(换行等生效)

s = '''

'''

Bool: True 或False， and or nor 计算

空值: None

常量： 约定全部大写：PI

if name == 'hello' or name == 'hi' or name == 'bs' or name == 'admin': 可以用 if name in ("", ""):代替

运算：10/3 = 3.33 10//3 = 3

数组：list

[1,2,3] a[1] a[-1]#最后一个 a[-2]#倒数第二

append #追加

insert # 插入

pop # 删除 pop(i) #删除指定位置

a[I] = 'bb' # 赋值

test = a[I] # 取值

切片

a[0:3] #从0开始，取3个

a[-2:] 取最后2个

a[:10] #取前十

a[:10:2] 取前十个，隔2取1

a[::5] 隔5取1

a[::-1] # 倒序，相当于reverse

a[1:3] = [1] # 数量不对等时，相当于删除或增加

元组: tuple

元组是常量 a[1] a[n]

collections.nameDump # 自定义一个元组

字典：dict

d = {"a"=123,"b"=23,"name"="shijian"}

d["a"] # 123

d["a"] = 1

d.get["c", 111] # 取不到取默认值111

for (k,v) in d.items(): # 遍历

# 两个独立数组可以被压缩成一个字典： zip

numbers = [61, 62, 63, 64, 65]

letters = ['a', 'b', 'c', 'd', 'e']

dict(zip(letters, numbers))

迭代：Iteration

isinstance(a, Iterable) #是否可迭代

用iter()函数从可迭代对象中获取迭代器

实现了__iter__方法或者__getitem__的类的实例都是可迭代对象

列表生成式

[x * x for x in list] #将list内容分别执行x * x形成新的数组

[m + n for m in 'ABC' for n in 'XYZ'] # 两个数组

生成器generator

g=(x * x for x in range(10))

next(g)

for循环迭代

生成器另一种表示：yield # 函数定义中包含yield关键字

def fib(max):

n, a, b = 0, 0, 1

while n < max:

yield b #遇到yield返回，调用next继续向下执行

a, b = b, a + b

n = n + 1

return 'done'

函数

def name(para): #函数定义

# do something

# 定义空函数可以直接在内容中使用pass

def name(para1, para2 = 10) #默认参数

必选参数需在前

默认参数不能是可变对象(想想指针，默认参数指向某个地址)

如果是可变的默认参数，默认应该为None，在函数内再设置默认值

def name(*paras) # 可变参数

name(1,2,3) # 直接使用

name(*list) list = [1,2,3] #使用*将list转为可变参数

def name(para1, **kw) # 关键字参数

name("aaa", age=18,grade=3) # 直接使用

name("aaa", **bbb) # 使用**将dict转为参数

kw是参数拷贝，修改不影响

def name(para1, *, name, age) #命名关键字参数， 关键字必须是已经命名的

必须传入参数名

name('Jack', name='Beijing', age ='Engineer')

name(name, age, *args, city, job) #可变参数后面跟命名参数可以省略*

参数顺序： 必选参数、默认参数、可变参数、命名关键字参数和关键字参数

任意函数，都可以通过类似func(*args, **kw)的形式调用

匿名函数：lambda

lambda x: x * x 等价于x*x的函数

f.__name__属性获取函数名称

偏函数：Partial function

f2 = functools.partial(int, base=2) #生成默认参数为base=2的int函数

装饰器:Decorator 函数动态增加功能

def log(func):

@functools.wraps(func) # 将func属性(__name__等)赋值到wrapper

def wrapper(*args, **kw):

print('call %s():' % func.__name__)

return func(*args, **kw)

return wrapper

@log

def now():

print('2015-3-25')

@log写在now定义处 等价于 now = log(now)

Python函数可理解为混合传值: 不可变的是值传递，可变的是引用

常用函数

range()

isinstance()

type() type(123) type(fn)==types.FunctionType

dir() 获得一个对象的所有属性和方法

hasattr(obj, 'x') # 有属性'x'吗

setattr(obj, 'y', 19) # 设置一个属性'y'

getattr(obj, 'y') # 获取属性'y' getattr(obj, 'z', 404)#默认值

模块

一个py文件代表一个模块

若干模块组成一个包Package

模块名= package.module

每个包必有一个__init__.py模块

import sys 导入sys模块

if __name__=='__main__' # 当在命令行运行时才为true，一般用于测试

模块作用域：没有实质控制private

约定以_开头的不应被直接使用

安装第三方模块: pip/pip3

pip3 install pillow # 安装pillow

from io import StringIO 从io中导入StringIO

面向对象：

class Student(object): # object 继承自基类

def init(self, para1, para2): # 构造函数

__ 开头的属性是private, # 可以通过"类名_属性名"访问(不建议)

重写不需要其他标志符

实例可以绑定任意多的方法、属性。方法只在当前有效，全局有限可使用Student.func1 = func1

@property 修饰属性，不写set时表示只读

支持多重继承MixIn

__slots__ = ('name', 'age') # 允许的属性名，对子类无效

__len__() #让该类能作用于len()函数

__str__() # 控制打印的内容 __repr__()供调试的打印， 可以__str__()和__repr__()

__getitem__() a[4], 通过下标取数据，需要考虑传入的是切片

__iter__ 迭代，需要实现next(), StopIteration表示结束

__next__() 返回下一个元素

__getattr__ 调用不存在的属性

__call__() 实例调用的方法 s = Student() s()

__dict__() 所有属性

定义函数时要加上self参数 def cry(self, time): 调用时可以忽略该参数

Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class 参数：名称，父类，方法绑定

class Chain(object):

def __init__(self, path=''):

self._path = path

def __getattr__(self, path):

return Chain('%s/%s' % (self._path, path))

// REST API

print(Chain("user").document.pictures.name)

user/document/pictures/name

静态函数，类方法

@staticmethod 可以被继承和重写

def sayHello():

@classmethod

def sayHello(cls): # 参数为类

枚举类

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

@unique # 保证值唯一

class Weekday(Enum):

Sun = 0 # Sun的value被设定为0

Mon = 1

Tue = 2

访问：

Weekday.Tue

Weekday['Tue']

Weekday.Tue.value 枚举值

Weekday(1) == Weekday.Mon

class Fib(object):

def __init__(self):

self.a, self.b = 0, 1 # 初始化两个计数器a，b

def __iter__(self):

return self # 实例本身就是迭代对象，故返回自己

def __next__(self):

self.a, self.b = self.b, self.a + self.b # 计算下一个值

if self.a > 100000: # 退出循环的条件

raise StopIteration()

return self.a # 返回下一个值

错误处理

可以跨越多层调用(只需要在外层使用try)

try:

# something

except ValueError as e:

print('ValueError:', e)

except ZeroDivisionError as e:

print('ZeroDivisionError:', e)

else:

print('no error!')

finally:

# ....

IO处理

# 文件操作一般用try catch

open(path, rb) # 打开文件 路径，模式

read() # 读取所有内容 read(size) readLine() readLines()

write()

close # 关闭

简化版： with 自动帮助关闭

with open(path, "r") as f:

print(f.read)

StringIO: 在内存中读写str

BytesIO: 二进制数据

os: 目录或文件系统

os.name() uname()

os.mkdir() # 创建文件夹

os.rmdir() # 删除

os.path.join() # 拼接路径

os.rename(a,b)

os.remove()

序列化pickling: 内存 -> 可存储

反序列化unpickling： 可存储 -> 内存

使用pickle 模块

json： json模块

dumps(dict) # 序列化

loads(str) # 反序列化

class -> json

class中定义转换的方法convert

dumps(clas1, default=convert)

json.loads(json_str, object_hook=dict2student)

常用内建模块

collections

namedtuple

创建一个自定义的tuple对象,可以用属性访问

Point = namedtuple('Point', ['x', 'y'])

p = Point(1, 2)

p.x

deque

高效实现插入和删除操作的双向列表，适合用于队列和栈

appendleft() popleft()

defaultdict

key不存在时，返回一个默认值

dd = defaultdict(lambda: 'N/A')

OrderedDict

有序的dict，按照插入的先后顺序

执行shell

import os

r = os.popen('pwd')

print(r.readlines())

多线程

def doSM():

#

t = threading.Thread(target=doSM)

t.start() # 异步执行的

t.join() # 如果想同步执行，调用join