Python语法

2017-11-07 本文已影响28人 Ashen_

*** 环境

安装： 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 = '''<HTML><HEAD><TITLE>
</BODY></HTML>
'''

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