python语法基础之元组，函数

元组

元组不可修改。 

函数

#定义调用函数
def print_menu():
    print('='*50)
    print('xxxx')
    print('=' * 50)

def print_sanjioaxing():
    print('*')
    print('*'*2)
    print('*'*3)
    print('*'*4)


print_menu()
print_sanjioaxing()

带有参数的函数 

#带有参数的函数
def sum(a,b):
    result=a+b
    print(result)

num1=int(input('输入第一个数：'))
num2=int(input('输入第二个数：'))

sum(num1,num2)

return的作用 

#return的作用
def get_wendu():
    wendu=22
    print(wendu)
    return wendu
def get_wendu_huashi(wendu):
    wendu=wendu+3
    print(wendu)

result=get_wendu()
get_wendu_huashi(result)

#返回多个值
def test():
    a=1
    b=2
    c=3
    #返回列表
    return [a,b,c]
    #返回元组两种
    return (a,b,c)
    return a,b,c
num=test()
print(num)

函数嵌套 

#函数嵌套
def print_line():
    print('-'*50)

def print_five_line():
    i=0
    while i<5:
        print_line()
        i+=1

print_five_line()

def sum(a,b,c):
    result=a+b+c
    return result

def avg(a1,a2,a3):
    result=sum(a1,a2,a3)
    result=result/3
    return result

num1=int(input('输入第一个数:'))
num2=int(input('输入第二个数:'))
num3=int(input('输入第三个数:'))

result=sum(num1,num2,num3)
print('和%d'%result)
avg=avg(num1,num2,num3)
print('平均数%d'%avg)

局部变量 

局部变量（Local variables）指在程序中只在特定过程或函数中可以访问的变量。

 

 

全局变量 

在程序的一开始定义的变量称为全局变量。全局变量作用域是整个程序。

局部变量和全局变量的区别 

 

名字管理系统—函数版 

card_infors=[]


def print_menu():
    """打印功能提示"""
    print ('='*50)
    print ('名字管理系统')
    print ('1:添加一个新的名字：')
    print ('2:删除一个新的名字：')
    print ('3:修改一个新的名字：')
    print ('4:查询一个新的名字：')
    print ('5:退出系统')

    print ('='*50)

def add_card_infor():
    new_name = input('输入新的名字：')
    new_qq = input('输入新的qq：')
    new_weixin = input("请输入新的微信:")
    new_addr = input("请输入新的住址:")

    new_infor = {}
    new_infor['name'] = new_name
    new_infor['qq'] = new_qq
    new_infor['weixin'] = new_weixin
    new_infor['addr'] = new_addr

    card_infors.append(new_infor)

def find_card_infor():
    find_name = input('请输入您要查询的名字：')

    flag_name = 0
    for temp in card_infors:
        if find_name in temp['name']:
            print("%s\t%s\t%s\t%s" % (temp['name'], temp['qq'], temp['weixin'], temp['addr']))
            flag_name = 1
            break
    if flag_name == 0:
        print('查无此人')

def show_card_infor():
    print('姓名\tQQ\t微信\t地址')

    for temp in card_infors:
        print("%s\t%s\t%s\t%s" % (temp['name'], temp['qq'], temp['weixin'], temp['addr']))
def main():
    """完成对整个程序的控制"""
    print_menu()

    while True:
        num = int(input('请输入功能序号：'))
        if num==1:
            add_card_infor()
            #print(card_infors)
        elif num==2:
            pass
        elif num==3:
            pass
        elif num==4:
            find_card_infor()



        elif num==5:
            show_card_infor()
        elif num==6:
            pass
        else:
            print('输入有误，请重新输入：')

        print('')
main()

函数返回多个值

缺省参数 

所谓缺省参数，顾名思义，就是在声明函数的某个参数的时候为之指定一个默认值，在调用该函数的时候如果采用该默认值，你就无须指定该参数。带缺省值的参数必须放在参数表的最后面。 缺省值必须是常量。

不定长参数 

• 使用*arg_name定义的位置参数，表示任意多个位置参数；
• Python标准库中习惯使用*args来命名不定长位置参数，当然我们可以自定义这个名称；
• 不定长位置参数的类型为元组。

• 有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。

  基本语法如下：加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

"""不定长参数"""
def test(a,b,*args):
    result = a + b
    for i in args:
        result+=i
    print(result)

test(1,2,3,3,3,3,3)

拆包 

*将元组的元素拆开；**将字典的元素拆开。

引用 

python中变量名和对象是分离的；最开始的时候是看到这句话的时候没有反应过来。决定具体搞清楚一下python中变量与对象之间的细节。（其实我感觉应该说 引用和对象分离 更为贴切）

　　从最开始的变量开始思考：

　　　在python中，如果要使用一个变量，不需要提前进行声明，只需要在用的时候，给这个变量赋值即可 (这个和C语言等静态类型语言不同，和python为动态类型有关)。

　　　举第一个例子：

　　　　a = 1

　　　这是一个简单的赋值语句，整数 1 为一个对象，a 是一个引用，利用赋值语句，引用a指向了对象1；这边形象比喻一下：这个过程就相当于“放风筝”，变量a就是你手里面的“线”，python就跟那根“线”一样，通过引用来接触和拴住天空中的风筝——对象。

　　　你可以通过python的内置函数 id() 来查看对象的身份(identity)，这个所谓的身份其实就是 对象 的内存地址：

