面向对象与调试

在 2017年7月7日上张贴由 BestLove

# 面向对象 object:表示该类是从哪个类继承下来的
class Student(object):
    class_name = '类属性,实例和类都能访问'
    __slots__ = ('name', 'age') # 定义允许绑定的属性名称，只对当前类有效，对子类无效
    def __init__(self, name, score):
        self.__name = name    # 加上两个__就变成私有变量了 注意:__变量名__是特殊变量，这样取名不会变成私有变量
        self.score = score

    def print_info(self):
        print('%s: %s' % (self.__name, self.score))

tang = Student('tang', 100)
tang.age = 666
tang.print_info()
print(tang.class_name)
print(Student.class_name)
print(tang.age)
print(isinstance(tang, Student))    #True
print(isinstance(tang, object))     #True
print(type(tang) == Student)        #True
print(type(tang) == object)         #False
dir(tang)                           #获得一个对象的所有属性和方法
hasattr(tang, 'score')              #True
hasattr(tang, 'print_info')         #True
setattr(tang, 'score', 66)
getattr(tang, 'score')

# 给对象动态绑定方法
def set_age(self, age):
    self.age = age
from types import MethodType
tang.set_age = MethodType(set_age, tang)

# 给类动态绑定方法
Student.set_age = set_age

# 类装饰器
class Student(object):
    @property
    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

test = Student()
test.score = 100
print(test.score)

# 多继承
# 通常，主线都是单一继承下来的，需要混入额外的功能，可以使用多继承
# 这种设计通常称之为MixIn(约定俗成)
class Bird(Anmial, FlyableMixIn)

# 定制类
# __str__、__repr__、__iter__、__next__、__getitem__、__call__等

# 枚举类
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)

# 枚举类
from enum import Enum, unique
@unique
class Weekday(Enum):
    Sun = 7
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

for name, member in Weekday.__members__.items():
    print(name, '=>', member, "星期", member.value)

# 元类:metaclass 从type类型派生 通常用不到 不展开

# 异常处理
# https://docs.python.org/3/library/exceptions.html#exception-hierarchy
def test(num):
    try:
        10 / num
        print('ok')
    except Exception as e:
        print('not ok')
    finally:
        print('over')
test(1)
test(0)

# 断言 -O参数能关闭断言 python -O test.py
def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n

def main():
    foo('0')
main()

# 日志 debug info warning error
import logging
logging.basicConfig(level=logging.INFO)
s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)

# pdb python3 -m pdb test.py
# l 查看代码
# n 单步执行
# p 变量名 查看变量
# q 结束调试
# c 继续运行
s = '0'
n = int(s)
print(10 / n)

# 手动设置断点
import pdb
s = '0'
n = int(s)
pdb.set_trace()    # 运行到这里会自动暂停
print(10 / n)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

# 面向对象 object:表示该类是从哪个类继承下来的

class Student(object):

class_name = '类属性,实例和类都能访问'

__slots__ = ('name', 'age') # 定义允许绑定的属性名称，只对当前类有效，对子类无效

def __init__(self, name, score):

self.__name = name # 加上两个__就变成私有变量了注意:__变量名__是特殊变量，这样取名不会变成私有变量

self.score = score

def print_info(self):

print('%s: %s' % (self.__name, self.score))

tang = Student('tang', 100)

tang.age = 666

tang.print_info()

print(tang.class_name)

print(Student.class_name)

print(tang.age)

print(isinstance(tang, Student)) #True

print(isinstance(tang, object)) #True

print(type(tang) == Student) #True

print(type(tang) == object) #False

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

hasattr(tang, 'score') #True

hasattr(tang, 'print_info') #True

setattr(tang, 'score', 66)

getattr(tang, 'score')

# 给对象动态绑定方法

def set_age(self, age):

self.age = age

from types import MethodType

tang.set_age = MethodType(set_age, tang)

# 给类动态绑定方法

Student.set_age = set_age

# 类装饰器

class Student(object):

@property

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

test = Student()

test.score = 100

print(test.score)

# 多继承

# 通常，主线都是单一继承下来的，需要混入额外的功能，可以使用多继承

