笔记 python 02

1.字符串   

• 双引号或者单引号中的数据，就是字符串
• 使用input获取数据时，不论输入数字或是文字，都是以字符串的方式保存。

  userName = input('请输入用户名:')
  print("用户名为：%s"%userName) 
  password = input('请输入密码:')
  print("密码为：%s"%password)
  # 请输入用户名: 我是asd
  # 用户名为：我是asd
  # 请输入密码: asdffg
  # 密码为：asdffg
  

• 索引

  • 字符串支持下标索引，若想取出部分字符，可以通过下标的方法，python中下标从 0 开始。

• 切片

  • 是指对操作的对象截取其中一部分的操作
  • 语法：[起始:结束:步长]，选取的区间是左闭右开的，即从起始位开始，到结束位的前一位结束。
  • 字符串、列表、元组都支持切片操作

• name = 'abcdef'
  print(name[0:3]) # abc
  print(name[3:5]) # de
  print(name[2:]) #取下标为2开始到最后的字符 cdef
  print(name[1:-1]) #取下标为1开始到最后第2个之间的字符 bcde
  
  #练习
  a = "abcdef"
  a[:3] #从索引0元素取到索引2元素的所有字符 'abc'
  a[::2] #从索引0元素每隔步长2取一个元素，'ace'
  a[5:1:2] #从索引5元素每隔步长1取到索引3元素，步长大于0无法索引，返回 ''
  a[1:5:2] #从索引1元素每隔步长2取到索引4元素，'bd'
  a[::-2] #从最后的索引元素每隔步长-2取一个元素，'fdb'
  a[5:1:-2] #从索引5元素每隔步长-2取到索引2元素，'fd'

• 常见函数

• fnd

  • 检测目标str 是否包含在 mystr中，如果包含返回目标str开始时的索引值，否则返回-1

    mystr = 'hello world itcast and itcastcpp'
    # mystr.find(str, start=0, end=len(mystr))
    end=len(mystr) #计算mystr的长度
    print(end)  # 32
    mystr.find('itcast') #12，在字符串的第12个索引找到了
    mystr.find('itcast'，0，10)  # -1，从索引0元素找到索引10元素，在这段字符串里没有找到

• index

  • 与find方法一样，只不过如果目标str不在 mystr中会报异常

    • mystr = 'hello world itcast and itcastcpp'
      # mystr.index(str, start=0, end=len(mystr)) 
      mystr.index('itcast') #12
      mystr.index('itcast',0,10) # ValueError: substring not found

•  rfind / rindex

  • 类似于 find()函数，不过是从右边开始查找

  • 类似于 index()，不过是从右边开始.

    # mystr.rfind(str, start=0,end=len(mystr) )
    mystr.rfind('itcast') # 23,从左至右第23个元素的索引
    
    # mystr.rindex( str, start=0,end=len(mystr))
    mystr.rindex('itcast') # 23,从左至右第23个元素的索引

• count

  • 返回目标str在start和end之间，目标str在mystr里面出现的次数

    # mystr.count(str, start=0, end=len(mystr))
    mystr.count('itcast') # 2

• replace

  • 把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次

    # mystr.replace(str1, str2,  mystr.count(str1))
    name='My name is Mr Aa Aa Aa Aa'
    name.replace('Aa','Cc') # 'My name is Mr Cc Cc Cc Cc'
    name.replace('Aa','Cc',2) # 'My name is Mr Cc Cc Aa Aa'
    name.replace('Aa','Cc',8)  #'My name is Mr Cc Cc Cc Cc'

• split

  •  以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

    # mystr.split(str=" ",maxsplit )   
    name.split(' ') #['My', 'name', 'is', 'Mr', 'Aa', 'Aa', 'Aa', 'Aa']
    name.split(' ',2) # ['My', 'name', 'is Mr Aa Aa Aa Aa']
    name.split(' ',10) #['My', 'name', 'is', 'Mr', 'Aa', 'Aa', 'Aa', 'Aa']
    

• capitalize 

  • 把字符串的第一个字符大写

    # mystr.capitalize()
    mystr.capitalize() #'Hello world itcast and itcastcpp'

• title

  •  把字符串的每个单词首字母大写

    mystr.title() #'Hello World Itcast And Itcastcpp'
    

