python 函数之day3

一 函数的语法及特性

什么是函数?

定义：函数是一个功能通过一组语句的集合，由名字（函数名）将其封装起来的代码块，要想执行这个函数，只要调用其函数名即可。

特性:

1. 减少重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

定义函数

>>> 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语句把结果返回

注意:

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定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()