数据结构
# =========base
print('=================base')
name = 'name'
print('hello,忠翁', name)
print('''line1
line2
line3''')
print('hello %s, %.2f ' % ('zw', 1.22222))
# ==========list
print('=================list')
list_1 = [1, 2, 3]
print(list_1[0], list_1[-1])
# -----基本操作
list_1.append(4)
list_1.insert(1, 11)
print(list_1)
list_1.pop()
print(list_1)
list_1.pop(1)
print(list_1)
# ------不同类型
list_1.append('s1')
list_1.append(['a1', 'a2'])
print(list_1)
# ===========tuple
# tuple和list非常类似，但是tuple一旦初始化就不能修改
print('=================tuple')
tuple_1 = (1, 2)
print(tuple_1[0], tuple_1[-1])
# --tuple的陷阱:
# 1 定义的时候，tuple的元素就必须被确定下来
# 2 只有1个元素时，必须加一个逗号,，来消除歧义；否则只是定义了一个变量
tuple_2 = (1)
print(tuple_2)
tuple_2 = (1,)
print(tuple_2)
# 3 嵌套元素可能可变,其不变指 直接元素的指向不变
tuple_3 = (1, [11, 12], 2)
tuple_3[1][0] = 10
print(tuple_3)
# ===========set
print('=================set')
set_1 = set([1, 1, 2, 2, 3, 3])
print(set_1)
set_1.add(4)
set_1.add(5)
print(set_1)
set_1.remove(1)
# -- set可以做数学意义上的交集、并集等操作
set_2 = set([1, 2, 'a'])
print(set_1 & set_2 )
print(set_1 | set_2)
# =============dic
print('=================dic')
dic_1 = {'k1':1, 'k2':'v2'}
dic_1[3] = 'v3'
dic_1['k4'] = 'v4'
print(dic_1)
print('k1' in dic_1)
print(dic_1.get('k5'))
dic_1.pop('k1')
print(dic_1)
# ===========条件判断
print('=================if else')
age = 20
if age >= 6:
print('teenager 1')
print('teenager 2')
elif age >= 18:
print('adult')
else:
print('kid')
if age:
print('not empty')
# -- 非零数值、非空字符串、非空list等，就判断为True，否则为False
list_empty = []
if list_empty:
print('list not empty')
else:
print('list empty')
# =============循环
print('=================for while')
# -- for x in ...
for item_list_1 in list_1:
print(item_list_1)
sum = 0
for integer in range(101):
sum += integer
print(sum)
# -- while 表达式
sum = 0
n = 99
while n > 0:
sum += n
if sum < 300:
print('sum[%d] < 300 continue' % sum)
continue
if sum > 2000:
print('sum[%d] > 2000 break' % sum)
break
n -= 2
print(sum)
函数
# 函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”
my_abs = abs
print(my_abs(-100))
# -----------定义函数 def
def fun_abs(x):
if x >= 0:
return x
else:
return -x
print(fun_abs(-200))
# ------------空函数 pass
def fun_empty(a):
pass
def fun_empty_block(a):
if a > 10:
print('pass block')
pass
print(fun_empty(11))
print(fun_empty_block(11))
# -- 参数类型检查
def fun_val_param(x):
if not isinstance(x, (int, float)):
raise TypeError("illegal param")
return -x
# -- 返回多个值
def return_multi(x):
return x+1, x+2
a1, a2 = return_multi(1)
print(a1, a2)
# - 其实这只是一种假象，Python函数返回的一个tuple
print(return_multi(1))
# -- 默认参数
# - 1 必选参数在前，默认参数在后
# - 2 把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数
# - 3 定义默认参数要牢记一点：默认参数必须指向不变对象！
def fun_default_param(name, age = 0, city = '北京'):
print('name:', name)
print('age:', age)
print('city:', city)
fun_default_param('a0', 10, '河北')
fun_default_param('a1', 30)
fun_default_param('a2')
# - 参数非顺序指定，需给出名称
fun_default_param(age=100, city='保定', name='老子')
# - 默认参数有个最大的坑：默认参数L的值[]，在函数定义时已计算好，
# - 调用，L指向的默认值是共享的！！
def fun_big_hole(l = []):
l.append('end') # - 关键这里把共享的默认参数值改变了
print(l)
return l
list_def_big_hole = [1]
fun_big_hole(list_def_big_hole)
fun_big_hole(list_def_big_hole)
fun_big_hole()
fun_big_hole()
# -- 可变参数：传入的参数的个数是可变的
def calculate(beg , *numbers):
print('beg', beg)
sum = 0
for n in numbers:
sum += n
print('sum:', sum)
return sum
calculate(1, 1, 2, 3)
calculate(1, *[1, 2, 3])
calculate(4, 5)
calculate(*(4, 5))
calculate(1)
# -- 关键字参数
# 可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
# 而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
person('Michael', 30)
person('Bob', 35, city='Beijing')
person('Adam', 45, gender='M', job='Engineer')
dic_person = {'k1':1, 'k2':'v2'}
person('XiaoMing', 10, **dic_person)
# -- 命名关键字参数
# 如果要限制关键字参数的名字，就可以用命名关键字参数
# 如只接收city和job作为关键字参数
# 和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数
def person_named(name, age, *, city, job):
print(name, age, city, job)
# 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
def person_var_named(name, age, *args, city, job):
print(name, age, args, city, job)
# 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错
# 命名关键字参数可以有缺省值, 调用时，可不传入city参数
def person_var_named_default(name, age, *, city='Beijing', job):
print(name, age, city, job)
person_var_named_default('hao', 10, job = 'jobMe')
# -- 参数组合
# 在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。
# 但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
def args_compose_1(b, c=0, *args, **kw):
print('b =', b, 'c =', c, 'args =', args, 'kw =', kw)
args_compose_1(1, 2, 3, 4, 5, kw1 = [1, 1], kw2 = 'kw2')
args_compose_1(1, 2, kw1 = [1, 1], kw2 = 'kw2')
def args_compose_2(b, c=0, *, d, **kw):
print('b =', b, 'c =', c, 'd =', d, 'kw =', kw)
args_compose_2(1, 2, d = 'hello', kw1 = [1, 1], kw2 = 'kw2')
args_compose_2(1, 2, a = 'a', d = 'd')
高级特性
from collections import Iterable
# ========== 切片
# -- 开始索引:结束索引(但不包括)
L = [0, 1, 2, 3, 4, 5]
print(L[0:3])
print(L[:3])
print(L[-1:-2])
print(L[-2:-1])
print(L[-2:])
L2 = L[:]
L2[0] = 10
print(L)
print(L2)
# --tuple也是一种list，唯一区别是tuple不可变。
# tuple也可以用切片操作，只是操作的结果仍是tuple
T = (1, 2, 3, 4)
print(T[:2])
# -- 字符串'xxx'也可以看成是一种list, 每个元素就是一个字符。
# 字符串也可以用切片操作，只是操作结果仍是字符串
S = '123456'
print(S[:3])
# ===========迭代 iterable
# 当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，
# 而我们不太关心该对象究竟是list还是其他数据类型。
D = {'a': 1, 'b': 2, 'c': 3}
for key in D:
print(key)
for value in D.values():
print(value)
for item in D.items():
print('item', item, ' key:', item[0], " v:", item[1])
# - 如何判断一个对象是可迭代对象呢？
# - 方法是通过collections模块的Iterable类型判断
print(isinstance(D, Iterable))
print(isinstance('123', Iterable))
# - 如果要对list实现类似Java那样的下标循环怎么办？
# - Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身
print(enumerate(D))
for i, key in enumerate(D):
print(i, key)
# ==================列表生成式
# -- 生成[1x1, 2x2, 3x3, ..., 10x10]
print( [x * x for x in range(1, 11)])
# -- for循环后面还可以加上if判断
print([x * x for x in range(1, 11) if x % 2 == 0])
# -- 使用两层循环(甚至三层或以上)
print([m + n for m in 'ABC' for n in 'XYZ'])
# -- for循环其实可以同时使用两个甚至多个变量
d = {'x': 'A', 'y': 'B', 'z': 'C' }
print([k+'='+v for k, v in d.items()])
# ===================（数据、逻辑）生成器
# 一边循环一边计算的机制, 生成器内部保存的是逻辑，吐出的是数据/逻辑，有点像发射器
g = (x for x in range(5))
print(g)
print(next(g))
print(next(g))
print('--- in g ')
for n in g:
print(n)
# 斐波拉契数列（Fibonacci） 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
# 斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易
def fibonacci(index, resList):
n = 0
a = 0
b = 1
while n < index:
resList.append(b)
a, b = b, a + b
n += 1
fib_res = []
fibonacci(6, fib_res)
print(fib_res)
# - fibonacci逻辑其实非常类似generator
# - 把 fibonacci 函数 变为 generator, 只需要增加yield b就可以了
# - generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。
# 而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，
# 再次执行时从上次返回的yield语句处继续执行。
def fib_generator(max):
n, a, b = 0, 0, 1
while n < max:
yield b # 相当于数据流的源头
a, b = b, a + b
n = n + 1
return 'done'
# - 但是用for循环调用generator时，发现拿不到generator的return语句的返回值。
# 如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中
gen_fib = fib_generator(5)
while True:
try:
print(next(gen_fib))
except StopIteration as e:
print('return value:', e.value)
break
函数式编程
# ===============函数式编程
# - 公式性质：只要输入是确定的，输出就是确定的
# - 函数可做参数、返回值传递
# - 变量可以指向函数
def fun_1(x):
print("in fun 1 x:", x)
return x + 1
def fun_2(x):
print("in fun 2, x:", x)
var_fun = fun_1
var_fun(1)
# - 函数名也是变量
# 那么函数名是什么呢？函数名其实就是指向函数的变量！
# 对于fun_1()这个函数，完全可以把函数名fun_1看成变量，它指向一个函数！
# 如果把fun_1指向其他对象，会有什么情况发生？
fun_1 = fun_2
fun_1(2)
# -- 高阶函数：参数还有指向函数的变量
def high_fun(x, y, f):
print("in hight fun :", f(x) + f(y))
数据结构