•  startswith / endswith

  • 检查字符串是否是以obj开头, 是则返回 True，否则返回 False
  • 检查字符串是否以obj结束，如果是返回True,否则返回 False

    # mystr.startswith(obj)
    mystr.startswith('hello') #True
    mystr.startswith('Hello') #False
    mystr.startswith('He') #False
    mystr.startswith('he') #True
    
    # mystr.endswith(obj)
    mystr.endswith('app') #False
    mystr.endswith('cpp') #True

•  lower / upper

  • 转换 mystr 中所有大/小写字符为小/大写

    # mystr.lower()  
    name2='HELLO LILI how are you'
    name2.lower() # 'hello lili how are you'
    
    # mystr.upper()
    name2.upper() #'HELLO LILI HOW ARE YOU'

•  ljust / rjust

  • 返回一个原字符串左/右对齐,并使用空格填充至长度 width 的新字符串

    # mystr.ljust(width)
    name3='lisa'
    name3.ljust(10) #'lisa      '
    name3.rjust(10) #'      lisa'
    

• center 

  • 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

    # mystr.center(width)  
    mystr.center(50) # '         hello world itcast and itcastcpp         '

•  lstrip / rstrip / strip

  • 删除mystr字符串两端的空白字符
  • 删除 mystr 字符串末尾的空白字符
  • 删除 mystr 左边的空白字符

    # mystr.lstrip()
    # mystr.rstrip()  
    # mystr.strip()
    name4='    Tom    '
    name4.lstrip() # 'Tom    '
    
    name4.rstrip() # '    Tom'
    
    name4.strip() #'Tom'

•  partition / rpartition

  • 把mystr以str分割成三部分,str前，str和str后
  • 类似于 partition()函数,不过是从右边开始.

    # mystr.partition(str)
    # mystr.rpartition(str)
    mystr.partition('itcast') #('hello world ', 'itcast', ' and itcastcpp')
    mystr.rpartition('itcast') #('hello world itcast and ', 'itcast', 'cpp')

• splitlines

  • 执行前需要对元素按照行分隔，然后返回一个包含各行作为元素的列表

    # mystr.splitlines()
    mystr = 'hello world itcast and itcastcpp'
    mystr.splitlines()  # ['hello world itcast and itcastcpp']
    
    mystr1='hello\nitcast\nand\nitcastcpp'
    print(mystr1)
    # hello
    # itcast
    # and
    # itcastcpp
    mystr1.splitlines() # ['hello', 'itcast', 'and', 'itcastcpp']

•  isalpha / isdigit / isalnum / isspace

  • 如果 mystr 所有字符都是字母 则返回 True,否则返回 False
  • 如果 mystr 只包含数字则返回 True 否则返回 False
  • 如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
  • 如果 mystr 中只包含空格，则返回 True，否则返回 False

    # mystr.isalpha()
    # mystr.isdigit() 
    # mystr.isalnum() 
    # mystr.isspace() 
    
    mystr = 'hello world itcast and itcastcpp'
    name3='lisa'
    name4='666'
    name5='he is 65'
    name6='heis65'
    
    mystr.isalpha() # False
    name3.isalpha() # True
    
    mystr.isdigit() # False
    name4.isdigit() # True
    
    name5.isalpha() # False
    name5.isdigit() # False
    name5.isalnum() # False
    name6.isalnum() # True
    
    name7=' '
    name5.isspace() # False
    name7.isspace() # True

•  join

  • mystr 中每个字符后面插入str,构造出一个新的字符串

    # mystr.join(str)
    str='_'
    li=['my','name','is','li']
    str.join(li) # 'my_name_is_li'

•  2、列表  

  • 比C语言的数组强大的地方在于列表中的元素可以是不同类型的

    #列表的循环遍历
        namesList = ['xiaoWang','xiaoZhang','xiaoHua']
        for name in namesList:
            print(name)
    #等价于
        namesList = ['xiaoWang','xiaoZhang','xiaoHua']
        length = len(namesList)
        i = 0
        while i<length:
            print(namesList[i])
            i+=1
    #    xiaoWang
    #    xiaoZhang
    #    xiaoHua

• 列表的增加

  • append  作为整体向列表添加元素 
  • extend   将另一个集合中的元素逐一添加到列表中
  • insert     insert(index, object) 在指定位置index前插入元素object

