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 <class 'tuple'> <class 'tuple'>
元组的常用操作
-
代码
# 定义一个元组 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类型： <class 'list'> 使用tuple转换成元组后的类型： <class 'tuple'> 使用list转换成列表后的类型： <class '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
-
- 创建快速体验文件
- 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": "111@qq.com"},
{"name": "jsj2002", "phone": "100862", "qq": "222", "email": "222@qq.com"}]
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}]
扫一扫
737
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
