python学习笔记

python笔记

列表

列表的定义

列表的循环遍历

基本元素定义

列表的循环遍历 for

infos = ["你好", 123, 3.14]
print(infos)
for temp in infos:
    print(temp)

列表的循环遍历 while

infos = ["你好", 123, 3.14]
print(infos)
i = 0
while i < len(infos):
    print(infos[i])
    i += 1

在列表中增加元素 – 增加元素

• 代码

# 增加
name_list = ["小一", "小二", "小三"]
# append 方法可以向列表的末尾追加数据
name_list.append("小四")
print(name_list)

# insert 方法可以在列表的指定索引位置插入数据
name_list.insert(1, "小五")
print(name_list)

# extend 方法可以把其他列表中的完整内容，追加到当前列表
temp_list = ["小六", "小七", "小八"]
name_list.extend(temp_list)
print(name_list)

• 结果

['小一', '小二', '小三', '小四']
['小一', '小五', '小二', '小三', '小四']
['小一', '小五', '小二', '小三', '小四', '小六', '小七', '小八']

列表中查找数据 --查找

• 代码

# 增加
name_list = ["小一", "小二", "小三"]
# 1. 取值和取索引
# list index out of range - 列表索引超出范围
print(name_list[2])

# 知道数据的内容,想知道数据在列表中的位置
# 使用index方法需要注意,如果传递的数据不在列表中.
print(name_list.index("小二"))

• 结果

小三
1

在列表中删除元素 -元素

• 代码 remove pop clear的用法

name_list = ["小一", "小二", "小三", "小四"]

print(name_list)

# 删除
# remove 方法可以从列表中删除指定的数据
name_list.remove("小三")
print(name_list)

# pop 方法默认可以把列表中最后一个元素删除
name_list.pop()
print(name_list)

# pop 方法可以指定要删除元素的索引
name_list.pop(1)
print(name_list)

# clear 方法可以清空列表
name_list.clear()
print(name_list)

• 结果

['小一', '小二', '小三', '小四']
['小一', '小二', '小四']
['小一', '小二']
['小一']
[]

• 代码 del 用法 (平常开发中不推荐您使用)
  -结果

• 1.使用del语句删除列表元素。

# 数据
name_list = ["小一", "小二", "小三", "小四"]

print(name_list)

# 删除
# (知道)使用del关键字(delete) 删除列表元素
# 提醒: 在日常开发中，要从列表删除数据，建议使用列表
del name_list[1]

print(name_list)

# del 关键字本子上是用来将一个变量从内存中删除的
name = "小明"

del name
# 注意：如果使用del关键字将变量从内存中删除
# 后续的代码就不能再使用这个吧年来那个了
# name 'name' is not defined
print(name)

['小一', '小二', '小三', '小四']
['小一', '小三', '小四'] 

NameError: name 'name' is not defined

• 2.使用pop方法删除列表元素。
  

• 3.使用remove方法删除列表元素
  

在列表中修改数据.

列表的排序操作

• 升序

  • 代码

  # 数据
  name_list = ["zhangsan", "xiaoer", "wangwu", "wangxiao"]
  num_list = [6, 8, 4, 1, 10]
  # 升序
  name_list.sort()
  num_list.sort()
  
  print(name_list)
  print(num_list)
  
  

  • 结果

  ['wangwu', 'wangxiao', 'xiaoer', 'zhangsan']
  [1, 4, 6, 8, 10]
  

• 降序

  • 代码

  # 数据
  name_list = ["zhangsan", "xiaoer", "wangwu", "wangxiao"]
  num_list = [6, 8, 4, 1, 10]
  # 降序
  name_list.sort(reverse=True)
  num_list.sort(reverse=True)
  
  print(name_list)
  print(num_list)
  
  

  • 结果

  ['zhangsan', 'xiaoer', 'wangxiao', 'wangwu']
  [10, 8, 6, 4, 1] 
  

• 降序

  • 代码

  # 数据
  name_list = ["zhangsan", "xiaoer", "wangwu", "wangxiao"]
  num_list = [6, 8, 4, 1, 10]
  # 逆序 (反转)
  name_list.reverse()
  num_list.reverse()
  
  print(name_list)
  print(num_list)
  
  

  • 结果

  ['wangxiao', 'wangwu', 'xiaoer', 'zhangsan']
  [10, 1, 4, 8, 6]
  

