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

程序断点运行(可以调试的时候用到)

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @Time    : 2016/10/16 20:06
 4 # @Author  : Derby
 5 # @File    : SendMail.py
 6 import smtplib
 7 from email.mime.text import  MIMEText
 8 from email.utils import formataddr
 9 
10 def sendMail():
11     try:
12         msg = MIMEText('邮件内容', 'plain', 'utf-8')
13         msg['From'] = formataddr(["derby", 'dbb-2008@163.com'])
14         msg['To'] = formataddr(["dbb", '499245549@qq.com'])
15         msg['Subject'] = "主题"
16 
17         server = smtplib.SMTP("smtp.163.com", 25)
18         server.login("dbb-2008@163.com", "邮箱密码")
19         server.sendmail('dbb-2008@163.com', ['499245549@qq.com', ], msg.as_string())
20         server.quit()
21     except:
22         return "发送失败"
23     else:
24         return '发送成功'
25 
26 result=sendMail()
27 print(result)
Python发邮件

 

函数返回之return

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

  1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
  2. 如果未在函数中指定return,那这个函数的返回值为None 
 1 def f1():
 2     print ('deng')
 3     return '111'     #在函数中，一旦执行return，函数立即终止
 4     print ('derby')
 5 
 6 r=f1()
 7 print(r)
 8 #执行结果
 9 deng
10 111
11 
12 def f2():
13     print('derby')    #函数中没有return,默认返回None
14 
15 re=f2()
16 print(re)
17 
18 #执行结果
19 derby
20 None
return

 

 函数的参数

1.普通参数  通过调用函数，传入参数，并且一一对应

1 #定义和调用函数 
2 def f1(name):        #name为f1函数的形式参数，简称：形参
3     print ('Hello,%s'%name)
4     return 'yes'     
5 
6 r=f1('derby')         #derby为传入f1的实际参数,简称:实参
7 print(r)
8 
9 Hello,derby
View Code

2.默认参数  默认参数要放在参数列表的最后

 1 def f1(name,classroom=13):
 2     print ('Hello,%s you classroom is %s'%(name,classroom))
 3     return 'yes'
 4 
 5 r1=f1('derby',15)  #指定参数
 6 
 7 r=f1('derby')      #使用默认的参数
 8 
 9 结果：
10 Hello,derby you classroom is 15
11 Hello,derby you classroom is 13
View Code

3.指定参数   正常情况下，给函数传参数要按顺序，不想按顺序就可以用指定参数，只需指定参数名即可

   但记住一个要求就是，关键参数必须放在位置参数之后。

1 def f1(name,classroom=13):
2     print ('Hello,%s you classroom is %s'%(name,classroom))
3     return 'yes'
4 
5 r=f1(classroom=15,name='hangbazi')
View Code

4.动态参数 一个形参可以接受多个参数,一个"*"默认放在元祖里，两个"**"默认放在字典里

 1 def f1(classroom,*name):
 2     print ('Hello,%s your classroom is %s'%(name,classroom))
 3     return 'yes'
 4 
 5 li=['cangjingkong','wutonglan','marliya']
 6 
 7 #使用方式一，一个一个的传入
 8 f1(15,'cangjingkong','wutenglan','mariya')
 9 
10 #使用方式二，列表的方式传入
11 f1(15,*li)    #传入多个参数时，相当于做for循环加入元祖
12 f1(15,li)     ##默认情况会把传进来的参数，放进一个元祖里
13 
14 结果：
15 Hello,('cangjingkong', 'wutenglan', 'mariya') your classroom is 15
16 Hello,('cangjingkong', 'wutonglan', 'marliya') your classroom is 15
17 Hello,(['cangjingkong', 'wutonglan', 'marliya'],) your classroom is 15
动态参数之 * tuple
 1 def f1(classroom,**name):
 2     print ('Hello,%s your classroom is %s'%(name,classroom))
 3     return 'yes'
 4 
 5 #li=['cangjingkong','wutonglan','marliya']
 6 dic={'name1':'cangjingkong','name2':'wutenglan','name3':'marliya'}
 7 
 8 #使用方式一，一个一个的传入
 9 f1(15,name1='cangjingkong',name2='wutenglan',name3='mariya')
