python2.7使用教程_Python2.7 入门教程

数据类型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))