# 这种设计通常称之为MixIn(约定俗成)

class Bird(Anmial, FlyableMixIn)

# 定制类

# __str__、__repr__、__iter__、__next__、__getitem__、__call__等

# 枚举类

from enum import Enum

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

for name, member in Month.__members__.items():

print(name, '=>', member, ',', member.value)

# 枚举类

from enum import Enum, unique

@unique

class Weekday(Enum):

Sun = 7

Mon = 1

Tue = 2

Wed = 3

Thu = 4

Fri = 5

Sat = 6

for name, member in Weekday.__members__.items():

print(name, '=>', member, "星期", member.value)

# 元类:metaclass 从type类型派生通常用不到不展开

# 异常处理

# https://docs.python.org/3/library/exceptions.html#exception-hierarchy

def test(num):

try:

10 / num

print('ok')

except Exception as e:

print('not ok')

finally:

print('over')

test(1)

test(0)

# 断言 -O参数能关闭断言 python -O test.py

def foo(s):

n = int(s)

assert n != 0, 'n is zero!'

return 10 / n

def main():

foo('0')

main()

# 日志 debug info warning error

import logging

logging.basicConfig(level=logging.INFO)

s = '0'

n = int(s)

logging.info('n = %d' % n)

print(10 / n)

# pdb python3 -m pdb test.py

# l 查看代码

# n 单步执行

# p 变量名查看变量

# q 结束调试

# c 继续运行

s = '0'

n = int(s)

print(10 / n)

# 手动设置断点

import pdb

s = '0'

n = int(s)

pdb.set_trace() # 运行到这里会自动暂停

print(10 / n)

函数与模块

在 2017年6月14日上张贴由 BestLove

# map [1+4, 2+5, 3+6] -> [5, 7, 9]
def f(x, y):
    return x + y
res = map(f, [1, 2, 3], [4, 5, 6])
print(list(res))
# reduce f(f(f(1,6),2),3) -> 1+6+2+3 = 12
from functools import reduce
res = reduce(f, [1, 2, 3], 6)
print(res)
# filter 返回 true | false 过滤
def f(x):
    return x > 0
print(list(filter(f, [1, 0, -1, 2])))
# sorted(data [,key=func] [,reverse=True])
list = ['Zoo', 'about', 'kiss', 'Fuck']
print(sorted(list))    #['Fuck', 'Zoo', 'about', 'kiss']
print(sorted(list, key=str.lower))     #['about', 'Fuck', 'kiss', 'Zoo']
print(sorted(list, key=str.lower, reverse=True))     #['Zoo', 'kiss', 'Fuck', 'about']
# 返回函数
def my_sum(*args):
    def do_sum():
        x = 0
        for v in args:
            x = x + v
        return x
    return do_sum
f = my_sum(1, 2, 3, 4, 5, 6)
print(f())
# 匿名函数 关键字:lambda
print(list(map(lambda x : x * x, [1,2,3])))
# 装饰器 decorator
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
# @log相当于 now=log() (*args, **kw)表示传任意参数
@log
def now(date, time):
    print(date, time)
now('2017-06-14', '12:12:12')
print(now.__name__)         # wrapper
# 3层嵌套的decorator、使用包装器
import functools
def log(text):
    def decorator(func):
        @functools.wraps(func)   # wrapper.__name__ = func.__name__ python自带的包装器，完成了类似的赋值功能
        def wrapper(*args, **kw):
            print(text, func.__name__)
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now(date):
    print(date)
now('2017-06-14 13:13:13')
print(now.__name__)         # now
# 偏函数,只是把默认值改了,还是可以显示传入的
import functools
def hello(data, language='ENGLISH'):
    if language == '中文':
        print('你好', data)
    else:
        print('hello', data)
helloChinese = functools.partial(hello, language = '中文')
helloChinese('世界')
hello('world')
helloChinese('world', language = 'ENGLISH')
hello('世界', language = '中文')
# 模块(Module)、包(Package)
# 一个python文件就是一个模块，外层的目录就是包
# 每一个包目录下面都会有一个__init__.py的文件,否则，Python就把这个目录当成普通目录
# __init__.py可以是空文件,也可以有Python代码
# 因为__init__.py本身就是一个模块，而它的模块名就是目录名
# 一个包中可以放另外的包
# 约定属性 abc(PUBLIC) _abc __abc(PRIVATE) __name__(特殊变量)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
' a test module '
__author__ = 'BestLove'
import sys
def test():
    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')
