Python 基础

1. 第一个程序：Hello World

print("hello world")
print(666)
print(13.14)

解释：
print()是 Python 的输出函数，用于在屏幕上显示内容
双引号""包裹的是字符串（文字内容）
直接写数字可以输出整数（666）和小数（13.14）

2. 变量

money=50
print("钱包还有：",money)

#买了冰淇淋
money=money-10
print("买了冰淇淋，钱包还有：",money)

解释：
变量就像一个容器，用来存储数据
money=50表示创建一个名为money的变量，并赋值 50
变量可以被重新赋值，money=money-10表示将money原来的值减 10 后再存回money

3. 数据类型

print(type(666.666))  # 浮点数（小数）
print(type("hello world"))  # 字符串（文字）
print(type(True))  # 布尔值（真）

string_type="hello world"
print(type(string_type))  # 字符串类型

int_type=666
print(type(int_type))  # 整数类型

float_type=13.14
print(type(float_type))  # 浮点数类型

解释：
type()函数用于查看数据的类型
常见数据类型：
int：整数（如 666）
float：浮点数（如 13.14）
str：字符串（用引号包裹的内容）
bool：布尔值（只有 True 和 False 两个值）

4. 数据转换

num_str=str(11)  # 整数转字符串
print(type(num_str),num_str)

float_str=float(num_str)  # 字符串转浮点数
print(type(float_str),float_str)

num=int(11)  # 整数转换（本身就是整数）
print(type(num),num)

float_num=float(num)  # 整数转浮点数
print(type(float_num),float_num)

num2=float(11.314)  # 浮点数转换（本身就是浮点数）
print(type(num2),num2)

int_num2=int(num2)  # 浮点数转整数（会丢失小数部分）
print(type(int_num2),int_num2)

解释：
数据转换可以通过str()、int()、float()等函数实现
注意：浮点数转整数会直接去掉小数部分，不是四舍五入
只有符合数字格式的字符串才能转成数字（如 “123” 可以转，“abc” 不行）

5. 输入函数

name=input("告诉我你是谁？")
print("我知道了，你是%s"%name)
print(type(name))  # 输入的内容默认是字符串类型

print("告诉我你电话？")
name1=input()
name1=int(name1)  # 把字符串转成整数
print("电话是%s"%name1)
print(type(name1))

"""
input接受都是字符串
"""

a,b,c=input()  # 输入单个字符串并拆分
print(f"According to preliminary estimation, the gross domestic product (GDP) in %s was %s billion yuan, up by %s percent over the previous year." %(a,b,c))

解释：
input()是输入函数，会暂停程序等待用户输入
括号里的文字是提示信息，会显示给用户
无论输入什么，input()返回的都是字符串类型
如果需要数字，必须用int()或float()转换

6. 字符串

6.1 字符串定义

"""
演示字符串的三种定义方式：
单引号定义法
双引号定义法
三引号定义法
"""

#单引号定义法，使用单引号进行包围
name1='黑马程序员'
print(type(name1))
print(name1)

# 双引号定义法
name2="黑马程序员"
print(type(name2))
print(name2)

#三引号定义法，写法和多行注释是一样的
name3= """
我是
黑马
程序员
"""
print(type(name3))
print(name3)

解释：
字符串可以用单引号’’、双引号"“或三引号”"" “”"定义
单引号和双引号功能一样，三引号可以定义多行字符串
三引号定义的字符串会保留换行格式

6.2 字符串拼接

print("学习python"+"很有趣")  # 直接拼接两个字符串

name="学习"
name1="python"
print(name+name1)  # 拼接两个字符串变量

class_num=57
avg_salary=10000
message="Python大数据，武汉%s期，平均薪资：%s元"%(class_num,avg_salary)  # 使用%占位符
print(message)

name2="很有趣"
message2="学习python%s"%name2  # 单个占位符
print(message2)

name="传智播客"
set_up_year = 2006
stock_price = 19.99
message3 = "我是:%s,我成立于:%d,我今天的股价是:%f" %(name, set_up_year,stock_price)  # 不同类型占位符
print(message3)

message4 = "我是:%s,我成立于:%d,我今天的股价是:%.2f" %(name, set_up_year,stock_price)  # 控制小数位数
print(message4)

print(f"我是{name}，我成立于{set_up_year}，我今天的股价是{stock_price}")  # f-string格式化

print("1*1的结果是：%d"%(1*1))  # 表达式结果作为参数

