Python之函数

简介：

定义函数：

def xx():　　

　　print("xxx")

执行函数

xx()

函数返回值：

def emile():
    print("发邮件")
    return '123'
r = emile()
print(r)

结果：
发邮件
123

上述中，return为返回值，返回给r。return想返回什么就返回什么，如果没有写返回值，就返回None，就是空。

def emile():
    if True:
        return True
    else:
        return False
ret = emile()

if ret:
    print('好的')
else:
    print('滚')

结果：
好的

函数的普通参数：

def i1(p,q,r):    #p，q，r为形参
    print(p,q,r)    #打印出p，q，r的值    
    return True    #返回True
ret = i1('11',[22,11],'33')      #i1里面的为实参，是按照顺序给形参值
print(ret)

结果：
11 [22, 11] 33
True

如果实参不是按照顺序给形参值的情况：（在实参内指定就行了）

def i1(p,q,r):
    print(p,q,r)
    return True
ret = i1(q = '11',p = [22,11],r = '33')
print(ret)

结果：
[22, 11] 11 33
True

函数的默认值：

temp = ""
def drive(name="小七"):　　#这里的name = "小七"，就是函数默认值，当函数没有给name实参时，就会用默认值。注意默认值，都会放在形参的最后的位置。
    temp = name + "开车"
    return temp

ret = drive("小二")
print(ret)

ret = drive("小三")
print(ret)

ret = drive()
print(ret)

结果：
小二开车
小三开车
小七开车

函数的动态参数：　

动态参数一（*a）：

def i1(*args):     #保存为元组
    print(args)
    
i1(12,33,44,55)    #实参能够全部传给a

结果：
(12, 33, 44, 55)

动态参数二（**a）：

def i1(**kwargs):    #保存为字典形式
    print(kwargs)

i1(k1 = 123, k2 = 234)      #实参全部传给a

结果：
{'k1': 123, 'k2': 234}

动态参数形式结合（万能参数）：

def i1(p,*args,**kwargs):
    print(p)
    print(args)
    print(kwargs)

i1(11,22,33,43,k1 = 123, k2 = 234)

结果：
11
(22, 33, 43)
{'k1': 123, 'k2': 234}

def i1(**kwargs):
    print(kwargs,type(kwargs))
dic={"k1":123,"k2":345}
i1(**dic)

结果：
{'k1': 123, 'k2': 345} <class 'dict'>

全局变量与局部变量：

全局变量要大写，局部变量要小写。

深浅拷贝：

对于int和str来说，深浅拷贝都是一样的，都能拷贝完整。

对于其他，浅拷贝只拷贝最外面一层，深拷贝除最内层都要拷贝。

import copy
i1 = "123avc"
i2 = copy.copy(i1)  　　　　#浅拷贝

i3 = copy.deepcopy(i1)　　　　#深拷贝
print(i2)
print(i3)

结果：
123avc
123avc

lambda表达式：

def func1():
    return 123
i = func1()
print(i)

f2 = lambda :123
i1 = f2()
print(i1)

结果：
123
123

def func1(a1,a2):
    return a1+a2
i = func1(11,22)
print(i)

f2 = lambda a1,a2: a1+a2
i1 = f2(11,22)
print(i1)

结果
33
33

Python的内置函数：　

abs()　　　　取绝对值

def func1(a1,a2):

    i2 = abs(a1+a2)
    print(i2)

i = func1(-11,-22)

结果：
33

type()　　　　查看对象类型

all()　　　　循环参数，如果每个元素都为真，那么就返回真，只要有一个为假都返回False（假：0，None，空字符串，空列表，空元组，空字典）

any()　　　　循环参数，只要有一个元素是真就返回真（True）

ascii(对象)　　　　对象的类中找_repr_功能，获取其返回值

class Foo:
    def __repr__(self):
        return "hello"
    
obj = Foo()
r = ascii(obj)
print(r)

结果：
hello

bin()　　　　二进制

oct()　　　　八进制

int()　　　　十进制

hex()　　　　十六进制

#!/bin/bash/env python
# -*- coding:utf-8 -*-
#functio:二进制改为十进制

i = int("0b11",base=2)　　　　#其他进制之间的转换也一样，注意base的作用
print(i)

结果：
3

boll()　　　　判断真假，把一个对象转换为布尔值

bytes()　　　　字节（和bytearray类似于str和list的关系）　　bytes("xxx",encoding="utf-8")

bytearray()　　　　字节列表

chr()　　　　输入一个数字找到相对应的字符（参照ascii表，数字找到对应的字符）