a = [1, 2]
b = [3, 4]
a.append(b) 
a    #[1, 2, [3, 4]]
a.extend(b) 
a    #[1, 2, 3, 4]

a = [0, 1, 2]
a.insert(1, 3)
a    #[0, 3, 1, 2]

#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----添加之前，列表A的数据-----")
for tempName in A:
    print(tempName)
#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
A.append(temp)
print("-----添加之后，列表A的数据-----")
for tempName in A:
    print(tempName)
#-----添加之前，列表A的数据-----
#xiaoWang
#xiaoZhang
#xiaoHua
#请输入要添加的学生姓名: ABC
#-----添加之后，列表A的数据-----
#xiaoWang
#xiaoZhang
#xiaoHua
#ABC

• 列表的修改

  •   要通过下标来确定要修改的是哪个元素，然后才能进行修改

    #定义变量A，默认有3个元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']
    print("-----修改之前，列表A的数据-----")
    for tempName in A:
        print(tempName)
    #修改元素
    A[1] = 'xiaoLu'
    print("-----修改之后，列表A的数据-----")
    for tempName in A:
        print(tempName)
#-----修改之前，列表A的数据-----
#xiaoWang
#xiaoZhang
#xiaoHua
#-----修改之后，列表A的数据-----
#xiaoWang
#xiaoLu
#xiaoHua

• 列表的查找 

  • in（存在）,如果存在那么结果为true，否则为false
  • not in（不存在），如果不存在那么结果为true，否则false

    #待查找的列表
    nameList = ['xiaoWang','xiaoZhang','xiaoHua']
    #获取用户要查找的名字
    findName = input('请输入要查找的姓名:')
    #查找是否存在
    if findName in nameList:
       print('在字典中找到了相同的名字')
    else:
        print('没有找到')
    #请输入要查找的姓名: xiaoWang
    #在字典中找到了相同的名字
    
    #请输入要查找的姓名: ABC
    #没有找到

  • index 检测目标str 是否包含在 mystr中，如果包含返回目标str开始时的索引值，否则返回-1
  • count  返回目标str在start和end之间，目标str在mystr里面出现的次数

    a = ['a', 'b', 'c', 'a', 'b']
    a.index('a', 1, 3) # ValueError: 'a' is not in list
    a.index('a', 1, 4) # 3
    a.count('b') # 2
    a.count('d') # 0
    

• 列表的删除

  • del：根据下标进行删除
  • pop：删除最后一个元素
  • remove：根据元素的值进行删除

        movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
    
        print('------删除之前------')
        for tempName in movieName:
            print(tempName)
        del movieName[5]
    # 等价于
    #   movieName.pop()
    #   movieName.remove('速度与激情')
    
        print('------删除之后------')
        for tempName in movieName:
            print(tempName)
    
    #------删除之前------
    #加勒比海盗
    #骇客帝国
    #第一滴血
    #指环王
    #霍比特人
    #速度与激情
    #------删除之后------
    #加勒比海盗
    #骇客帝国
    #第一滴血
    #指环王
    #霍比特人

• 列表的排序 

  • sort方法是将list按特定顺序重新排列，默认为由小到大
  • reverse方法是将list逆置（从小到大），参数reverse=True可改为倒序，由大到小

    a = [1, 4, 2, 3]
    a.sort()
    a  #[1, 2, 3, 4]
    
    a.reverse()
    a  #[3, 2, 4, 1]
      
    a.sort(reverse=True)
    a  #[4, 3, 2, 1]

• 列表的嵌套 

  import random
  # 定义一个列表用来保存3个办公室
  offices = [[],[],[]]
  # 定义一个列表用来存储8位老师的名字
  names = ['A','B','C','D','E','F','G','H']
  i = 0
  for name in names:
      index = random.randint(0,2)    
      offices[index].append(name)
  i = 1
  for tempNames in offices:
      print('办公室%d的人数为:%d'%(i,len(tempNames)))
      i+=1
      for name in tempNames:
          print("%s"%name,end='')
      print("\n")
      print("-"*20)
  #办公室1的人数为:3
  #ABC
  #
  #--------------------
  #办公室2的人数为:4
  #DFGH
  #
  #--------------------
  #办公室3的人数为:1
  #E
  #
  #--------------------