# 命令行执行时，会调试test()方法
if __name__=='__main__':
    test()
# 第三方库地址 https://pypi.python.org/pypi
# MySQL的驱动：mysql-connector-python
# 科学计算的NumPy库：numpy
# 生成文本的模板工具Jinja2等等
# 安装图片处理工具库 pip install Pillow
from PIL import Image
im = Image.open('1.jpg')
print(im.format, im.size, im.mode)
# JPEG (75, 95) RGB
# 保存缩略图
im.thumbnail((50, 50))
im.save('thumb.jpg', 'JPEG')
# 默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块
import sys
print(sys.path)
# 运行时修改，运行结束失效
sys.path.append('/data/wwwroot/test')
# 设置环境变量PYTHONPATH Python自己本身的搜索路径不受影响

100

101

102

103

104

105

106

107

108

109

110

111

# map [1+4, 2+5, 3+6] -> [5, 7, 9]

def f(x, y):

return x + y

res = map(f, [1, 2, 3], [4, 5, 6])

print(list(res))

# reduce f(f(f(1,6),2),3) -> 1+6+2+3 = 12

from functools import reduce

res = reduce(f, [1, 2, 3], 6)

print(res)

# filter 返回 true | false 过滤

def f(x):

return x > 0

print(list(filter(f, [1, 0, -1, 2])))

# sorted(data [,key=func] [,reverse=True])

list = ['Zoo', 'about', 'kiss', 'Fuck']

print(sorted(list)) #['Fuck', 'Zoo', 'about', 'kiss']

print(sorted(list, key=str.lower)) #['about', 'Fuck', 'kiss', 'Zoo']

print(sorted(list, key=str.lower, reverse=True)) #['Zoo', 'kiss', 'Fuck', 'about']

# 返回函数

def my_sum(*args):

def do_sum():

x = 0

for v in args:

x = x + v

return x

return do_sum

f = my_sum(1, 2, 3, 4, 5, 6)

print(f())

# 匿名函数关键字:lambda

print(list(map(lambda x : x * x, [1,2,3])))

# 装饰器 decorator

def log(func):

def wrapper(*args, **kw):

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

return func(*args, **kw)

return wrapper

# @log相当于 now=log() (*args, **kw)表示传任意参数

@log

def now(date, time):

print(date, time)

now('2017-06-14', '12:12:12')

print(now.__name__) # wrapper

# 3层嵌套的decorator、使用包装器

import functools

def log(text):

def decorator(func):

@functools.wraps(func) # wrapper.__name__ = func.__name__ python自带的包装器，完成了类似的赋值功能

def wrapper(*args, **kw):

print(text, func.__name__)

return func(*args, **kw)

return wrapper

return decorator

@log('execute')

def now(date):

print(date)

now('2017-06-14 13:13:13')

print(now.__name__) # now

# 偏函数,只是把默认值改了,还是可以显示传入的

import functools

def hello(data, language='ENGLISH'):

if language == '中文':

print('你好', data)

else:

print('hello', data)

helloChinese = functools.partial(hello, language = '中文')

helloChinese('世界')

hello('world')

helloChinese('world', language = 'ENGLISH')

hello('世界', language = '中文')

# 模块(Module)、包(Package)

# 一个python文件就是一个模块，外层的目录就是包

# 每一个包目录下面都会有一个__init__.py的文件,否则，Python就把这个目录当成普通目录

# __init__.py可以是空文件,也可以有Python代码

# 因为__init__.py本身就是一个模块，而它的模块名就是目录名

# 一个包中可以放另外的包

# 约定属性 abc(PUBLIC) _abc __abc(PRIVATE) __name__(特殊变量)

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

' a test module '

__author__ = 'BestLove'

import sys

def test():

args = sys.argv

if len(args)==1:

print('Hello, world!')

elif len(args)==2:

print('Hello, %s!' % args[1])

else:

print('Too many arguments!')

# 命令行执行时，会调试test()方法

if __name__=='__main__':

test()

# 第三方库地址 https://pypi.python.org/pypi

# MySQL的驱动：mysql-connector-python

# 科学计算的NumPy库：numpy

# 生成文本的模板工具Jinja2等等

# 安装图片处理工具库 pip install Pillow

from PIL import Image

im = Image.open('1.jpg')

print(im.format, im.size, im.mode)

# JPEG (75, 95) RGB

# 保存缩略图

im.thumbnail((50, 50))

im.save('thumb.jpg', 'JPEG')

# 默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块

import sys

print(sys.path)

# 运行时修改，运行结束失效

sys.path.append('/data/wwwroot/test')

# 设置环境变量PYTHONPATH Python自己本身的搜索路径不受影响

python简介到高级特性

在 2017年6月13日2017年6月13日上张贴由 BestLove

# sublime插件：SublimeCodeIntel、[Anaconda]、SublimePythonIDE
# list 列表:有序的集合
list = ['test1', 'test2', 'test3', 123, True, ['child1', 'child2']]
print(list)
# 输出倒数第一个
print(list[-1])
print(list[len(list)-1])
# 末尾添加
list.append('test4')
print(list[len(list)-1])
# 指定索引处插入
list.insert(0, 'test0')
print(list)
# 末尾移除
list.pop()
# 指定索引处移除
list.pop(1)
# 赋值(替换)
list[0] = 't0'

# tuple 元组:不能修改的有序集合
t = (1, 2, 3)
# 当tuple中只有一个元素时，可能和括号中的一个数字产生歧义，加个,
t = (1,)
# tuple中的list是可以变的，因为tuple指向的list并没有改变
t = (1, 2, [3, 4])
t[2][0] = 1
t[2][1] = 2

# 判断 (":"和缩进)
a = 2
if a > 100:
    print("大")
elif a > 0:
    print("中")
else:
    print("小")

# 循环 (":"和缩进)  break continue
# for in
list = ['a', 'b', 'c', 'd']
for v in list:
    print(v)

# while
sum = 0
num = 100
while num > 0:
    sum += num
    num -= 1
print(sum)

# dict 字典 全称dictionary
dict = {'张三': 100, '李四': 99, '王八': 60}
print(dict['张三'])
# key不存在会报错
dict['王五'] = 99
# 用in判断
if ('王五' in dict):
    dict['王五'] = 99
# 用dict的get方法，第2个参数非必填[获取不到给默认值]，但是dict中并没有添加王五
five = dict.get('王五', 99)
print(five)
# 删除某个值
dict.pop('王八')

# set 无序、不重复的不变值集合 可以理解为一个没有value的dict或者说dict的key的集合
# 要创建一个set，需要提供一个list作为输入集合
s = set([1, 2, 3, 2, 3])
# 输出{1,2,3}
print(s)
s.add(4)
s.remove(3)
sb = set([2, 3, 4, 5, 6])
# 交集
rs = s & sb
print(rs)
# 并集
rs = s | sb
print(rs)
# 函数
abs(-100)
# 函数可以赋值
a = abs
a(-100)
# 定义函数
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x
# 定义空函数 pass是一个占位符，防止代码，还可以用在其它语句中
def nop():
    pass
# 返回多个值
def more_res(x):
    return x+1, x-1
rs1,rs2 = more_res(22)
print(rs1)
print(rs2)
# 默认参数 默认值需要是不变参数，否则多次调用后的返回值会不符合预期
def student_info(name, score, age=6, city='上海'):
    print(name, score, age, city)
student_info("王八", 90)
student_info("王八", 90, city="北京")
# 关键字参数
def person(name, age, **kw):
    print(name, age, kw)
person('张三', '13', city='上海', sex='男')
wangba = {'city': '山东', 'sex': '女'}
person('王八', '22', **wangba)
# 可变参数
def person(name, *age):
    print(name, age)
person('张三', 1, '2', '三')
# 命名关键字参数
def person(name, age, *, city, sex):
    print(name, age, city, sex)