　　　　注：

　　　　　python一切皆对象的理念，所以函数也是一个对象，因此可以使用 id() 函数的__doc__方法来查看这个函数的具体描述：

>>> id.__doc__
    "id(object) -> integer\n\nReturn the identity of an object. This is guaranteed to be unique among\nsimultaneously existing objects. 　　　　　　(Hint: it's the object's memory address.)"

第二个例子：

　　　　a = 2

　　　　a = 'banana'

　　　利用上面第一个栗子用到的 id()函数：　　　　

>>> a = 1
>>> id(a)
24834392
>>> a = 'banana'
>>> id(a)
139990659655312

　　　　第一个语句中， 2是储存在内存中的一个整数对象，通过赋值 引用a 指向了 对象 1

　　　　第二个语句中，内存中建立了一个字符串对象‘banana’，通过赋值 将 引用a 指向了 ‘banana’，同时，对象1不再有引用指向它，它会被python的内存处理机制给当我垃圾回收，释放内存。

　　　第三个例子：

　　　　a = 3

　　　　b = 3

　　　通过函数查看 变量a 和 变量b的引用情况：　

>>> a = 3
>>> b = 3
>>> id(a)
10289448
>>> id(b)
10289448

　　在这里可以看到  这俩个引用 指向了同一个 对象，这是为什么呢？ 这个跟python的内存机制有关系，因为对于语言来说，频繁的进行对象的销毁和建立，特别浪费性能。所以在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。

　　　第四个栗子：

　　　　1.  a = 4

　　　　2.  b = a（这里就是让引用b指向引用a指向的那个对象）

　　　　3.  a = a + 2

　　　通过函数查看引用情况：

　　　　当执行到第2步的时候，查看一下 a 和 b 的引用：　　　　　　

>>> a = 4
>>> b = a
>>> id(a)
36151568
>>> id(b)
36151568

　　　　可以看到 a 和 b 都指向了 整数对象 4

　　　　接下来指向第3步：

>>> a = a+2
>>> id(a)
36151520
>>> id(b)
36151568

　　　　可以看到 a 的引用改变了，但是 b 的引用未发生改变；a，b指向不同的对象； 第3句对 a 进行了重新赋值，让它指向了新的 对象6；即使是多个引用指向同一个对象，如果一个引用值发生变化，那么实际上是让这个引用指向一个新的引用，并不影响其他的引用的指向。从效果上看，就是各个引用各自独立，互不影响。

　　　第五个例子（这个例子会涉及到 python中的 可变数据类型 和 不可变数据类型）：

　　　开始这个例子之前，请记得注意到 第四个例子的不同之处。

　　　　　1.   L1 = [1, 2, 3]

　　　　　2.   L2 = L1

　　　　　3.   L1[0] = 10

　　　通过函数查看引用情况：

　　　　　当执行第1步 和 第二步 的时候，查看一下 L1 和 L2 的引用情况：

>>> L1 = [1,2,3]
>>> L2 = L1
>>> id(L1)
139643051219496
>>> id(L2)
139643051219496

　　　　　此时 L1 和 L2 的引用相同，都是指向 [1,2,3]这个列表对象。

　　　　　接下来，继续执行第3步：

>>> L1[0] = 10
>>> id(L1)
139643051219496
>>> id(L2)
139643051219496
>>> L2
[10, 2, 3]

　　　　　同样的跟第四个栗子那样，修改了其中一个对象的值，但是可以发现 结果 并不与 第四个栗子那样， 在本次实验中，L1 和 L2 的引用没有发生任何变化，但是 列表对象[1,2,3] 的值 变成了 [10,2,3]（列表对象改变了）

　　　　　在该情况下，我们不再对L1这一引用赋值，而是对L1所指向的表的元素赋值。结果是，L2也同时发生变化。

　　　　　原因何在呢？因为L1，L2的指向没有发生变化，依然指向那个表。表实际上是包含了多个引用的对象（每个引用是一个元素，比如L1[0]，L1[1]..., 每个引用指向一个对象，比如1,2,3), 。而L1[0] = 10这一赋值操作，并不是改变L1的指向，而是对L1[0], 也就是表对象的一部份(一个元素)，进行操作，所以所有指向该对象的引用都受到影响。

（与之形成对比的是，我们之前的赋值操作都没有对对象自身发生作用，只是改变引用指向。）

　　　　　列表可以通过引用其元素，改变对象自身(in-place change)。这种对象类型，称为可变数据对象(mutable object)，词典也是这样的数据类型。

　　　　　而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象(immutable object)。

　　　　　我们之前学的元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是immutable object.

　　　　　　　　

　　　　is关键字：

　　　　当然，我们也可以要想知道是否指向同一个对象，我们可以使用 python的 is 关键词，is用于判断两个引用所指的对象是否相同。

　　　　就像上述第四个栗子 当进行到 第1步 和 第2步 的时候：

>>> a = 4  ……id(a) = 36151568
>>> b =a   ……id(b) = 36151568
>>> a is b
True

　　　　当进行到第3步的时候：

>>> a = a + 2  ……id(a) = 36151520
>>> a is b  ……id(b) = 36151568
False

 递归

"""递归"""
def jiecheng(num):
    if num>1:
        return num*jiecheng(num-1)
    else:
        return num
result=jiecheng(4)
print(result)