•  3、元组

  • Python的元组与列表类似，不同之处在于元组的元素不能修改，也不能删除。
  • 元组使用小括号，列表使用方括号。
  •  元组的内置函数 count，index,用来索引元素

    aTuple = ('et',77,99.9)
    aTuple[0]  #'et'
    aTuple[1]  #77
    aTuple[1]=188  #TypeError: 'tuple' object does not support item assignment
    
    a = ('a', 'b', 'c', 'a', 'b')
    a.index('a', 1, 4)
    # 3
    a.count('b')
    # 2
    a.count('d')
    # 0

• 4、字典

  • 能同时存储不同类型的数据，并可以根据定义的类型部分访问  print（name['类型名字']）

    info = {'name':'班长', 'id':100, 'sex':'f', 'address':'亚洲'}
    print(info['name'])    #班长
    print(info['address'])  #亚洲
    print(info['age'])    #访问不存在的键会报错 KeyError: 'age'

  • 修改元素  input( )

    info = {'name':'班长', 'id':100, 'sex':'f', 'address':'亚洲'}
    newId = input('请输入新的学号')
    info['id'] = int(newId)
    print('修改之后的id为:%d'%info['id'])
    #请输入新的学号 465
    #修改之后的id为:465

  • 添加元素  input()

    info = {'name':'班长', 'id':100, 'sex':'f', 'address':'亚洲'}
    new = input('请输入QQ号')
    info['QQ'] = int(new)
    print('添加之后的QQ为:%d'%info['QQ'])
    print('添加后%s'%info)
    #请输入QQ号 456789
    #添加之后的QQ为:456789
    #添加后{'name': '班长', 'id': 100, 'sex': 'f', 'address': '亚洲', 'QQ': 456789}

  • 删除元素  del

    #删除一个元素
    info = {'name':'班长', 'id':100, 'sex':'f', 'address':'亚洲'}
    print('删除前:%s'%info['name'])    #删除前:班长
    del info['name']
    print('删除后:%s'%info['name'])    #报错
    print('删除后 %s'%info)    #删除后{'id': 100, 'sex': 'f', 'address': '亚洲'}
    
    
    #删除整个字典
    info = {'name':'班长', 'id':100, 'sex':'f', 'address':'亚洲'}
    print('删除前 %s'%info)    
    del info
    print('删除后 %s'%info)
    #删除前 {'name': '班长', 'id': 100, 'sex': 'f', 'address': '亚洲'}
    #报错
    
    
    #清空整个字典
    info = {'name':'monitor', 'sex':'f', 'address':'China'}
    print('清空前 %s'%info)
    info.clear()
    print('清空后 %s'%info)
    #清空前 {'name': 'monitor', 'sex': 'f', 'address': 'China'}
    #清空后 {}

• len() 

  • 测量字典中键值对的个数

• keys() 

  • 返回一个包含字典所有KEY的列表

• values()  

  • 返回一个包含字典所有value的列表

• intems() 

  •  返回一个包含所有（键，值）元祖的列表

• in 

  • 若key在字典中，返回True，否则返回False

    info = {'name':'monitor', 'sex':'f', 'address':'China'}
    len(info)    # 3
    info.keys()    #dict_keys(['name', 'sex', 'address'])
    info.values()    #dict_values(['monitor', 'f', 'China'])
    info.items()    #dict_items([('name', 'monitor'), ('sex', 'f'), ('address', 'China')])
    info = {'name':'monitor', 'sex':'f', 'address':'China'}
    #info.has_key('address') #在 Python3 里面， dict.has_key() 被移除了
    #info.has_key('name')
    print ('Height' in info)    #False
    print ('Height' not in info)    #True
    print ('name' in info)    #True

