函数

函数的目的

函数的主要目的是提高程序的重复可用性

如何定义一个函数

def 函数名(形参):
    函数体
    return 返回值

定义函数

def关键字，通过这个关键字通知告知解释器，这个是定义的函数，而def后为函数的名字

函数返回值

一个函数不一定要有返回值，如果没有return，函数会返回一个None，如果需要返回值，就需要加上return，另外函数一旦执行到return，余下的内容就不进行执行，python语言就是这样一个特点，只有执行到的代码有异常才会报错，而不被执行的错误代码是不会产生异常的。

执行函数

函数名(实参)

参数传递

普通参数

def f(a,b,c):
    return a+b+c
print(f(1,2,3))

执行结果

6

这里在调用f函数的时候，参数1,2,3根据位置分别传递给a,b,c

指定参数

参数默认按照顺序，但也可以指定形参的值

print(f(c=3,b=2,a=1))

并且普通参数传递的时候可以和指定参数混用，默认参数要出现在指定参数之前

print(f(1,c=3,b=2))

默认参数

形参可以有默认参数，有默认参数的形参放在没有默认参数的形参后边

def f(a,b,c=10):
    return a+b+c

print(f(3,2))

执行结果

15

如果指定了c的值

print(f(3,2,1))

执行结果

6

在第一次调用的时候，c没有被传递参数，进而使用默认值10， 而在第二次调用的时候，c被传递了参数1，函数使用c=1进行赋值

动态参数

动态参数是可以传递多个参数

第一种动态参数

def func(*name):
    print type(name)
    print name
func(1,2,3,4,5,6)

执行结果

<type 'tuple'>
(1, 2, 3, 4, 5, 6)

传递进去表现为一个元组

第二种动态参数

def func(**dict):
    print type(dict)
    print dict
func(a=1,b=9)

执行结果

<type 'dict'>
{'a': 1, 'b': 9}

传递进去表现为一个字典

如果同时出现的时候需要通过这种方式

def func(*name,**dict):
    print name
    print dict
func(1,2,3,4,5,6,a=1,b=9)

对于列表，集合，字典，python传递参数的时候传递的引用。

另外，一般规范化都会写作args和*kwargs

lambda表达式

lambda表达式是一种简化的函数

def f1():
    return 123

等价于

f2 = lambda : 123

def f3(a1,a2):
    return a1 + a2

等价于

f4 = lambda ：a1 + a2

三元运算符

与lambda表达式类似的是三元运算符，是一个简化的if else的判断

name = 'why' if 1 == 1 else 'wanghongyu'
print(name)

输出

why

Python内置函数

• abs()取绝对值
• all()循环参数，如果每个参数为真，则返回真，真的太多，而假的只有0，None，空字符串''，空列表[],空元组(),空字典{}
• any()如果一个参数为真，则为真
• ascii()会到对象的类中执行__repr__方法

class Foo:
    def __repr__(self):
        return 'why'

a = Foo()       #创建类的对象，类似于a = list()和a = []
print(ascii(a))

输出

why

• bin()将十进制转化成二进制
• oct()将十进制转化成八进制
• int()十进制
• hex()将十进制转换成十六进制

进制转换 1. 二进制转换为十进制,int('0b11',base=2) 2 .然后就能转换成我们需要的进制

• bytes()将字符转换为字节
• bytearray()字节列表
• chr()数字转换为ascii码
• ord()将ascii码转换为数字
• callable()确认是否为可执行

def f1():
    return 123
print(callable(f1))

执行结果

True

• compile()编译字符串为可执行，例如函数
• complex()复数
• getattr()反射需要
• delattr()反射需要
• hasattr()反射需要
• setattr()反射需要
• dir()显示类中的方法

>>> li = []
>>> print(dir(li))
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

而help更详细

>>> help(list)
Help on class list in module builtins:

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)

• divmod()

>>> print(divmod(101,5))
(20, 1)

• enumerate()迭代输出

list = ['a','b','c','d']
for a in enumerate(list):
    print a

for a,b in enumerate(list):
    print a,b

for a,b in enumerate(list,1):
    print a,b

输出