解释：
+可以直接拼接字符串
%s、%d、%f是占位符，分别对应字符串、整数、浮点数
%.2f表示保留两位小数
f-string格式更简单，直接在字符串前加f，用{变量}嵌入内容

6.3 字符串常用操作

mystr="itheima and itcast"

value=mystr[2]  # 取索引为2的字符（索引从0开始）
value2=mystr[-16]  # 负数索引表示从末尾开始
print(value)
print(value2)

value3=mystr.index("and")  # 查找子字符串的位置
print(value3)

new_mystr=mystr.replace("it","程序")  # 替换字符串
print(new_mystr)

mystr="hello python itheima itcast"
mystr_list=mystr.split(" ")  # 按空格分割字符串
print(mystr_list,type(mystr_list))

mystr="  itheima and itcast  "
new1=mystr.strip()  # 去除首尾空格
print(new1)

mystr="12itheima and itcast 21"
new2=mystr.strip("12")  # 去除首尾指定字符
print(new2)

#count 统计出现次数
#len 计算长度

解释：
字符串可以像列表一样通过索引访问单个字符，索引从 0 开始
index()用于查找子字符串第一次出现的位置
replace(a,b)将字符串中的 a 替换为 b
split(sep)按 sep 分割字符串，返回列表
strip()去除首尾空格，strip(“12”)去除首尾的 1 和 2

7. 运算符