• 5、遍历操作

  • 字符串遍历

    a_str = "hello itcast"
    for char in a_str:
        print(char,end=' ')
    #h e l l o   i t c a s t 

  • 列表遍历

    a_list = [1, 2, 3, 4, 5]
    for num in a_list:
        print(num,end=' ')
    #1 2 3 4 5

  • 元组遍历

    a_turple = (1, 2, 3, 4, 5)
    for num in a_turple:
        print(num,end=" ")
    #1 2 3 4 5 

  • 字典遍历

    info = {'name':'monitor', 'sex':'f', 'address':'China'}
    
    #遍历字典的key（键）
    for key in info.keys():
        print(key)
    #name
    #sex
    #address
    
    #遍历字典的value（值）
    for value in info.values():
        print(value)
    #monitor
    #f
    #China
    
    #遍历字典的元素
    for item in info.items():
        print(item)
    #('name', 'monitor')
    #('sex', 'f')
    #('address', 'China')
    
    #遍历字典的key-value（键值对）
    for key,value in info.items():
        print('key=%s,value=%s'%(key,value))
    #key=name,value=monitor
    #key=sex,value=f
    #key=address,value=China

  • 带下标的遍历 

    chars = ['a', 'b', 'c', 'd']
    i = 0
    for chr in chars:
        print("%d %s"%(i, chr))
        i += 1
    
    #等价于 
    chars = ['a', 'b', 'c', 'd']
    for i, chr in enumerate(chars):
        print (i, chr)
    #0 a
    #1 b
    #2 c
    #3 d

•  6、一些公共方法

• 对字符串、列表、元组可用
  • +          合并
  • *          复制
• 对字符串、列表、元组、字典可用
  • in     判断元素是否存在
  • in      在对字典操作时，判断的是字典的键
  • not in   判断元素是否不存在

    "hello " + "itcast"                  #'hello itcast'
    [1, 2] + [3, 4]                      #[1, 2, 3, 4]
    ('a', 'b') + ('c', 'd')              #('a', 'b', 'c', 'd')
    'ab'*4                               #'abababab'
    [1, 2]*4                             #[1, 2, 1, 2, 1, 2, 1, 2]
    ('a', 'b')*4                         #('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
    'itc' in 'hello itcast'                   #True
    3 in [1, 2]                               #False
    4 in (1, 2, 3, 4)                         #True
    "name" in {"name":"Delron", "age":24}     #True

• operator   比较两个值

  • operator.ge(a, b)    a >= b
  • operator.gt(a, b)    a > b
  • operator.ne(a, b)    a != b
  • operator.eq(a, b)    a == b
  • operator.le(a, b)    a <= b
  • operator.lt(a, b)    a < b
• len(item)  计算元素个数
• max(item)  返回元素最大值
• min(item)  返回元素最小值
• del(item)  删除变量
• 多维列表/元组的访问

  # cmp('hello', 'itcast')  #python3中不能用
  import operator
  operator.eq('hello', 'itcast')    #False
  operator.eq("itcast", "hello")    #False
  operator.eq("hello", "hello")     #True
  operator.lt("itcast", "hello")    #False
  operator.gt("itcast", "hello")    #True
  operator.eq([1, 2], [1, 1])       #False
  
  len("hello itcast")     #12
  len([1, 2, 3, 4])       #4
  len({"a":1, "b":2})     #2
  
  max("hello itcast")    #'t'
  max([1,4,522,3,4])     #522
  max({"a":1, "b":2})    #'b'
  max({"a":10, "b":2})   #'b'
  max({"c":10, "b":2})   #'c'
  
  a = 1
  del a
  a    #报错
  
  a = ['a', 'b']
  del a[0]
  a    #['b']
  del(a)
  a    #报错
  
  tuple1 = [(2,3),(4,5)]
  tuple1[0]    #(2, 3)
  tuple1[0][0] #2
  tuple1[0][1] #3
  tuple1[0][2] #报错
  tuple1[1][2] #报错
  tuple1[1][1] #5
  tuple2 = tuple1+[(3)]
  tuple2       #[(2, 3), (4, 5), 3]
  tuple2[2]    #3
  tuple2[2][0]    #报错

• 7、引用 

•  python中，值是靠引用来传递的
• 用id()来判断两个变量是否为同一个值的引用
• 可变类型，引用中值改变后仍相等
  • 列表list，字典dict
• 不可变类型，引用中值改变后不再相等
  • 数值类型 int，long，bool，float，字符串 str，元组 tuple

    a=1
    b=a
    id(a)    #1316436470064
    id(b)    #1316436470064
    a=3
    id(a)    #1316436470128
    id(b)    #1316436470064
    
    a = [1, 2]
    b=a
    id(a)    #1316538178688
    id(b)    #1316538178688
    a.append(3)
    a    [1,2,3]    
    id(a)    #1316538178688
    id(b)    #1316538178688

