一：元组和集合
#元组
data1 = (10,30,40,50)
#元组是只读性质
print(data1[1])
# data1[1] = '小菜菜'
#元组支持数据的析构操作
num1, num2 = (10,20)
print(num1, num2)
#元组合并
data2 = (1,2)+(3,4)
print(data2)
# 元组的复制
data2 = (1,2,3)*3
print(data2)
#元组的切片
print(data2[1:4])
#元组内部如果只有一个元素，此时元素后面一定要添加","表明该数据是一个元组类型
data2 = (1, )
#遍历元组
for item in data2:
print(item)
"""
集合特点：
1、无序性
2、唯一性
"""
set1 = {1,2,3,4,5,2,3,4,5}
print(set1)
#遍历集合
for item in set1:
print(item)
#使用一行代码将列表[1,2,3,2,4,1,2,3]中重复的元素过滤掉
list1 = list(set([1,2,3,2,4,1,2,3]))
print(list1)
tu = tuple(list1)
print(tu)
#列表，元祖和集合可以相互转化
list = list1(set1) #集合转换成列表
set1 = set(list1) #列表转换成集合
tu = tuple(set1) #集合转换成元组
二：函数的作用
#定义一个列表存储10个[5,15]的随机整数，之后输出该随机数，之后对列表做降序排序，并输出降序排序之后的结果
import random
list1 = [random.randint(5,15) for i in range(10)]
# 输出随机数
for item in list1:
print(item)
print('----------------------------------------')
#对列表进行降序排序
list1.sort(reverse=True)
#输出排序之后的元素
for item in list1:
print(item)
"""
函数作用：
可以实现对公共代码的封装，这样相同代码只需要写一遍，之后根据需求灵活调用此段代码，这样可以减少代码冗余，提高代码执行效率
"""
三：函数的定义和调用
#函数的定义
"""
def 函数名(参数列表):
函数体
"""
"""
定义函数完成对可迭代数据的遍历(函数定义)
注意：函数定义过程是函数从无到有的过程，该过程函数内部代码并不会自动执行，需要外界调用对应函数时，函数内部代码才开始执行
"""
def map(iterable):
for item in iterable:
print(item)
"""
函数的调用：
函数名(参数列表)
注意：函数调用过程中，函数内部的代码才会开始执行
"""
map([1,2,3,4,5,6,7,8,9])
四：形参和实参
#函数的参数列表
"""
实参--实际参数，函数调用过程中传递的参数被称为实际参数
形参--形式参数，函数在定义过程中设置的参数称为形式参数
注意：
1、形参没有任何实际含义，只有实参能够决定未来使用数据的类型
2、实参向形参传递数据是一个值拷贝的过程，因此在函数内部对形参数据的修改一般不会影响实参中的数据
"""
import random
#定义一个函数完成商品的购买
def shopping(money):
price = random.randint(10,100)
if money > price:
money -= price
print('商品购买成功,当前剩余%d元'%(money))
else:
print('钱不够无法购买该商品')
#调用购物功能
dollar = 200
shopping(dollar)
print(dollar)
#完成对列表数据的排序操作
"""
注意：
当列表(字典)作为函数实际参数传递给形参时，此时拷贝为地址拷贝，此时在函数内部对列表数据（字典数据）的修改等价于直接修改外部列表（外部字典）（址拷贝）
"""
def sort_value(list_data, information):
list_data.sort()
information['name'] = '小呆呆'
list1 = [12,1,5,3,4,6,2,3]
infor = {'name':'小菜菜'}
sort_value(list1, infor)
print(list1)
print(infor)
五：形参的类
"""
形参的分类必须参数--该参数在函数调用时必须提供对应的实参数据
默认参数--该参数在函数调用时，可以省略，此时参数使用对应的默认值
可变参数--对应的参数的个数可以动态变化
关键字参数--在函数调用时可以为每一个参数提供一个对应的键，即数据以键值对的形式传入到函数内部
命名关键字参数--关键字的键值对提前定义好，函数调用时对应的键不允许修改
"""
#必须参数
def shopping(money):
print(money)
shopping(10)
#默认参数
def outTime(date="1990-01-01"):
print(date)
outTime('2019-07-23')
#可变参数
"""
可变参数：
*参数名， 注意在开发中可变参数的变量名用args来表示, 可变参数是将用户传递的数据转换成一个元组返回
"""
def getMax(*args):
max_num = args[0]
for item in args:
if max_num < item:
max_num = item
print(max_num)
getMax(10, 20)
#关键字参数
def outInfor(**kwargs):
print(kwargs)
outInfor(name1='小菜菜', sex1="男", age1="30")
#命名关键字参数：可以在函数定义过程中对关键字参数对应的键提前规定好名字，此时当外界调用时可以保证调用该函数的人员给定的关键在参数键值对保持一致
"""
在开发中*(*args)右侧的参数会被当成命名关键字参数来使用
"""
def outInfor1(*, name, age, sex):
print(name)
print(age)
print(sex)
infor = {'name':'小菜菜', 'sex':"男", "age":30}
# outInfor1(name='小菜擦', sex="男", age=30)
outInfor1(**infor)
outInfor(**infor)
"""
关键字参数（命名关键字参数）：
相同点：在进行数据传递时都是以键值对形式进行数据传递，同时也可以以字典的形式直接一次性将数据传递给对应的函数
不同点：关键字参数传输的键值对中键可以自定义，但是命名关键字参数传递的键值对键是提前定义好的，不允许随意修改
形参在构建过程中可以混合使用
必须参数，默认参数，可变参数，命名关键字参数
"""
六：函数的返回值
#函数返回值
"""
return 将函数调用结束之后产生的结果返回给外界调用的代码
注意：return关键词是函数调用结束的标志，如果程序执行过程中遇到return关键字，此时不管return关键字后面是否存在代码，都不在执行，因此在函数调用过程中return必须写在整个函数调用结束的位置
"""
import random
def getMax(*args):
max_num = args[0]
for item in args:
if max_num < item:
max_num = item
return max_num
num = getMax(10,20,30,40)
print(num)
# yield
"""
yield直接返回一个生成器，之后通过next调用生成器，此时函数内部会根据之前定义好的规则，动态生成一个数据
yield作用：程序执行的频率会根据开发人员需求动态调整，可以提高程序的执行效率
"""
def getRandome(min, max):
for i in range(1000000000):
num = random.randint(min, max)
print('当前执行的是第%d次循环'%(i+1))
yield num
print('第%d次循环结束'%(i+1))
list1 = getRandome(10,100)
num1 = next(list1)
num2 = next(list1)
# print(num1, num2)
七：变量的作用域：
#变量的作用域
"""
局部变量：定义在函数内部的变量, 局部变量的生命周期从变量定义开始到整个函数运行结束
全局变量：定义在函数外部的变量，全部变量的生命周期从变量定义开始到整个程序运行结束
注意：全局变量可以被任何一段程序访问，因此全局变量使用过程中数据可能随时变化，开发中全局变量需要慎用
注意：
1、学会区分全局变量和局部变量
2、函数在使用变量时遵循就近原则
3、函数内部如果需要使用全局变量，需要提前通过global声明对应变量是全局变量
"""
#
money = 10
def shopping(money1):
money1 -= 20
print(money1)
shopping(200)
def puy():
global money
money -= 5
print(money)
puy()
print('当前剩余%d元'% money)