person('张三', '13', city='广州', sex='男')
# 切片
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3]              #索引0 - 索引3 而不是 索引0后面取长度3
L[:3]               #索引0 - 索引3
L[1:3]              #索引1 - 索引3
L[-2:]              #最后2个
L[:10:2]            #前10个，每2个取1个
L[::5]              #所有数，每5个取1个
L[:]                #原样复制一个
'ABCDEFG'[:3]       #字符串也可以使用切片操作
# dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样
dect = {"k1":"v1","k2":"v2","k3":"v3","k4":"v4","k5":"v5"}
for k in dect:
    print(k)
for v in dect.values():
    print(v)
for k,v in dect.items():
    print(k,v)
# 可以多个迭代
for x,y,z in [(1,1,1),(2,2,2)]:
    print(x,y,z)
#列表生成式
list_a = [x * x for x in range(1,9)]        # [1, 4, 9, 16, 25, 36, 49, 64]
print(list_a)
list_b = [x * x for x in range(1,9) if x % 2 == 0]          # [4, 16, 36, 64]
print(list_b)
#两层循环
test_c = [m + n for m in 'ABC' for n in 'XYZ']
print(test_c)
# 生成器 generator 把列表生成式的"[]"变成"()"
# 生成器的好处，节省空间，保存的是一个对象或者说是一种算法，每次迭代推算出后续的元素
g = (x * x for x in range(1,9))
print(next(g))
for i in g:
    print(i)
# yield关键字
def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield 2
    print('step 3')
    yield 3
    return 'ok'
g = odd()
for i in g:
    print(i)
# Iterable可迭代对象 list、tuple、dict、set、str、generator
from collections import Iterable
print(isinstance('abc', Iterable))
# 可以被next()方法调用的称为迭代器 Iterator
from collections import Iterator
print(isinstance( (x for x in range(1,9)), Iterable ))
print(isinstance( (x for x in range(1,9)), Iterator))
# 把list、dict、str等Iterable变成Iterator可以使用iter()函数
iter([])
# Iterator对象表示的是一个数据流,可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误
# 可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据
# Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算
# 所以Iterator甚至可以表示一个无限大的数据流，例如全体自然数，但list确做不到，因为内存不够

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

# sublime插件：SublimeCodeIntel、[Anaconda]、SublimePythonIDE

# list 列表:有序的集合

list = ['test1', 'test2', 'test3', 123, True, ['child1', 'child2']]

print(list)

# 输出倒数第一个

print(list[-1])

print(list[len(list)-1])

# 末尾添加

list.append('test4')

print(list[len(list)-1])

# 指定索引处插入

list.insert(0, 'test0')

print(list)

# 末尾移除

list.pop()

# 指定索引处移除

list.pop(1)

# 赋值(替换)

list[0] = 't0'

# tuple 元组:不能修改的有序集合

t = (1, 2, 3)

# 当tuple中只有一个元素时，可能和括号中的一个数字产生歧义，加个,

t = (1,)

# tuple中的list是可以变的，因为tuple指向的list并没有改变

t = (1, 2, [3, 4])

t[2][0] = 1

t[2][1] = 2

# 判断 (":"和缩进)

a = 2

if a > 100:

print("大")

elif a > 0:

print("中")

else:

print("小")

# 循环 (":"和缩进) break continue

# for in

list = ['a', 'b', 'c', 'd']

for v in list:

print(v)

# while

sum = 0

num = 100

while num > 0:

sum += num

num -= 1

print(sum)

# dict 字典全称dictionary

dict = {'张三': 100, '李四': 99, '王八': 60}

print(dict['张三'])

# key不存在会报错

dict['王五'] = 99

# 用in判断

if ('王五' in dict):

dict['王五'] = 99

# 用dict的get方法，第2个参数非必填[获取不到给默认值]，但是dict中并没有添加王五

five = dict.get('王五', 99)

print(five)

# 删除某个值

dict.pop('王八')

# set 无序、不重复的不变值集合可以理解为一个没有value的dict或者说dict的key的集合

# 要创建一个set，需要提供一个list作为输入集合

s = set([1, 2, 3, 2, 3])