print("1 + 1 = ",1 + 1)  # 加法
print("2 - 1 = ",2 - 1)  # 减法
print("3 * 3 = ",3 * 3)  # 乘法
print("4 / 2 = ",4 / 2)  # 除法（结果是浮点数）
print("11 // 2 = ",11 // 2)  # 整除（只保留整数部分）
print("9 % 2 = ",9 % 2)  # 取余（模运算）
print("2 ** 3 = ",2 ** 3)  # 幂运算（2的3次方）

解释：
基本运算符和数学中的含义一致
注意/除法结果总是浮点数，//是整除
%取余常用于判断奇偶（结果为 0 是偶数）
表示幂运算，23相当于 2×2×2

8. 判断语句

8.1 基本判断

age=17

if age>=18:
    print("我已经成年了")

print("不受判断改变")

解释：
if后面跟判断条件，条件成立（True）则执行缩进的代码块
缩进通常是 4 个空格
不缩进的代码不受 if 判断影响，总会执行

8.2 if-else

print("欢迎来到黑马儿室游乐场，儿京免费，成人收费。")
print("请输入你的年龄：")
age=int(input())

if age>=18:
    print("您己成年，游玩需要补票10元。")
else:
    print("您未成年，可以免费游玩")

print("祝您游玩愉快。")

解释：
if-else表示二选一：条件成立执行 if 块，否则执行 else 块
input()获取用户输入，int()转换为整数
无论条件如何，最后一句 “祝您游玩愉快” 都会执行

8.3 if-elif-else

print("欢迎来到动物园")
print("请输入您的身高（cm）")
height=int(input())
vip_level=int(input("请输入vip级别(1~5)"))
if height<120:
    print("您的身高小于120cm，可以免费游玩")
elif vip_level>3:
    print("您的vip级别大于3，可以免费游玩。")
else:
    print("不好意思，所有条件都不满足，需要购票10元。")
print("祝您游玩愉快。")

解释：
if-elif-else用于多条件判断，依次检查每个条件
只要有一个条件成立，就执行对应的代码块，后面的条件不再检查
如果所有条件都不成立，执行 else 块

8.4 条件表达式

if int(input("请输入你的身高（cm）：")) < 120:
    print("身高小于120cm ，可以免费。")
elif int(input("请输入你的VIP等级（1-5）：")) > 3:
    print("vip级别大于3 ，可以免费。")
elif int(input("请告诉我今天几号：")) == 1:
    print("今天是1号免费日 ，可以免费")
else:
    print("不好意思，条件都不满足，需要买票10元。")

解释：
可以直接在if后面写表达式，简化代码
每个条件都会按顺序判断，满足一个就执行对应操作

8.5 布尔值与比较

result=10>5  # 比较运算，结果是布尔值
print (f"10>5结果是：{result},类型是：{type(result)}")

result1="itcast"=="itheima"  # 判断两个字符串是否相等
print(f"字符串itcast是否和itheima相等，结果是：{result1},类型是：{type(result)}")

bool_1=True  # 布尔值True
bool_2=False  # 布尔值False
print(f"bool_1变量的内容是：{bool_1},类型是：{type(bool_1)}")
print(f"bool_2变量的内容是：{bool_2},类型是：{type(bool_2)}")

#== != > < >= <= 比较运算符
num1=10
num2=10
print(f"10=10的结果是：{num1==num2}")

num3=10
num4=15
print(f"10=15的结果是：{num3==num4}")

解释：
比较运算的结果是布尔值（True 或 False）
常见比较运算符：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）
注意=是赋值，==才是判断相等

9. 循环语句

9.1 while 循环

i=0
while i<100:
    print("循环")
    i+=1  # 等同于i=i+1

解释：
while循环格式：while 条件: 循环体
当条件成立时，重复执行循环体
一定要在循环体内修改条件相关的变量（如 i+=1），否则会变成无限循环

9.2 while 案例（猜数字）

import random
num=random.randint(1,100)  # 生成1-100的随机数
count=0  # 记录猜测次数

flag=True
while flag:
    guess_num=int(input("输入一个数："))
    if guess_num==num:
        print("对")
        flag=False  # 猜对了就退出循环
    else:
        if guess_num>num:
            print("大了")
        else:
            print("小了")
    count+=1  # 每次猜测后次数加1

print("你猜了%d次"%(count))

解释：
random.randint(a,b)生成 a 到 b 之间的随机整数
用flag变量控制循环是否继续
每次循环让用户输入猜测的数字，根据比较结果提示大了 / 小了
猜对后将flag设为 False，退出循环

9.3 for 循环

name="itheima"

for x in name:  # 遍历字符串
    print(x)

name1="itheima is a brand of itcast"
count=0
for x in name1:  # 统计字母a出现的次数
    if x=="a":
        count+=1

print(count)

解释：
for循环用于遍历序列（如字符串、列表等）
格式：for 变量 in 序列: 循环体
每次循环，变量会依次取序列中的每个元素

9.4 for-range 循环

for x in range(10):  # 0-9（不包含10）
    print (x)

for x in range(5,10):  # 5-9（包含5，不包含10）
    print (x)

for x in range(5,10,2):  # 5,7,9（步长为2）
    print (x)

解释：
range(n)生成 0 到 n-1 的整数序列
range(a,b)生成 a 到 b-1 的整数序列
range(a,b,step)生成 a 到 b-1 的整数序列，步长为 step（每次增加 step）

9.5 for 嵌套循环

i=1
for i in range(1,101):  # 外层循环：1-100天
    print(f"第{i}天")
    for j in range(1,11):  # 内层循环：每天10朵花
        print(f"第{j}朵")
    print(f"第{i}天结束")

print(f"总共{i}天")

解释：
循环可以嵌套，内层循环会在外层循环的每次迭代中完整执行
这里外层循环控制天数（1-100），内层循环控制每天的花朵数（1-10）

9.6 99 乘法表

for i in range(1,10):  # 控制行数（1-9）
    for j in range (1,i+1):  # 控制每行的列数（1到i）
        print(f"{j}*{i}={j*i}\t",end='')  # \t是制表符，end=''表示不换行
    print()  # 每行结束后换行

解释：
外层循环i控制乘数（1-9）
内层循环j控制被乘数（1 到 i）
end=’'让 print 不自动换行，实现同一行输出多个结果
内层循环结束后，用print()换行

10. 函数

10.1 函数定义与调用

def say_hi():  # 定义函数
    print("HI")

say_hi()  # 调用函数

解释：
用def关键字定义函数，格式：def 函数名(): 函数体
函数名后面必须有括号()
调用函数时需要写函数名加括号say_hi()

10.2 初级函数（自定义长度计算）

str1="itheima"
str2="itcast"
str3="python"

def my_len(data):  # 定义带参数的函数
    count=0
    for i in data:
        count+=1
    print(f"字符串{data}的长度是:{count}")

my_len(str1)  # 调用函数，传入参数
my_len(str2)
my_len(str3)

解释：
函数可以接收参数，data是形参（形式参数）
调用函数时传入的str1等是实参（实际参数）
这个函数实现了类似len()的功能，计算字符串长度

10.3 函数注释

def add(x, y):
    """
    add加法
    :param x: 形参1
    :param y: 形参2
    :return: 返回两数相加结果
    """
    result = x + y
    print(f"2数相加的结果是：{result}")
    return result

add(5,6)

解释：
函数内部的三引号字符串是文档字符串，用于说明函数功能
:param说明参数含义，:return说明返回值
文档字符串可以通过help(函数名)查看

10.4 函数返回值

def add (x,y):
    result=x+y
    return result  # 返回计算结果

r=add(9,4)  # 接收返回值
print (r)

解释：
return用于返回函数的计算结果
调用函数时，可以用变量接收返回值
函数执行到return后会立即结束

10.5 函数返回 None

def say_hello():
    print("Hello...")

# 使用变量接收say_hello函数的返回值
result = say_hello()
# 打印返回值
print(result)        # 结果None
# 打印返回值类型
print(type(result))  # 结果<class 'NoneType'>

# None可以主动使用return返回，效果等同于不写return语句:
def say_hello():
    print("Hello...")
    return None

# 使用变量接收say_hello函数的返回值
result = say_hello()
# 打印返回值
print(result)        # 结果None

解释：
如果函数没有return语句，或者return后面没有值，默认返回None
None是一个特殊值，表示 “无”，类型是NoneType
常用于表示空结果或作为默认值

10.6 函数的多返回值

def test_return():
    return 1,"hello",True  # 返回多个值


x,y,z=test_return()  # 接收多个返回值
print(x)
print(y)
print(z)

解释：
函数可以一次返回多个值，用逗号分隔
接收时可以用多个变量，按顺序对应接收
本质上返回的是一个元组

10.7 函数的传入参数

def add(x,y,z):  # 三个参数
    result=x+y+z
    print(f"{x}+{y}+{z}={result}")

add(5,9,11)  # 传入三个参数

def check(x):  # 一个参数
    print("欢迎来到黑马程序员！请出示您的健康码以及72小时核酸证明，并配合测量体温！")
    if x>37.5:
        print(f"体温测量中，您的体温是：{x}度，需要隔离!")
    else:
        print(f"体温测量中，您的体温是：{x}度，体温正常请进！")

x=float(input())  # 输入体温
check(x)  # 传入参数

解释：
函数可以定义多个参数，用逗号分隔
调用时需要传入对应数量的参数（除非有默认值）
参数可以是不同类型（整数、浮点数等）

10.8 函数的多种参数

def user_info(name, age, gender):
    print(f'您的名字是{name}，年龄是{age}，性别是{gender}')

# 关键字传参
user_info(name="小明", age=20, gender="男")
# 可以不按照固定顺序
user_info(age=20, gender="男", name="小明")
# 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("小明", age=20, gender="男")


def user_info(name, age, gender='男'):  # gender有默认值
    print(f'您的名字是{name}，年龄是{age}，性别是{gender}')

user_info('TOM', 20)  # 可以不传入gender，使用默认值
user_info('Rose', 18, '女')  # 传入gender，覆盖默认值


def user_info(*args):  # 不定长位置参数
    print(type(args))
    print(args)

user_info('TOM')        # 输出: ('TOM',)
user_info('TOM', 18)    # 输出: ('TOM', 18)


def user_info(**kwargs):  # 不定长关键字参数
    print(type(kwargs))
    print(kwargs)

user_info(name='TOM', age=18, id=110)  # 输出字典

解释：
位置参数：必须按顺序传入，如user_info(“小明”, 20, “男”)
关键字参数：用参数名=值的形式，可打乱顺序
默认参数：定义时给参数赋值，调用时可省略
*args：接收多个位置参数，打包成元组
**kwargs：接收多个关键字参数，打包成字典

10.9 匿名函数

def test_func(compute):
    result = compute(1, 2)
    print(type(compute))
    print(result)

# def compute(x, y):
#     return x + y
#
# test_func(compute)

test_func(lambda x, y: x + y)  # 匿名函数作为参数

解释：
匿名函数用lambda定义，格式：lambda 参数: 表达式
匿名函数只能有一个表达式，自动返回结果
适合简单的功能，不需要单独定义函数

10.10 函数综合案例（银行系统）

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

def query(T):  # 查询余额
    if T:
        print("---------查询余额---------")
    print(f"余额为{money}元")

def saving(num):  # 存款
    global money  # 声明使用全局变量
    money+=num
    print("---------存款---------")
    print(f"存了{num}元")
    query(False)

def get_money(num):  # 取款
    global money
    money-=num
    print("---------取款---------")
    print(f"取了{num}元")
    query(False)

def main():  # 主菜单
    print("---------主菜单---------")
    print(f"请选择操作：")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")
    print("退出\t\t[输入4]")
    return input("请输入您的选择：")

# 设置无限循环，确保程序不退出
while True:
     keyboard_input = main()
     if keyboard_input == "1":
         query(True)
         continue
     elif keyboard_input == "2":
         num=int(input("存多少钱"))
         saving(num)
         continue
     elif keyboard_input == "3":
         num=int(input("取多少钱"))
         get_money(num)
         continue
     else:
          print("退出")
          break

解释：
这个程序模拟了简单的银行系统，包含查询、存款、取款功能
global关键字用于在函数内部修改全局变量
main()函数显示菜单，接收用户选择
while True创建无限循环，直到用户选择退出

11. 数据容器

11.1 列表定义

name_list=['itheima','itcast','python']  # 字符串列表
print(name_list)
print(type(name_list))

my_list=['itheima',666,True]  # 混合类型列表
print(my_list)
print(type(my_list))

my_list1=[[1,2,3],[4,5,6]]  # 嵌套列表（二维列表）
print(my_list1)
print(type(my_list1))

解释：
列表用[]定义，元素之间用逗号分隔
列表可以包含不同类型的元素（字符串、数字、布尔值等）
列表可以嵌套，形成二维或多维列表

11.2 列表下标（索引）

name_list=['tom','lily','rose']
print(name_list[0])  # 第一个元素（索引0）
print(name_list[1])  # 第二个元素（索引1）
print(name_list[2])  # 第三个元素（索引2）

print(name_list[-1])  # 最后一个元素
print(name_list[-2])  # 倒数第二个元素
print(name_list[-3])  # 倒数第三个元素

my_list=[[1,2,3],[4,5,6]]  # 二维列表
print(my_list[1][1])  # 第二个列表的第二个元素

解释：
列表元素通过索引访问，索引从 0 开始
负数索引表示从末尾开始，-1是最后一个元素
二维列表访问格式：列表名[外层索引][内层索引]

11.3 列表遍历

def list_while_func():
    """
    while遍历列表
    :return: None
    """
    mylist=["传智教育","黑马程序员","python"]
    index=0
    while index<len(mylist):  # len()获取列表长度
        element=mylist[index]
        print(element)
        index+=1

list_while_func()

def list_for_func():
    """
    for遍历列表
    :return: None
    """
    mylist=[1,2,3,4,5]
    for element in mylist:  # 直接遍历元素
        print(element)

list_for_func()

解释：
遍历列表有两种方式：while 循环和 for 循环
while 循环需要通过索引访问，配合len()函数获取长度
for 循环更简单，直接遍历每个元素，不需要索引

11.4 列表的常见操作方法

mylist=["itcast","itheima","python"]
index=mylist.index("itheima")  # 查找元素位置
print(index)

mylist[0]="修改了"  # 修改元素
print(mylist)

#insert 插入元素
mylist.insert(1,"插入")  # 在索引1位置插入
print(mylist)

#append 末尾添加
mylist.append("黑马")  # 追加到末尾
print(mylist)

#extend 合并列表
mylist2=[1,2,3]
mylist.extend(mylist2)  # 将mylist2的元素添加到mylist
print(mylist)


mylist=["itcast","itheima","python"]

#del 删除元素
del mylist[2]  # 删除索引2的元素
print(mylist)


mylist=["itcast","itheima","python"]

#pop 弹出元素（返回被删除的元素）
element=mylist.pop(2)  # 弹出索引2的元素
print(mylist)


mylist=["itcast","itheima","itcast","itheima","python"]

#remove 删除第一个匹配的元素
mylist.remove("itheima")  # 删除第一个"itheima"
print(mylist)

#clear 清空列表
mylist.clear()
print(mylist)


mylist=["itcast","itheima","itcast","itheima","python"]

#count 统计元素出现次数
count=mylist.count("itheima")
print(count)

#len 计算长度
count1=len(mylist)
print(count1)

解释：
列表提供了多种操作方法：
index(x)：查找 x 第一次出现的索引
insert(i,x)：在索引 i 处插入 x
append(x)：在末尾添加 x
extend(list)：合并另一个列表
del list[i]：删除索引 i 的元素
pop(i)：删除并返回索引 i 的元素
remove(x)：删除第一个 x
clear()：清空列表
count(x)：统计 x 出现的次数
len(list)：计算列表长度

11.5 元组

t1=(1,"Hello",True)  # 包含多种类型的元组
t2=()  # 空元组
t3=tuple()  # 空元组
print(f"t1的类型是：{type(t1)},内容是:{t1}")
print(f"t2的类型是：{type(t2)},内容是:{t2}")
print(f"t3的类型是：{type(t3)},内容是:{t3}")

t4=("hello")  # 注意：这是字符串，不是元组
print(f"t4的类型是：{type(t4)},内容是:{t4}")

t5=("hello",)  # 单个元素的元组，必须加逗号
print(f"t5的类型是：{type(t5)},内容是:{t5}")

解释：
元组用()定义，元素之间用逗号分隔
元组是不可变的（创建后不能修改元素）
定义单个元素的元组时，必须在元素后加逗号（(x,)），否则会被认为是其他类型
可以用tuple()创建空元组

11.6 字典

my_dict1={ "王力宏":99, "周杰伦":88,"林俊杰":77}  # 字典定义

my_dict2={}  # 空字典
my_dict3=dict()  # 空字典
print(f"字典1的内容是：{my_dict1}，类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}，类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}，类型：{type(my_dict3)}")

my_dict1={ "王力宏":99, "王力宏":88,"林俊杰":77}  # 重复的key会被覆盖
print(f"重复key字典1的内容是：{my_dict1}，类型：{type(my_dict1)}")

my_dict1={ "王力宏":99, "周杰伦":88,"林俊杰":77}
score=my_dict1["王力宏"]  # 通过key获取value
print(score)
score2=my_dict1["周杰伦"]
print(score2)


stu_score_dict = {  # 嵌套字典
    "王乃鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "周杰伦": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "林俊杰": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}

print(f"{stu_score_dict}")

score=stu_score_dict["周杰伦"]["语文"]  # 访问嵌套字典
print(score)

解释：
字典用{}定义，由键值对key:value组成
键（key）必须唯一，重复的键会被后面的覆盖
通过字典名[key]获取对应的值（value）
字典可以嵌套，形成复杂的数据结构

11.7 字典的常用操作

my_dict = {"周杰伦": 99, "林俊杰": 88, "张学涵": 77}
my_dict["张信哲"] = 66  # 添加键值对
print(my_dict)

my_dict["周杰伦"]=33  # 修改值
print(my_dict)

score=my_dict.pop("周杰伦")  # 删除键值对，返回值
print(my_dict)


my_dict.clear()  # 清空字典
print(my_dict)


my_dict = {"周杰伦": 99, "林俊杰": 88, "张学涵": 77}
keys=my_dict.keys()  # 获取所有key
print(keys)


for key in keys:  # 遍历字典
    print(key)
    print(my_dict[key])


num=len(my_dict)  # 计算字典长度（键值对数量）
print(num)

解释：
字典常用操作：
添加 / 修改：字典名[key] = value（key 存在则修改，不存在则添加）
删除：pop(key)删除指定 key 的键值对，返回 value
清空：clear()
获取所有 key：keys()
遍历：通常遍历 key，再通过 key 获取 value
长度：len(字典)返回键值对数量

11.8 集合

my_set={"传智教育","黑马程序员","itheima","传智教育","黑马程序员","itheima","传智教育","黑马程序员","itheima"}  # 集合会自动去重
my_set_empty=set()  # 空集合（不能用{}，{}是字典）
print(f"{my_set},{type(my_set)}")
print(f"{my_set_empty},{type(my_set_empty)}")

my_set.add("python")  # 添加元素
print(f"{my_set},{type(my_set)}")

my_set.remove("黑马程序员")  # 删除元素
print(f"{my_set},{type(my_set)}")


my_set={"传智教育","黑马程序员","itheima"}
element=my_set.pop()  # 随机删除一个元素并返回
print(f"{element}      {my_set}")


my_set={"传智教育","黑马程序员","itheima"}
my_set.clear()  # 清空集合
print(my_set)


set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)  # 差集：set1有而set2没有的元素
print(set3)    # 结果: {2, 3}
print(set1)    # 结果: {1, 2, 3} 不变
print(set2)    # 结果: {1, 5, 6} 不变


set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)  # 差集更新：set1只保留与set2不同的元素
print(set1)  # 结果: {2, 3}
print(set2)  # 结果: {1, 5, 6}