• 8、函数

•  把部分有独立功能的程序封装在一起并命名，在需要使用时调用该程序的名字来实现目标功能。
• 规范：
  • 方法的命名规则与变量相同
  • 方法中能调用别的方法，但不能定义新的方法
  • 命名时可以采用驼峰式命名，使命名更清晰。如getname可以写为getName
• 定义函数时小括号中的参数，用来接收参数用的，称为 “形参”
• 调用函数时小括号中的参数，用来传递给函数用的，称为 “实参”
• 定义完函数后，函数是不会自动执行的，需要调用它才可以

  def printInfo():
      print('hello tomorrow')
  
  printInfo()    #hello tomorrow
  
  def test(a,b):
      print('%d'%(a+b))
  
  test(11,22)    #33

•  定义带有参数的函数

  def add2num(a,b):
      c=a+b
      print(c)
  
  add2num(11,22)    #33

•  调用函数参数时的顺序

  def test(a,b):
      print(a,b)
  
  test(1,2)    #1 2
  test(b=1,a=2)    #2 1
  test(b=1,2)    #SyntaxError: positional argument follows keyword argument
  

•  函数嵌套应用

  def printOneLine():
      print("-"*30)
  def printNumLine(num):
      i=0
      while i<num:
          printOneLine()
          i+=1
  
  printNumLine(3)
  #------------------------------
  #------------------------------
  #------------------------------
  
  def sum3Number(a,b,c):
      return a+b+c
  
  def average3Number(a,b,c):
      sumResult = sum3Number(a,b,c)
      aveResult = sumResult/3
      return aveResult
  
  result = average3Number(11,2,55)
  print("average is %d"%result)    #average is 22

• 局部变量

  •  在函数内部定义的变量
  • 不同的函数，可以定义相同的名字的局部变量，各自使用时不会产生影响（形参）
  • 作用：临时保存数据

• 全局变量

  • 既能在一个函数中使用，也能在其他的函数中使用的变量（实参）
  • 如果在函数中修改全局变量，那么就需要使用global进行声明，否则要报错
    • 本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
    • 对于可变类型的全局变量，因其指向的数据可以修改，所以不使用global时也可修改全局变量。
    • 对于不可变类型的全局变量，因其指向的数据不能修改，所以不使用global时无法修改全局变量。

      a = 100    #全局变量
      def test1():
              print(a)
      
      def test2():
              print(a)
      
      def test3():
          a=300     #局部变量
          print('test3 修改前a=%d'%a)
          a=500
          print('test3 修改后a=%d'%a)
      
      def test4():
          global a
          print('test4 修改前a=%d'%a)
          a=600
          print('test4 修改后a=%d'%a)
      
      def test5():
          print('test5 a=%d'%a)
      test1()    #100
      
      test2()    #100
      
      test3()
      #test3 修改前a=300
      #test3 修改后a=500
      
      test4()
      #test4 修改前a=100
      #test4 修改后a=600
      
      test5()
      #test5 a=100
        
      #可变类型 不可变类型
      a = 1
      def fo():
          a += 1
          print a
      
      fo()    #UnboundLocalError: local variable 'a' referenced before assignment
      
      a = 1
      def fo():
          global a
          a += 1
          print(a)
      
      fo()    #2
      
      #不可变类型
      li = [1,]
      def f1():
          li.append(1)
          print(li)
      
      f1()    #[1, 1]
      li      #[1, 1]

• 函数返回多个值 

  • 本质是利用了元组

    def divid(a, b):
        shang = a//b
        yushu = a%b 
        return shang, yushu
    
    sh, yu = divid(5, 2)
    sh    #2
    yu    #1

• 缺省参数 

  • 调用函数时，缺省参数的值如果没有传入，则被认为是默认值。
  • 带有默认值的参数一定要位于参数列表的最后面，否则会报错。

    def printinfo( name, age = 35 ):
        print( "Name: ", name)
        print("Age ", age)
    
    printinfo(name="miki" )
    #Name:  miki
    #Age  35
    
    printinfo( age=9,name="miki" )
    #Name:  miki
    #Age  9
    
    def printinfo(name, age=35, sex):
        print name
    #SyntaxError: non-default argument follows default argument

    ​​​​​​​