学习PYthon第二天

1.嵌套调用函数：

 2.变量在函数中的作用域

        函数内部定义的变量：局部变量，在函数外不能访问

        全局变量：函数内部不可修改，通过global 关键字将变量定义为全局变量

        案例：ATM机

money = 5000
name = input("请输入您的姓名：")

def check():
    print(f"您好，您的余额剩余{money}")

def cun():
    cunMony = int(input("请输入存款金额："))
    global money
    money += cunMony
    print(f"存款成功，当前余额为{money}")

def qu():
    quMony = int(input("请输入取款金额："))
    global money
    if quMony > money:
        print("余额不足")
    else:
        money -= quMony
        print(f"取款成功，当前余额为{money}")

def main():
    print("--------主菜单--------")
    print(f'{name}你好，欢迎使用ATM机')
    print('查询金额   输入【1】')
    print('存款      输入【2】')
    print('取款      输入【3】')
    print('退出      输入【4】')
    return input('请输入你的选择')

while True:
    keyboard_input = main()
    if keyboard_input == "1":
        check()
        continue
    elif keyboard_input=="2":
        cun()
        continue
    elif keyboard_input=="3":
        qu()
    else:
        print("程序退出")
        break

3.数据容器list：

        （1）列表的定义：使用 [ ]         name_list = ['123','it' ,'周迅']，里面可以嵌套列表，列表中元素的类型不受限制，数据容器内的每一份数据称为元素，允许元素重复

         （2）通过下标索引取对应位置的数据。name_list[0] = 123；也可以通过反向索引取数据，比如：name_list [-1] = ‘周迅’

          （3）列表常用的操作方法：list内部可用的很多函数

                list.index（元素）:查找元素下标索引

                list[下标]  = 值：修改元素值

                list.insert(插入位置，插入值):列表插入元素

                list.append(元素）：列表最后追加一个元素

                list.extend(将要追加的其它列表容器)：追加很多元素

                del list[下标]: 删除指定下标的元素

                list.pop(下标）：取出列表中的元素，并把取出的值作为返回值返回

                list.remove(元素)：遍历列表，找到指定元素进行删除

                list.clear()：清空列表

                list.count() : 统计元素在列表中的数量

                count = len(list) : 统计列表中元素的总数

# while循环遍历列表
while i < len(myList):
    element = myList[i]
    print(element)
    i += 1

# for循环遍历列表
for element in myList:
    print(element)

4.数据容器元组tuple：

        （1）元组的定义：使用（）        t1 = (1,'hello', True)        如果元组只有一个元素

                元组具有不可修改性

        （2）元组中的方法：

                tuple.index（传入元素）：查找某个元素的下标

                tuple.count（元素）：元组中某元素的个数

                len（tuple）：元组的长度

        （3）元组中嵌套一个list，list中的内容可以修改

# for循环遍历元组
t1 = (123,'hhh',True,'12341')
for element in t1:
        print(f"t1中的元素有{element}")

  5.字符串str：

        （1）定义：name = 'hfncwiue'，不可以修改（增加或删除元素）

         （2）方法：

                str[1] ：取下标为1的字符

                str.index(字符）：查找字符的下标

                str.replace（字符串1，字符串2）：替换字符串中字符

                str.split（字符）：按照字符进行字符串切分

                str.strip（）：不传入参数，去前后空格；传入字符，去除前后相同字符

6.序列：内容连续、有序、可使用下表索引的一类容器（列表、元组、字符串）

        序列常用操作：

        （1）切片表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，生成一个新的序列：

                步长为1表示一个一个的取元素

                步长为2表示，每次跳过一个元素取数据

                步长为n表示，每次跳过n-1个元素取数据

                步长为负数，反向取

my_list=[0,1,2,3,4,5,6]
# 对list切片，从1开始，4结束 步长为一（可省略不写）
new_list = my_list[1:4]
print(new_list)

my_tuple = (0,1,2,3,4,5,6)
# 对tuple进行切片，从头开始，到最后结束，步长为1 可以省略
new_tuple = my_tuple[:]
print(new_tuple)

my_str = '0123456'
# 对字符串进行切片，从头开始，到尾结束，步长为-1
new_str = my_str[::-1]
print(new_str)

7.集合：不支持元素重复，无序的，无法进行下标索引访问

       （1） 定义集合： my_set = {‘哈哈哈’，‘呜呜呜’，‘嘿嘿嘿’}                       myset = set()

        （2）集合方法：

                添加新元素：my_set.add(元素)

                移除元素：my_set.remove(元素)

                随机取出一个元素：my_set.pop() 没有参数，随机取，返回取出的元素

                清空集合：my_set.clear() 

                取出集合的差集：set1.difference(set2)

# 取出集合一中有，集合2中没有的元素
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(set3)
# set3 = {2,3}

                消除两个集合的差集：set1.difference_update(set2)

# 消除set1和set2中相同的元素
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(set1)
# 修改了 set1 = {2,3}
# set2 不变

                合并两个集合：（去重）set1.union（set2）

# 合并两个集合，生成新的集合，原来的两个集合不会改变
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set3)
# set3 = {1,2,3,5,6}

                统计集合元素：len（set）：返回一个整数，自动去重

                集合的遍历：由于集合没有下标，不能使用while遍历，只能使用for循环遍历

8.字典

        （1）定义：使用大括号{ }，存储键值对 key：value 定义空字典 dict1 = dict（）；不允许key重复，后面的会自动覆盖前面的value，没有下标索引，可以嵌套

        （2）基于key取value值：my_dict [key值] = 对应的value值

        （3）常用操作：

                新增/更新 元素：字典 [ key ] = value

                删除元素 ： my_dict.pop(key)         返回对应的value值

                清空元素：dict.clear()

                获取全部的key：my_dict . keys() 用来做字典的遍历,不支持while循环

my_dict = {'周迅':100,'寻二':44,'哈哈':88}
keys = my_dict.keys()
for key in keys:
    print(my_dict[key])

for i in my_dict:
    print(my_dict[i])

                      字典中的元素数量：len(my_dict)          

9.五类数据容器对比：

10.通用容器转换：

        str（）        tuple（）        set（）        dict（）         list（）