python简介到高级特性

# 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确做不到，因为内存不够

唐晓锋–BLOG

This is just a personal note.