python基础篇2

1. 函数

• 定义一个函数：关键字def开头，后接函数标识符和参数列表，然后加上冒号

def 函数名（参数列表）:
	函数体

• 参数类型
  必须参数：正常声明时指明的参数
  关键字参数：在函数调用时将具体的实参指明传递给形参，这样函数调用可以不用按照顺序传递。
  默认参数：函数声明时指明参数默认值
  不定长参数：声明时加星号*param 表示tuple方式传入可变参数， **param表示字典方式传入可变参数

# 必须参数声明
def printDiy(str):  #str 为必须参数

#关键字参数
def printDiy(str1, str2): #声明
printDiy(str2 = 'aaa', str1 = 'bvbb') #函数调用,可以不按照顺序传入参数

#默认参数
def printDiy(str = 'default'): 

#不定长参数
def printDiy(s, *ss):  #声明
printDiy(2,3,4,54)  # ss为（3,4，54）

def printDiy(s, **ss): 
printDiy(2, a = '2', b = '1') # ss为 {'a' = '2', 'b' = '1'}

• 参数传递

在python中，类型属于对象，变量是没有类型的，如a = [1,2,3] 和 a = 'dsfs', 对象 [1,2,3] 是List类型， 'dsfs’是string类型，但是变量a没有类型，a只是一个引用，可以指向List，也可以指向string。

python对象类型中，string、tuples、numbers是不可更改的对象，list、dict可更改

# 不可变更
a = 23;
a = 1; // 实质上1是新生成的对象，并不是将23变成1
a = '1'
a = 'adfa'  // a重新指向了一个新的字符串对象 

#可变更
a = [1,2,3,4]
a[2] = 232; // 实质上是将[1,2,3,4]变成[1,2,232,4]

python参数传递时，对于不可变类型，传入函数的是拷贝值，对于可变类型，传入的是引用类型。

• 匿名函数
  使用 lambda 来创建匿名函数。
  lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum(2,3,))

---

2. 容器常见操作

• 2.1 列表list操作[ ]

list.append(x)  == a[len(a):]= [x]  x为一个元素
list.extend(L)  == a[len(a):] = L   L为一个列表
list.insert(i,x)
list.remove(x)
list.pop()/list.pop(i) 如果没有指定索引i，则返回最后一个元素，同时元素从列表中移除
list.clear() 从列表中移除所有项
list.index(x) 返回第x位的元素，没有返回错误
list.count(x) 返回x出现的次数
list.sort() 对元素排序
list.reverse() 元素倒序
list.copy() 返回列表浅复制（值拷贝）
取容器最后一个元素[-1]

列表推导式：

vec = [12,2,3]
[2*x for x in vec] ==> [24,4,6]

#if过滤
[3*x for x in vec if x > 2] ⇒ [36, 9]
#双层for循环
vec1 = [2,3,4]
vec2 = [3,4,5]
[x*y for x in vec for y in vec2] ==>[6,8,10,9,12,15,12,16,20]
#与range组合
[x+2 for x in range(2,4)]  ⇒ [4,5,6]

列表推导式实现矩阵互转

#原始3*4矩阵
matrix = [
	[1, 2, 3, 4],
	[5, 6, 7, 8],
	[9, 10, 11, 12],
]
#转成 4*3 矩阵
[[row[i] for row in matrix] for i in range(4)] 
#外层for i in range(4) 4次循环，每次循环得出一个list,list为[row[i] for row in matrix], [row[i] for row in matrix]表示遍历matrix，每次取一行中的第i个数

del语句
可以用del删除某个元素，也可以用del删除一个范围内的元素，同样可以清空整个列表

a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0] #删除第一个元素
del a[2:4] #删除第2到4的元素
del a[:] #清空整个a列表

• 2.2 元组（）
  元组在输入时可以没有括号，在输出时肯定有括号

t = 1,2 ,4
print(t) # (1, 2, 4)
tt = t, 23,33423
print(tt) #((1, 2, 4), 23, 33423)
ttt = tt, (2,23,4,1) 
print(ttt) #(((1, 2, 4), 23, 33423), (2, 23, 4, 1))
tttt = ttt, t, [232]
print(tttt)  #((((1, 2, 4), 23, 33423), (2, 23, 4, 1)), (1, 2, 4), [232])

• 2.3 集合 {key}
  集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 删除重复的
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 检测成员
True
>>> 'crabgrass' in basket
False
#访问
for v in basket:
    print(v)
for i, v in enumerate(basket): # 用enumerate修饰后可以访问索引值和对应的value
    print(i, v)

集合推导式
a = {x for x in 'abcdefghijkl' if x not in 'sxgadd'} == > {‘j’, ‘c’, ‘e’, ‘f’, ‘l’, ‘b’, ‘h’, ‘k’, ‘i’}

• 2.4 字典{key:value}
  支持del、sorted、 in属于集合检查，转换成list

tel = {'jack': 4098, 'sape': 4139} #创建
tel['guido'] = 4127   ===>{'sape': 4139, 'guido': 4127, 'jack': 4098} #创建
tel['jack']   ===>4098    #访问
del tel['sape']  #del 删除
tel['irv'] = 4127 #改变
list(tel.keys()) ==> ['irv', 'guido', 'jack'] #转变成list
sorted(tel.keys())  ==>['guido', 'irv', 'jack']  #根据key排序
'guido' in tel ==>True  #测试
'jack' not in tel  ==>False 
dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) # 从列表[]中包含元组且元组内为keyValue对的方式创建dic

#访问: 注意和集合遍历的区别，集合中k代表索引值，用的是enumerate，dic中是items 
for k, v in tel.items():
	print(k, v)

字典推导式
{x: x**2 for x in (2,3,4)} ==> {2:4, 3:9, 4:16}

• string

str.strip() 去掉字符串两边空格

---

3. 迭代器

迭代器有两个基本的方法：iter(序列) 和next()。字符串，列表或元组对象都可用于创建迭代器。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

list = [1,2,3,4]
# iter产生容器迭代器
it = iter(list)
for x in it:
	print(x)

#next 访问当前迭代器指向，并将迭代器移动至下一个
it = iter(list)
for i in range(4):
	print(next(it))

• 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
  __iter__()方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__()方法并通过 StopIteration异常标识迭代的完成。__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象.

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 5:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)
====>
1
2
3
4
5

StopIteration异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__()方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

• 生成器
  在 Python 中，使用了yield 的函数被称为生成器（generator）。跟普通函数不同的是，**生成器是一个返回迭代器的函数，**只能用于迭代操作，更简单点理解生成器就是一个迭代器，只能对返回值进行迭代器操作。
  在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息。

#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
====>
0 1 1 2 3 5 8 13 21 34 55