10 
11 #使用方式二，字典的方式传入
12 f1(15,**dic)  
13 
14 结果：
15 Hello,{'name3': 'mariya', 'name2': 'wutenglan', 'name1': 'cangjingkong'} your classroom is 15
16 Hello,{'name3': 'marliya', 'name2': 'wutenglan', 'name1': 'cangjingkong'} your classroom is 15
动态参数之 ** 字典
 1 #注意万能参数用法一个*在前，两个** 在后
 2 
 3 def f1(*classroom,**name):
 4     print ('Hello,%s classroom in %s'%(name,classroom))
 5     return 'yes'
 6 
 7 li=[15,16,17]
 8 dic={'name1':'cangjingkong','name2':'wutenglan','name3':'marliya'}
 9 
10 #使用方式一，一个一个的传入
11 f1(15,16,17,name1='cangjingkong',name2='wutenglan',name3='mariya')
12 
13 #使用方式二，字典列表的方式传入
14 
15 f1(*li,**dic)
16 
17 结果：
18 Hello,{'name1': 'cangjingkong', 'name3': 'mariya', 'name2': 'wutenglan'} classroom in (15, 16, 17)
19 Hello,{'name1': 'cangjingkong', 'name3': 'marliya', 'name2': 'wutenglan'} classroom in (15, 16, 17)
动态参数之万能用法
 1 #format 格式化输出普通用法
 2 >>> s = 'I am {0},age:{1}'  #{0}{1}为占位符
 3 >>> s.format('derby',18)
 4 'I am derby,age:18'
 5 >>> s.format(*['derby',19])   #使用动态参数用法
 6 'I am derby,age:19'
 7 
 8 #上面传入为tumple,还可以传入字典
 9 
10 >>> s = 'I am {name},age:{age}'.format(name='derby',age=18)
11 >>> print (s) 
12 I am derby,age:18    
13 
14 #传入字典方式
15 >>> dic = {'name':'derby','age':18}
16 >>> s.format(**dic)
17 'I am derby,age:18'
动态参数用法之format

 

函数补充知识点

Python中传递参数是复制一份传入，还是应用传入的参数?

1 >>> def f1(a1):
2     a1.append(999)
3 
4     
5 >>> li=[11,22,33,44]
6 >>> print(f1(li))            #当函数没有return 返回None
7 None 
8 >>> print(li)                #可以看出行数传参是引用
9 [11, 22, 33, 44, 999]

 

Python 函数的变量

 1 #局部变量
 2 
 3 >>> def f1():           #局部变量name 只能在函数内进行调用
 4     name='derby'
 5     print(name)    
 6 >>> def f2():           #无法调用上面的局部变量
 7     print(name)
 8 
 9 #全局变量 潜规则：全局变量都大写
10 #注意对于字典，列表，读的时候可以修改，不可重新赋值
11 
12 >>> NAME='derby'        #定义全局变量
13 >>> def f1():
14     age=18
15     NAME='123'         #局部赋值只能在函数内部使用
16         #gloab NAME        #重新全局赋值使用 gloab NAME
17     print(age,NAME)
18 
19 >>> def f2():
20     age=19
21     print(age,NAME)
22     
23 >>> f1()
24 18 123
25 >>> f2()
26 19 derby

 三元运算

三元运算（三目运算），是对简单的条件语句的缩写。

1 #书写格式
2 
3 return =值1  if  条件成立 else 值2
4 
5 # 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量
6 
7 示例
8 x="derby" if 19>18 else "alex"

 

lambda 表达式

 1 #普通定义函数返回值
 2 >>> def f1(a1):
 3     return a1+100
 4 
 5 #使用lambda表达式 
 6 >>> f2 = lambda a1,a2:a1+a2+120  
 7 
 8 >>> f1(120)
 9 220