ord()　　　　接受一个字母找到对应的数字（只使用于ascii码）

实现随机验证码：（应用到chr（）--这个是对照ascii表和str（））

import random

tmp = ""
for i in range(6):
    num = random.randrange(0,4)
    if num == 1 or num == 3:
        rad2 = random.randrange(0,10)
        tmp = tmp + str(rad2)
    else:
        rad1 = random.randrange(65,91)
        c1 = chr(rad1)
        tmp = tmp + c1

print(tmp)

flush()　　　　使对象立即保存在硬盘中

callable()　　　　检查输入对象是否可以执行（如果命令加（）表示该命令可以被执行）

complie()　　　　编译对象，使之能成为python可以执行的代码

divmod()　　　　求除数的商和余数

i1 = 10/3
print(i1)
i2 = divmod(10,3)
print(i2)

结果：
3.3333333333333335
(3, 1)

enumerate()　　　自动生成一列，默认从0开始自增1，也可以自己指定字符串转换成数字int（字符串）

i1 = ["you","i","she","he"]
for key,item in enumerate(i1):
    print(key,item)

结果：
0 you
1 i
2 she
3 he

eval()　　　　（做表格汇总）执行一个字符串形式的表达式

i1 = eval("1 + 3")
print(i1)

结果：
4

filter(函数，可迭代对象)　　　　循环可迭代的对象，获取每一个参数（函数），筛选功能

ret = filter(lambda x:x > 22,[11,22,33,44])
for i in ret:
    print(i)

结果：
33
44

map(函数，可迭代对象)　　　　

def func1(x):
    return x + 100
ret = map(func1,[1,2,3,4,5])
print(ret)
for i in ret:
    print(i)

结果：
<map object at 0x000000000260B2B0>
101
102
103
104
105

globals()　　　　获取全部的全局变量

locals()　　　　获取全部的局部变量

hash()　　　　获取哈希值（为了节省内存，而且快速找到，优化key

isinstance()　　　　判断某个对象是否由某个类创建的

issubclass()　　　　判断是否是子类

iter()　　　　next()

obj = iter([11,22,33,44])
print(obj)
r1 = next(obj)
print(r1)
r2 = next(obj)
print(r2)

结果：
<list_iterator object at 0x000000000291B1D0>
11
22

max()　　　　取最大值

min()　　　　取最小值

pow()　　　　求幂

round()　　　　四舍五入

sum()　　　　求和

sorted()　　　　排序：（想要排序必须是同一种类型，比如都是数字）字符串比较，先比第一个字符，以后一个一个比，然后排序

i1 = [11,22,11,33,22,44,55,66,]
new_list = sorted(i1)
print(new_list)

结果：
[11, 11, 22, 22, 33, 44, 55, 66]

打开文件的模式有：

默认是只读模式

r：只读模式（默认）

w：只写模式（不可读，不存在创建键；存在则清空内容）

x：只写模式（不可读，不存在创建键，存在则报错）

a：追加模式（不可读，不存在创建键，存在则只追加内容）

 

+表示可以同时读写某个文件：

r+：读写（可读，可写）

w+：写读（可读，可写） 先清空，再写之后就可以读了

x+：写读（可读，可写和上面差不多）

a+：写读（可读，可写）  打开同时，指针已经到最后了，写时追加，放在最后

 

b表示以字节的形式操作：

rb　　或r+b

wb　　或w+b

xb　　或x+b

ab　　或a+b

f = open('cai.log','r',encoding="utf-8")
i1 = f.read()
f.close()
print(i1)

结果：
中国

基本打开：

#1、只读r
i1 = open('cai.log','r')
i2 = i1.read()
i1.close()
print(i2)

#2、w，只写模式,清空原来的内容，重新输入，文件不存在则创建
i3 = open('cai.log','w')
i4 = i3.write('111')
i3.close()

#3、x，只写模式，原来有内容则报错
i5 = open('cai.log','x')
i6 = i5.write('222')
i5.close()

#4、追加模式，追加在末尾
i1 = open('cai.log','a')
i2 = i1.write('222')
i1.close()

以字节（二进制）的方式打开：

①只读，rb

②只写wb

 

 

 

 

 

　

 

 

关闭：

with open("cai.log","r") as f:

　　f.read()

执行过后自己关闭，不需要close

 

Python2.7之后，with可以同时支持打开两个文件：

with open("log1") as obj1,open("log2") as obj2:

　　pass

 

　不需要消耗很大的内存的复制