一 函数的语法及特性
什么是函数?
定义：函数是一个功能通过一组语句的集合，由名字（函数名）将其封装起来的代码块，要想执行这个函数，只要调用其函数名即可。
特性:
- 减少重复代码
- 使程序变的可扩展
- 使程序变得易维护
定义函数
>>> def hello(): #def 关键字 hello 函数名
print('Hello,world!') >>> hello() #通过名字调用函数
Hello,world!>>> def product(x,y): #传入两个参数，返回两个数的乘积
result = x*y
return(result)>>> product(5,7) #调用函数
35
程序断点运行(可以调试的时候用到)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2016/10/16 20:06
# @Author : Derby
# @File : SendMail.py
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr def sendMail():
try:
msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["derby", 'dbb-2008@163.com'])
msg['To'] = formataddr(["dbb", '499245549@qq.com'])
msg['Subject'] = "主题" server = smtplib.SMTP("smtp.163.com", 25)
server.login("dbb-2008@163.com", "邮箱密码")
server.sendmail('dbb-2008@163.com', ['499245549@qq.com', ], msg.as_string())
server.quit()
except:
return "发送失败"
else:
return '发送成功' result=sendMail()
print(result)
Python发邮件
函数返回之return
要想获取函数的执行结果，就可以用return语句把结果返回
注意:
- 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
- 如果未在函数中指定return,那这个函数的返回值为None
def f1():
print ('deng')
return '' #在函数中，一旦执行return，函数立即终止
print ('derby') r=f1()
print(r)
#执行结果
deng
111 def f2():
print('derby') #函数中没有return,默认返回None re=f2()
print(re) #执行结果
derby
None
return
函数的参数
1.普通参数 通过调用函数，传入参数，并且一一对应
#定义和调用函数
def f1(name): #name为f1函数的形式参数，简称：形参
print ('Hello,%s'%name)
return 'yes' r=f1('derby') #derby为传入f1的实际参数,简称:实参
print(r) Hello,derby
2.默认参数 默认参数要放在参数列表的最后
def f1(name,classroom=13):
print ('Hello,%s you classroom is %s'%(name,classroom))
return 'yes' r1=f1('derby',15) #指定参数 r=f1('derby') #使用默认的参数 结果：
Hello,derby you classroom is 15
Hello,derby you classroom is 13
3.指定参数 正常情况下，给函数传参数要按顺序，不想按顺序就可以用指定参数，只需指定参数名即可
但记住一个要求就是，关键参数必须放在位置参数之后。
def f1(name,classroom=13):
print ('Hello,%s you classroom is %s'%(name,classroom))
return 'yes' r=f1(classroom=15,name='hangbazi')
4.动态参数 一个形参可以接受多个参数,一个”*”默认放在元祖里，两个”**”默认放在字典里
def f1(classroom,*name):
print ('Hello,%s your classroom is %s'%(name,classroom))
return 'yes' li=['cangjingkong','wutonglan','marliya'] #使用方式一，一个一个的传入
f1(15,'cangjingkong','wutenglan','mariya') #使用方式二，列表的方式传入
f1(15,*li) #传入多个参数时，相当于做for循环加入元祖
f1(15,li) ##默认情况会把传进来的参数，放进一个元祖里 结果：
Hello,('cangjingkong', 'wutenglan', 'mariya') your classroom is 15
Hello,('cangjingkong', 'wutonglan', 'marliya') your classroom is 15
Hello,(['cangjingkong', 'wutonglan', 'marliya'],) your classroom is 15
动态参数之 * tuple
def f1(classroom,**name):
print ('Hello,%s your classroom is %s'%(name,classroom))
return 'yes' #li=['cangjingkong','wutonglan','marliya']
dic={'name1':'cangjingkong','name2':'wutenglan','name3':'marliya'} #使用方式一，一个一个的传入
f1(15,name1='cangjingkong',name2='wutenglan',name3='mariya') #使用方式二，字典的方式传入
f1(15,**dic) 结果：
Hello,{'name3': 'mariya', 'name2': 'wutenglan', 'name1': 'cangjingkong'} your classroom is 15
Hello,{'name3': 'marliya', 'name2': 'wutenglan', 'name1': 'cangjingkong'} your classroom is 15
动态参数之 ** 字典
#注意万能参数用法一个*在前，两个** 在后 def f1(*classroom,**name):
print ('Hello,%s classroom in %s'%(name,classroom))
return 'yes' li=[15,16,17]
dic={'name1':'cangjingkong','name2':'wutenglan','name3':'marliya'} #使用方式一，一个一个的传入
f1(15,16,17,name1='cangjingkong',name2='wutenglan',name3='mariya') #使用方式二，字典列表的方式传入 f1(*li,**dic) 结果：
Hello,{'name1': 'cangjingkong', 'name3': 'mariya', 'name2': 'wutenglan'} classroom in (15, 16, 17)
Hello,{'name1': 'cangjingkong', 'name3': 'marliya', 'name2': 'wutenglan'} classroom in (15, 16, 17)
动态参数之万能用法
#format 格式化输出普通用法
>>> s = 'I am {0},age:{1}' #{0}{1}为占位符
>>> s.format('derby',18)
'I am derby,age:18'
>>> s.format(*['derby',19]) #使用动态参数用法
'I am derby,age:19' #上面传入为tumple,还可以传入字典 >>> s = 'I am {name},age:{age}'.format(name='derby',age=18)
>>> print (s)
I am derby,age:18 #传入字典方式
>>> dic = {'name':'derby','age':18}
>>> s.format(**dic)
'I am derby,age:18'
动态参数用法之format
函数补充知识点
Python中传递参数是复制一份传入，还是应用传入的参数?
>>> def f1(a1):
a1.append(999) >>> li=[11,22,33,44]
>>> print(f1(li)) #当函数没有return 返回None
None
>>> print(li) #可以看出行数传参是引用
[11, 22, 33, 44, 999]
Python 函数的变量
#局部变量 >>> def f1(): #局部变量name 只能在函数内进行调用
name='derby'
print(name)
>>> def f2(): #无法调用上面的局部变量
print(name) #全局变量 潜规则：全局变量都大写
#注意对于字典，列表，读的时候可以修改，不可重新赋值 >>> NAME='derby' #定义全局变量
>>> def f1():
age=18
NAME='' #局部赋值只能在函数内部使用
#gloab NAME #重新全局赋值使用 gloab NAME
print(age,NAME) >>> def f2():
age=19
print(age,NAME) >>> f1()
18 123
>>> f2()
19 derby
三元运算
三元运算（三目运算），是对简单的条件语句的缩写。
#书写格式 return =值1 if 条件成立 else 值2 # 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量 示例
x="derby" if 19>18 else "alex"
lambda 表达式
#普通定义函数返回值
>>> def f1(a1):
return a1+100 #使用lambda表达式
>>> f2 = lambda a1,a2:a1+a2+120 >>> f1(120)
220
>>> f2(120,130)
370
lambda 示例
内置函数
Python所有的内置函数如下：
内置函数使用示例
>>> n=abs(-1)
>>> print(n)
1
abs取绝对值
#python 中 布尔为False有 0，None,' ',[],()
>>> print(bool(0))
False
>>> print(bool(None))
False
>>> print(bool(''))
False
>>> print(bool([]))
False
>>> print(bool(()))
False
#all 只要有一个为False 即False
>>> n = all ([1,2,3,None])
>>> print (n)
False
#any 只要有一个为真即为True
>>> n = any([0,'',None,13])
>>> print (n)
True
all,any
#进制转换
>>> print(bin(10)) #转换成二进制0b
0b1010
>>> print(oct(10)) #转换成8进制 0o
0o12
>>> print(hex(10)) #转换成16进制0x
0xa
bin,oct,hex
# bytes 字符串转换成字节,表现形式为16进制，占用空间最少
>>> s = '等一程'
>>> n = bytes(s,encoding='utf-8') #utf-8编码一个汉字为3个字节
>>> print(n)
b'\xe7\xad\x89\xe4\xb8\x80\xe7\xa8\x8b'
>>> n = bytes(s,encoding='gbk') #GBK编码一个汉字为2个字节
>>> print (n)
b'\xb5\xc8\xd2\xbb\xb3\xcc' #字节编码成字符串
>>> s = str(bytes(s,encoding='utf-8'),encoding='utf-8')
>>> print (s)
等一程
bytes 字符转换
#callable 检测能否传入的值能否被调用
def f1():
pass f2 = 123 print(callable(f1))
print(callable(f2))
j结果：
Ture
False #对照ASCII码表 将数字转化成字母
>>> r = chr(65)
>>> print (r)
A
#对照ASCII标码表 将字母转化成数字
>>> r = ord("a")
>>> print(r)
97
callbale,chr,ord
import random #创建6个大写的字母
li = []
for i in range(6):
temp = random.randrange(65,91)
c = chr(temp)
li.append(c)
result = ''.join(li)
print(result) ASWEFK
chr 生成随机验证码
#生成数字字母随机数
li = []
for i in range(6):
if i == 2 or i==4:
temp = random.randrange(0,10)
#c = chr(temp)
li.append(str(temp))
else:
temp = random.randrange(65, 91)
c = chr(temp)
li.append(c)
result = ''.join(li)
print(result)
字母+字符随机
#生成完全随机数
li = []
for i in range(6):
r = random.randrange(0,5)
if i == 2 or i==4:
temp = random.randrange(0,10)
#c = chr(temp)
li.append(str(temp))
else:
temp = random.randrange(65, 91)
c = chr(temp)
li.append(c)
result = ''.join(li)
print(result)
完全随机数
重要函数值 complile(),evel(),exec()
#compile() 编译字符成Python代码
#exec() 编译成跟Python一样的代码,只执行，没有返回值 s = 'print(123)'
#将字符串编译Python代码
r = compile(s,'<string>','exec')
#执行Python代码
exec(r)
结果：
123 #eval() 只编译执行表达式，有返回值
t = "8*8"
ret = eval(t)
print (ret)
结果：
64
# dir 快速查看，对象提供了哪些功能
#print(dir(list))
#print(dir(dict))
# help 查看对象的帮助，有哪些参数
#help(list) #做除法，返回商，和余数
n1,n2 = divmod(9,5)
print(n1,n2)
1 4 s = "derby"
ret = isinstance(s,list) #判断某个对象是否是某个类的实例
print(ret) False
dir,help,divmod,isinstance
#filter 过滤
def f2(a):
if a > 22:
return True
li = [11,22,33,44,55,66]
#filter内部，循环第二个参数,将每个元素传入第一个函数
#如果函数返回值为True,则元素合法，加入filter内部列表
ret = filter(f2,li)
print(list(ret))
结果：[33,44,55,66] #lamdba 函数能自动return
f1 = lambda a: a >30
ret = f1(90)
print(ret)
True
#filter 和lambda 结合使用
result = filter(lambda a:a>22,li)
print (list(result))
结果：[33,44,55,66] #map (函数，可迭代的对象（可以for循环的东西)将后面的参数依次传入前面的函数，结果写入列表)
li = [11,22,33,44,55,66]
#def f2(a):
# return a+100: #result = map(f2,li)
result = map(lambda a: a+100,li)
print (list(result))
filter(),map()
#globals () 打印所有的全局变量 locals() 打印所有的局部变量
NAME='derby'
def f2():
a=123
b=a+100
print(locals()) # 打印a,b 为局部变量
print(globals()) #打印NAME 和系统内置的全局变量 f2() #hash（）将一个传入的对象，转为哈希值，一般在字典里使用
#作用一节省内存空间，作用二，根据哈希值查找方便 >>> s = 'marliyasdfdfdfsdfdfsdf'
>>> print(hash(s))
-7295414716637379284
>>>
#python 3.x 默认是按字符找，2.0 默认是按字节找
>>> s='中国'
>>> print(len(s))
2
>>> b = bytes(s,encoding='utf-8')
>>> print(len(b))
6
locals,globals,hash(),len()
# sum() 求和 max() 最大值 min()最小值
print(sum([11,23,34,12]))
print(max([11,23,34,12]))
print(min([11,23,34,12])) # pow() 求平方
r = pow(2,10)
print(r) li= [23,42,23]
# repr() 执行类中的 _repr_ 函数
repr('dengbin') #reversed() 反转
reversed(li) #round() 四舍五入
print(round(1.23))
sum,max,min,pow,repr,reversed
#sorted 排序
>>> li=[23,45,43]
>>> print(sorted(li))
[23, 43, 45]
>>> #zip () 将几个列表对应的元素放进一个元组里 l1 = ['deng',11,23]
l2 = ['bin','',22]
r = zip(l1,l2)
#print(list(r)) #结果：[('deng', 'bin'), (11, '11'), (23, 22)]
temp = list(r)[0]
print (temp)
ret = ' '.join(temp)
print(ret) 结果：
('deng', 'bin')
deng bin
sorted(),zip()