set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)  # 并集：合并两个集合，去重
print(set3)  # 结果: {1, 2, 3, 5, 6}
print(set1)  # 结果: {1, 2, 3}
print(set2)  # 结果: {1, 5, 6}


set1 = {1, 2, 3, 4, 5,1, 2, 3, 4, 5}  # 自动去重
num = len(set1)  # 集合长度
print(f"集合{set1}的长度是{num}")


for element in set1:  # 遍历集合
    print(element)

解释：
集合用{}定义，元素唯一（自动去重）
空集合必须用set()创建，{}是字典
集合是无序的，不能通过索引访问
常用操作：
添加：add(x)
删除：remove(x)删除指定元素，pop()随机删除
清空：clear()
差集：set1.difference(set2)获取 set1 独有的元素
并集：set1.union(set2)合并两个集合

11.9 序列切片

my_list=[0,1,2,3,4,5,6]
result1=my_list[1:4]  # 列表切片：索引1到3（不包含4）
print(result1)

my_tuple=(0,1,2,3,4,5,6)
result2=my_tuple[:]  # 元组切片：所有元素
print(result2)

my_str="01234567"
result3=my_str[::2]  # 字符串切片：步长2（每隔一个取一个）
print(result3)

my_str="01234567"
result4=my_str[::-1]  # 字符串切片：反转（步长-1）
print(result4)