10 >>> f2(120,130)
11 370
lambda 示例

 

内置函数

Python所有的内置函数如下：

内置函数使用示例

1 >>> n=abs(-1)
2 >>> print(n)
3 1
abs取绝对值 
 1 #python 中 布尔为False有 0，None,' ',[],()
 2 >>> print(bool(0))
 3 False
 4 >>> print(bool(None))
 5 False
 6 >>> print(bool(''))
 7 False
 8 >>> print(bool([]))
 9 False
10 >>> print(bool(()))
11 False
12 #all 只要有一个为False 即False
13 >>> n = all ([1,2,3,None])
14 >>> print (n)
15 False
16 #any 只要有一个为真即为True
17 >>> n = any([0,'',None,13])
18 >>> print (n)
19 True
all,any
1 #进制转换
2 >>> print(bin(10))    #转换成二进制0b
3 0b1010
4 >>> print(oct(10))     #转换成8进制 0o
5 0o12
6 >>> print(hex(10))    #转换成16进制0x
7 0xa
bin,oct,hex
 1 # bytes 字符串转换成字节,表现形式为16进制，占用空间最少
 2 >>> s = '等一程'
 3 >>> n = bytes(s,encoding='utf-8')  #utf-8编码一个汉字为3个字节
 4 >>> print(n)
 5 b'\xe7\xad\x89\xe4\xb8\x80\xe7\xa8\x8b'
 6 >>> n = bytes(s,encoding='gbk')    #GBK编码一个汉字为2个字节
 7 >>> print (n)
 8 b'\xb5\xc8\xd2\xbb\xb3\xcc'
 9 
10 #字节编码成字符串
11 >>> s = str(bytes(s,encoding='utf-8'),encoding='utf-8')
12 >>> print (s)
13 等一程
bytes 字符转换
 1 #callable 检测能否传入的值能否被调用
 2 def f1():
 3     pass
 4 
 5 f2 = 123
 6 
 7 print(callable(f1))
 8 print(callable(f2))
 9 j结果：
10 Ture
11 False
12 
13 #对照ASCII码表 将数字转化成字母
14 >>> r = chr(65)
15 >>> print (r)
16 A
17 #对照ASCII标码表 将字母转化成数字
18 >>> r = ord("a")
19 >>> print(r)
20 97
callbale,chr,ord
 1 import random
 2 
 3 #创建6个大写的字母
 4 li = []
 5 for i  in  range(6):
 6     temp = random.randrange(65,91)
 7     c = chr(temp)
 8     li.append(c)
 9 result = ''.join(li)
10 print(result)
11 
12 
13 ASWEFK
chr 生成随机验证码
 1 #生成数字字母随机数
 2 li = []
 3 for i  in  range(6):
 4     if i == 2 or i==4:
 5         temp = random.randrange(0,10)
 6         #c = chr(temp)
 7         li.append(str(temp))
 8     else:
 9         temp = random.randrange(65, 91)
10         c = chr(temp)
11         li.append(c)
12 result = ''.join(li)
13 print(result)
字母+字符随机

 

 1 #生成完全随机数
 2 li = []
 3 for i  in  range(6):
 4     r = random.randrange(0,5)
 5     if i == 2 or i==4:
 6         temp = random.randrange(0,10)
 7         #c = chr(temp)
 8         li.append(str(temp))
 9     else:
10         temp = random.randrange(65, 91)
11         c = chr(temp)
12         li.append(c)
13 result = ''.join(li)
14 print(result)
完全随机数

 

重要函数值 complile(),evel(),exec()

 1 #compile() 编译字符成Python代码
 2 #exec() 编译成跟Python一样的代码,只执行，没有返回值
 3 
 4 s = 'print(123)'
 5 #将字符串编译Python代码
 6 r = compile(s,'<string>','exec')
 7 #执行Python代码
 8 exec(r)
 9 结果：