列表的嵌套

• 代码

  import random
  
  # 1. 定义一个列表，嵌套的列表
  rooms = [[], [], []]
  
  # 2. 有一个列表，保存了8名老师的名字
  teachers = ["A", "B", "C", "D", "E", "F", "G", "H"]
  
  # 3. 随机把8名老师的名字添加到 第1个列表中
  
  for name in teachers:
      randomNum = random.randint(0, 2)
      rooms[randomNum].append(name)
  
  # print(rooms)
  
  i = 0;
  for room in rooms:
      print("办公室%d里面的老师姓名是:" % i)
      for name in room:
          print(name, end=" ")
  
      print("")
      i += 1
  
  

• 效果 (随机分配学生)

  测试1:

  
  办公室0里面的老师姓名是:
  A E F 
  办公室1里面的老师姓名是:
  B C H 
  办公室2里面的老师姓名是:
  D G 
  

  测试2:

  
  办公室0里面的老师姓名是:
  D E 
  办公室1里面的老师姓名是:
  A C G 
  办公室2里面的老师姓名是:
  B F H 
  
  

元组

元组的概念

• 访问元组

• 代码

  # 定义一个元组
  name_tuple = ("zhangsan", "张三", 18, 1.75)
  print(name_tuple[0])
  print(name_tuple[1])
  print(name_tuple[2])
  print(name_tuple[3])
  
  # 定义空元组
  empty_tuple = ()
  
  print(type(empty_tuple))
  # 定义一个元组(单元组)
  one_tuple = (50,)
  print(type(one_tuple))
  
  

• 结果

  zhangsan
  张三
  18
  1.75
  
  
  

元组的常用操作

• 代码

  # 定义一个元组
  info_tuple = ("zhangsan", "张三", 18, 1.75, "zhangsan")
  
  # 1. 取值和取索引
  print(info_tuple[0])
  
  # 2. 已经知道数据的内容，希望知道该数据在元组中的索引
  print(info_tuple.index("zhangsan"))
  
  # 3. 统计计数
  print(info_tuple.count("zhangsan"))
  
  # 4. 统计元组中包含元素的个数
  print(len(info_tuple))
  
  

• 结果

  zhangsan
  0
  2
  5
  

元组的遍历

• 代码

  # 定义一个元组
  info_tuple = ("zhangsan", "张三", 18, 1.75)
  
  # 使用迭代遍历元组
  for my_tuple in info_tuple:
      # 使用格式字符串拼接 my_info 这个变量不方便！
      # 因为元组中通常保存的数据类型是不同的！
      print(my_tuple)
  
  

• 结果

  zhangsan
  张三
  18
  1.75
  

元组和列表之间的转换

• 使用list函数可以把元组转换成列表

  list(元组)
  

• 使用tuple函数可以把列表转换成元组

  tuple(列表)
  

• 代码

  # 定义一个元组
  num_list = [1, 2, 3, 4]
  
  print("num_list类型：", type(num_list))
  
  num_tuple = tuple(num_list)
  print("使用tuple转换成元组后的类型：", type(num_tuple))
  
  num2_tuple = list(num_tuple)
  print("使用list转换成列表后的类型：", type(num2_tuple))
  

• 结果

  num_list类型： 
  使用tuple转换成元组后的类型： 
  使用list转换成列表后的类型： 
  

修改元组

元组的内置函数

字典

字典的定义

• 代码

  # 字典是一个无序的数据集合，使用print函数输出字典时，通常
  # 输出的顺序和定义的顺序是不一致的！
  xiaoming = {"name": "小明",
              "age": 18,
              "gender": True,
              "height": 1.75,
              "weight": 75.5,
              }
  
  print(xiaoming)
  
  

• 结果

  
  {'name': '小明', 'age': 18, 'gender': True, 'height': 1.75, 'weight': 75.5}
  

字典的常见操作(取值、增加/修改、删除)

• 代码

  xiaoming_dict = {"name": "小明"}
  
  # 1. 取值
  print("取值", xiaoming_dict["name"])
  
  # 在取值的时候，如果指定的key不存在，程序会报错！
  # print(xiaoming_dict[123])
  
  # 2.增加/修改
  # 如果key不存在,则会新增键值对
  xiaoming_dict["age"] = 18
  
  # 如果key存在,会修改已经存在的键值对
  xiaoming_dict["name"] = "小小明"
  
  print("增加/修改:", xiaoming_dict)
  
  
  # 3. 删除
  xiaoming_dict.pop("name")
  print("删除",xiaoming_dict)
  
  # 在删除指定键值对的时候,如果key不存在,程序会报错
  # xiaoming_dict[123]
  
  

