python学习3__基础编程2

元组（tuple）

元组的定义：元组与列表类似，不同之处在于元组的元素不能修改

元组的基本操作：

分类	方法	说明
查询	元组[索引]	根据索引取值，索引不存在会报错
	index(数据)	根据值查询索引，返回首次出现时的索引，没有查到会报错
	count(数据)	数据在元组中出现的次数
	len(列表)	元组长度
	if 数据 in 元组:	检查元组中是否包含某元素
遍历	for 元素 in 元组:	取出元组中的每个元素

元素不能修改举例：

l=(1,2,3)
for ele in l:
    print(ele)
    ele='nihao'
    print(ele)
print(l)                           #输出仍为(1,2,3)

元组应用场景：

1. •作为自动组包的默认类型

2. •自动解包

   可以将容器中多个数据拆出来，下图中*后面的eles可以用任意变量代替，eg：a，_,a0等。表示 print(a)输出1.。。print(eles)输出[2，3].。。print(a,eles)输出1，[2,3]。

3. •交换数据

   

4. •格式化输出

   t进行拆包后附给%s和%d，一个元组内可以有不同的数据类型

5. •让列表不可被修改,保护数据安全

   列表和元组之间的相互转换，主要为了修改元组内数据或者使数组内的数据不被更改

"""---------------------------- 作为自动组包类型 ----------------------------"""
# 自动组包 (把多个数据自动组合为一个元组)
a= 1,2,3,4
print(a)
print(type(a))
"""---------------------------- 自动解包 ----------------------------"""
# 自动解包  把元组元素赋值给多个变量
t = (1,2,3,4)
a,b,c,d = t
print(a,b,c,d)
e,*args = t
print(*args)
print(args)
print(e)
*args,f = t
print(f)
"""---------------------------- 多个变量定义 ----------------------------"""
# 先自动组包,自动解包
# a,b,c,d = 1,2,3,4
"""---------------------------- 交换 ----------------------------"""
# go语言
# a = 10
# b = 20
#
# temp  =a
# a = b
# b = temp
# 组包和解包
a,b = b,a
#
print(a,b)
"""---------------------------- 格式化输出 ----------------------------"""
a = 10
b = 20
t = (40,50)
print('a=%d b = %d'%(a,b))
# 元组可以直接格式化输出
print('a=%d b=%d'%t)
"""---------------------------- 把列表变成元组,元素不可修改 ----------------------------"""
l = [1,2,3]
t = tuple(l)
print(type(t))

函数

定义：•所谓函数，就是把 具有独立功能的代码块 组织为一个整体，在需要的时候 调用。

•函数的使用包含两个步骤：

1. 定义函数 —— 在函数中编写代码，实现功能

2. 调用函数 —— 执行编写的代码

   函数名命名规范

函数的定义格式和函数的调用格式

def 函数名(参数):

函数封装的代码

​ …

函数调用： 函数名(参数)

函数的参数可以有多个eg：（a,b）

函数的执行过程：

​ •代码执行到函数定义时,不会走函数内部的代码,只是把函数名这个标识符,添加到内存中，调用函数时,会去内存中查询这个函数,并执行函数内部的代码。

形参和实参

形参：形式参数，在定义函数名和函数体时所使用的参数，目的时接受调用该函数时传入的参数。（函数被调用时用来接收实际参数的变量。）

实参：在调用时传递给函数的变量

*注意两点：

•1.在调用函数时，实参将赋值给形参。因而，必须注意实参的个数，类型应与形参一一对应，并且实参必须要有***确定的值***。

•2.实参可以是常量、变量、表达式、函数等. 无论实参是何种类型的量,在进行函数调用时，它们都***必须具有确定的值***。

形参的作用域

•形参的作用域只在定义函数的代码块 中，一旦超出该范围就不能再使用了

•不同的函数中,可以有同名的形参,不会相互影响

•作用域的使用提高了程序逻辑的局部性，增强程序的可靠性，减少名字冲突。

•函数间的形参是不能相互使用的

def sayHello(name):
    print(type(name))
    print('hello %s'%name)

sayHello('林青霞')
sayHello('高圆圆')
sayHello([1,2,3])         #函数的实参类型可以室多种数据类型

# 实际使用过程中参数定义和调用的个数一定要保持一致
def sum(a,b):
    print('和为%d'%(a+b))

sum(10,20)
#sum(10)             #会报错

函数的返回值

"""---------------------------- 无参无返回值 ----------------------------"""
def sayHello():
    print('hello')

"""---------------------------- 无参有返回值 ----------------------------"""
import random
# 获取温度
def getTemperature():
    return random.randint(0,100)

t = getTemperature()
print(t)

"""---------------------------- 有参无返回值 ----------------------------"""
# 数据加工模块
def max(a,b):
    print(a+b)

"""---------------------------- 有参有返回值 ----------------------------"""
 def max(a,b):
     if a>=b:
         return a
     else:
         return b