10 123
11 
12 #eval()  只编译执行表达式，有返回值
13 t = "8*8"
14 ret = eval(t)
15 print (ret)
16 结果：
17 64

 

 1 # dir 快速查看，对象提供了哪些功能
 2 #print(dir(list))
 3 #print(dir(dict))
 4 # help 查看对象的帮助，有哪些参数
 5 #help(list)
 6 
 7 #做除法，返回商，和余数
 8 n1,n2 = divmod(9,5)
 9 print(n1,n2)
10 1 4
11 
12 s = "derby"
13 ret = isinstance(s,list) #判断某个对象是否是某个类的实例
14 print(ret)
15 
16 False
dir,help,divmod,isinstance
 1 #filter 过滤
 2 def f2(a):
 3     if a > 22:
 4         return True
 5 li = [11,22,33,44,55,66]
 6 #filter内部，循环第二个参数,将每个元素传入第一个函数
 7 #如果函数返回值为True,则元素合法，加入filter内部列表
 8 ret = filter(f2,li)
 9 print(list(ret))
10 结果：[33,44,55,66]
11 
12 #lamdba 函数能自动return
13 f1 = lambda a: a >30
14 ret = f1(90)
15 print(ret)
16 True
17 #filter 和lambda 结合使用
18 result = filter(lambda a:a>22,li)
19 print (list(result))
20 结果：[33,44,55,66]
21 
22 
23 
24 #map (函数，可迭代的对象（可以for循环的东西)将后面的参数依次传入前面的函数，结果写入列表)
25 li = [11,22,33,44,55,66]
26 #def f2(a):
27 #     return a+100:
28 
29 #result = map(f2,li)
30 result = map(lambda a: a+100,li)
31 print (list(result))
filter(),map()
 1 #globals () 打印所有的全局变量 locals() 打印所有的局部变量
 2 NAME='derby'
 3 def f2():
 4     a=123
 5     b=a+100
 6     print(locals())   # 打印a,b 为局部变量
 7     print(globals())  #打印NAME 和系统内置的全局变量
 8 
 9 f2()
10 
11 
12 #hash（）将一个传入的对象，转为哈希值，一般在字典里使用
13 #作用一节省内存空间，作用二，根据哈希值查找方便
14 
15 >>> s = 'marliyasdfdfdfsdfdfsdf'
16 >>> print(hash(s))
17 -7295414716637379284
18 >>> 
19 #python 3.x  默认是按字符找，2.0 默认是按字节找
20 >>> s='中国'
21 >>> print(len(s))
22 2
23 >>> b = bytes(s,encoding='utf-8')
24 >>> print(len(b))
25 6
locals,globals,hash(),len()
 1 # sum() 求和 max() 最大值 min()最小值
 2 print(sum([11,23,34,12]))
 3 print(max([11,23,34,12]))
 4 print(min([11,23,34,12]))
 5 
 6 # pow() 求平方
 7 r = pow(2,10)
 8 print(r)
 9 
10 li= [23,42,23]
11 # repr() 执行类中的 _repr_ 函数
12 repr('dengbin')
13 
14 #reversed() 反转
15 reversed(li)
16 
17 #round() 四舍五入
18 print(round(1.23))
sum,max,min,pow,repr,reversed
 1 #sorted 排序
 2 >>> li=[23,45,43]
 3 >>> print(sorted(li))
 4 [23, 43, 45]
 5 >>> 
 6 
 7 #zip () 将几个列表对应的元素放进一个元组里
 8 
 9 l1 = ['deng',11,23]
10 l2 = ['bin','11',22]
11 r = zip(l1,l2)
12 #print(list(r))      #结果：[('deng', 'bin'), (11, '11'), (23, 22)]
13 temp  = list(r)[0]
14 print (temp)
15 ret = ' '.join(temp)
16 print(ret)
17 
18 结果：
19 ('deng', 'bin')
20 deng bin
sorted(),zip()

 

 
 
 

 

posted @ 2016-10-16 19:38  Derby666  阅读(213)  评论(0)  编辑  收藏  举报