1.数据容器-list
#定义列表 -list
s=[56,90,60,"hello",True,90]
print(type(s))
#当问列表元素
#获取
print(s[0]) #正向索引，从0开始
print(s[-6]) #反向索引 从 -1开始
print(s[2])
print(s[-5])
#修改
s[5] =("ASD")
print(s)
#注意：如果指定的索引，超过范围将会报错
# s[10] ="DEP"
# print(s)
#删除
del s[5]
print(s)
#遍历
for i in s:
print(i)
#列表-切片截取
s=["A","B","C","D","E","F","G","H","I","J"]
#切片操作 s[开始索引:结束索引:步长]
print(s[0:5:1])
print(type(s[0:5:1]))
print(s[:5:1])
print(s[:5:])
print(s[:5])
print(s[0:5:2])
print(s[0:-2:1])
2list-常用方法
#append():都在末尾添加元素 和JavaScript 数组中的push()一样
students = ["小明", "小红"]
students.append("小刚")
print(students)
#insert()在指定位置插入 和JavaScript 数组中的splice()一样
arr = [1, 2, 4]
arr.insert(2, 3)
print(arr)
#remove()按值直接删除的方法和JavaScript 数组中的indexOf + splice()一样
arr = [10, 20, 30]
arr.remove(20)
print(arr)
#pop() 删除并返回最后一个和JavaScript 数组中pop()一样
tasks = ["语文", "数学", "英语"]
item = tasks.pop()
print("剩余：", tasks)
print("被删除的：", item)
#pop(i)删除指定索引和avaScript 数组中splice(i, j)一样
nums = [10, 20, 30, 40]
x = nums.pop(1)
print("删除的元素：", x)
print("删除后的列表：", nums)
#sort()按真实大小排序 和avaScript 数组中sort()不太一样
nums = [10, 2, 30, 1]
nums.sort()
print(nums)
3.数据容器-str常用方法
#find()------ 查找子串位置
# 定义一个字符串变量 s
s = "Hello Python World"
# 尝试查找 "Python"
position = s.find("Python")
print(f"'Python' 第一次出现的索引位置是: {position}")
# 尝试查找一个不存在的词 "Java"
position_not_found = s.find("Java")
print(f"'Java' 的位置是: {position_not_found}")
#count()------ 统计出现次数
email_text = "Please contact us at support@example.com for assistance."
# 统计字母 'e' 出现的次数
count_e = email_text.count("e")
print(f"字母 'e' 在这段话中出现了 {count_e} 次")
#upper()------ 全部转为大写
title = "introduction to python"
# 转换为全大写
upper_title = title.upper()
print(f"原始标题: {title}")
print(f"转换后标题: {upper_title}")
#lower()------ 全部转为小写
user_input = "YES"
# 转换为全小写
standard_input = user_input.lower()
if standard_input == "yes":
print("用户同意了请求")
else:
print("等待用户确认")
#split()------ 分割字符串
# 假设有一行由空格隔开的名字
names = "Alice Bob Charlie David"
# 默认按空格分割，返回一个列表
name_list = names.split()
print(f"分割前的类型: {type(names)}")
print(f"分割后的类型: {type(name_list)}")
print(f"分割后的结果: {name_list}")
#strip()------ 去除两端字符
# 模拟用户输入，前后带有多余的空格和星号
raw_data = " *** Hello World *** "
# 去除两端的空白字符（默认行为）
cleaned_data = raw_data.strip()
print(f"去除空白后: '{cleaned_data}'")
# 去除两端的指定字符 '*' 和空格
final_data = raw_data.strip(' *')
print(f"去除星号后: '{final_data}'")
#replace()------ 替换子串
sentence = "The rain in Spain stays mainly in the plain."
# 将所有的 "ain" 替换为 "*"
replaced_sentence = sentence.replace("ain", "*")
print(f"原文: {sentence}")
print(f"替换后: {replaced_sentence}")
#startswith()------ 检查开头
filename = "report_2023_sales.csv"
# 检查文件名是否以 "report" 开头
if filename.startswith("report"):
print(f"{filename} 是一份报告文件，准备处理...")
else:
print(f"{filename} 不是报告文件，跳过。")
6.数据容器-元组(tuple
#元组（tuple） 是 Python 中的一种内置数据类型，用于存储多个元素。
# 方式一：使用小括号 ()
t1 = (1, 2, 3)
print(t1)
# 方式二：省略括号（推荐写法）
t2 = 1, 2, 3
print(t2)
# 方式三：只有一个元素的元组（⚠️必须加逗号）
t3 = (5,)
print(type(t3))
t = ("Python", "Java", "C++", "Go")
# 正向索引
print(t[0]) # Python
# 负向索引
print(t[-1]) # Go
# 切片
print(t[1:3]) # ('Java', 'C++')
#元组不可变（重点案例）
# t = (10, 20, 30)
# # ❌ 错误示例：不能修改元组元素
# t[1] = 99
#如果元组中包含可变对象（如列表），列表内部是可变的：
#元组本身不可变，但其引用的对象可能可变
t = (1, 2, [3, 4])
t[2].append(5)
print(t)
#、元组常用操作
#遍历元组
languages = ("Python", "Java", "C")
for lang in languages:
print(lang)
#统计元素个数：count()
scores = (90, 85, 90, 100)
print(scores.count(90))
# 查找索引：index()
colors = ("red", "green", "blue")
print(colors.index("green"))
#元组拼接
t1 = (1, 2)
t2 = (3, 4)
t3 = t1 + t2
print(t3)
#元组解包（Unpacking）
point = (10, 20)
x, y = point
print(x, y)
#常用于函数返回多个值：
def get_user():
return "Alice", 18
name, age = get_user()
print(name, age)
7.数据容器-集合set
#是 Python 中的一种无序、不重复的数据类型，用于存储唯一元素。
import difflib
s1 = {1, 2, 3, 4}
print(s1)
s2 = set([1, 2, 2, 3])
print(s2)
#添加元素：add()
s = {"Python", "Java"}
s.add("C++")
print(s)
s = set() # ✅ 空集合
print(s)
#1.add(...)：添加元素到集合
s1 = {1, 2, 3}
s1.add(4) # s1变为 {1, 2, 3, 4}
s1.add(2) # 2已存在，集合不变，仍为 {1, 2, 3, 4}
print(s1)
#2.remove(...)：移除指定元素
s1={1,2,3}
s1.remove(2)
print(s1)
#3.pop()：随机删除并返回元素,从集合中随机删除一个元素，并返回该元素（集合为空时调用会报错）。
s1 = {1, 2, 3}
e = s1.pop() # 随机删一个（比如删了2），e=2，s1变为 {1, 3}
print(e, s1)
s2 = set() # 空集合
# s2.pop() # 报错：KeyError（空集合无法pop）
#4.clear()：清空集合
s1={1,2,3}
s1.clear()
print(s1)
#5. difference()：求差集（A - B）
#返回一个新集合，包含在第一个集合但不在第二个集合的元素。
s1={1,2,3}
s2={3,4,5,6}
diff = s1.difference(s2)
print(diff)
#union()：求并集（A ∪ B） 返回一个新集合，包含两个集合的所有元素（去重）。
s1 = {1, 2, 3}
s2 = {3, 4, 5}
union_set = s1.union(s2) # union_set = {1, 2, 3, 4, 5}
print(union_set)
#intersection()：求交集（A ∩ B） 返回一个新集合，包含两个集合都有的元素（去重）。
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
inter = s1.intersection(s2) # inter = {3, 4}
print(inter)
8.数据容器-字典dict
#字典是 Python 中非常有用的内置数据类型，它以 键值对（key-value） 的形式存储数据，就像一本真正的"字典"：
#键：必须是唯一且不可变的（如字符串、数字、元组）
#值：可以是任意类型（数字、字符串、列表、甚至另一个字典）
#增（添加键值对）
d={}
d["name"]="小明"
d["age"]=18
print(d)
#删（删除键值对）
# 方法1：del（直接删除）
del d["age"] # 删除键"age"及其值
print(d) # {'name': '小明'}
# 方法2：pop（删除并返回被删除的值）
name = d.pop("name") # 删除键"name"，返回值赋给name
print(name) # 小明
print(d) # {}
#改（修改键对应的值）
d = {"name": "小明", "score": 80}
d["score"] = 95 # 直接赋值，如果键已存在就是修改
print(d) # {'name': '小明', 'score': 95}
#查（获取键对应的值）
d = {"name": "小明", "age": 12}
# 方法1：直接用方括号（键不存在会报错）
print(d["name"]) # 小明
# 方法2：使用 get()（推荐，键不存在返回None或默认值）
print(d.get("age")) # 12
print(d.get("score", 0)) # 0（键不存在，返回默认值0）
9.函数
#函数1：计算圆的面积--半径
def circle_area(radius):
area=3.14*radius**2
return area
print(circle_area(10))
#函数3计算
def circle_area(radius):
return 3.14*radius**2
al=circle_area(10)
print(al)
#1.全局变量作用域局部变量（Local）
# def my_func():
# x=10
# print(x)
#
# my_func()
# print(x)
#2. 全局变量（Global）
name = "小明" # 全局变量
def say_hello():
print(name) # 可以读取全局变量
say_hello() # 小明
def change_name():
name = "小红" # 注意：这是在函数内创建了一个新的局部变量，不会修改全局变量
print(name) # 小红
change_name()
print(name) # 小明（全局没变）
# 正确修改全局变量：使用 global
def really_change():
global name
name = "小华"
really_change()
print(name) # 小华
#嵌套作用域（Enclosing） 函数里面再定义函数，内层函数可以访问外层函数的变量（使用 nonlocal 修改
def outer():
count = 0 # 嵌套作用域的变量
def inner():
nonlocal count # 声明要修改外层变量
count += 1
print(count)
inner() # 1
inner() # 2
outer()
#高阶函数（Higher-Order Function），也就是把函数当作参数来传递
def add(a,b):
return a+b
def sub(a,b):
return a-b
def calc(x, y, oper):
return oper(x, y)
result = calc(10, 20, add)
print("@",result)
# 匿名函数Python中的匿名函数，正如其名，指的是没有名称的函数。它们主要通过 lambda表达式来声明，这种写法非常适合用来简化简单的、单行表达式的函数编写。
# 语法格式 lambda 参数列表: 函数体(表达式)
# 示例一（无参数）：
lambda: print('----------------------')
#示例二（带参数）：
lambda x, y: x + y #冒号前的 x, y是接收的参数，冒号后的 x + y是执行的表达式。这个函数的作用就是接收两个数，然后返回它们的和。
#如何调用匿名函数？
(lambda x, y: x + y)(10, 20) # 输出 30
#将其赋值给一个变量，然后通过变量名来调用（此时该匿名函数实际上被赋予了名字）。
add = lambda x, y: x + y
print(add(10, 20)) # 输出 30
#递归
def jc(n):
if n == 1:
return 1
else:
return n * jc(n-1)
result = jc(10)
print(result)
10.类型注解
#Python 3.5 版本引入了一种强大的语法特性------类型提示（Type Hints），也就是 PEP 484 标准。
# 没有类型提示
age = 18
height = 1.75
name = "小明"
age: int = 18
height: float = 1.75
name: str = "小明"
def add(a: int, b: int) -> int:
return a + b
add(10, 20) # ✅ 正确
# add("10", 20) # ⚠ IDE 会警告，但还能跑