• 结果

  
  取值 小明
  增加/修改: {'name': '小小明', 'age': 18}
  删除name: {'age': 18}
  

字典中常用的操作2（统计键值对数量、合并字典、清空字典）

• 代码

  xiaoming_dict = {"name": "小明"}
  
  # 1. 统计键值对数量`在这里插入代码片`
  print("统计键值对数量", len(xiaoming_dict))
  
  # 2.合并字典
  temp_dict = {"height": 1.75,
               "age": 20}
  # 注意：如果被合并的字典中包含已经存在的键值对,会覆盖原有的键值对
  xiaoming_dict.update(temp_dict)
  print("合并字典", xiaoming_dict)
  
  # 3.清空字典
  xiaoming_dict.clear()
  print("清空字典:", xiaoming_dict)
  
  

• 结果

  
  统计键值对数量 1
  合并字典 {'name': '小明', 'height': 1.75, 'age': 20}
  清空字典: {}
  

字典的循环遍历

• 代码

xiaoming_dict = {
    "name": "小明",
    "phone": "10086",
    "qq": "123456"
}

# 迭代遍历字典
# 变量k是每一次遍历中，获取到的键值对的key
for k in xiaoming_dict:
    print("%s-%s" % (k, xiaoming_dict[k]))

• 效果

name-小明
phone-10086
qq-123456

函数

函数基础

函数的快速体验

• 0创建两个python文件
  

• 1.创建九九乘法表文件 写一个九九乘法表函数

• def multiple_table(): 使用def创建函数

# 1. 打印 乘法表 
def multiple_table():
    row = 1

    while row <= 9:
        col = 1
        while col <= row:
            print("%d * %d= %d" % (col, row, col * row), end="\t")

            col += 1
        print("")
        row += 1

• 2. 创建快速体验文件
• import引入 调用

import hm_01_九九乘法表

hm_01_九九乘法表.multiple_table()

• 效果
  

函数的基本使用

函数的定义

第一个函数

• 代码

  name = "小明"
  
  
  # python 解释器知道下方定义了一个函数
  def say_hello():
      print("Hello 1")
      print("Hello 2")
      print("Hello 3")
  
  
  print(name)
  
  # 只有在程序中,主动调用函数, 才会让函数执行
  say_hello()
  
  print(name)
  
  

• 结果

  
  小明
  Hello 1
  Hello 2
  Hello 3
  小明
  

函数的参数

• 代码

  def sum_2_num(num1, num2):
      """对两个数字的求和 """
      result = num1 + num2
      print("%d+%d=%d" % (num1, num2, num1 + num2))
  
  
  sum_2_num(10, 20)
  
  

• 结果

  
  10+20=30
  

函数的返回值

def sum_2_num(num1, num2):
    '''对两个数字求和'''
    result = num1 + num2

    # 可以使用返回值,告诉调用函数一方计算的结果
    return result
    # 注意： return 就表示返回，下方的diamante不会被执行到！
    # num = 1000


# 可以使用变量,来接收函数执行的返回结果
sum_result = sum_2_num(10, 20)

print("计算结果: %d" % sum_result)

• 结果

计算结果: 30

函数的四种类型

全局变量和局部变量

全局变量

• 代码

# 在函数的外边定义的变量就叫做  全局变量
num = 100


def test1():
    # 如果在函数中直接修改全局变量，那么会产生异常
    # 如果真的需要进行修改, 那么可以在函数里面进行声明
    global num
    print(num)
    num += 2
    print(num)


def test2():
    print(num)


test1()
test2()

• 效果

100
102
102

局部变量

---

案例-名片管理器

第一步创建 (card_main 和 card_tools)

card_main代码

import card_tools

while True:
    card_tools.show_menu()
    action_str = input("请输入你要选择的功能项: ")
    print(f'你选择的操作是【{action_str}】')
    if action_str in ['1', '2', '3']:
        if action_str == '1':
            card_tools.new_card()
        elif action_str == '2':
            card_tools.show_all()
        elif action_str == '3':
            card_tools.search_card()
    elif action_str == '0':
        print("欢迎再次使用【名片管理系统】")
        break
    else:
        print("您输入的不正确,请重新输入！")
        print()