局部变量和全局变量

•全局变量是在整个py文件中声明，全局范围内都可以访问

•如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错

# 函数内部不能修改全局变量
# 想要修改全局变量,需要变量加上global关键字

# 定义全局变量
m = 20

def sub():
    # 意图修改全局变量
    # 创建了新的局部变量
    global m
    m = 30
    print('函数里面',m)


# 修改之前输出
print(m)            #输出m=20
sub()
# 意图修改之后打印
print(m)             #输出m=30

函数的返回值

函数可以有多个返回值，但只能执行一个return指令

需求:
需求:定义函数接收参数a和参数b,并返回a和b的和以及a和b的差

多个返回值,结果是元组类型,可以使用多个变量接收
'''
def func(a,b):
    return a+b,a-b


# go
sum,_ = func(10,20)
print(sum)                    #30
print(_)                      #-10
print(type(func(10, 20)))     #tuple

模块

•模块是Python 程序架构的一个核心概念

•模块就好比是 工具包，要想使用这个工具包中的工具，就需要导入 import 这个模块

•每一个以扩展名py 结尾的 Python 源代码文件都是一个 模块

•在模块中定义的全局变量、 函数都是模块能够提供给外界直接使用的工具

'''
1. 定义python文件,定义全局变量  函数 类
2. 使用import导入模块,  模块名.变量/函数/类       #使用的时候需要加上模块名.变量/函数/类
3. 导入方式二:from  card_util import *  从模块中导入所有的全局变量和函数以及类,使用时就不需要加上模块名了
'''
# 保存名片的列表全局变量
# import card_util

from  card_util import *         #导入模块内所有的全局变量和函数以及类
#from  card_util import showMenu             #若只导入showMenu()函数，则使用
while True:
    # 打印菜单
    showMenu()
    # 读取用户输入
    code = int(input('请选择执行的操作:'))
    # 判断执行的操作
    if code == 1:
        addCard()
        continue   #可删除
    elif code == 2:
        showAll()
        continue
    elif code == 3:
        searchCard()
        continue
    else:
        print('退出系统')
        break

高阶函数和lambda表达式

函数式编程

•函数式编程:函数可以作为函数的参数,也可以作为函数的返回值

高阶函数

•就是把函数当成参数传递的一种函数

'''
需求:
1.定义一个求两个数和的函数
2.定义一个求两个数差的函数
3.定义一个函数既可以求和又可以求差
4.定义一个函数求三个数的和和三个数的乘  返回三个数最大值
'''
def sum(a,b):
    return a+b
def sub(a,b):
    return a-b
def div(a,b):
    return a/b
def r(a,b):
    return a*b
# func 函数参数
def d(a):
    return a*2
def cacl(a,b,func):
    result = func(a,b) # 函数必须有两个参数
    return result
a = 10
b = 20
result = cacl(a,b,r)      
print(result)
#result = cacl(a,b,d)   #这种形式会提示错误，因为d()只需要传入一个参数
#print(result)
'''
高阶函数:函数的参数有函数参数的函数称为高阶函数
传递函数:传递函数名即可  代表函数的引用

lambda表达式

•lambda也称为匿名函数

这种函数得名于省略了用def声明函数的标准步骤

lambda函数的定义格式：

lambda 参数:表达式

def sum(a,b):
    return a+b
# func 函数参数
def cacl(a,b,func):
    return func(a,b)

# print(cacl(a, b, sum))
a=1
b=3
print(cacl(a, b, lambda a, b: a + b))    #注意这里lambda a, b: a + b式子等于sum。而不是sum(),如以下代码
                                         #f = lambda a,b:a+b
                                         #print(f(10, 20)) 
'''
lambda表达式不用return返回数据
lambda表达式可以独立存在
'''

sort()函数

'''
l = ['abd','ewetrwef','fered','qwszfgfsaffs']
1，元素按照长度从小到大排序
2，按照第二个元素进行排序  倒叙排序
'''
#按长度进行排序
# sort内部调用
# 参数a 每一个列表元素
# 函数的作用是提取比较键
def myfunc(a):
    return len(a)
    # [3,5,8,12]
l = ['abd','ewetrwef','fered','qwszfgfsaffs']
l.sort(key=myfunc)
# l.sort(key=lambda a:len(a))        #这两种方式也可以直接算出
# l.sort(key=len)                    #注意比较键key不是一个函数，而是一个函数名称，默认参数为每个元素
print(l)

#按2进行排序
# 提取比较键
l = ['abd','ewetrwef','fered','qwszfgfsaffs']
# ll=['z','a','f']
# ll.sort(reverse=True)
# print(ll)

def func(ele):
    return ele[1]

l.sort(key=func)
#l.sort(key=lambda ele:ele[1],reverse=True)
print(l)

***python中函数必须先定义再进行使用

***函数内部不能修改全局变量，若想要修改，需要变量加global。直接在局部赋值不能改变全局变量，但在局部增加变量内的内容用法一样