(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
0 a
1 b
2 c
3 d
1 a
2 b
3 c
4 d

• eval()将表达式转换成运算，有返回值

>>> print(eval('15+15'))
30
>>> print(eval('a+15',{'a':12}))
27

• exec()执行代码，无返回值

>>> exec('for i in range(10):print i')
0
1
2
3
4
5
6
7
8
9

没有返回值

• filter(函数，可迭代的对象) 循环可迭代的对象，获取每一个参数并作为函数参数执行，如果返回值为True，将参数返回，并将所有返回值作为list返回

def f1(x):
    return x > 2
ret = filter(f1,[1,2,3,4])
print(ret)

这个ret是一个filter对象，可以通过for循环迭代输出，另外函数也可以当做参数，都是指向内存地址

当然如果和lambda表达式结合 ret = fileter(lambda x: x > 2,[1,2,3,4])

相同的还有map()和reduce()

• map()

li = [1,2,3,4]
def f(arg):
    return arg + 100
r = map(f,li)
print r

执行结果

[101,102,103,104]

• format()字符串格式化
• frozenset()创建一个不可变的集合，集合没有add()和remove()等方法，而set()创建的
• globals()获取所有的全局变量
• locals()获取所有的局部变量
• hash()计算hash值，一般用于
• isinstance()判断对象是否为类创建

li = []
r = isinstance(li,list)

• issubclass()判断是否为子类
• iter()用于创建可迭代对象，可以通过next()获取下一个对象，和yield为生成器配合使用
• max()取列表的最大值
• min()取列表的最小值
• object()所有类的基类
• open()文件操作
• pow()指数运算

pow(2,10) <=>2**10

• property()面向对象的属性
• round()四舍五入
• slice()切片
• sorted()排序
• staticcmethod()用于面向对象
• zip()合并
• __import__()用于引入模块

更详细的介绍可以参考官方文档(https://docs.python.org/2/library/functions.html)

生成随机验证码

import random
temp = ''
for i in range(6):
    num = random.randrange(0,4)
    if num >= 2:
        rad2 = random.randrange(0,10)
        temp = temp + str(rad2)
    else:
        rad1 = random.randrange(65,91)
        c1 = chr(rad1)
        temp = temp + c1
print(temp)

文件操作

基本操作

1. 打开文件 打开的函数使用方式为 open('文件名', '模式', encoding='utf-8')

f =  open('a.txt','r')

1. 操作文件

data = f.read()

1. 关闭文件

f.close()

默认模式为r，只读

基本文件打开模式

• r，只读模式
• w，只写模式，不可读，文件不存在则创建，文件存在则清空内容
• x，只写模式，不可读，文件不存在则创建，文件存在则报错(3.0新增)
• a，追加模式，可读，文件不存在则创建，文件存在则只追加内容

默认情况下我们读取到的为str格式，如果想要转换成字节需要bytes(str,encoding='utf-8')，而其中的原理是，数据再内存中本来是以二进制的方式存储，读取的时候也正是二进制，是open的过程中读到二进制而直接按照编码转换成字符串。

在python3中提供了二进制的转换方式。

二进制打开方式

open('文件名', '模式')

• rb或r+b
• wb或w+b
• xb或x+b
• ab或a+b

f = open('a',wb)
f.write(bytes('王宏宇',encoding='utf-8')) 

同时读写，某个文件

• r+，读写
• w+，写读
• a+，追加读

最常用的就是r+

open指针

指定指针位置

f.seek(3)

一般打开文件的时候为0，而执行过读或写的操作的过后就会都会在文件写入或读取的末尾，然后就需要指定指针

输出当前指针位置

f.tell() seek()在文件打开的时候保留，一旦文件关闭就不存在，如果需要保存指针位置，可以选择保存到数据库或者文件中，在下次打开文件的时候指定。

文件操作的其他方法

• close()关闭文件
• fileno()文件描述符，用于判断文件是否被修改
• flush()刷新文件内部缓冲区，如果文件不被关闭也不被刷新，并且进程没有终止，这时之前写入的内容在文件内部缓冲区中，其他进程读取程序的时候无法读取到刚才写入的内容
• read()不加参数读取所有内容，如果指定去读的长度，如果以字符方式读取，一个长度代表一个字符，如果以字节方式读取，一个长度代表一个字节。
• readline()仅读取一行数据，第二次执行readline的时候获取第二行，依次类推
• readlines()将文件的每一行都读取到列表中，每行是一个元素
• seek()指定文件中指针位置
• tell()获取指针位置，指针以字节形式
• truncate()截取从开头到指针位置的文件内容，其他内容舍弃

还有就是循环读出所有文件

for line in f:
    print f

循环会自动判断文件是否还有内容

自动关闭文件

with open('a.txt','r') as f:
    f.read()

同时打开两个文件

with open('a.txt','r') as f1, open('b.txt','w') as f2:
    for line in f1:
        f2.write(line)

冒泡排序

li = [123,32,22,333,44]
i = 0
while i < li.:
    i + 1
    for i in range(4):
        if li[i] > li[i + 1]:
            a = li[i + 1]
            li[i + 1] = li[i]
            li[i] = a

print li