card_tools代码

card_list = [{"name": "jsj2001", "phone": "100861", "qq": "111", "email": "[email protected]"},
             {"name": "jsj2002", "phone": "100862", "qq": "222", "email": "[email protected]"}]


def show_menu():
    '''显示菜单'''
    print("*" * 50)
    print("欢迎使用【名片管理系统】")
    print("")
    print("1、新增名片")
    print("2、显示所有名片")
    print("3、搜索名片")
    print("")
    print("0、退出系统")
    print("*" * 50)


def show_all():
    '''显示所有名片'''
    print("-" * 50)
    # 打印表头
    if len(card_list) == 0:
        print('当前列表中没有任何数据，请使用新增功能添加名片！')
        return
    for name in ['姓名', '电话', 'qq', '邮箱']:
        print(f"{name}", end="\t\t\t")

    print()

    # 遍历名片列表，依次输出字典信息
    for card_dict in card_list:
        print(f"{card_dict['name']}\t\t"
              f"{card_dict['phone']}\t\t"
              f"{card_dict['qq']}\t\t"
              f"{card_dict['email']}\t\t"
              )


def new_card():
    '''新增名片'''
    print("-" * 50)
    # 1. 提示用户输入名片的详细信息
    name = input('姓名: ')
    phone = input('电话: ')
    qq = input('QQ号: ')
    email = input('邮箱: ')
    # 2. 用输入的信息,形成一个字典数据
    card_dict = {'name': name, 'phone': phone, 'qq': qq, 'email': email}

    # 3. 将字典添加到列表中
    card_list.append(card_dict)

    # 4.提示用户添加成功！
    print(f"添加{name}的名片成功!")


def search_card():
    '''搜索名片'''
    print('-' * 50)
    print('搜索名片')
    find_name = input('请输入要搜索的姓名：')
    for card_dict in card_list:
        if (card_dict['name'] == find_name):
            print(f"{card_dict['name']}\t\t"
                  f"{card_dict['phone']}\t\t"
                  f"{card_dict['qq']}\t\t"
                  f"{card_dict['email']}\t\t"
                  )
            deal_card(card_dict)
            break
    else:
        print(f"未找到{find_name}")
        pass


def deal_card(find_card):
    ''' 修改 删除 返回上级菜单'''
    action_str = input("请选择要执行的操作 【1】 修改 【2】 删除 【0】 返回上级菜单")
    if action_str == '1':
        '''  修改名片 '''
        find_card['name'] = input_card_info(find_card['name'], "姓名")
        find_card['phone'] = input_card_info(find_card['phone'], "电话")
        find_card['qq'] = input_card_info(find_card['qq'], "QQ号")
        find_card['email'] = input_card_info(find_card['email'], "邮箱")
    elif action_str == '2':
        card_list.remove(find_card)
        print('删除名片成功！')


def input_card_info(dict_value, tip_message):
    # 1. 提示用户输入内容
    result_str = input(tip_message)
    # 2. 针对用户输入的状态进行判断,如果用户输入了内容，直接返回结果
    if len(result_str) > 0:
        return result_str
    # 3. 如果用户没有输入内容，返回 字典中原有的值
    else:
        return dict_value

效果

递归函数

• 一个函数调用了他自己,就叫做递归函数

• 代码

# 一个函数调用了它本身,那么这样的函数叫做递归函数

def test(num):
    if num > 1:
        return num * test(num - 1)
    else:
        return 1


result = test(100)

print(result)

• 结果

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

匿名函数

• 代码

b = [{'xuhao': 1, 'age': 18}, {'xuhao': 13, 'age': 13}
    , {'xuhao': 22, 'age': 19}, {'xuhao': 7, 'age': 7}]

b.sort(key=lambda x: x['age'])
print(b)

b.sort(key=lambda x: x['age'], reverse=True)
print(b)

• 效果

[{'xuhao': 7, 'age': 7}, {'xuhao': 13, 'age': 13}, {'xuhao': 1, 'age': 18}, {'xuhao': 22, 'age': 19}]
[{'xuhao': 22, 'age': 19}, {'xuhao': 1, 'age': 18}, {'xuhao': 13, 'age': 13}, {'xuhao': 7, 'age': 7}]