my_list=[0,1,2,3,4,5,6]
result5=my_list[3:1:-1]  # 列表切片：索引3到2（反向）
print(result5)

my_tuple=(0,1,2,3,4,5,6)
result6=my_list[::-2]  # 列表切片：反转，步长2
print(result6)

解释：
切片格式：序列[开始:结束:步长]
开始索引包含，结束索引不包含
省略开始：从开头开始；省略结束：到末尾结束
步长为负数表示反向切片（从后往前）
切片适用于列表、元组、字符串等序列

11.10 数据容器的通用功能

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# 计算长度
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串 元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")


# 最大值
print(f"列表 最大的元素是: {max(my_list)}")
print(f"元组 最大的元素是: {max(my_tuple)}")
print(f"字符串 最大的元素是: {max(my_str)}")  # 字符按ASCII值比较
print(f"集合 最大的元素是: {max(my_set)}")
print(f"字典 最大的元素是: {max(my_dict)}")  # 字典取key的最大值


# 最小值
print(f"列表 最小的元素是: {min(my_list)}")
print(f"元组 最小的元素是: {min(my_tuple)}")
print(f"字符串 最小的元素是: {min(my_str)}")
print(f"集合 最小的元素是: {min(my_set)}")
print(f"字典 最小的元素是: {min(my_dict)}")


