|
函数作用
增强代码的重用性和可读性 在没有使用函数编程之前，我们可能一直遵循的都是面向过程编程，即根据业务逻辑从上到下实现各个功能，这样的做的坏处是代码可读性不强，大量冗余代码，而且执行效率不高；有了函数后，我们就可以将多次使用到的相同代码模块放在单独的函数定义中，在任何想要调用它的地方随时调用，这就叫做函数式编程。 面向对象编程其实就是对函数进行再分类和封装，让开发"更快更好更强..."
函数的定义
def 函数名(参数):
... 函数体 ... 返回值 函数的定义主要有如下要点： 1）def：表示函数的关键字 2）函数名：函数的名称，日后根据函数名调用函数 3）函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等... 4）参数：为函数体提供数据 5）返回值：当函数执行完毕后，可以给调用者返回数据
函数参数 可以对Python函数传以下几种形式的参数： 1、普通参数（严格按照顺序，将实际参数赋值给形式参数） 2、默认参数（必须放置在参数列表的最后） 3、指定参数（将实际参数赋值给指定的形式参数） 4、动态参数： * 默认将传入的参数，全部放置在元组中 ** 默认将传入的参数，全部放置在列表中 5、万能参数 *args，**kwargs
这几种参数原理有点类似字符串的格式化输出 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| str.format() 格式化输出
s1 = "i am {0}, age {1}".format("kobe",18)
print(s1)
s2 = "i am {0}, age {1}".format(*["kobe",18])
print(s2)
s3 = "i am {name}, age {age}".format(name='kobe',age='18')
print(s3)
dic_01 = {'name':'kobe','age':18}
s4 = "i am {name}, age {age}".format(**dic_01)
print(s4)
输出：
i am kobe, age 18
i am kobe, age 18
i am kobe, age 18
i am kobe, age 18
|
1）普通参数 1
2
3
| def login(user,pwd):
print（user,pwd）
login(user,pwd)
|
2）默认参数 1
2
3
| def login(user="kobe", pwd=123):
print(user,pwd)
login()
|
3）指定参数 1
2
3
| def login(user, pwd): print(user,pwd)
login(pwd=123, user="kobe")
#指定参数的话，参数顺序就可以随便
|
4）动态参数 *args 一个星号 1
2
3
4
5
6
7
8
9
10
11
12
13
| def f1(*args):
print(args,type(args))
f1(11,22,'hhhh')
li = [22,33,'hehe']
f1(li,'44')
f1(*li) # 给全部的参数作为元组的每一个元素添加
lii = 'kobe'
f1(*lii) # 循环字符串每一个元素
输出
(11, 22, 'hhhh') <class 'tuple'> # 函数接受所有参数，还是原来的元组
([22, 33, 'hehe'], '44') <class 'tuple'> # 函数接受列表元素，并将他的整体作为一个元组的一部分
(22, 33, 'hehe') <class 'tuple'> # 用一个星号可以将列表中的每一个元素添加进元组
('k', 'o', 'b', 'e') <class 'tuple'> # 字符串循环的话，是每一个字符
|
**args 两个星号 1
2
3
4
5
6
7
8
9
| def f2(**args):
print(args,type(args))
f2(n1="kobe")
dic = {'k1':'v1','k2':'v2'}
f2(kk=dic) # 只有一个键值对f2(**dic)
输出
{'n1': 'kobe'} <class 'dict'> # 两个星号动态参数会将键值保存为字典
{'kk': {'k1': 'v1', 'k2': 'v2'}} <class 'dict'> # 传字典参数要是不加两个**，只会出现一个键值对
{'k1': 'v1', 'k2': 'v2'} <class 'dict'> # 传字典参数，正确做法是加两个**
|
混合传参 1
2
3
4
5
6
7
| def f3(*args,**kwargs): # 万能参数只能放置在args后
print(args)
print(kwargs)
f3(11,22,33,k1="v1",k2="v2")
输出
(11, 22, 33) # Python会自动将列表通过*args接收为元组
{'k1': 'v1', 'k2': 'v2'} # 键值对会自动通过**args接收为字典
|
函数扩展01：重复函数定义 1
2
3
4
5
6
7
8
9
| def f4(a1,a2):
return a1 + a2def
f4(a1,a2):
return a1 * a2
ret = f4(8,8)
print(ret)
输出
64
# 原因是因为Python执行代码自上而下，之前被执行的 a1+a2 =16由于在内存中没人使用，很快会被Python的垃圾回收机制所回收
|
函数扩展02：函数传参是原值引用还是重新创建的新值？ 1
2
3
4
5
6
7
8
| def f5(a1):
a1.append(999)
li_01 = [11,22,33]
f5(li_01)
print(li_01)
输出
[11, 22, 33, 999]
# 结果表明函数传参是使用的引用，增加的话会改变原列表
|
函数扩展03：全局变量 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| NAME = "kobe"
# 全局变量(潜规则：全局变量都用大写)
def f6():
age = 18
# 局部变量
global NAME
# 修改全局变量
# 如果需要修改的变量是一个列表，则在函数里面可以读，可以append添加
但是不可以修改或者赋值
name = "jordan"
print(NAME,age)
f6()
输出
kobe 18
|
Python的内置函数
1、 abs取绝对值
2、all（）所有元素为真则为真 1
2
| n = all([1, 2, 3, 4])
print(n)
|
# any() 只要有真则为真
1
2
| n = any([1, 0, None])
print(n)
|
3、ascii()自动执行对象的__repr__方法
4、进制转化
1
2
3
| # bin() 10进制转换成2进制
# oct() 10进制转换成8进制
# hex() 10进制转换成16进制
|
5、bool值 1
2
| # 0,None,"",[],{},() 都为False
print(bool(0))
|
6、 bytes() 1
2
3
4
5
6
7
8
9
10
| # bytes()字符串转换字节类型
# bytearray()字符串转换字节生成列表
# utf-8 一个汉字占用3个字节
# gbk 一个汉字占用2个字节
# 真是这个原因才导致很多gbk文件用utf-8打开会出现乱码
s = "李杰"
n = bytes(s, encoding="utf-8")
print(n)
输出
b'\xe6\x9d\x8e\xe6\x9d\xb0'
|
7、将字节转换成字符串 1
2
3
4
| n = str(bytes(s, encoding="utf-8"), encoding="utf-8")
print(n)
输出
李杰
|
8、 定义的函数功能模块是否可以被调用
1
2
3
4
5
6
7
| def f1(a, b):
return a + b
a = 100
b = 10
print(callable(f1))
输出：
True
|
9、 ACSII码转换数字
1
2
3
4
5
| print(chr(65))
print(ord('A'))
输出：
A
65
|
10、 利用random生成6位数字加字母随机验证码 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| import random
li = []
for i in range(6):
r = random.randrange(0, 5)
if r == 2 or r == 4:
num = random.randrange(0, 9)
li.append(str(num))
else:
temp = random.randrange(65, 91)
c = chr(temp)
li.append(c)
result = "".join(li) # 使用join时元素必须是字符串
print(result)
输出
335HQS
VS6RN5
...
|
11、 将字符串编译后执行 compile → exec + eval 1
2
3
4
| s = "print(123)"r = compile(s, "<string>", "exec") # 将字符串编译成Python代码
exec(r)
输出：
123
|
12、 exec 和 eval 都可以执行，通常exec功能更强大（可以接受代码或者字符串） 1
2
3
4
5
| # 但是 eval 有返回值，exec没有
s = "8*8"ret = eval(s)
print(ret)
输出：
64
|
13、 查看对象提供的功能
1
2
3
4
| print(dir(dict))
输出：
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
help(list) # 读模块源码
|
14、 共97，每页显示10条，需要最少页 1
2
3
4
5
| r = divmod(97, 10)
n1, n2 = divmod(97, 10)
print(n1, n2)
输出：
9 7
|
15、 判断某一对象是否是某类的实例 1
2
3
4
| s = [1, 2, 3]
print(isinstance(s, list))
输出：
True
|
16、筛选函数filter 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| # 函数返回True，将元素添加到结果中
# filter(函数， 可迭代对象)
# 循环第二个参数，让每一个参数去执行函数，如果返回True，表示元素合法
def f2(a):
if a > 22:
return True
li = [11, 22, 33]
ret = filter(f2, li)
print(list(ret))
输出：
[33]
或者用lambda代替
result = filter(lambda a: a > 22, li)
print(list(result))
# lambda 会自动 return
f1 = lambda a: a > 30
ret = f1(90)
print(ret)
|
17、筛选函数 map 1
2
3
4
5
6
7
| # 将函数返回值添加到结果中
# 对可迭代对象内的元素做统一操作
li = [11, 22, 33, 44]
result = map(lambda a: a+100, li)
print(list(result))
输出：
[111, 122, 133, 144]
|
18、所有的全局变量、局部变量 1
2
3
4
5
6
7
| NAME = 'AAA'
def show():
a = 123
b = 456
print(locals())
print(globals())
show()
|
19、hash值 1
2
3
4
5
| # 将一个对象转换成他的hash值
s = 'hhh'
print(hash(s))
输出：
3160577387536464976
|
20、len长度计算 1
2
3
4
| # python 3 里面按照字符查找，返回2
# Python 2 里面按照字节查找，返回6
s = '李杰'
print(len(s))
|
21、round取相邻整数 1
2
3
4
5
| print(round(1.4))
print(round(1.8))
输出：
1
2
|
22、zip 并行迭代 1
2
3
4
5
6
7
8
| l1 = ["kobe", 11, 22, 33]
l2 = ["is", 11, 22]
l3 = ["boy", 11, 22, 33]
r = zip(l1, l2, l3)
tmp = list(r)[0]
print(" ".join(tmp))
输出：
kobe is boy
|
函数示例小程序：用户登陆注册 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
| def login(user,pwd):
"""
用户用户登陆验证
:param: user 用户名
:param: pwd 密码
:return: Ture 登陆成功 False 登陆失败
"""
f = open('db','r')
for line in f:
if line.split('|')[0] == user and line.split('|')[1] == pwd:
return True
return False
def register(user, pwd):
"""
用户用户注册
:param user: 用户名
:param pwd: 密码
:return: 默认None
"""
f = open('db', 'a')
temp = "\n" + user + "|" + pwd
f.write(temp)
f.close()
def main():
select = input("请选择：【1】登陆 【2】注册 ：")
if select == "1":
print("正在登陆...")
user = input("请输入用户名： ")
pwd = input("请输入密码： ")
ret = login(user, pwd)
if ret is True:
print("登陆成功！")
else:
print("登陆失败！")
if select == "2":
print("正在注册...")
user = input("请输入用户名： ")
pwd = input("请输入密码 ")
ret = register(user, pwd)
print("注册成功！")
main()
|
三元运算&三目运算 # 三元运算 通过一条命令代替if else语句
1
2
3
4
5
| if 1==1:
name = "kobe"
else:
name = "jordan"
name = "kobe" if 1 == 1 else "jordan"
|
# lambda表达式
1
2
3
4
5
6
7
8
| def f1(a1):
return a1 + 100
f2 = lambda a1, a2: a1 + a2
ret = f1(10)
ret2 = f2(100,10)
print(ret,ret2)
输出
110 110
|
文件操作 1)打开文件
1
2
3
4
5
6
| # f = open('db', 'r') # 只读
# f = open('db', 'w') # 只写，先清空
# f = open('db', 'x') # python 3.0 新加（如果文件存在报错，不存在则创建并写内容）
# f = open('db', 'a') # 追加
# f = open('db', 'r', encoding="utf-8") # 指定字符编码，防止乱码
# f = open('db', 'rb') # 以二进制打开
|
r+ a+ w+的区别 1
2
3
4
5
6
7
8
| # r+ 能调整写文件指针位置,其他的总是写到末尾
# a+ 能读，但是写文件只能在末尾添加
# w+ 会先清空文件再写
f = open('db', 'r+', encoding="utf-8") # 如果模式没有加 b 中文默认按照一个字符读取数据
data = f.read(1)
f.seek(3) # 调整文件指针到执行位置（以字节方式查找）
print(f.tell())
f.write("777") # 会覆盖已经存在的元素
|
2）操作文件
1
2
3
4
5
6
7
8
9
10
| f.read() # 无参数默认读全部;有参数（b按字节;无b按字符）
f.tell() # 查看指针位置
f.seek() # 按字节调整指针位置
f.write() # 写文件
f.close() # 关闭
f.fileno() # 文件的描述符
f.flush() # 强刷文件到硬盘
f.readable() # 是否可读
f.readline() # 仅读取一行
f.truncate() # 截断指针后面的所有数据
|
for循环文件对象
1
2
| for line in f:
print(line)
|
关闭文件
1
2
3
| f.close()
with open('db') as f:
pass
|
同时打开两个文件
1
2
| with open('db01') as f1, open('db02') as f2:
pass
|
|
QQ群⑧：
窥视卡
雷达卡
发表于 2016-11-30 08:43:21
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
千斤顶
显身卡