数据类型1
2
3
4
5
6
7
8int, float, long, complex
Bool
String
Byte
List
Tuble
Dict
Set
输入raw_input, 输出print
#注释,:结尾时缩进语句为代码块
r''内部不转义
通常用全大写表示常量
编码ASCII编码转换ord('A') == 65, chr(65) == 'A'
Unicode u'中文'
UTF-8 u'中文'.encode('utf-8')
格式化占位符
含义
%d
整数
%f
浮点数
%s
字符串
%x
十六进制整数
'Hello%%%s %s' % (',','world') -> Hello%, world
python文件文件头1
2#!/usr/bin/env python
# -*- coding: utf-8 -*-
List1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#定义
classmates = ['Michael', 'Bob', 'Tracy']
#长度
len(classmates)
#正向随机访问
classmates[1]
#反向随机访问
classmates[-1]
#追加
classmates.append('Adam')
#插入
classmates.insert(1, 'Jack')
#删除末尾
classmates.pop()
#删除索引位置
classmates.pop(1)
#切片(零可以省略)
classmates[0:1]
classmates[-1:0]
#list里面的元素的数据类型也可以不同。相当厉害
Tuple(不可变的List)1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#定义(和List不同,这是个圆括弧
classmates = ('Michael', 'Bob', 'Tracy')
#但是,要定义一个只有1个元素的tuple,如果你这么定义,那就只能是个1:
>>> t = (1)
>>> t
1
#所以,只有1个元素的tuple定义时必须加一个逗号,,来消除歧义
>>> t = (1,)
>>> t
(1,)
#可变的tuple,变的不是tuple,而是他指向的对象
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
dict (Map)1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#定义
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
#访问
#1 索引
d['Bob']
#如果key不存在,d['Thomas']就会报错,所以要做判断
if 'Thomas' in d:
d['Thomas']
#2 函数带默认值
d.get('Thomas')
d.get('Thomas', -1)
#增改
d['Jack'] = 90
#删除
d.pop('Bob')
#需要牢记的第一条就是dict的key必须是不可变对象,所以List不能作为key
set1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#定义 需要list作为输入集合
s = set([1, 2, 3])
#增加
s.add(4)
#删除
s.remove(4)
#交集
s1 & s2
#并集
s1 | s2
#差集
s1 - s2
迭代1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#判断是否可迭代类型
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False
#List实现类似Java那样的下标循环,ython内置的enumerate函数可以把一个list变成索引-元素对
for i, value in enumerate(['A', 'B', 'C']):
#dic迭代
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.iteritems():
列表生成式1
2>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
条件判断1
2
3
4
5
6
7
8
9
10
11
12
13
14
15if xxxxx:
gg
g
if xxxxx:
gg
else:
gg
if xxxxx:
gg
elif yyy:
kk
else:
zzz
循环1
2
3for xxx in XXXXX:
while xxx:
函数1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#定义
def my_func(x,y,z):
#pass
#return 1,2,3,4
#可变参数(个数)
def calc(*x):
#关键字参数(传入dict?)
def func(a, b, c=0, *args, **kw):
nums = [1, 2, 3]
calc(*nums)
#参数检查
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
函数式编程
map:映射,map(func, [1,2,3]), 每一个list的元素通过func去映射
reduce:规约,reduce(func, [1,2,3]),就是停做累计func(func(1,2),3)
lambda:lambda x,y: x+y
filter:过滤
sorted:
返回函数:
def lazy_sum(*args):
def sum():
return sum
装饰器:(设计模式方面,装饰模式。应用方面,注解)
利用了返回函数的语法糖
无参数,两层嵌套
1
2
3
4
5
6
7
8
9
10def log(func):
def wrapper(*args, **kw):
print 'call %s():' % func.__name__
return func(*args, **kw)
return wrapper
@log
def now():
print '2019'
如果需要传入参数,三层嵌套
1
2
3
4
5
6
7
8
9
10
11def log(text):
def decorator(func):
def wrapper(*args, **kw):
print '%s %s():' % (text, func.__name__)
return func(*args, **kw)
return wrapper
return decorator
@log('execute')
def now():
print '2013-12-25'
偏函数
偏函数是把函数的参数设定默认值,使得函数调用更加容易
OOP
定义
class Student(object) 对应 class Student extends Object
__init__构造函数
selfthis指针
__两个下划线表示private,但其实只是python解释器解释成了_Student__name,不同版本的解释器可能不一样。
__xxx__双下划线开始和结尾是特殊变量,也可以从外部访问
_单下划线语义是可以访问,但其实是个private变量
type()获取基本类型,也可以引入python的模块功能更强大一些1
2import types
type('abc')==types.StringType
isinstance,type无法直接处理class的继承关系1
2isinstance(dog, Dog)
isinstance(dog, Animal)
dir()获取一个对象的所有属性和方法
OOP 高级特性
python作为动态语言,即便在实例化一个class后照样可以给实例添加属性
__slots__ 可以限定这个class只能动态绑定那些属性(名称)
@property 方法变成属性….是真的机智
定制类
__str__ toString()
__iter__ implemets Iterator
__getitem__ 牛逼牛逼,下标访问
还有很多,省略了..
元类:metaclass,运行时可以对类做修改。
IO 编程1
2
3
4
5
6
7f = open('/a/a/a/a.txt', 'r')
f.read()
f.close
#closeable
with open('/a/a/a/a.txt', 'r') as f:
f.read()
正则表达式1
2
3
4import re
re.match(r'^d{3}-d{3,8}$', '010-12345')
re.groups()
re.group(0)
网络编程1
2
3
4
5import socket
# 创建一个socket:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 建立连接:
s.connect(('www.sina.com.cn', 80))