# 转列表
print(f"列表转列表的结果是: {list(my_list)}")
print(f"元组转列表的结果是: {list(my_tuple)}")
print(f"字符串转列表的结果是: {list(my_str)}")  # 每个字符作为元素
print(f"集合转列表的结果是: {list(my_set)}")  # 集合无序，转换后顺序不确定
print(f"字典转列表的结果是: {list(my_dict)}")  # 只转key


# 转元组
print(f"列表转元组的结果是: {tuple(my_list)}")
print(f"元组转元组的结果是: {tuple(my_tuple)}")
print(f"字符串转元组的结果是: {tuple(my_str)}")
print(f"集合转元组的结果是: {tuple(my_set)}")
print(f"字典转元组的结果是: {tuple(my_dict)}")


# 转字符串
print(f"列表转字符串的结果是: {str(my_list)}")
print(f"元组转字符串的结果是: {str(my_tuple)}")
print(f"字符串转字符串的结果是: {str(my_str)}")
print(f"集合转字符串的结果是: {str(my_set)}")
print(f"字典转字符串的结果是: {str(my_dict)}")


# 转集合
print(f"列表转集合的结果是: {set(my_list)}")
print(f"元组转集合的结果是: {set(my_tuple)}")
print(f"字符串转集合的结果是: {set(my_str)}")
print(f"集合转集合的结果是: {set(my_set)}")
print(f"字典转集合的结果是: {set(my_dict)}")


