函数
python中的函数格式
def function_name(para1,para2)python中函数特性（与c语言不同的）有：
- def是函数标志，函数名之前不用写返回类型
- 返回值可以有多个
- 调用函数，直接给形参赋值（形参=“值”）,参数顺序可变。不推荐这样做
- 函数参数可以不固定
例1：传递一个参数
def test_Exam(word):
name="my name is {}"
print name.format(word)
test_Exam('apple')
控制台输出：
my name is apple例2：传递两个参数，主调函数和形参和实参名字相同并被赋予值，顺序不同，不影响输出结果。也可以按顺序传入参数。
def test_Exam(name,fruit):
word="my name is {},I like {}"
print word.format(name,fruit)
test_Exam(fruit='apple',name="John")
控制台输出：
my name is John,I like apple
顺序传入参数
def test_Exam(name,fruit):
word="my name is {},I like {}"
print word.format(name,fruit)
test_Exam('apple',"John")
结果相同例3：函数返回值不止一个。当函数有一个返回结果，将得到一个返回值；当有多个返回结果，用自定义的一个变量名可以得到一个列表。如果要一一得到返回结果，需要和返回结果相同的变量接受返回结果。过多或者过少的接受变量，系统会报错。
#coding:utf-8
def test_Exam(name,age,score):
total=0
for s in score:
total+=s
return name,age,total
outcom1=test_Exam('wangfang',23,[85,91,95]) #依次输入参数
print outcom1
outcom2=test_Exam(age=21,score=[86,82,88],name="lee") #直接给形参名赋值，顺序可以不同
print outcom2
sn,sa,sc=test_Exam(age=21,score=[86,82,88],name="lee")
print sn,sc
#score,name=test_Exam(age=21,score=[86,82,88],name="lee") 错误，用于接收的变量过少
#print score,name
控制台输出
('wangfang', 23, 271)
('lee', 21, 256)
lee
256传递可变参数
当用户可能输入多个参数，函数形参暂时没有办法确定。可以使用**kwargs和*args.两者的区别在于，前一个若作为返回值，将输出键值对的形式（所以调用函数时，未确定的参数要输入键值（变量名）），后一个只输出值。
#coding:utf-8
def test_Exam(name,age,**kwargs):
return name,age,kwargs
par=test_Exam("xiaowang",23,score=86)#未知参数要输入变量和值
print par
def test_Exam(name,age,*args):
return name,age,args
par=test_Exam("xiaowang",23,86,88,89)#直接输入值即可
print par
控制台输出
('xiaowang', 23, {'score': 86})
('xiaowang', 23, (86, 88, 89))
函数参数默认值
可以为函数设置默认值，设置默认值的参数放在函数参数列表的最后。（为什么这样？因为可以优先给没有默认值的参数赋值）。可不可以参数都设置为默认值？（极端情况下，这个程序不需要接受用户输入，自己运行，那我们写的程序就没有意义。是不是就不满足算法的五个特性之一即至少一个输入？）
#coding:utf-8
def test_Exam(name,age,score=86):
print name,age,score
test_Exam("xioawang",23)#只输入两个参数，最后一个参数默认值
test_Exam("xiaoliu",21,99)#给最后一个参数赋值
控制台输出
xioawang 23 86
xiaoliu 21 99类
在c++和java中已经学习过面向对象的思想，类包括属性和函数（方法）。在phthon中，可以使用_init_(self,参数1，…)给属性赋值（类似与构造函数，如果有这个函数，每定义一个实例，将会运行这个函数）。在类中可以使用self.变量访问属性（相当于this函数）.类的创建和生成实例例子如下：
#coding:utf-8
class Student(object):
name=''
age=22
address=''
def show_info(self):
print self.name,self.age,self.address #self的作用类似this
stu=Student() #创建实例对象stu
print stu.age #访问对象的属性
stu.show_info() #访问对象的函数
stu.name="xiaowang"#给实例赋值
stu.age=26
stu.address="beijing"
stu.show_info()
#控制台输出
22
22
xiaowan 26 beijing
可以使用_init_()对类进行初始化，每创建一个实例就要执行这个函数。变量要是使用self.变量。
#coding:utf-8
class Student(object):
def __init__(self,age,name="xiaoming",address="beijing"):
self.name=name
self.age=age
self.address=address
def show_info(self):
print self.name,self.age,self.address #self的作用类似this
stu=Student(name='zhangwei',age=28,address='shanghai') #创建实例对象并初始化
print stu.age #访问对象的属性
stu.show_info() #访问对象的函数
stu.name="xiaowang"#给实例赋值
stu.age=26
stu.address="beijing"
stu.show_info()
控制台输出
28
zhangwei 28 shanghai
xiaowang 26 beijing
类生成的对象。可以像字符的对象，int的对象一样，存储在列表、字典中中。
#coding:utf-8
class Student(object):
def __init__(self,name='',address='',age=''):
if not name:
name=raw_input("please input name")
if not address:
address=raw_input("please input address")
if not age:
age=raw_input("please input age")
self.name=name
self.address=address
self.age=int(age)
self.show_info()
def show_info(self):
print self.name,self.age,self.address #self的作用类似this
def main():
stu1=Student()
stu2=Student(name="wangfang",age=18,address='zhengzhou')
stu=[stu1,stu2]
for st in stu:
print "name:{}".format(st.name)
print "age:{}".format(st.age)
print "address:{}".format(st.address)
if __name__=="__main__":
main()
控制台输出
please input namelee
please input addresswuhan
please input age18
lee 18 wuhan
wangfang 18 zhengzhou
name:lee
age:18
address:wuhan
name:wangfang
age:18
address:zhengzhou前面提到可以把类对象和其他基本类型一样，并进行使用。那怎么进行类对象大小比较呢？当我们print 类对象时，它应该输出什么呢？python不知道如何比较他们大小，我们需要自己去定义比较大小的函数，同样也不知道输出对象的哪些参数，都需要我们自己去定义。
- 使用__equal__(self,other)判断是否(==)相等
- 使用__gt__(self,other)判断是否大于(>)
- 使用__lt__(self,other)判断是否小于(<)
- 使用__gte__(self,other)判断是否大于等于(>=)
- 使用__lte__(self,other)判断是否小于等于(<=)
- 使用__str__(self)输出对象
例子如下：
#coding:utf-8
class Student(object):
def __init__(self,name='',address='',age=''):
if not name:
name=raw_input("please input name")
if not address:
address=raw_input("please input address")
if not age:
age=raw_input("please input age")
self.name=name
self.address=address
self.age=int(age)
def __eq__(self, other):#判断是否相等，（类似于c++中操作符重载），重载了基类型的方法
if self.age==other.age:
print True
else:
print False
def __gt__(self, other):#判断大于号左边的对象是否大于右边的对象，大于输出true
if self.age>other.age:
print True
else:
print False
def __lt__(self, other):
if self.age>=other.age:
print True
else:
print False
def __str__(self):#返回类型必须为一个字符串，否则会报错
return "my name is {},age {},address {}".format(self.name,self.age,self.address)
def main():
stu1=Student(name="wangfang",age=18,address='zhengzhou')
stu2=Student(name="xiaoming",age=26,address='wuhan')
stu3=Student(name="lee", age=26, address='hanyang')
stu3==stu2
stu1>stu2
print stu1
print stu2
print stu3
if __name__=="__main__":
main()
控制台输出：
True
False
my name is wangfang,age 18,address zhengzhou
my name is xiaoming,age 26,address wuhan
my name is lee,age 26,address hanyang类的继承
继承的思想和c++和java一样，假设我们创建基类class Person(object),要继承object这个类，所有的基类都要继承这个类。我们创建派生类class Student(Student),class Worker(Student),继承基类。在派生类中调用.super()函数可以直接用基类中的函数，不需要编写重复的代码：
#coding:utf-8
class Person(object):
def __init__(self,name='',sex='male'):
self.name=name
self.sex=sex
def __str__(self):
return "my name is {},age {}".format(self.name,self.sex)
class Student(Person):
def __init__(self,name='',sex='',address='',age=''):
super(Student,self).__init__(name=name,sex=sex)
if not address:
address=raw_input("please input address")
if not age:
age=raw_input("please input age")
self.address=address
self.age=int(age)
def __str__(self):#返回类型必须为一个字符串，否则会报错
return "my name is {},sex {},age {},address {}".format(self.name,self.sex,self.age,self.address)
class Worker(Person):
def __init__(self,name='',sex='',position='',tel=''):
super(Worker,self).__init__(name=name,sex=sex)
if not position:
position=raw_input("please input position")
if not tel:
age=raw_input("please input tel")
self.position=position
self.tel=tel
def __str__(self):#返回类型必须为一个字符串，否则会报错
return "my name is {},sex {},position {},tel {}".format(self.name,self.sex,self.position,self.tel)
def main():
stu=Student(name="wangfang",sex="female",age=18,address='zhengzhou')
wor=Worker(name="xiaoming",sex="female",position='leader',tel='2589')
print stu
print wor
if __name__=="__main__":
main()
控制台输出：
my name is wangfang,sex female,age 18,address zhengzhou
my name is xiaoming,sex female,position leader,tel 2589包的导入
导入包可以提高编程效率。在python中导入的语句为 from 模块 import 函数 。下面介绍几个常用的模块和函数，需要了解更多包可以登录 更多包的信息.
random模块中的randint()函数接受两个整数参数，输出一个包括左右两两端的随机数。
#coding:utf-8
from random import randint#从random模块中导入randint()函数
test_random=[]
for i in range(5):
num=randint(1,20)
test_random.append(num)
print test_random
控制台输出：
[12, 12, 19, 3, 5]random模块中包含一个random()函数，不接受参数，返回一个(0,1)之间的随机浮点数.例子
#coding:utf-8
from random import random#从random模块中导入random()函数
test_random=[]
for i in range(10):
num=random()
test_random.append(num)
print test_random
#输出（0，100）之间的整数
for i in range(10):
print int(test_random[i]*100)
控制台输出：
[0.07726934698627286, 0.1344094564532684, 0.24215768279396688, 0.01072124610336389, 0.9854731663512878, 0.6447458833785876, 0.42872186552424196, 0.745168512365353, 0.8498303290273697, 0.7018554819212699]
7
13
24
1
98
64
42
74
84
70random模块中使用randint(para1,para2)可以打印出[para1,para2]之间的任意整数，那么怎么打印出两个数之间的浮点数呢？使用uniform(para1,para2)可以解决这个问题
#coding:utf-8
from random import uniform#从random模块中导入random()函数
test_random=[]
for i in range(10):
num=uniform(3,5)
test_random.append(num)
print test_random
控制台输出:
[4.666427103228829, 4.388414947551379, 3.29957256799056, 4.266960999462864, 4.468409921451909, 3.6386073206159177, 3.0895111140399214, 4.005002567683271, 3.0892633450877414, 3.867633906]当我们在举办比赛中随意挑选一个幸运观众时，使用python怎么实现呢？random模块中的choice()函数可以很好的解决这个
#coding:utf-8
from random import choice#从random模块中导入random()函数
test_random=['liu','wan','lee','zhou','dong','shen','leng']
for i in range(5):
print choice(test_random)
控制台输出：
shen
zhou
leng
wan
lee
datime模块中的几个常用函数
time（）函数。可以接受四个参数，时、分、秒、微秒。可以进行时间的比较和基本计算。
#coding:utf-8
from datetime import time#
nowTime=time()
print nowTime
nowTime=time(12)#一个参数
print nowTime
nowTime=time(12,28)#二个参数
print nowTime
nowTime=time(12,28,36)#三个参数
print nowTime
nowTime2=time(12,28,28)#三个参数
print nowTime>nowTime2
控制台:
00:00:00
12:00:00
12:28:00
12:28:36
Truedatetime()函数。可以使用datetime.now()输出当前时间,使用datetime()生成的时间可以计算两者之差。使用timedelta()函数用来对日期进行加减。
#coding:utf-8
import datetime
time1=datetime.datetime.now()#输出当前日期时间
print '现在时间为：{}'.format(time1)
time2=datetime.datetime(year=2017,month=9,day=15,hour=12,minute=35,second=16)
time3=datetime.datetime(year=2017,day=21,month=10,hour=18,minute=36,second=25)
print 'time3时间为：{},time2的时间为:{},相差的日期为：{}'.format(time3,time2,time3-time2)#输出两个日期相差的天数
#timedelta()函数用来对日期进行加减
temp=datetime.timedelta(hours=3,minutes=8)
print '现在时间加上3小时8分为：{}'.format(time1+temp)
控制台输出为：
现在时间为：2017-10-21 22:33:17.733000
time3时间为：2017-10-21 18:36:25,time2的时间为:2017-09-15 12:35:16,相差的日期为：36 days, 6:01:09
现在时间加上3小时8分为：2017-10-22 01:41:17.733000
6290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