# 输出{1,2,3}

print(s)

s.add(4)

s.remove(3)

sb = set([2, 3, 4, 5, 6])

# 交集

rs = s & sb

print(rs)

# 并集

rs = s | sb

print(rs)

# 函数

abs(-100)

# 函数可以赋值

a = abs

a(-100)

# 定义函数

def my_abs(x):

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x >= 0:

return x

else:

return -x

# 定义空函数 pass是一个占位符，防止代码，还可以用在其它语句中

def nop():

pass

# 返回多个值

def more_res(x):

return x+1, x-1

rs1,rs2 = more_res(22)

print(rs1)

print(rs2)

# 默认参数默认值需要是不变参数，否则多次调用后的返回值会不符合预期

def student_info(name, score, age=6, city='上海'):

print(name, score, age, city)

student_info("王八", 90)

student_info("王八", 90, city="北京")

# 关键字参数

def person(name, age, **kw):

print(name, age, kw)

person('张三', '13', city='上海', sex='男')

wangba = {'city': '山东', 'sex': '女'}

person('王八', '22', **wangba)

# 可变参数

def person(name, *age):

print(name, age)

person('张三', 1, '2', '三')

# 命名关键字参数

def person(name, age, *, city, sex):

print(name, age, city, sex)

person('张三', '13', city='广州', sex='男')

# 切片

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

L[0:3] #索引0 - 索引3 而不是索引0后面取长度3

L[:3] #索引0 - 索引3

L[1:3] #索引1 - 索引3

L[-2:] #最后2个

L[:10:2] #前10个，每2个取1个

L[::5] #所有数，每5个取1个

L[:] #原样复制一个

'ABCDEFG'[:3] #字符串也可以使用切片操作

# dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样

dect = {"k1":"v1","k2":"v2","k3":"v3","k4":"v4","k5":"v5"}

for k in dect:

print(k)

for v in dect.values():

print(v)

for k,v in dect.items():

print(k,v)

# 可以多个迭代

for x,y,z in [(1,1,1),(2,2,2)]:

print(x,y,z)

#列表生成式

list_a = [x * x for x in range(1,9)] # [1, 4, 9, 16, 25, 36, 49, 64]

print(list_a)

list_b = [x * x for x in range(1,9) if x % 2 == 0] # [4, 16, 36, 64]

print(list_b)

#两层循环

test_c = [m + n for m in 'ABC' for n in 'XYZ']

print(test_c)

# 生成器 generator 把列表生成式的"[]"变成"()"

# 生成器的好处，节省空间，保存的是一个对象或者说是一种算法，每次迭代推算出后续的元素

g = (x * x for x in range(1,9))

print(next(g))

for i in g:

print(i)

# yield关键字

def odd():

print('step 1')

yield 1

print('step 2')

yield 2

print('step 3')

yield 3

return 'ok'

g = odd()

for i in g:

print(i)

# Iterable可迭代对象 list、tuple、dict、set、str、generator

from collections import Iterable

print(isinstance('abc', Iterable))

# 可以被next()方法调用的称为迭代器 Iterator

from collections import Iterator

print(isinstance( (x for x in range(1,9)), Iterable ))

print(isinstance( (x for x in range(1,9)), Iterator))

# 把list、dict、str等Iterable变成Iterator可以使用iter()函数

iter([])

# Iterator对象表示的是一个数据流,可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误

# 可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据

# Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算

# 所以Iterator甚至可以表示一个无限大的数据流，例如全体自然数，但list确做不到，因为内存不够

python入门

在 2017年1月5日上张贴由 BestLove

# 适合开发
// 首选是网络应用，包括网站、后台服务等等
// 其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等
// 另外就是把其他语言开发的程序再包装起来，方便使用。

# 缺点
// 运行慢、代码不能加密 (相对于编译型的语言)

# 下载安装  勾上Add Python 3.5 to PATH -> Install Now
https://www.python.org/ftp/python/3.5.2/python-3.5.2-amd64.exe

// 命令行进入输入python进入python环境(mac|linux输入python3)

# python解释器有很多 CPython是C语言开发的官方的，使用最广泛
CPython IPython PyPy Jython IronPython

