python笔记01(详情请看廖雪峰的官方网站)

python 在调用函数的时候，

如果传入的参数数量不对，

如果传入的参数类型不对

会报TypeError的错误，并且Python会明确提示参数错误原因。

hex()内置函数会把一个整数转换成十六进制表示的字符串。

’定义一个函数要使用def语句。依次写出函数名，括号，括号中的参数和冒号：”

调用函数时，参数不对，会自检。抛出TypeError,参数类型不对，无法检查，修改my_abs,对类型做检查。只允许整数和浮点类型。

def my_abs():

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

　　　　raise TypeError('bad operand type')

　　if x>=0:

　　　　return x

　　else:

　　　　return -x

import math

def move(x,y,step,angle=0):

　　nx=x+step*math.cos(angle)

　　ny=y-step*math.sin(angle)

　　return nx,ny

>>x,y=move(100,100,60,math.pi / 6)

>>print(x,y)

同时获得返回值。但是这只是一个假象，Python函数返回的任然是单一值：

r=move(100,100,60,math.pi /6 )

print(r)

返回的值是一个tuple ，在语法上tuple可以省略括号，多个变量可以同时接受tuple.

type("asdhu") 返回str.测试类型。

Class myClass():

　　pass

test = myClass()

isinstance(test,myClass) 返回true  isinstance的测试范围更广 。

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数，至于到底传入了哪些，需要kw检查。

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

　　if 'city' in kw:

　　　　pass

　　if 'job' in kw:

　　　　pass

　　print('name',name,'age',age','other',kw)

不可变参数

def add_end(L=None):

　　if L=None:　

　　　　L=[]

　　L.append('END')

　　return L

把函数的参数该为可变参数

def calc(*numbers):

　　sum=0

　　for i in numbers:

　　　　　sum=sum+i**2

　　return sum

nums=[1,2,3]

calc=(*nums)

如果要限制关键字的名字，

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

　　print(name,age,city,job)

与**kw不同。命名关键字参数需要一个特殊分隔符* ,  *后面的参数呗视为命名关键字参数。

调用方式:

>>>person(‘JACK’，24，city='beijing',job='engineer')

如果函数定义中已经有了一个课表参数，后面跟着的命名关键字参数就不在需要一个特殊分隔符*、

def person(name,age,*args,city,job):

　　print(name,age,args,city,job)

def fii(name,age,city='shanghai',*args,*，d,**kw) 正确的定义函数的参数的顺序，必选的位置参数，默认，可变参数，命名关键字参数，关键字参数。

对于任意函数，都可以通过类似function(*args, **kw)的形式调用它，无论它的参数是如何定义的。

def fact(n):

　　if n==1:

　　　　return 1

　　return n*fact(n-1)

以上递归函数的作用是返回1到n的阶层， 但是存在一个严重的问题 ，传入较大的数时，栈溢出，调用一个函数，栈就增加一层，函数返回，栈就减少一层。

解决递归栈溢出 ： 尾递归优化。（无论递归本身调用多少次，都不会出现栈溢出）

def fact(n):

　　return fact_iter(n,1)

def fact_iter(num,product):

　　if num==1:

　　　　return  product

　　return  fact_iter(num-1,num*product)

练习：

汉诺塔的移动。

请编写move(n,a,b,c)的函数，它接受参数n，表示3个柱子 A,,B,C中第一个柱子A的盘子数量，然后打印出把所有盘子从A借助B移动到C的方法。

　　def move(n,a,b,c):

if n==1:

　　　　　　return (a," ->",c)

　　　else:

　　　　　　move(n-1,a,c,b)

　　　　　　move(1,a,b,c)

　　　　　　move(n-1,b,a,c)

利用切片操作，实现一个trim（）函数，去掉字符串首尾空格。注意不要用strip（）方法

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

def trim(s):

　　if s[:1] !=' ' and s[:-1] !=' ':

　　　　return s

　　elif s[:1]==' ':

　　　　return trim(s[1:])

　　else:

　　　　return trim(s[:-1])

请用迭代查找一个list中最小和最大值。并返回一个tuple:

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

def findMinAndMax(L):

　　if L!=[]:

　　　　min=l[0]

　　　　max=l[0]

　　　　for i in L:

　　　　　　if max<i:

　　　　　　　　max=i

　　　　　　if min>i:

　　　　　　　　min=i

　　　　return (min,max)

　　else:

　　　　return(None,None)

列表生成式：

　>>>[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] 偶数的平方。

写一个功能、。 列出当前目录下的所有文件和目录名，可以通过一行代码实现、

>>>import os

>>>[d for d in os.listdir('.')]

把一个list的所有的字符串变成小写:

>>> L=['Hello','World','IBM','Apple']

>>>[s.lower() for s in L]

测试可迭代对象：>>>isinstance([],Iterable)

　　　　　　　　>>>isinstance('2124',Iterable)

高级特性之生成器：

　　创建生成器的方法 :

　　　　①  把列表生成式的[ ]改成（）即可。、

　　　　　　g=(x*x for x in range(10)),通过next(g)返回generator的下一个返回值。一般都用for循环来迭代

　　　　　　generator保存的是算法。计算到最后一个元素抛出stopIteration错误。

　　　　②  def fib(max):

　　　　　　　　n,a,b=0,0,1

　　　　　　　　while n<max:

　　　　　　　　　　yield b

　　　　　　　　　　a,b=b,a+b

　　　　　　　　return 'done'              ####斐波那契数列 后一个数是前两个数的和