# 排序
my_list = [3,1,2,5,4]
my_tuple = (3,1,2,5,4)
my_str = "bdcefga"
my_set = {3,1,2,5,4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}
print(f"列表对象的排序结果: {sorted(my_list)}")  # 返回新列表
print(f"元组对象的排序结果: {sorted(my_tuple)}")  # 返回列表
print(f"字符串对象的排序结果: {sorted(my_str)}")  # 返回字符列表
print(f"集合对象的排序结果: {sorted(my_set)}")  # 返回列表
print(f"字典对象的排序结果: {sorted(my_dict)}")  # 按key排序，返回列表


# 反向排序
print(f"列表对象的反向排序结果: {sorted(my_list, reverse=True)}")
print(f"元组对象的反向排序结果: {sorted(my_tuple, reverse=True)}")
print(f"字符串对象的反向排序结果: {sorted(my_str, reverse=True)}")
print(f"集合对象的反向排序结果: {sorted(my_set, reverse=True)}")
print(f"字典对象的反向排序结果: {sorted(my_dict, reverse=True)}")

解释：
所有数据容器都支持的功能：
len()：计算元素个数
max()：获取最大值（元素必须可比较）
min()：获取最小值
类型转换：list()、tuple()、str()、set()
sorted()：排序，返回列表（原容器不变）
sorted(容器, reverse=True)可以进行反向排序
字典转换和排序都是基于 key 进行的

