Python 入门
HelloWorld
1.1 简单的输入输出
print('hello, world')
name = input()
python是不需要要类型声明的。
1.2 编码
要把bytes变为str，就需要用 decode() 方法
以Unicode表示的str通过 encode() 方法
1.3 基本数据结构
# List -> 有序表
可以使用下标，可变，[方括号]
classmates = ['Michael', 'Bob', 'Tracy']
classmates.append('Adam') # 追加
classmates.insert(1, 'Jack')
classmates.pop() # 删除末尾
classmates[1] = 'Sarah'
# tuple -> 元组
定长，不可修改，(圆括号)
classmates = ('Michael', 'Bob', 'Tracy')
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
# dict -> 字典,MAP
Key：Value，{花括号}
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Adam'] = 67 # 设定value
'Thomas' in d # 是否存在
d.get('Thomas')
d.pop('Bob') # delete Key with Value
# set
一组Key，不存储Value，Key不重复
要创建一个set，需要提供一个list作为输入集合
s = set([1, 1, 2, 2, 3, 3，4])
s.remove(4)
s
->{1, 2, 3}
1.4 基本逻辑条件
# if
age = 20
if age >= 6:
print('teenager')
elif age >= 18:
print('adult')
else:
print('kid')
# 循环
n = 1
while n <= 100:
if n > 10:
break
print(n)
n = n + 1
print('END')
Function
# 定义函数
def my_abs(x):
if x >= 0:
return x
else:
return -x
结构特性
3.1 切片
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3] # 0开始，3结束
L[-2:] # 取倒数第二个
L[:] # 复制一个list
'ABCDEFG'[:3]
->'ABC'
'ABCDEFG'[::2]
->'ACEG'
3.2 迭代
循环遍历，python的for有更高级的抽象
isinstance('abc', Iterable) # str是否可迭代
for x, y in [(1, 1), (2, 4), (3, 9)]:
print(x, y)
3.3 列表生成器 range()
生成[1x1, 2x2, 3x3, ..., 10x10]
L = []
for x in range(1, 11):
L.append(x * x)
-> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 另一种写法
[x * x for x in range(1, 11)]
# 还可以加条件
[x * x for x in range(1, 11) if x % 2 == 0]
# 甚至嵌套
[m + n for m in 'ABC' for n in 'XYZ']
3.4 生成器 generator
如果list受内存限制，我们可以不必存储他
generator可以断推算出list
只要把一个列表生成式的[]改成()，就创建了一个generator
next()函数获得generator的下一个返回值
g = (x * x for x in range(10))
for n in g:
print(n)
# 关键字 yield 函数与generator ...略
高阶函数
函数可以被传入
f=abs # 不要括号
# 神奇把...
def add(x, y, f):
return f(x) + f(y)
4.1 Map 不四dic那个map呀
map()函数接收两个参数，一个是函数，一个是Iterable
def f(x):
return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(r)
-> [1, 4, 9, 16, 25, 36, 49, 64, 81]
# 把这个list所有数字转为字符串
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
4.2 reduce 累计运算
def add(x, y):
return x + y
reduce(add, [1, 3, 5, 7, 9])
-> 25
# 把str转换为int的函数,把序列[1, 3, 5, 7, 9]变换成整数13579
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
# s='13579'
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return DIGITS[s]
return reduce(fn, map(char2num, s))
-> 13579
4.3 sorted 排序
# 反向，忽略大小写
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
4.4 匿名函数
lambda x: x * x实际上就是：
def f(x):
return x * x
4.5 装饰器 decorator
代码运行期间动态增加功能的方式
def log(func): # 打印日至
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
# 这样
@log
def now():
print('2015-3-25')
# 或者这样
now = log(now)
4.6 偏函数
把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数
int('12345', base=8)
-> 5349
int2 = functools.partial(int, base=2)
int2('1000000')
-> 64
模块
5.1 使用模块
import sys
OOP
6.1 类和实例
class Student(object):
def __init__(self, name, score): #构造函数?
self.name = name
self.score = score
# -----
bart = Student('Bart Simpson', 59)
访问和限制
class Student(object):
def __init__(self, name, score):
self.__name = name #注意这个下划线，私有
self.__score = score
def get_name(self):
return self.__name
def get_score(self):
return self.__score
def set_score(self, score):
self.__score = score
6.3 继承和多台
class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
def run(self):
print('Dog is running...')
def eat(self):
print('Eating meat...')
class Cat(Animal):
pass
# 鸭子特性，不必继承Animal，但又run方法，那么他看起来像只鸭子他就是鸭子
class Timer(object):
def run(self):
print('Start...')
6.4 获取类型
type(123)
-> <class 'int'>
a = Animal()
d = Dog()
h = Husky()
isinstance(h, Husky)
-> True
高级OOP
7.1__slots__
我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性。
s = Student()
s.name = 'Michael' # 动态给实例绑定一个属性
# ------
def set_age(self, age): # 定义一个函数作为实例方法
self.age = age
from types import MethodType
s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
但是，给一个实例绑定的方法，对另一个实例是不起作用的
为了给所有实例都绑定方法，可以给class绑定方法：
Student.set_score = set_score
限制实例的属性,即用__slots__
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
7.2 @property
把一个方法变成属性调用
class Student(object):
@property # getter
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
# ----
s = Student()
s.score = 60 # OK，实际转化为s.set_score(60)
s.score # OK，实际转化为s.get_score()
-> 60
s.score = 9999
-> Traceback (most recent call last):
-> ...
-> ValueError: score must between 0 ~ 100!
7.3 多重继承
class Dog(Mammal, Runnable):
pass
7.4 定制类
# __str__ = toString()
# __iter__= 可被循环的
def __iter__(self):
return self # 实例本身就是迭代对象，故返回自己
# __call__ ...梅高东有啥用
7.4 枚举Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
异常处理
try...catch...finally
断言：
assert n != 0, 'n is zero!'
IO
文件读写
f=open('/Users/michael/notfound.txt', 'r',encoding='gbk', errors='ignore')
f.read()
f.close()
# or
with open('/path/to/file', 'r') as f:
print(f.read())
with open('/Users/michael/test.txt', 'w') as f:
f.write('Hello, world!')
序列化 pickle
d = dict(name='Bob', age=20, score=88)
pickle.dumps(d)
# 反序列化
pickle.loads()
JSON
json.dumps(d)
json.loads(json_str)
# JSON一个类时，我们需要写一个方法
def student2dict(std):
return {
'name': std.name,
'age': std.age,
'score': std.score
}
# -----
json.dumps(s, default=student2dict)
# 反序列化
def dict2student(d):
return Student(d['name'], d['age'], d['score'])
json.loads(json_str, object_hook=dict2student)