python系统学习Day3

section4 python function

part one：函数的参数

python函数的参数共有五种类型

#位置参数
def power(x):
	return x * x

#默认参数
def power(x, n = 2) #设置默认值（可省略）
	s = 1
	while n > 0:
		n = n - 1
		s = s * x
	return s
	#note
print('''默认参数必须指向不变对象。
由于默认参数是在函数创建时被计算出来的，
可变对象在调用后可能影响到之后函数调用的结果''')

#可变参数
def sum(*num):
	sum = 0
	for n in num:
		sum = sum + n
	return sum
	
	#调用
	sum(1, 2, 3)
	L = [1, 2, 3]
	sum(*L)

#关键字参数
def person(name, age, **kw):
	print('name:', name)
	print('age:', age)
	print('other:', kw)
	# kw指任意个数关键字参数
	
	#调用
	person('Bob', 23, job='Teacher')
	dic = {'job': 'Teacher', 'city': 'Beijing'}
	person('Bob', 24, **dic)

#命名关键字参数，限制特定关键字
def person(name, age, *, city, job):  #注意这里city和job是指关键字
	pass
def person(name, age, *args, city, job): #已有可变参数的不需要加  *,
    print(name, age, args, city, job)
	#关键字参数也可以缺省， 指定初始值就好
	#关键字调用时必须写成key=value的形式，为了解释器能区分位置参数和关键字参数

参数定义的顺序必须是：必选参数， 默认参数， 可变参数， 命名关键字参数， 关键字参数

理解起来有两种分类方式：普通参照位置的参数/、 / 关键字参数， 固定个数的参数 / 可变参数。
位置参照在前，固定个数在前。
部分类型可指定默认值从而实现缺省。

综上，对于任意类型的函数都可以通过类似func(*args, **kw)实现调用

section5 Advanced features

part one：切片

切片对象：list、tumple、strings
切片参数：[x:y:z]，起始位置，终止位置，步长。默认值分别为首元素，尾元素，1

>>>L = list(range(100))
>>>L[:10]
>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>L[-10:]
>[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>>L[:10:2]
>[0, 2, 4, 6, 8]
>>>L[:]  #原样复制L

tips about Slice

切片操作通常用在等号右面，不能用在左面
对于字符串，单独取出某个字符同样不能放在等号左面，修改字符串时不能单独拎出来一个进行修改

part two：迭代

python中的迭代抽象程度很高，for循环只要作用于一个可迭代元素就可以正常运行

#字典迭代
for key in d:
	print(key)  #字典默认迭代元素是关键字

for value in d.values():
	pass

for kye, value in d.items():
	pass

#字符串迭代
for ch in 'ABC':
	print(ch)

#对list下标循环
for i, value in enumrate(['A', 'B', 'C'])
	print(i, value)

#同时引用两个变量
for x, y in [(1, 1), (2, 4), (3, 9)]
	print(x, y)

part three：列表生成器

列表生成器list comprehensions，可以用来创建列表，非常强大

#简单生成
>>>[x * x for x in range (1, 11)]
>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 满足特定条件的部分生成
>>>[x * x for x in range(1, 11) if x % 2 == 0]
>[4, 16, 36, 64, 100]
# 对满足不同条件的元素分别处理（需要全覆盖）
>>>[x if x % 2 == 0 else -x for x in range (1,5)]
>[-1, 2, -3, 4]
#if在前必须搭配else, if在后不能搭配else

#两层循环生成全排列
>>>[m + n for m in 'AB' for n in 'XY']
>['AX', 'AY', 'BX', 'BY']

# 依次遍历生成两个变量
d = {'x':'A', 'y':'B'}
>>>[k + '=' + v for k, v in d.items()]

part four：生成器

列表容量有限，我们可以采用另一种存储方式：存储生成器（生成列表的算法）

• 方法一：将列表生成器的方括号改为圆括号

>>>L = [x*x for x in range(10)]
>>>L
[0, 1, 4, 16, ..., 81]
>>>g = (x*x for x in range(10))   #圆括号--生成器
>>>g
<generator object <genexpr> at 0x1022ef630>
>>>next(g)        #通过next输出生成的下一个元素
0
>>>next(g)
1
>>>next(g)
4
... ...
>>>next(g)      #没有元素后抛出错误
Traceback (most recent call last):
	File "", line 1, in <module>
StopIteration
#另一种遍历
>>>g = (x*x for x in range(10)) 
>>>for n in g:
...    print(n)
...
0
1
... ...
81
#不需要关心StopIteration的错误

part five：迭代器

凡是能直接作用于for循环的对象都是Iterable类型
凡是能作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列

• Iterable包括：list tumple dict set str等
• Iterator不包括list dict str
• Iterable可以通过iter()函数转化为Iterator

from collections.abc import Iterator
isinstance((x for x in range(10)), Iterator)    #Ture