12. 异常处理

try:
    f = open("D:/abc.txt", "r", encoding="UTF-8")  # 尝试打开文件
except:
    print("出现异常了")  # 发生异常时执行


try:
    print(name)  # 尝试访问未定义的变量
except NameError as e:  # 捕获特定异常
    print("出现了变量未定义的异常")
    print(e)  # 打印异常信息


try:
    1/0  # 尝试除以0
    #print(name)
except (NameError,ZeroDivisionError) as e:  # 捕获多种异常
    print(e)
    print("出现了变量未定义的异常,或者,除以0的异常错误")


try:
    print("hello")  # 无异常的代码
except Exception as e:
    print("出现异常了")
else:
    print("没有异常")  # 无异常时执行
finally:
    print("无论是否异常都会执行")  # 无论是否异常都执行

解释：
异常处理用于捕获程序运行时的错误，避免程序崩溃
基本结构：try: 可能出错的代码 except: 出错时执行的代码
except 异常类型 as e可以捕获特定类型的异常，并获取异常信息
else块在没有异常时执行
finally块无论是否有异常都会执行，常用于释放资源（如关闭文件）

13. 综合案例：猜数字游戏

import random
# 1. 构建一个随机的数字变量
num = random.randint(1, 10)  # 生成1-10的随机数
guess_num = int(input("输入你要猜测的数字："))

# 2. 通过if判断语句进行数字的猜测
if guess_num == num:
    print("恭喜，第一次就猜中了")
else:
    if guess_num > num:
        print("你猜测的数字大了")
    else:
        print("你猜测的数字小了")

    guess_num = int(input("再次输入你要猜测的数字："))
    if guess_num == num:
        print("恭喜，第二次猜中了")
    else:
        if guess_num > num:
            print("你猜测的数字大了")
        else:
            print("你猜测的数字小了")

        guess_num = int(input("第三次输入你要猜测的数字："))
        if guess_num == num:
            print("第三次猜中了")
        else:
            print("三次机会用完了，没有猜中。")

解释：
这个程序实现了一个简单的猜数字游戏，有 3 次猜测机会
random.randint(1,10)生成 1 到 10 之间的随机整数
通过嵌套的if-else语句判断猜测结果，并给出提示
每次猜错后允许再次猜测，最多 3 次

14. 注释

# 我是单行注释
"""
我是多行注释
我是多行注释

"""

解释：
注释是对代码的说明，不会被执行
单行注释用#开头
多行注释用三引号""" “”"包裹
良好的注释可以提高代码的可读性

15. 股价计算小程序

name="传智播客"
stock_price=19.99  # 当前股价
stock_code="003032"  # 股票代码
stock_price_daily_growth_factor=1.2  # 每日增长系数
growth_days=7  # 增长天数

finally_stock_price=stock_price*stock_price_daily_growth_factor**growth_days  # 计算最终股价

print(f"公司：{name},股票代码：{stock_code},当前股价：{stock_price}")
print("每日增长系数：%.1f,经过%d天的增长后，股价达到了：%.2f"%(stock_price_daily_growth_factor,growth_days,finally_stock_price))

解释：
这个程序计算股票经过一定天数增长后的价格
是幂运算，ab表示 a 的 b 次方
格式化输出时用%.1f保留 1 位小数，%.2f保留 2 位小数
变量名应该有意义，清晰表示变量的用途