python语法基础

选择循环语句

条件分支语句 if else

a=1
b=2
if a>b:
	print(f"{a}>{b}")
elif a<b:
	print(f"{a}<{b}")
else:
	print(f"{a}={b})	

选择逻辑符号
b and c -b c同时成立为True
b or c -b c只要有一个成立为True
b >= c
b <= c
b == c

循环语句

while循环

while 循环语句
满足某条件的情况，重复执行该程序

如10进制转二进制

n=int(input())
if n<0:
	n=-n
	print("-",end="")
elif n==0:
	print("0")
	exit()
result=""
while n>0:
	result+=str(n%2)
	n//=2
print(result[::-1])

for循环

for 迭代变量 in 对象：
循环体

通过索引遍历对象

str = '12345'
for i in range(len(string)):
	print(i)

for i in str:
	print(i)

range(start,end,step)
start 默认值为0
一个参数传给end
两个参数传给start,end

for i in range(1,5):
    print(i,end='')

输出1234
说明end为最后一位的后一位

如斐波那契推导

#求斐波那契第项
k = int(input())
a1=a2=1
for i in range(k-2):
	a1,a2=a2,a1+a2
print(a2)

for列表推导式

[表达式 for 迭代变量 in 可迭代对象 [if 条件]]

new = [i*2 for i in range(10)]
print(new)

函数

函数定义

函数代码块以def关键字开头
后接函数标识符名和圆括号()
圆括号中用于放入参数定义

return [表达式] 结束函数，并返回一个值
return 相当于返回None

一个函数实例

def my_max(a,b):
	if a>b:
		return a
	else:
		return b 

全局变量和局部变量

在所有函数外定义(即首次赋值)的变量为全局变量
在函数内部定义的变量为局部变量

局部变量在定义函数的外部不能使用，因此局部变量同名互不影响

注意：
1.函数内部可以使用global声明函数里的全局变量
2.如果函数没有对赋值，函数中的x就是全局的x

函数参数类型

参数类型主要包括：
默认参数
必选参数
可选参数
位置参数
关键字参数
强制关键字参数

默认参数

即调用时如果不给出这些参数，这些参数的值就自动取默认值

如果函数定义时将参数写成x=y的形式
即意味着参数的默认值是表达式y

必选参数

必须输入的参数，否则就会报错

可选参数

可以不用传入函数，会有一个默认值
如果没有传入不会报错，使用默认值

位置参数

也叫必传参数，顺序参数，是必须在调用函数时明确提供的参数
位置参数必须按照先后顺序一一对应，个数不多不少的传递

可变参数

即不定长参数

传入的参数个数是可变的，可以是0-n个
使用(*)号将输入参数自动组装为一个元组(tuple)

一个实例

def test_sum(*numbers):
	print(numbers)
	print(type(numbers))
	sum = 0
	for num in numbers:
		sum + = num
	return sum
print(test_sum(1,2,3,4))

使用星号(**)将输入参数自动组装为一个字典(dict)

一个实例

def person(**message):
	print(message)
	print(type(message))
	if 'name' in message:
		print(f"my name is {message['name']}")
person(name = 'ZTX',age = 18)
		

注意：
由于传入的参数个数不定，所以当与普通参数一同使用时，必须把带星号的参数放最后

关键字参数

函数调用时，参数传入使用了参数名称
示例

def key_param(p1,kp1,kp2):
	print(pi,kp1,kp2)
	return
key_param('p1',kp2="kp1",kp1="kp2")

在函数调用时，关键字参数放置的位置顺序可以随意，但关键字参数必须跟随在位置参数的后面

强制关键字参数

python3新引入的特性
使用一个星号(*)隔开
示例：

def person(name,age=20,*,height,weight):
    print(f"my name is {name},age {age},height {height},weight {weight}")

person('Ztx',18,weight=175,height=60)

(*)星号后面的参数都是强制关键字参数，必须以指定参数名的方式传参
如果强制关键字没有设置默认值
调用参数时必须传参

匿名函数

python 使用lambda创建匿名函数
所谓匿名是不再使用def语句这样的标准形式定义一个函数
是没有名字的函数
语法:
lambda 参数1，参数2:表达式
{
只能写一个表达式，表达式的结果就是返回值
只能用于一些简单的操作处理

lambda拥有自己的命名空间
且不能访问自己参数列表之外或全局命名空间里的参数

}

示例:

add = lambda x,y:x+y
print(add(5,4))

s=lambda x:x*x
print(s(5))

print((lambda x:x+1)(3))

高阶函数和闭包

高阶函数

在python中，函数可以赋值给变量也可以作为函数的参数和返回值
如果函数能接受函数作为参数
或者其返回值是函数
该函数就称为高阶函数

示例：

# 函数作为参数
def square(x):
	return x*x
def inc(x)
	return x+1
def combine(f,g,x)
	return f(g(x))
print(combine(square,inc,4))
print(combine(inc,square,4))

# 函数作为返回值
def combineFunctions(f,g):
	return lambda x:f(g(x))
def powerFunction(f,n):
	def h(x):
		for i in range(n):
			x=f(x)
			return x
	return h
print(combineFunctions(square,inc)(4))#lambda
print(powerFunction(inc,5)(1))
print(powerFunction(square,4)(2))

闭包

在嵌套函数中，来自于父函数，且在父函数调用结束后仍然能够存在的变量
称为自由变量

闭包就是由其他函数动态生成并返回的函数

通俗地讲
在函数内部还有’内层‘的函数，这个函数是作为返回值的
它可以访问其创建者的局部命名空间中的变量

每个闭包有一套自由变量
lambda x:f(g(x)) 也是嵌套函数，该语句也返回该嵌套函数的实例
即一个闭包

示例：

# 定义一个函数
def make_closure(a):
	#在函数内部再定义一个函数，这个里面的函数就被认为是闭包
	def closure():
		#打印传进来的数字
		print(f"I know the secret : {a}")
	return closure

closure1 = make_closure(7)
# 此时closure已经生成
closure1() 
# 其实就是调用返回的closure函数，然后执行closure函数
# 也等价于
make_closure(7)()

函数的参数传递

在python中，参数传递是按对象引用传递
函数参数传递的是对象的引用(即内存地址)，而非对象本身的副本
最终行为会因对象是否可变而有所不同

对于不可变对象
示例：

# 给函数传递不可变对象
def testFun(var):
    print("------------------------函数内部------------------------")
    print("函数内部赋值前,变量值:",var," --- 变量地址：",id(var) )
    var+=77
    print("函数内部赋值后,变量值:",var," --- 变量地址：",id(var) )
    print("------------------------函数内部------------------------")
    return(var)

var_a=11
print("函数外部调用前,变量值:",var_a," --- 变量地址：",id(var_a) )
testFun(var_a)
print("函数外部调用后,变量值:",var_a," --- 变量地址：",id(var_a) )

可以发现
不可变对象在传递给函数时，实参和形参是同一个对象(值和地址都相同)
但对于函数内部
不可变对象类型的变量在重新赋值后
形参变成一个新的对象(地址发生变化)
函数外部的实参在函数调用前后并未发生变化

对于可变对象
示例：

# 给函数传递可变对象
def TestFun2(varlist):
    print("------------------------函数内部------------------------")
    print("函数内部赋值前,变量值:",varlist," --- 变量地址：",id(varlist) )
    varlist+=[4,5,6,7]
    print("函数内部赋值后,变量值:",varlist," --- 变量地址：",id(varlist) )
    print("------------------------函数内部------------------------")
    return(varlist)
    
#函数调用
varlist_a=[1,2,3]
print("函数外部调用前,变量值:",varlist_a," --- 变量地址：",id(varlist_a) )
TestFun2(varlist_a)
print("函数外部调用后,变量值:",varlist_a," --- 变量地址：",id(varlist_a) )

可以发现传递可变对象的实参，把值和引用都传给了形参
函数内部对形参改变，同时也会改变了实参

看一组代码
示例：

def test_func3(l):
    l.append(4)

l1=[1,2,3]
l2=l1
test_func3(l1)
print(l1)
print(l2)
print(id(l1))
print(id(l2))

l1 和 l2 指向相同的地址，由于列表可变，l1改变，l2也跟着改变了

看另一组代码
示例：

def test_func4(l):
    l=l+[4]

l3=[1,2,3]
print(l3)
test_func4(l3)
print(l3)

def test_func5(l):
    l+=[4]
l4=[1,2,3]
print(l4)
test_func5(l4)
print(l4)

为什么测试4中的列表没有被改变，而测试5的列表被改变

看一些地址
示例：

def test_func4(l):
    
    print("------------------------函数内部------------------------")
    print("函数内部赋值前,变量值:",l," --- 变量地址：",id(l) )
    l=l+[4]
    print("函数内部赋值后,变量值:",l," --- 变量地址：",id(l) )
    print("------------------------函数内部------------------------")

l3=[1,2,3]
print("函数外部调用前,变量值:",l3," --- 变量地址：",id(l3) )
test_func4(l3)
print("函数外部调用后,变量值:",l3," --- 变量地址：",id(l3) )

def test_func5(l):
    print("------------------------函数内部------------------------")
    print("函数内部赋值前,变量值:",l," --- 变量地址：",id(l) )
    l+=[4]
    print("函数内部赋值后,变量值:",l," --- 变量地址：",id(l) )
    print("------------------------函数内部------------------------")
l4=[1,2,3]
print("函数外部调用前,变量值:",l4," --- 变量地址：",id(l4) )
test_func5(l4)
print("函数外部调用后,变量值:",l4," --- 变量地址：",id(l4) )

可以发现
l=l+[4] 表示创建一个“末尾加入元素4” 的新列表
并让l指向这个新的对象，但不影响外部的l1,故l1的值不变

而l+=[4] 是原地修改原列表，会同步改变外部原列表

这就是两个函数结果不同的原因

再看一组代码验证结论

def test_func6(l):
    l=l+[4]
    return l
l5=[1,2,3]
l6=l5
print(l5 is l6)
l5=test_func6(l5)
l6+=[4]
print(l5)
print(l6)
print(l5 is l6)

数据类型

变量

直接赋值即可以创建各种类型的变量
用type(/c)可以查看变量类型

python 中所有的变量都是指针
所有可赋值的都是变量

如列表的元素是可以赋值的，因此列表的元素就是指针
指针的本质就是内存地址，它指向内存单元中存放的数据

变量就是箭头
对变量赋值就是将箭头指向内存中的某处
而不是改写箭头指向地方的内容

a=3 #a->3
b=4 #b->4
a=b #a->b,->4
print(a is b) #a,b所指向同一处

is 表地址相同为True
/== 表值相同为True

数字

1.浮点数运算结果永远是浮点数
2.除法永远返回float类型
3.位数太多显示科学计数法
如

print(5/100000)

4.//为整除符号，即忽略小数，向下取整
5.abs(-1)=1 绝对值函数
6.无自增自减运算符
7.科学计数法默认float型
8.** 幂运算符
9.pow(a,b,mod) 快速幂并取模函数
10.complex 复数类型
11.类型转换 要转换类型后括号内加要转换内容

a=1
b=float(a)
print(a)
print(b)

12.round() 函数 取整
浮点数小数部分>5进1
小数部分<5取整
若小数部分等于5
整数为奇数进1
整数为偶数取整
13.ceil(x) 函数 返回大于等于x的最小整数
14.floor(x) 函数 返回小于等于x的最大整数

字符串

字符串切片

str[start/:end/:step]

str:待切片的字符串(不可变，切片会返回新字符串)
start:起始索引(包含该位置，默认值为0）
end:结束索引(不包含该位置，默认值为字符串长度len(str))
即最后一位索引的后一位
故总长度为end - start
step:步长(每次跳跃的间隔，默认值为1，为负数表示反向提取）

示例：

a='ABCD'
print(a[1:2])
print(a[:])
print(a[:len(a)])
print(a[0:])

字符串分割

str.split(sep=None,maxsplit=-1)

按指定分割符分割字符串，返回分割后的子串列表

sep:分割符(默认为任意空白字符，包括空格，换行，制表符等)
maxsplit:最大分割次数(默认-1表示不限制，若设为n则最多分割n次，得到n+1个子串）

示例：

str = "12..34.534 6...a"
print(str.split("."))
print(str.split(".",3))

str.rsplit()从右往左分割

正则表达式

re.split(pattern,str,flags=0)

用正则表达式定义分割符，能处理负责，动态分割的需求

pattern:必选，正则表达式(定义分割的“分割符”)
string:必选，待分割的原始字符串
flags:可选，正则匹配标志（如 re.IGNORECASE忽略大小写、re.MULTILINE多行模式等，默认 0）

示例：

import re

sub='beautiful, is; better*than\nugly.right?'
print(re.split(';| |,|\n|\.|\?',sub))

字符串格式化

把常量变量或表达式值
按照一定的格式2填到一个字符串里面

使用格式控制符可以进行字符串格式化

s.format(参数0，参数1，参数2，… … )
字符串s中可以带有“槽”-{}

f-string- 以F或者f开头的字符串
基本格式
{<参数序号>:<填充字符><对齐方式><输出宽度><.精度><类型>}

示例：

#{<参数序号>:<填充字符><对齐方式><输出宽度><.精度><类型>}

# 第一种s.format(参数.....)
x="hello {0} {1:+^10},you get ${2:.4f}".format("Mr.","jack",3.2)
print(x)


# 第二种f-string-以F或者f开头的字符串

name,age="jack",18
print(f"My name is {name},I am {age} yeras old.")

元组

元组是类似于列表的数据类型
也是元素的有序结合，可通过下标索引

元组是不可修改的
表示为
(元素1，元素2，元素3， … …)

不可修改以下几个方面：
对元组的元素进行赋值
对元组添加元素或者删除元素
改变元组元素的顺序，对元组排序

示例：

v=("hello",1,[1,2,3],(1,2,3))
print(v)
for i in v:
	print(i)

列表

列表的元素都是指针

列表是可以修改的
对元素赋值
添加删除元素
修改元素顺序

修改原列表(原地操作，改变列表本身)

#1.append(x)
#在列表末尾添加单个元素 且添加的是元素的引用

示例：

lst = [1, 2]
lst.append(3)  # lst → [1, 2, 3]
print(lst)

#2.extend(iterable)
#将可迭代对象所有元素依次追加到列表末尾

lst = [1, 2]
print(lst)
lst.extend([3, 4])   # lst → [1, 2, 3, 4]
print(lst)
lst.extend("ab")     # lst → [1, 2, 3, 4, 'a', 'b']（字符串拆分为字符）
print(lst)
lst.extend((5, 6))   # lst → [1, 2, 3, 4, 'a', 'b', 5, 6]
print(lst)

#3.insert(i,x)
#在列表第i位插入元素x

示例：

lst = [1, 3, 4]
print(lst)
lst.insert(1, 2)  # lst → [1, 2, 3, 4]（在索引1处插入2）
print(lst)
lst.insert(0, 0)  # 头部插入 → [0, 1, 2, 3, 4]
print(lst)

lst.insert(len(lst),x) - >同append(X) 等价于尾部插入

#4.remove(x)
#列表中第一个匹配的元素x(按值删除

示例：

lst = [1, 2, 2, 3]
print(lst)
lst.remove(2)  # lst → [1, 2, 3]（仅删除第一个2）
print(lst)

#5.pop(i)
#删除第i未元素，并返回元素值()
#默认i=-1，即删除最后一个元素

示例：

lst = [1, 2, 3]
print(lst)
last = lst.pop()   # last=3，lst→[1, 2]
print(lst)
print(last)
first = lst.pop(0) # first=1，lst→[2]
print(lst)  
print(first)

#6.clear()
#清空列表

示例：

lst = [1, 2, 3]
print(lst)
lst.clear()  # lst→[]
print(lst)

#7.reverse()
#反转元素顺序(原地修改）

示例：

lst = [1, 2, 3, 4]
print(lst)
lst.reverse()  # lst→[4, 3, 2, 1]
print(lst)

若需保留原列表，用切片lst[::-1](创建新列表

#8.sort(key=None,reverse=False)
#对列表原地排序
#key：排序依据的函数(如len按长度，lambda x:x%2 按奇偶性)
#reverse:是否降序

示例：

# 升序排序
lst = [3, 1, 4, 2]
print(lst)
lst.sort()  # lst→[1, 2, 3, 4]
print(lst)

# 降序排序
lst.sort(reverse=True)  # lst→[4, 3, 2, 1]
print(lst)

# 按字符串长度排序
words = ['apple', 'banana', 'cherry', 'date']
print(words)
words.sort(key=len)  # lst→['date', 'apple', 'banana', 'cherry']（date长度4最短）
print(words)

注意：
sort是稳定排序(相等元素的相对顺序不变)
若需新列表，用内置函数sorted(list)

列表查询统计(不修改原列表)

1.count(x)
统计元素x在列表出现的次数

示例：

lst = [1, 2, 2, 3, 2]
print(lst.count(2))  # 输出3

2.index(sx,start,end)
返回元素x在列表中第一次出现的索引，可指定查找范围

示例：

lst = [1, 2, 3, 2, 4]
print(lst.index(2))    # 输出1（第一次出现的位置）
print(lst.index(2, 2)) # 从索引2开始找，输出3

列表拷贝方法

浅拷贝
会创建一个新对象，但只拷贝原对象中的引用(对于可变元素，新对象和原对象会共享这部分引用）

示例：

lst = [1, [2, 3]]          # 原列表，包含一个不可变整数和一个可变的内层列表（引用）
lst_copy = lst.copy()      # 浅拷贝

# 1. 修改外层元素（不可变对象）
lst_copy[0] = 10
print(lst)                 # 输出：[1, [2, 3]] -> 原列表未受影响

# 2. 修改内层元素（可变对象）
lst_copy[1].append(4)
print(lst)                 # 输出：[1, [2, 3, 4]] -> 原列表的内层列表被改变了！

可以发现
修改 lst_copy0 是给 lst_copy的第一个位置赋了一个新值（10），这不会影响 lst。

但 lst_copy[1]和 lst[1]持有的是对同一个内层列表对象的引用。所以通过这个引用修改列表（.append(4)），两边都会看到变化。

深拷贝
要实现深拷贝，需要创建内层对象的独立副本，这时就要用到copy模块的deepcopy函数

import copy

lst = [1, [2, 3]]
lst_deepcopy = copy.deepcopy(lst)  # 深拷贝

lst_deepcopy[1].append(4)
print(lst)                         # 输出：[1, [2, 3]] -> 原列表完全不受影响
print(lst_deepcopy)                # 输出：[1, [2, 3, 4]]

列表初始化

• 直接字面量：用方括号包裹元素，元素用逗号分隔。

  nums = [1, 2, 3, 4]          # 整数列表
  mixed = [1, "hello", True]   # 混合类型列表
  

• 重复元素初始化：用 * 运算符重复某个元素（仅适用于不可变元素，否则可能有副作用）。

zeros = [0] * 5              # [0, 0, 0, 0, 0]
# 注意：若元素是可变对象（如列表），重复会导致共享引用！
# bad_example = [[]] * 3  # 结果是三个指向同一个空列表的引用，修改其中一个会影响所有

• 列表推导式：通过表达式动态生成列表（最灵活的方式）。

  even_nums = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]
  squares = [x**2 for x in range(5)]               # [0, 1, 4, 9, 16]
  

• 从其他可迭代对象转换：用 list() 函数将其他可迭代对象（如元组、字符串、生成器）转为列表。

  tuple_to_list = list((1, 2, 3))    # [1, 2, 3]
  str_to_list = list("hello")        # ['h', 'e', 'l', 'l', 'o']
  gen_to_list = list(range(5))       # [0, 1, 2, 3, 4]
  

• 动态初始化：通过 append()、extend() 或 += 动态添加元素（适用于需要逐步构建的场景）。

  dynamic_list = []
  dynamic_list.append(1)       # [1]
  dynamic_list.extend([2, 3])  # [1, 2, 3]
  dynamic_list += [4, 5]       # [1, 2, 3, 4, 5]
  

字典

用于快速查找的一类数据类型
由
键:key
值:value
两部分组成

• 字典初始化：
  示例：

# 空字典
# 花括号直接构造
empty_dict={}
#有数据的字典
person={"name":"Alice","age":30,"city":"new york"}

# dict()构造函数
#dict()是字典的内置构造函数,支持多种参数形式

# 无参 相当于花括号直接构造空字典
d1=dict()


# 关键字参数(键是字符串)--值为对应参数值
d2 = dict(name="Bob",age=25,city="london")

# 可迭代对象(二元列表)转化为字典
d3=dict[("id",1),("username","charlie"),("email",".com")]

#3.zip()组合键列表与值列表
#若有两个列表分别存储键和值,可用zip合并后传给dict
#特点:适合键和值分离的场景()
keys = ["product", "price", "quantity"]
values = ["Apple", 9.99, 10]

# zip(keys, values) 生成迭代器：(('product','Apple'), ('price',9.99), ...)
d4 = dict(zip(keys, values))
print(d4)  # {'product': 'Apple', 'price': 9.99, 'quantity': 10}

#字典推导式(动态生成)
# 示例1：生成1~5的平方字典
square_dict = {x: x**2 for x in range(1, 6)}
print(square_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 示例2：过滤偶数，生成偶数的平方字典
even_square = {x: x**2 for x in range(1, 6) if x % 2 == 0}
print(even_square)  # {2: 4, 4: 16}

# 示例3：将字符串列表转为索引字典（键是索引，值是字符）
chars = ["a", "b", "c"]
char_index = {idx: char for idx, char in enumerate(chars)}
print(char_index)  # {0: 'a', 1: 'b', 2: 'c'}



#5.fromkeys()方法(批量设置默认值)
#dict.fromkeys(keys,default_value)用于创建所有映射到同一个默认值的字典
#若不传default_value,默认值为None
#若默认值是可变对象(列表，字典)，所有键会共享同一个对象(修改一个会影响所有)
# 所有键默认值为0
default_dict = dict.fromkeys(["status", "count"], 0)
print(default_dict)  # {'status': 0, 'count': 0}

# 默认值为None
none_dict = dict.fromkeys(["a", "b"])
print(none_dict)  # {'a': None, 'b': None}

# 注意：可变对象的陷阱！
mutable_dict = dict.fromkeys(["list1", "list2"], [])
mutable_dict["list1"].append(1)
print(mutable_dict)  # {'list1': [1], 'list2': [1]}（两个键共享同一个列表）

# 解决陷阱：用字典推导式替代（每个键都是新对象）
safe_dict = {key: [] for key in ["list1", "list2"]}
safe_dict["list1"].append(1)
print(safe_dict)  # {'list1': [1], 'list2': []}（独立列表）


#其它
#字典合并操作符
# 合并两个字典初始化
d5 = {"a": 1} | {"b": 2}
print(d5)  # {'a': 1, 'b': 2}

# 或用 |= 更新（原地修改）
d6 = {"a": 1}
d6 |= {"b": 2}
print(d6)  # {'a': 1, 'b': 2}


#键唯一性:初始化时若有重复键,后面的值会覆盖前面的

dup_dict = {"a": 1, "a": 2}
print(dup_dict)  # {'a': 2}

• 字典成员操作函数
  示例：

def demonstrate_dict_operations():
    # 示例字典
    sample_dict = {
        "name": "Alice",
        "age": 30,
        "city": "New York",
        "email": "alice@example.com",
        "is_active": True
    }
    
    print("原始字典:", sample_dict)
    print("\n" + "="*50)
    
    # 1. 检查键是否存在 - in 操作符
    print("1. 使用 in 操作符检查键是否存在:")
    print(f"   'age' 在字典中: {'age' in sample_dict}")
    print(f"   'salary' 在字典中: {'salary' in sample_dict}")
    print(f"   'name' 不在字典中: {'name' not in sample_dict}")
    
    # 2. get() 方法 - 安全获取值
    print("\n2. 使用 get() 方法安全获取值:")
    age_value = sample_dict.get('age')
    salary_value = sample_dict.get('salary')
    salary_with_default = sample_dict.get('salary', 0)  # 提供默认值
    
    print(f"   get('age'): {age_value}")
    print(f"   get('salary'): {salary_value} (键不存在返回None)")
    print(f"   get('salary', 0): {salary_with_default} (返回默认值)")
    
    # 3. setdefault() 方法 - 获取值并设置默认值（如果键不存在）
    print("\n3. 使用 setdefault() 方法:")
    existing_city = sample_dict.setdefault('city', 'Unknown')
    new_country = sample_dict.setdefault('country', 'USA')
    
    print(f"   setdefault('city', 'Unknown'): {existing_city} (键已存在)")
    print(f"   setdefault('country', 'USA'): {new_country} (键不存在，已设置)")
    print(f"   更新后的字典: {sample_dict}")
    
    # 4. keys() 方法 - 获取所有键
    print("\n4. 使用 keys() 方法:")
    dict_keys = sample_dict.keys()
    print(f"   所有键: {dict_keys}")
    print(f"   键的列表: {list(dict_keys)}")
    
    # 5. values() 方法 - 获取所有值
    print("\n5. 使用 values() 方法:")
    dict_values = sample_dict.values()
    print(f"   所有值: {dict_values}")
    print(f"   值的列表: {list(dict_values)}")
    
    # 6. items() 方法 - 获取所有键值对
    print("\n6. 使用 items() 方法:")
    dict_items = sample_dict.items()
    print(f"   所有键值对: {dict_items}")
    print("   遍历键值对:")
    for key, value in dict_items:
        print(f"     {key}: {value}")
    
    # 7. pop() 方法 - 移除指定键并返回值
    print("\n7. 使用 pop() 方法:")
    try:
        email_value = sample_dict.pop('email')
        print(f"   pop('email'): {email_value}")
        print(f"   移除后的字典: {sample_dict}")
        
        # 尝试移除不存在的键（会抛出KeyError）
        # sample_dict.pop('nonexistent')  # 这会抛出异常
        
    except KeyError as e:
        print(f"   KeyError: {e}")
    
    # 8. popitem() 方法 - 移除并返回最后一个键值对（Python 3.7+）
    print("\n8. 使用 popitem() 方法:")
    last_item = sample_dict.popitem()
    print(f"   popitem(): {last_item}")
    print(f"   移除后的字典: {sample_dict}")
    
    # 9. update() 方法 - 合并字典
    print("\n9. 使用 update() 方法合并字典:")
    additional_info = {"occupation": "Engineer", "hobby": "Reading"}
    sample_dict.update(additional_info)
    print(f"   合并后的字典: {sample_dict}")
    
    # 10. clear() 方法 - 清空字典
    print("\n10. 使用 clear() 方法:")
    sample_dict.clear()
    print(f"   清空后的字典: {sample_dict}")

# 高级用法示例
def advanced_membership_operations():
    print("\n" + "="*50)
    print("高级用法示例:")
    print("="*50)
    
    # 字典推导式与成员检查结合
    user_data = {
        "user1": {"name": "Alice", "age": 25, "active": True},
        "user2": {"name": "Bob", "age": 30, "active": False},
        "user3": {"name": "Charlie", "age": 35, "active": True}
    }
    
    # 找出所有活跃用户
    active_users = {user_id: info for user_id, info in user_data.items() 
                   if info.get('active', False)}
    print("活跃用户:", active_users)
    
    # 使用字典进行配置处理（带默认值）
    config = {"theme": "dark", "language": "en"}
    theme = config.get('theme', 'light')
    font_size = config.get('font_size', 14)
    print(f"主题: {theme}, 字体大小: {font_size}")

if __name__ == "__main__":
    demonstrate_dict_operations()
    advanced_membership_operations()

集合

set 是一种无序，可变且元素唯一的数据结构，主要用于存储不重复的元素，并支持高效的成员检查，去重和集合运算

• 集合的特性
  无序性：集合元素没有固定顺序，不支持索引或切片
  唯一性：集合自动去重

• 可作为集合成员的元素类型
  由于集合依赖哈希值判断元素是否重复，因此只有不可变且可哈希的对象才能作为集合对象
  常见的合法元素类型：
  整数
  浮点数
  字符串
  元组：若元组内所有元素均可哈希，则元组本身可哈希
  布尔值
  冻结集合

• 集合的初始化
  创建一个空集合必须使用set()
  直接使用{}会创建一个字典(dict)

创建非空集合
方法一：直接使用花括号{}包裹元素
方法二：通过set()构造函数传入可迭代对象

示例：

#从列表初始化
list_to_set = set([1,2,3,2])
print(list_to_set)

#从元组初始化
tuple_to_set = set((4,5,6,5))
print(tuple_to_set)

#从字符串初始化（每个元素作为独立元素
str_to_set = set("hello") #字符串作为可迭代的字符序列
print(str_to_set)

#从range对象初始化
range_to_set = set(range(3)) # range(3)生成0,1,2
print(range_to_set)

• 集合成员操作函数
  示例：

"""
一.基础成员检查：in 和not In操作符号
 """
fruits = {"apple", "banana", "cherry"}

print("apple" in fruits)    # 输出：True
print("grape" in fruits)    # 输出：False
print("mango" not in fruits)# 输出：True

""" 
二.延伸：集合间的成员关系方法​
除单个元素检查外，集合还提供判断集合间关系的方法（本质是成员操作的扩展）：
1. issubset(other)/ <=：判断子集
含义：当前集合的所有元素都属于 other集合 → 返回 True；
等价操作符：<=。
2. issuperset(other)/ >=：判断超集
含义：other集合的所有元素都属于当前集合 → 返回 True；
等价操作符：>=。
3. isdisjoint(other)：判断无交集
含义：两个集合没有任何共同元素​ → 返回 True；否则返回 False。
 """
set_a = {1, 2, 3}
set_b = {2, 3, 4}
set_c = {4, 5, 6}

# 子集检查
print(set_a.issubset(set_b))  # 输出：False（set_a 有1不在 set_b 中）
print({1, 2}.issubset(set_a)) # 输出：True（等价于 {1,2} <= set_a）

# 超集检查
print(set_b.issuperset(set_a)) # 输出：False（set_b 有4不在 set_a 中）
print(set_a.issuperset({1,2})) # 输出：True（等价于 set_a >= {1,2}）

# 无交集检查
print(set_a.isdisjoint(set_c)) # 输出：True（无共同元素）
print(set_a.isdisjoint(set_b)) # 输出：False（有2、3共同元素）

""" 
三.添加函数(仅限可哈希对象)
add(elem)添加单个元素
updata(iterable)：批量添加可迭代对象中的元素(自动去重)
 """
s = {1, 2}
s.add(3)       # s 变为 {1, 2, 3}
s.add(2)       # 无变化（重复元素）
s.update([4, 5, 5])  # s 变为 {1, 2, 3, 4, 5}

""" 
四.删除元素
remove(elem)删除指定元素，不存在抛出KeyError
discard(elem)删除指定元素，不存在无操作(更安全)
pop()随机删除并返回一个元素(集合无序，结果不确定)
clear():清空集合


 """
s = {1, 2, 3}
s.remove(2)    # s 变为 {1, 3}
s.discard(4)   # 无变化（4 不存在）
print(s.pop()) # 随机输出 1 或 3，s 剩余另一个元素
s.clear()      # s 变为空集合 {}
print(s)

""" 
五.特殊情况：集合作为集合的元素​
普通集合（set）是可变的，因此不能直接作为另一个集合的元素。但可以使用冻结集合（frozenset）​​（不可变的集合）作为成员：
 """
# 错误：普通集合不可哈希，无法作为集合元素
# s = { {1, 2}, {3, 4} }  # 报错: TypeError: unhashable type: 'set'

# 正确：使用 frozenset
fs1 = frozenset([1, 2])
fs2 = frozenset([3, 4])
s = {fs1, fs2}  # 结果为 {frozenset({1, 2}), frozenset({3, 4})}
print(s)

• 判断集合是否为空

示例：

#1.bool上下文判断
#集合是“ falsy 对象”——当集合为空时，其布尔值为 False；非空时为 True
my_set = set()  # 空集合
if not my_set:
    print("集合为空")  # 会执行
else:
    print("集合非空")

#2.显示检查长度
#通过内置函数 len() 获取集合的元素数量，若为0则表示空
my_set = set()
if len(my_set) == 0:
    print("集合为空")  # 会执行

#3.直接与空集合比较
#空集合的实例是 set()（注意：{} 表示空字典，不是空集合！），可直接比较
my_set = set()
if my_set == set():
    print("集合为空")  # 会执行

自定义数据类型

类是面向对象程序设计的概念
由类生产的变量称为对象
由类生产的一个变量称为类的实例化
类是一种事物共同特点的概括
对象就是该种事物的一个个体（实例

一.定义基本类

• 1.类结构
  使用class关键字定义类，包含构造函数__init__,属性和方法
  示例：

class Person:
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

    def greet(self):     # 实例方法
        return f"Hello, I'm {self.name}."
        

实例化对象：person = Person(“Alice”,30)
访问属性/方法：person.name 或person.greet()

• 2.类变量与实例变量
  类变量：所有实例共享的数据
  实例变量：每个对象独有的数据 如self.name

二.核心特性

• 1.继承与多态
  子类继承父类的属性和方法，支持扩展
  示例：

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id

多态允许不同类实现同名方法

• 2.封装和私有属性
  使用双下划线定义私有属性，如self.__balance 仅能通过类方法访问

• 3.特殊方法重载
  通过重载双下划线方法自定义行为

示例：

class Vector2D:
    def __add__(self, other):
        return Vector2D(self.x + other.x, self.y + other.y)

三.高级功能

• 1.数据类@dataclass
  python3.7+ 引入，自动生产__init__,__reper__等方法
  示例：

from dataclasses import dataclass
@dataclass
class Position:
    name: str
    lon: float
    lat: float

减少样板代码，提升可读性

• 2.属性装饰器@property
  控制属性访问，添加验证逻辑
  示例：

class Temperature:
    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Invalid temperature!")

实现安全的数据读写

• 3.组合与聚合
  组合：类包含其他类的实例（如Person包含Address对象
  聚合：类引用其他类的实例，但不完全依赖其生命周期

面向对象程序设计

结构化程序设计
也称为面向过程的程序设计，过程可以理解为函数

面向对象程序设计
该方法继承结构化程序设计的优点
也克服了其缺点

对象:在面向对象程序设计中，将事物个体称为对象
类：将同一类或者相似的事物的共同属性或者特点概括为类
对象包括：{
属性(对象的静态特征)
方法(对象的行为)
}

python中的类

类(class)用于代表事物。
如需设计一个类，首先就需要概括出该类所代表的事物属性，用成员变量表示
其次还要概括出这类事物能进行的操作，用成员函数表示(方法)

示例：

#定义矩形类
#两个属性 宽和高
#另有两个方法计算面积和周长

class Rec:
	def __init__(self,w,h):#定义构造函数
		self.w,self.h=w,h
	def Area(self):#计算面积方法
		return self.w*self.h
	def Per(self):#计算周长方法
		return 2*(self.w+self.h)
def main() :#定义main函数
	w,h=map(int,input().split())#map将函数int批量应用到input上
	rect = Rec(5,10)
	print(rect.Area(),rect.Per())
	rect.w,rect.h = 10,20
	print(rect.Area(),rect.Per())
	rect1 = Rec(2,3)
	print(rect1.Area(),rect1.Per())
main()

类属性和实例属性

Python的类定义有两种属性
类属性在类内部的所有方法之外进行定义，类属性是由类及其所有实例共同构成
可以通过类名或者实例名进行访问

实例属性是一个具体的实例所独有的，不同的实例的实例属性之间是完全独立的
可以通过传入参数的不同而不同
实例属性一般在构造器“init”方法里初始化

示例：

class A_Class:
	a=4#a是类属性，即所有实例共有的
	def __init__(self,b):#构造方法
		self.b=b #b是实例属性
a1 = A_Class("Mike")
a2 = A_Class("Tom")
print(a1.b) #通过实例访问属性

print(a2.a,A_Class.a)#通过实例或类访问类属性

A_Class.c = 'Jxnu'
print(a1.c,a2.c)

a1.d = 'edu'

print(a1.d)

Python除在类的内部定义类属性和实例属性，还可以使用动态添加的方式
如 A_Class.c = 'Jxnu
使用“类名.新的属性名=初始值”来动态添加类属性，类的其他实例都该属性

如 a1.d = ‘edu’
使用“实例名.新的属性=初始值”来动态添加实例属性
添加后该实例属性只属于相应的实例，类的其他实例并没有该属性，类也不具有

故有：
实例属性是由一个具体的实例所有的，对其修改不会影响到其他实例
类属性属于类和该类实例化出来的所有实例
类可以通过"."运算符读取或修改类属性
类实例可以读取类属性，但不能直接修改类属性

类成员的可见性

python 类的成员默认情况下在类的外面都完全可见

使用约定的命名规范来表示成员共有还是私有

以双下划线（ __ )开头的方法/属性会被视为私有成员
私有成员不能通过外部直接访问

示例：

class MyClass:
	__private_f =234
	value = 456
	def __init__(self):
		self.__private_value=123 #私有属性
	def __foo(self):# 私有方法
		print(f"hello {self.__private_value} and {self.__private_f}") #类内部可以直接访问私有属性
	def fun(self):
		self.__foo()#类内部可以直接访问私有方法
		print(f"hello {self.value}")
a = MyClass()
a.fun()

a._MyClass__foo()
print(a._MyClass__private_value)

修正方法
1.在类内部调用私有方法
2.外部强制访问私有方法 如 a._MyClass__foo()
将私有成员的名称改写未_类名__成员名的形式
可以供外部直接访问（破坏封装

类对象的比较

python中所有类包括自定义类都有一个 eq 方法
默认情况下，一个自定义类的__eq__方法是判断两个对象的id是否相同

基于内内存定义即is语义
通过自定义 eq 方法可以让对象根据业务逻辑属性判断是否相等

示例：

class point:
    def __init__(self,x,y=0):
        self.x,self.y=x,y
    def __eq__(self,other):
        return self.x==other.x and self.y==other.y
    def __lt__(self,other):
        if self.x == other.x:
            return self.y<other.y
        else:
            return self.x<other.x

对象的比较
lt :less than 小于 a.lt(b)
le :less than or equal 小于等于 to a.le(b)
eq :equal to 等于a.eq(b)
ne :not equal to 不等于 a.ne(b)
ge :greater thann or equal to 大于等于 a.ge(b)
gt :greater than 大于 a.gt(b)

输出类对象

Python 中，默认打印对象会显示类似 <main.Point object at 0x…>（内存地址），很难看懂。如果想让打印对象时显示自定义内容​（比如坐标、名称），就需要在类中重写 __str__方法。
​print(x)等价于 print(x.str())​
当你写 print(对象)时，Python 内部会自动调用这个对象的 __str__方法，然后打印 __str__的返回值。
​str(x)也等价于 x.str()​
如果你需要把对象强制转成字符串​（比如赋值给字符串变量、拼接字符串），str(对象)也会调用 __str__方法，返回对象的字符串表示。

定义一个对象，若重写__str__(self) 可以通过print将该对象的属性输出
示例：

class p():
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def __str__(self):
        return ("(%d,%d)" %(self.x,self.y))

print(p(3,5))
print(str(p(2,4)))

如果有__str__(self)方法,还可以将对象转化成字符串
str(x)就等价于x.str()

类继承和派生

类的继承是指在一个已有类的基础上构建一个新的类
构建出来的新类可以称为子类(派生类)

被继承的类称作为父类(基类)
子类会自动拥有父类可继承的属性和方法

一个子类存在多个父类的现象称为多继承

派生类:可以添加新的成员变量和成员函数
同时也可以重写父类继承的成员函数

多态:在同一个方法中，由于参数类型或者参数的个数不同
导致执行结果各异的现象称为多态

示例：

import datatime
class student:
	def __init__(self,id,name,gender,birthYear):
		self.id,self.name,self.gender,self.birthYear = id,name,gender,birthYear
	def printInfo(self):
		print("Name:",self.name)
		print("ID:",self.id)
		print("Birth Year:",self.birthYear)
		print("Gender:",self.gender)
		print("Age:",self.countAge())
	def countAge(self):
		return datetime.datetime.now().year-self.birthYear

class undergraduateStudent(student):#继承student
    def __init__(self, id, name, gender, birthYear,department):
        student.__init__(self,id, name, gender, birthYear) #新增属性department
        self.department=department
    def qualifiedForBaoyan(self): #新增方法
        print("Qualified for bao yan")
    def printInfo(self):#重写父类方法，添加一个输出
        student.printInfo(self)
        print("Department:",self.department)
def main():
    s2=undergraduateStudent("2023","张明","M",2006,"大数据管理与应用")

    s2.printInfo()
    s2.qualifiedForBaoyan()
    if s2.countAge()>18:
        print(s2.name,"is older than 18")
main()

静态属性和静态方法

对于类的属性，同类的不同对象各有一份
不会相互影响
如果需要调用一类中的方法就需要通过一个对象来调用
即为方法需要作用在一个具体的对象上面

在定义类时
还可以定义一种称为“静态属性”的特殊属性
该属性被所有类的对象共享

还可以定义一种称为"静态方法"的特殊方法，该方法不需要作用在一个具体的对象上
调用时也不需要通过具体的对象来进行

示例：

#静态属性和静态方法
class employee:
    totalSalary=0  #静态属性
    def __init__(self,name,income):#构造方法，属性初始化
        self.name,self.income=name,income
    def pay(self,salary):#定义类方法pay，具有一个参数
        self.income+=salary
        employee.totalSalary+=salary

    @staticmethod #定义静态方法
    def printTotalSalary():#该方法没参数，应不能访问类的非静态属性
        print(employee.totalSalary)
def m():
    e1=employee("jack",0)
    e2=employee("Tom",0)

    e1.pay(100)
    e2.pay(200)

    employee.printTotalSalary()

    e1.printTotalSalary()
    e2.printTotalSalary()

    print(employee.totalSalary)
employee.printTotalSalary()
m()
employee.printTotalSalary()

文件读写

文本文件的内容通常是由某种通用的编码表示
{
ASCLL
UTF-8
GBK
等
}

文本文件通常可以用记事本打开
扩展名：
.txt .html . csv

open()函数

Python对文件读写，首先打开文件，然后读写，最后关闭
open函数:使用open()函数一定要保证关闭文件对象
即调用closs()函数

open()函数通常是接受两个参数：文件路径名file 和 模式mode

open(file,mode=‘r’)#mode参数表示打开文件的模式

完整的语法格式
open(file,mode=‘r’,buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)

参数说明：
buffering 设置缓冲
encoding 编码？一般用utf-8
errors 保错级别
newline 区别换行符
clodefd 传入的file参数类型
opener 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符

open函数返回的值称为文件对象，通过文件对象对文件进行各种操作
如果是以文本方式打开文件，则读入和写入的数据都是字节流
字节流是Python中的一类数据类型，名为bytes
打开文件后，不论是否进行读写操作一定要关闭

文件对象读写函数
readall() 读取整个文件内容到一个字符串或一个字节流
read(x) 读取长度为x的内容到字符串或字节流，不写参数则读取整个文件内容
readline(x) 读取文件当前行中的前x个字符或字节，不写参数则读取一整行
readlines(x) 读取文件中x行内容到字符串列表或字节流列表，不写参数则读写所有行
write(x) 将字符串x或字节流x写入文件
writelines(x) 将一个字符串列表x或字节流列表x的元素写入文件

文本文件编码

文本文件的内容都是文字，用0和1表示
常见的编码
ASCLL 是一套表示英文字母，数字，常用标点符号的方案，用8个比特表示一个字符
GB2312 是我国颁发的一套能表示汉字和常规字符的编码
Unicode 是国际通用的文字编码，用两个字节表示一个字符
UTF-8 是不定长编码，即不同的字符在UTF-8编码中的字节数是不一样的

内存中的字符串都是采用Unicode编码，即所有字符包括常规字符都是用两个字节表示

读写文本文件

要读写文本文件首先用open()函数打开文件

将其返回值赋值给一个变量(对象)，然后调用对象的成员函数对文件进行读写

示例：

f=open("t1.txt","w",encoding="utf-8")#w表示写
#注意若此文件存在就会被覆盖
f.write("good\n")
f.write("你好你\n")
f.close()

f=open("t1.txt","r",encoding="utf-8")
lines=f.readlines()
for x in lines:
    print(x.end="")


#逐行读入文件内容并逐行处理

while True:
    data=f.readline()
    if data=="":
        break
    print(data,end="")
f.close()

#在已有的文件新增内容
f=open("t1.txt","a",encoding="utf-8")
#"a"要打开文件添加内容，若文件不存在，就创建文件
f.write("你好good\n")
f.write("good你好\n")
f.close()

文件夹操作

文件可相对路径也可绝对路径

Python 自带os库和shutil库中有函数可以操作文件和文件夹
os.chdir() 将当前文件夹设置为x
os.getcwd() 求程序的当前文件夹
os.listdir(x) 返回列表，包括文件夹x中所有的文件和子文件夹的名字
os.mkdir(x) 创建文件夹x
os.path.exists(x) 判断文件或文件夹是否存在着
os.path.getsize(x) 获取文件x的大小 字节为单位
os.isfile(x) 判断x是不是文件
os.remove(x) 删除文件x
os.rmdir(x) 删除文件夹 ，x必须为空才能删除成功
os.remame(x),将文件夹或文件改名为y，还可以直接改上级目录
如

os.rename(“c:/tmp/a”
,“c:/tmp2/b”)可以将文件夹或
文件"c:/tmp/a"移动到"c:/tmp2/"文件夹下面并改名为b

数据交换文件格式csv

CSV(逗号分割值)格式是一种通用的，相对简单的文本文件格式，通常用于在程序
之间传递数据，被广泛应用于商业和科学领域
CSV文件由任意数目的行组成，一行被称为一条记录，纪录间可以换行符分割
每条记录由若干数据项组成，这些数据项被称为字段

字段间的分隔符通常是逗号，也可以是制表符或其他符号

通常所有记录都有相同的字段序列

CSV格式存储的文件一般以csv为扩展名可以通过记事本或 officeexcel工具打开
也可以在其他操作系统上用文本编辑工具打开

CSV 读出的数据一般为字符串类型，要想获得数值类型，需要用户完成转换
以行为单位读取数据
列之间以半角逗号或制表符为分隔符
通常每行开头补空格，第一行是属性列，行之间无空行