# 输出hello world   python hello.py
#!/usr/bin/env python3                      #告诉Linux/OS X系统，这是一个Python可执行程序
# -*- coding: utf-8 -*-                     #按照UTF-8编码读取源代码
print('hello world', '可以多个输出哦')      #print需要顶格写 ','会自动变成一个空格
print(1+2+3)                

# 交互
name = input('please key your name:')
print('hello:', name)

# '#'是用来注释的，python语言大小写敏感    
a = 100
if (a > 1):         # 当语句以:结尾时，缩进语句视为代码块，约定使用4空格缩进
    print('a')
else:  
    print('b')

# r''可以让引号中的特殊字符不需要转义
print(r'\t test')
print('\\t test')

# 多行输出
print('''第一行
第二行
第三行''')

# True False(注意大小写) and or not(类似于&& || !)

# None空值

# PI = 3.14 python中没有常量，通常约定大写为常量(其实它还是个变量)

# 精确除 10/3=3.3333333333333335
# 地板除 10//3=3
# 取模   10%3=1

# ord函数获取字符的整数表示  chr函数把编码转换为对应的字符
test = ord('A')
print(test)
test = chr(test)
print(test)
test = ord('中')
print(test)
test = chr(test)
print(test)
print('\u4e2d')             #知道字符的整数编码，可以直接用十六进制

# bytes类型 b'' b""
x = b'ABC'
print(x)
print('ABC'.encode('ascii'))
print('中文'.encode('UTF-8'))
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8'))

# 格式化方式和C语言一致   输出hello world 100遍
print('hello %s %d遍' % ('world', 100))

# 记不起来类型的话，可以用%s统一处理，转换为字符串  %%正常输出%
print('比率为：%s%%' % 99)      #比率为：99%

# 适合开发

// 首选是网络应用，包括网站、后台服务等等

// 其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等

// 另外就是把其他语言开发的程序再包装起来，方便使用。

# 缺点

// 运行慢、代码不能加密 (相对于编译型的语言)

# 下载安装勾上Add Python 3.5 to PATH -> Install Now

https://www.python.org/ftp/python/3.5.2/python-3.5.2-amd64.exe

// 命令行进入输入python进入python环境(mac|linux输入python3)

# python解释器有很多 CPython是C语言开发的官方的，使用最广泛

CPython IPython PyPy Jython IronPython

# 输出hello world python hello.py

#!/usr/bin/env python3 #告诉Linux/OS X系统，这是一个Python可执行程序

# -*- coding: utf-8 -*- #按照UTF-8编码读取源代码

print('hello world', '可以多个输出哦') #print需要顶格写 ','会自动变成一个空格

print(1+2+3)

# 交互

name = input('please key your name:')

print('hello:', name)

# '#'是用来注释的，python语言大小写敏感

a = 100

if (a > 1): # 当语句以:结尾时，缩进语句视为代码块，约定使用4空格缩进

print('a')

else:

print('b')

# r''可以让引号中的特殊字符不需要转义

print(r'\t test')

print('\\t test')

# 多行输出

print('''第一行

第二行

第三行''')

# True False(注意大小写) and or not(类似于&& || !)

# None空值

# PI = 3.14 python中没有常量，通常约定大写为常量(其实它还是个变量)

# 精确除 10/3=3.3333333333333335

# 地板除 10//3=3

# 取模 10%3=1

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

test = ord('A')

print(test)

test = chr(test)

print(test)

test = ord('中')

print(test)

test = chr(test)

print(test)

print('\u4e2d') #知道字符的整数编码，可以直接用十六进制

# bytes类型 b'' b""

x = b'ABC'

print(x)

print('ABC'.encode('ascii'))

print('中文'.encode('UTF-8'))

print(b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8'))

# 格式化方式和C语言一致输出hello world 100遍

print('hello %s %d遍' % ('world', 100))

# 记不起来类型的话，可以用%s统一处理，转换为字符串 %%正常输出%

print('比率为：%s%%' % 99) #比率为：99%

唐晓锋–BLOG

This is just a personal note.

分类：python

面向对象与调试

函数与模块

python简介到高级特性

python入门