python期末复习（自用）

python期末复习

1.Python 中标识符命名规则：

1.1三大组成部分：

• 大小写字母（Python 区分字母大小写）
• 数字
• 下画线（_）

开头只能是“**大小写字母”**或者“数字”

除以上所述其他符号一律不能使用，如：

• 不能包括除下画线以外的其他任何特殊字符,如%、#、&、等
• 不能包含换行符、空格和制表符等空白字符

注意：不能使用 Python 的关键字和约定俗成的名称等,如 print。

举例：10_name(以数字开头)、if(Python 关键字)、￥10(包含特殊字符)、sno-sname(包含特殊字符一)等均为不合法标识符。

1.2变量的类型

具体来说，你可以直接通过赋值语句为变量名赋值，而不需要事先声明变量名及其类型。语法格式如下：

变量名 = 变量值

下面是一些具体的例子来说明这个概念：

# 整数赋值
a = 10
print(a)  # 输出: 10

# 浮点数赋值
b = 3.14
print(b)  # 输出: 3.14

# 字符串赋值
c = "Hello, Python!"
print(c)  # 输出: Hello, Python!

# 列表赋值
d = [1, 2, 3, 4, 5]
print(d)  # 输出: [1, 2, 3, 4, 5]

# 字典赋值
e = {"name": "Alice", "age": 30}
print(e)  # 输出: {'name': 'Alice', 'age': 30}

可以看到，不需要事先声明变量的类型，Python 会根据你赋予的值自动推断变量的类型

**问题：**如果一个变量先被赋值了一个整数然后又被赋值了一个浮点数 那这个变量是什么类型

**回答：**在 Python 中，变量的类型是动态的，即变量可以在不同时间被赋予不同类型的值。当一个变量先被赋值为一个整数，然后又被赋值为一个浮点数时，变量的类型会根据最新的赋值进行更新。

# 变量 x 首先被赋值为一个整数 
x = 10 print(type(x))  # 输出: <class 'int'> 
# 变量 x 然后被赋值为一个浮点数
x = 3.14 print(type(x))  # 输出: <class 'float'>

2.Python 支持的数据类型

Python 支持多种数据类型，主要包括数字类型、序列类型、集合类型和其他类型。以下是 Python 支持的主要数据类型及其简单介绍：

• 数字类型

1. 整数类型 (int):
   • 包含正整数、负整数和零。
   • 例如：10, -5, 0
2. 浮点类型 (float):
   • 包含带有小数点的数值。
   • 例如：3.14, -2.0, 0.0
3. 复数类型 (complex):
   • 包含实部和虚部的数值，虚部用 j 表示。
   • 例如：1+2j, -3.14+0.5j
4. 布尔类型 (bool):
   • 包含两个值：True 和 False。
   • 布尔类型实际上是整数类型的子类型，True 等价于 1，False 等价于 0。

• 序列类型

1. 字符串类型 (str):
   • 包含字符的有序序列，用单引号 ' 或双引号 " 包围。
   • 例如：'hello', "world"
2. 列表类型 (list):
   • 有序且可变的元素集合，用方括号 [] 包围，元素之间用逗号分隔。
   • 例如：[1, 2, 3], ['a', 'b', 'c']
3. 元组类型 (tuple):
   • 有序且不可变的元素集合，用圆括号 () 包围，元素之间用逗号分隔。
   • 例如：(1, 2, 3), ('a', 'b', 'c')

• 集合类型

1. 集合类型 (set):
   • 无序且不重复的元素集合，用花括号 {} 包围。
   • 例如：{1, 2, 3}, {'a', 'b', 'c'}
2. 冻结集合类型 (frozenset):
   • 无序且不重复的元素集合，但不可变。
   • 例如：frozenset([1, 2, 3]), frozenset(['a', 'b', 'c'])

• 映射类型

1. 字典类型 (dict)
   • 无序的键-值对集合，用花括号 {} 包围，键和值之间用冒号 : 分隔。
   • 例如：{'name': 'Alice', 'age': 25}, {'a': 1, 'b': 2}

• 特殊类型

1. 空类型 (None)
   • 表示空值或无值，用关键字 None 表示。
   • 例如：x = None

**注意：**Python 不直接支持 char 类型的数据

也就是说：在java中有单独的 char 类型来表示单个字符相反，Python 使用字符串类型（str）来表示字符序列，而单个字符实际上也是一个长度为 1 的字符串。

通过将字符和字符串统一为一种类型（str），Python 的类型系统变得更加简洁和一致，不需要处理单独的字符类型。

3.运算符

在 Python 中，运算符是用于执行操作的符号。它们可以分为以下几类：算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符和身份运算符。下面是对每类运算符的详细介绍和示例：

算术运算符

用于进行数学运算。

• + (加)：两数相加
• - (减)：第一个数减去第二个数
• * (乘)：两数相乘
• / (除)：第一个数除以第二个数（和java不一样，这里的有小数）
• % (取模)：返回除法的余数
• ** (幂)：返回第一个数的第二个数次幂
• // (整除)：返回除法的整数部分

示例：

a = 10
b = 3
print(a + b)  # 输出: 13
print(a - b)  # 输出: 7
print(a * b)  # 输出: 30
print(a / b)  # 输出: 3.3333333333333335
print(a % b)  # 输出: 1
print(a ** b) # 输出: 1000
print(a // b) # 输出: 3

比较运算符

用于比较两个值。

• == (等于)：如果两个值相等，则返回 True
• != (不等于)：如果两个值不相等，则返回 True
• > (大于)：如果第一个值大于第二个值，则返回 True
• < (小于)：如果第一个值小于第二个值，则返回 True
• >= (大于等于)：如果第一个值大于或等于第二个值，则返回 True
• <= (小于等于)：如果第一个值小于或等于第二个值，则返回 True

示例：

a = 10
b = 3
print(a == b)  # 输出: False
print(a != b)  # 输出: True
print(a > b)   # 输出: True
print(a < b)   # 输出: False
print(a >= b)  # 输出: True
print(a <= b)  # 输出: False

max() 是 Python 的内置函数，用于返回序列中的最大元素。

largest = max([1, 2, 3, 4, 5]) # 结果是 5

赋值运算符

用于将值赋给变量。

• = (赋值)：将右边的值赋给左边的变量
• += (加法赋值)：相当于 a = a + b
• -= (减法赋值)：相当于 a = a - b
• *= (乘法赋值)：相当于 a = a * b
• /= (除法赋值)：相当于 a = a / b
• %= (取模赋值)：相当于 a = a % b
• **= (幂赋值)：相当于 a = a ** b
• //= (整除赋值)：相当于 a = a // b

示例：

a = 10
b = 3
a += b  # a = a + b
print(a)  # 输出: 13
a -= b  # a = a - b
print(a)  # 输出: 10
a *= b  # a = a * b
print(a)  # 输出: 30
a /= b  # a = a / b
print(a)  # 输出: 10.0
a %= b  # a = a % b
print(a)  # 输出: 1.0
a **= b  # a = a ** b
print(a)  # 输出: 1.0
a //= b  # a = a // b
print(a)  # 输出: 0.0

注意这里变量类型发生改变

逻辑运算符

用于组合条件表达式。

1.and (与)：

• 如果 and 运算符找到一个假值，那么它返回这个假值。
• 如果所有操作数都为真，那么 and 运算符返回最后一个操作数
• 为什么找一个假值，因为他要确保整个式子都为真，所以先找假的，找到假的就不用找后面的

2.or (或)：

• 如果 or 运算符找到一个真值，那么它返回这个真值。
• 如果所有操作数都为假，那么 or 运算符返回最后一个操作数。
• 为什么找真值，因为整个式子只有一个或以上真的就可以了，所以找到真的就可以不用找后面

3.not (非)：如果表达式为真，则返回 False；如果表达式为假，则返回 True。

4.空值的表示

• 在布尔上下文中，以下值被认为是“假”的：None, False, 数值零（0, 0.0 等），空序列（'', (), [] 等），和空集合（{}, set()）。
• 其他所有值都被认为是“真”的

以下是更具体的示例：

# and 运算符示例
a = 10
b = 20
print(a and b)  # 输出: 20，因为 a 和 b 都为真，返回第二个操作数

a = 0
b = 20
print(a and b)  # 输出: 0，因为 a 为假，返回第一个为假的操作数

a = 10
b = 0
print(a and b)  # 输出: 0，因为 b 为假，返回第一个为假的操作数

# or 运算符示例
a = 10
b = 20
print(a or b)  # 输出: 10，因为 a 为真，返回第一个为真的操作数

a = 0
b = 20
print(a or b)  # 输出: 20，因为 a 为假，返回第一个为真的操作数

a = 0
b = 0
print(a or b)  # 输出: 0，因为 a 和 b 都为假，返回最后一个操作数

# not 运算符示例
a = True
print(not a)  # 输出: False，因为 a 为真

a = False
print(not a)  # 输出: True，因为 a 为假

位运算符

用于对整数类型的位进行操作。

• & (按位与)：对应位都为 1，则结果位为 1，否则为 0
• | (按位或)：对应位有一个为 1，则结果位为 1
• ^ (按位异或)：对应位不同时，结果位为 1
• ~ (按位取反)：对每个位取反
• << (左移)：将位左移指定的位数
• >> (右移)：将位右移指定的位数

示例：

a = 60  # 二进制: 0011 1100
b = 13  # 二进制: 0000 1101
print(a & b)  # 输出: 12 (二进制: 0000 1100)
print(a | b)  # 输出: 61 (二进制: 0011 1101)
print(a ^ b)  # 输出: 49 (二进制: 0011 0001)
print(~a)     # 输出: -61 (二进制: 1100 0011)
print(a << 2) # 输出: 240 (二进制: 1111 0000)
print(a >> 2) # 输出: 15 (二进制: 0000 1111)

成员运算符

用于测试序列中的成员关系。

• in：如果在指定的序列中找到值，则返回 True
• not in：如果在指定的序列中没有找到值，则返回 True

示例：

a = [1, 2, 3, 4, 5]
print(3 in a)      # 输出: True
print(6 not in a)  # 输出: True

身份运算符

用于比较对象的内存地址。

• is：如果两个变量引用同一个对象，则返回 True
• is not：如果两个变量引用不同的对象，则返回 True

示例：

a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a is b)      # 输出: True
print(a is c)      # 输出: False
print(a is not c)  # 输出: True

运算符的优先级

当一个表达式中包含多种运算符时，Python 会根据运算符的优先级来确定计算的顺序。以下是常见运算符按照优先级从高到低的顺序：

1. 括号：()，括号中的表达式具有最高的优先级，可以强制改变运算的顺序。
2. 指数运算：**，例如 2 ** 3，表示 2 的 3 次方。
3. 一元运算符：+（正号）、-（负号）、~（按位取反），例如 -x 表示负数，~x 表示按位取反。
4. 乘法、除法、取余、整除运算：*、/、%、//，例如 10 * 2、5 / 2、7 % 3、8 // 3。
5. 加法、减法运算：+、-，例如 3 + 5、7 - 2。
6. 按位左移、按位右移运算：<<、>>，例如 a << 2、b >> 1。
7. 位与运算：&，例如 a & b。
8. 位异或运算：^，例如 a ^ b。
9. 位或运算：|，例如 a | b。
10. 比较运算符：==、!=、>、<、>=、<=，例如 x > y、a == b。
11. 布尔运算符(逻辑运算符)：and、or、not，例如 x and y、a or b。逻辑运算符用于进行布尔运算，它们可以操作布尔值（True 或 False）并返回布尔值
12. 成员运算符：in、not in，例如 x in list、y not in set。
13. 身份运算符：is、is not，例如 x is None、y is not True。
14. 赋值运算符：=, +=, -=, *=, /=, %=, //=, **=, &=, |=, ^=, <<=, >>=，例如 x = 10、y += 5。

如果不确定运算符的优先级，可以使用括号来明确指定表达式的计算顺序。

算术运算符>比较运算符>逻辑运算符>赋值运算符

乘除运算符>加减运算符>比较运算符>逻辑运算符>赋值运算符，

4.差集、交集、并集

差集

**定义：**差集操作返回的是两个集合中只在一个集合中出现而在另一个集合中没有出现的元素。

即：集合独有的

在 Python 中，可以使用 - 运算符或 difference() 方法来执行差集操作。

示例：

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 使用 - 运算符执行差集操作
difference = set1 - set2
print(difference)  # 输出: {1, 2, 3}

# 使用 difference() 方法执行差集操作
difference = set1.difference(set2)
print(difference)  # 输出: {1, 2, 3}

例：字典对象的 keys（） 方法返回字典的“键”列表；values()方法，返回字典中所有的键值。

d = {‘a’: 1, ‘b’: 2}

keys = d.keys() # 结果是 dict_keys([‘a’, ‘b’])

例：d = {54:’护卫舰’ , 55:’护卫舰’ , 56:’驱逐舰’}和 b = {71 , 54 , 55}，那么表达式

d.keys() – b 的值为

# {56}

交集

**定义：**交集操作返回的是两个集合中都出现的元素。

即：集合共有的

在 Python 中，可以使用 & 运算符或 intersection() 方法来执行交集操作。

示例：

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 使用 & 运算符执行交集操作
intersection = set1 & set2
print(intersection)  # 输出: {4, 5}

# 使用 intersection() 方法执行交集操作
intersection = set1.intersection(set2)
print(intersection)  # 输出: {4, 5}

并集

**定义：**并集操作返回的是两个集合中所有的唯一元素。

即：大家都有的

在 Python 中，可以使用 | 运算符或 union() 方法来执行并集操作。

示例：

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 使用 | 运算符执行并集操作
union = set1 | set2
print(union)  # 输出: {1, 2, 3, 4, 5}

# 使用 union() 方法执行并集操作
union = set1.union(set2)
print(union)  # 输出: {1, 2, 3, 4, 5}

5.in 运算符

定义：in 运算符用于检查某个值是否存在于序列（如字符串、列表、元组、集合、字典的键）中。如果值存在于序列中，则返回 True；否则返回 False。

# 检查字符串中是否包含某个子串
string = "hello world"
print("hello" in string)  # 输出: True
print("world" in string)  # 输出: True
print("python" in string) # 输出: False

# 检查列表中是否包含某个元素
my_list = [1, 2, 3, 4, 5]
print(3 in my_list)  # 输出: True
print(6 in my_list)  # 输出: False

# 检查元组中是否包含某个元素
my_tuple = (1, 2, 3, 4, 5)
print(3 in my_tuple)  # 输出: True
print(6 in my_tuple)  # 输出: False

# 检查集合中是否包含某个元素
my_set = {1, 2, 3, 4, 5}
print(3 in my_set)  # 输出: True
print(6 in my_set)  # 输出: False

# 检查字典中是否包含某个键
my_dict = {"a": 1, "b": 2, "c": 3}
print("a" in my_dict)  # 输出: True
print("d" in my_dict)  # 输出: False

注意事项

• 对于字典，in 运算符检查的是字典的键，而不是值。
• 对于字符串，in 运算符检查的是子串是否包含在字符串中。
• 对于列表、元组、集合，in 运算符检查的是元素是否存在于序列中。

例： my_list = [1, 2, 3, 4]

# 检查列表 [2] 是否在列表 my_list 中

print([2] in my_list) # 输出 False （因为 [2] 是一个列表对象，而不是列表中的一个元素）

6.input() 函数

**定义：**input() 函数用于从标准输入（通常是键盘）读取一行文本。它的返回值总是一个字符串，即使用户输入的是数字或其他类型的值。

例：x = input() # 假设用户输入 20 并按回车键
print(type(x)) # 输出 <class 'str'>
print(x) # 输出 '20'

使用方法

# 简单的示例，获取用户输入并输出
user_input = input("请输入您的名字：")
print("您好，" + user_input + "！")

参数

input() 函数可以接受一个字符串作为参数，用于提示用户输入内容。这个字符串就是一个提示，告诉用户应该输入什么。

user_input = input("请输入一个数字：")

返回值

input() 函数返回用户输入的内容，以字符串的形式。如果需要不同的数据类型（如整数、浮点数等），则需要进行相应的类型转换。

user_input = input("请输入一个数字：")
user_input = int(user_input)  # 将用户输入的字符串转换为整数

7.len() 函数

定义：len() 函数用于返回一个序列（字符串、列表、元组等）或集合的长度或元素个数。它返回的是序列中元素的个数，或者集合中元素的数量。

使用方法

# 返回字符串的长度
my_string = "Hello, World!"
print(len(my_string))  # 输出: 13

# 返回列表的长度
my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # 输出: 5

# 返回元组的长度
my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple))  # 输出: 5

# 返回集合的长度
my_set = {1, 2, 3, 4, 5}
print(len(my_set))  # 输出: 5

# 返回字典的长度（字典的长度是指键值对的数量）
my_dict = {"a": 1, "b": 2, "c": 3}
print(len(my_dict))  # 输出: 3

注意事项

• 对于字符串，len() 函数返回字符串中字符的数量。
• 对于列表、元组、集合，len() 函数返回序列中元素的个数。
• 对于字典，len() 函数返回字典中键值对的数量（即字典中键的个数）。

len() 函数在许多情况下都很有用，特别是在需要确定序列或集合的大小时。

8.range() 函数

range() 可以有三种不同的调用方式：

1. range(stop)
2. range(start, stop)
3. range(start, stop, step)

1. range(stop)

生成从 0 到 stop（不包括 stop）的整数序列。

for i in range(5):
    print(i)

输出：

0
1
2
3
4

2. range(start, stop)

生成从 start 到 stop（不包括 stop）的整数序列。

for i in range(2, 5):
    print(i)

输出：

2
3
4

3. range(start, stop, step)

生成从 start 到 stop（不包括 stop），间隔为 step 的整数序列。如果 step 为负数，则生成递减的序列。

for i in range(1, 10, 2):
    print(i)

输出：

1
3
5
7
9

for i in range(10, 1, -2):
    print(i)

输出：

10
8
6
4
2

9.if语句区分

1. 单个 if 语句

x = 10

if x > 0:
    print("Positive")

• 功能：当条件为真时执行相应的代码块。
• 注意：如果条件不满足，代码块将被跳过。

2. if…else 语句

python复制代码x = 10

if x > 0:
    print("Positive")
else:
    print("Non-positive")

• 功能：当条件为真时执行 if 代码块，否则执行 else 代码块。
• 注意：只有两种情况。

3. if…elif…else 语句

x = 10

if x > 0:
    print("Positive")
elif x == 0:
    print("Zero")
else:
    print("Negative")

• 功能：当第一个条件为真时执行 if 代码块，否则检查下一个条件，如果所有条件都不满足，则执行 else 代码块。
• 注意：可以有多个 elif 分支，但只有一个 else 分支。
• elif 是 else if 的缩写，用于在 if 和 else 之间引入多个条件分支

4. 嵌套的 if 语句

x = 10
y = 5

if x > 0:
    if y > 0:
        print("Both x and y are positive")
    else:
        print("Only x is positive")
else:
    print("x is non-positive")

• 功能：在一个 if 代码块中嵌套另一个 if 代码块。
• 注意：嵌套的 if 语句可以有任意级别。
• 代码的可读性会变差。

10.循环结构

在 Python 中，循环结构允许您多次执行一段代码。主要的循环结构有 for 循环和 while 循环。以下是它们的介绍和示例：

1. for in循环

for 循环用于遍历可迭代对象（如列表、元组、字符串等），在每次迭代中执行一定的操作。

# 遍历列表
my_list = [1, 2, 3, 4, 5]
for num in my_list:
    print(num)

# 遍历字符串
my_string = "hello"
for char in my_string:
    print(char)

# 使用 range() 函数生成数字序列进行遍历
for i in range(5):
    print(i)

2. while 循环

while 循环在条件为真时重复执行一段代码，直到条件变为假为止。

# 使用 while 循环打印数字直到小于等于 5
x = 1
while x <= 5:
    print(x)
    x += 1

3. 循环控制语句

在循环中，有时您需要控制循环的行为，例如跳过当前迭代或提前退出循环。Python 提供了以下循环控制语句：

• break：终止循环，跳出当前循环体。
• continue：跳过当前迭代，继续下一次迭代。
• pass：在循环体中不执行任何操作，用作占位符。

# 使用 break 提前退出循环
for i in range(10):
    if i == 5:
        break
    print(i)

# 使用 continue 跳过奇数迭代
for i in range(10):
    if i % 2 != 0:
        continue
    print(i)

注意事项

• 使用 for 循环时，需要明确知道要遍历的对象的类型和结构。
• 使用 while 循环时，需要确保循环条件最终会变为假，否则可能导致无限循环。
• 在编写循环时，需要小心处理循环控制语句，以避免出现不必要的行为。

11.五道题目

1.给定一个正整数,编写程序计算有多少对质数的和等于输入这个正数,并输出结果。输入值小于 1000。

def prime_pairs_count(n):
    count = 0
    for i in range(2, n//2 + 1):
        if is_prime(i) and is_prime(n - i):
            count += 1
    return count


def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

#num ** 0.5：这部分是求给定数 num 的平方根。在判断一个数是否为质数时，只需要检查该数是否能被小于等于其平方根的数整除即可，因为如果一个数不是质数，它一定可以分解为两个因数，其中一个因数小于等于它的平方根。

#int(num ** 0.5) + 1：这部分是将平方根转换为整数，并且加 1。在 Python 中，range() 函数生成的序列不包含结束值，因此需要额外加 1，确保能够覆盖到平方根。


# 示例用法
num = int(input("请输入一个正整数："))
if num < 1000:
    pairs_count = prime_pairs_count(num)
    print("质数对的数量为:", pairs_count)
else:
    print("输入值应小于 1000")

2.编写函数 change(str),其功能是对参数 str进行大小写互换,即将字符串中的大写字母转为小写字母、小写字母转换为大写字母

def change(s):
    return s.swapcase()

# 示例用法
print(change("Hello World"))  # 输出: hELLO wORLD


def change(str):
    result = ""

    for char in str:

        if char.isalpha():

            if char.isupper():
                result += char.lower()
            if char.islower():
                result += char.upper()
    else:
        result += char
    return result
print(change("ksdjf"))

3.编写函数 digit(num,k),其功能是求整数 num 的第k位的值

def digit(num, k):
    return int(str(num)[k - 1])

# 示例用法
print(digit(12345, 3))  # 输出: 3

4.编写递归函数 fibo(n),其功能是求第n个斐波那契数列的值,进而实现将前20个斐波那契数列输出。

def fibo(n):
    if n <= 1:
        return n
    else:
        return fibo(n-1) + fibo(n-2)

# 输出前20个斐波那契数列
for i in range(20):
    print(fibo(i))

5.编写一个函数 cacluate，可以接收任意多个数,返回的是一个元组。元组的第一个值为所有参数的平均值，第二个值是小于平均值的个数。

def calculate(*args):
    if not args:
        return None, 0
    total = sum(args)
    avg = total / len(args)
    below_avg_count = sum(1 for arg in args if arg < avg)
    return avg, below_avg_count

# 示例用法
result = calculate(1, 2, 3, 4, 5)
print("平均值:", result[0])
print("小于平均值的个数:", result[1])

def calculate(*args)：函数 calculate 使用 *args 来接受任意数量的参数，参数被传递到函数中时会被封装成一个元组。

if not args:：检查是否没有传入参数。如果没有传入参数，则返回 None 和 0，分别表示没有平均值和小于平均值的个数为零。

total = sum(args)：计算所有传入参数的总和。

avg = total / len(args)：计算传入参数的平均值。这里的 len(args) 返回参数的数量

1 for arg in args if arg < avg：对于每一个小于平均值的参数，生成一个 1。

sum(...)：将所有的 1 相加，得到小于平均值的参数个数

12.random.randint()函数

random.randint(1, 100) 用于生成一个在 [1, 100] 区间上的随机整数。

13.函数的作用域

• 不同作用域中的同名变量之间互相不影响。

示例 1：局部变量和全局变量

x = 10  # 全局变量

def func():
    x = 20  # 局部变量
    print("局部变量 x:", x)

func()
print("全局变量 x:", x)

输出：

局部变量 x: 20
全局变量 x: 10

在这个例子中，全局变量 x 和局部变量 x 互不影响。函数 func 内部的 x 变量是局部的，只有在函数内部可见。而在函数外部，x 仍然指的是全局变量。

示例 2：嵌套函数中的同名变量

def outer():
    x = 5  # 外部函数的局部变量

    def inner():
        x = 10  # 内部函数的局部变量
        print("内部函数中的 x:", x)

    inner()
    print("外部函数中的 x:", x)

outer()

输出：

内部函数中的 x: 10
外部函数中的 x: 5

在这个例子中，内部函数 inner 和外部函数 outer 都定义了同名变量 x。这两个变量在不同的作用域中，互不影响。内部函数 inner 中的 x 变量只在 inner 内部可见，而外部函数 outer 中的 x 变量在整个 outer 函数内可见。

示例 3：全局变量和内建变量

len = 5  # 全局变量，覆盖内建 len 函数

def func():
    len = 10  # 局部变量
    print("局部变量 len:", len)

func()
print("全局变量 len:", len)
print("内建函数 len 被覆盖:", len([1, 2, 3]))  # 会出错，因为 len 被覆盖

输出：

局部变量 len: 10
全局变量 len: 5
TypeError: 'int' object is not callable

在这个例子中，全局变量 len 覆盖了内建的 len 函数。在函数 func 内部，len 被定义为局部变量，不影响全局变量 len。然而，当尝试调用 len 函数时，会出现错误，因为全局变量 len 覆盖了内建函数 len。

14.字典

# 创建一个字典
my_dict = {"apple": 10, "banana": 5, "orange": 8}

# 访问字典中的值
print("苹果的数量:", my_dict["apple"])  # 输出: 苹果的数量: 10

# 添加新的键值对
my_dict["grape"] = 15

# 修改键对应的值
my_dict["banana"] = 7

# 删除键值对
del my_dict["orange"]

# 检查键是否存在
if "banana" in my_dict:
    print("香蕉的数量:", my_dict["banana"])  # 输出: 香蕉的数量: 7

# 遍历字典的键
for fruit in my_dict:
    print(fruit)  # 输出: apple, banana, grape

# 遍历字典的值
for quantity in my_dict.values():
    print(quantity)  # 输出: 10, 7, 15

# 遍历字典的键值对
for fruit, quantity in my_dict.items():
    print(f"{fruit}: {quantity}")  # 输出: apple: 10, banana: 7, grape: 15

# 清空字典
my_dict.clear()
print(my_dict)  # 输出: {}

15.元组

元组（Tuple）是 Python 中的一种数据结构，类似于列表，但是元组是不可变的（immutable）。这意味着一旦创建了元组，就不能对其中的元素进行修改、添加或删除。元组用圆括号 () 来表示，其中的元素可以是任意类型的，并且可以包含重复的元素。

下面是一些关于元组的基本操作：

创建元组

# 创建一个空元组
empty_tuple = ()

# 创建一个包含元素的元组
my_tuple = (1, 2, 3, 'a', 'b', 'c')

# 创建一个只包含一个元素的元组（注意要在元素后面加上逗号）
single_element_tuple = (5,)

访问元组元素

# 使用索引访问元组元素
print(my_tuple[0])  # 输出: 1
print(my_tuple[-1])  # 输出: 'c'

元组切片

# 切片操作
print(my_tuple[2:5])  # 输出: (3, 'a', 'b')

元组不可变性

# 尝试修改元组元素会引发错误
# my_tuple[0] = 10  # TypeError: 'tuple' object does not support item assignment

遍历元组

# 使用循环遍历元组
for item in my_tuple:
    print(item)

元组拆包

# 元组拆包
a, b, c = my_tuple[:3]
print(a, b, c)  # 输出: 1 2 3

元组在不希望数据被修改的情况下非常有用，例如用来存储固定的数据集合，或者作为函数的返回值来返回多个值

• 列表是有序的对象集合，字典则是无序的键值对集合。（列表和字典最大的区别）

16.空值

空字符串、空列表、空元组、空字典、空集合以及任意形式的数字 0 都等价于 False。

17.查找元素的位置

• 字符串对应find方法
• 列表对应index方法

1.find 方法是字符串对象的方法，用于查找子字符串在字符串中的位置。

例：
s = "hello"

index = s.find("e")

print(index) # 输出 1

2.对于列表，Python 使用 in 操作符来检查元素是否存在。

例：

x = [1, 2, 3, 4]

print(5 in x) # 输出 False

3.如果要查找列表中元素的位置，可以使用 index 方法，例如：

x = [1, 2, 3, 4]

index = x.index(2)

print(index) # 输出 1

例：已知列表 x = [1, 2, 3, 4]，那么表达式 x.find(3) 的值应为（ ）

A. True

B. False C. [2]

D. [1, 2, 3, 4]

因为 x.find(3) 会引发错误，因为列表对象没有 find 方法，所以选项 B (False) 。

18.异常处理

在 Python 中，try...except...else 是一种异常处理的结构。它的语法如下：

try:
    # 可能会引发异常的代码块
    # 如果这里的代码执行出现异常，会跳转到 except 代码块
    # 如果没有异常，则会执行 else 代码块
except ExceptionType1:
    # 异常类型为 ExceptionType1 时的处理代码
except ExceptionType2:
    # 异常类型为 ExceptionType2 时的处理代码
...
else:
    # 当 try 代码块中的代码没有抛出任何异常时执行的代码

try...except...else 的基本思想是：尝试执行可能引发异常的代码块（try），如果没有异常发生，则执行 else 块中的代码。如果有异常发生，则跳转到与异常类型匹配的 except 块中执行相应的异常处理代码。

下面是一个简单的示例，演示了 try...except...else 的使用：

try:
    x = int(input("请输入一个整数："))
except ValueError:
    print("输入不是整数！")
else:
    print("输入的整数是:", x)

在这个示例中：

• try 块尝试将用户输入的内容转换为整数。
• 如果用户输入的内容无法转换为整数，则会引发 ValueError 异常，并跳转到相应的 except 块中进行处理。
• 如果用户输入的内容可以成功转换为整数，则会执行 else 块中的代码。

19.list() 函数

list() 函数是 Python 内置函数之一，用于将可迭代对象（iterable）转换为列表。可迭代对象包括序列（如元组、字符串、列表等）和迭代器（如生成器）。list() 函数的语法如下：

list(iterable)

其中，iterable 是要转换为列表的可迭代对象。

下面是一些使用 list() 函数的示例：

示例 1：将元组转换为列表

my_tuple = (1, 2, 3, 4)
my_list = list(my_tuple)
print(my_list)  # 输出: [1, 2, 3, 4]

示例 2：将字符串转换为列表

my_string = "hello"
my_list = list(my_string)
print(my_list)  # 输出: ['h', 'e', 'l', 'l', 'o']

示例 3：将生成器转换为列表

my_generator = (x ** 2 for x in range(5))
my_list = list(my_generator)
print(my_list)  # 输出: [0, 1, 4, 9, 16]

示例 4：将集合转换为列表

my_set = {1, 2, 3, 4}
my_list = list(my_set)
print(my_list)  # 输出: [1, 2, 3, 4]

示例 5：将范围转换为列表

r = range(5)
lst = list(r)
print(lst) # 输出 [0, 1, 2, 3, 4]

list() 函数的作用是创建一个新的列表对象，并将可迭代对象中的元素逐个添加到列表中。如果不传递任何参数给 list() 函数，它将返回一个空列表 []。

20.global 关键字

在 Python 中，global 是一个关键字，用于在函数内部声明一个变量是全局变量，即在函数外部定义的变量。这意味着在函数内部使用 global 关键字声明的变量，可以在函数内部进行修改，并且修改后的值将影响到全局作用域中该变量的值。

global 关键字的语法如下：

global variable_name1, variable_name2, ...

其中 variable_name1, variable_name2, … 是要声明为全局变量的变量名，可以是多个变量，用逗号分隔。

以下是一个简单的示例，演示了 global 关键字的使用：

x = 10  # 全局变量

def modify_global():
    global x  # 声明 x 是全局变量
    x = 20

modify_global()
print(x)  # 输出: 20

在这个示例中：

• 函数 modify_global 内部使用 global x 声明了变量 x 是全局变量。
• 在函数内部，修改了全局变量 x 的值为 20。
• 在函数外部打印 x 的值，得到的是修改后的值 20。

需要注意的是，在函数内部使用 global 声明的变量名必须在函数外部已经定义过，否则会引发 NameError 异常。

虽然使用 global 可以在函数内部修改全局变量的值，但是过度使用 global 可能会导致程序结构不清晰、难以维护。通常情况下，尽量避免使用 global 关键字，而是通过函数的参数和返回值来传递数据。

21.open() 函数

open() 函数是 Python 中用于打开文件的内置函数。它的主要作用是创建一个文件对象，以便对文件进行读取、写入或追加等操作。open() 函数的语法如下：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明：

• file：要打开的文件名（包括路径）或文件描述符（在某些系统中）。
• mode：打开文件的模式，如 'r'（只读，默认）、'w'（写入，如果文件存在则覆盖）、'a'（追加，如果文件存在则在末尾添加）等。
• buffering：设置缓冲策略，-1 表示使用系统默认的缓冲策略，0 表示不进行缓冲，1 或更大值表示缓冲区大小。
• encoding：指定文件编码，默认为 None，表示使用系统默认编码。
• errors：指定编码错误的处理方式，默认为 None。
• newline：指定换行符的处理方式，只在文本模式下有效。
• closefd：在打开文件时是否同时关闭文件描述符。
• opener：用于打开文件的自定义函数，通常不需要指定。

open() 函数返回一个文件对象，可以通过该对象来操作文件。通常，我们在使用完文件后应该调用文件对象的 close() 方法来关闭文件，以释放系统资源。

以下是几个使用 open() 函数的示例：

示例 1：读取文件内容

with open('example.txt', 'r') as f:
    content = f.read()
    print(content)

示例 2：写入文件内容

with open('example.txt', 'w') as f:
    f.write('Hello, world!')

示例 3：追加内容到文件末尾

with open('example.txt', 'a') as f:
    f.write('\nAppending new line.')

在使用 open() 函数时，应该注意文件的打开模式、编码以及错误处理方式，以确保正确地操作文件并处理可能出现的异常情况。

22.默认参数

在 Python 中，定义函数时可以为参数提供默认值。如果函数调用时没有提供对应参数的值，则使用默认值。下面是一个简单的例子：

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

# 调用函数，不指定 greeting 参数，默认使用 "Hello"
greet("Alice")  # 输出: Hello, Alice!

# 指定了 greeting 参数值为 "Hi"
greet("Bob", greeting="Hi")  # 输出: Hi, Bob!

在这个例子中，greet() 函数定义了一个默认参数 greeting，默认值为 "Hello"。在第一个函数调用中，只提供了 name 参数的值，因此 greeting 使用默认值 "Hello"。在第二个函数调用中，显式地指定了 greeting 参数的值为 "Hi"，因此会使用提供的值。

默认参数的使用使得函数在大多数情况下都能够工作，同时也保留了一定的灵活性，允许函数调用者根据需要覆盖默认值。

23.Enumerate（）函数

enumerate() 是 Python 中的一个内置函数，用于同时遍历列表等可迭代对象的索引和元素。它返回一个由索引-元素对组成的迭代器。enumerate() 函数的语法如下：

enumerate(iterable, start=0)

参数说明：

• iterable：要枚举的可迭代对象，如列表、元组、字符串等。
• start：可选参数，指定开始计数的值，默认为 0。

以下是一个示例，演示了如何使用 enumerate() 函数：

my_list = ['apple', 'banana', 'orange']

for index, value in enumerate(my_list):
    print(f"Index: {index}, Value: {value}")

输出：

Index: 0, Value: apple
Index: 1, Value: banana
Index: 2, Value: orange

在这个示例中，enumerate() 函数用于遍历列表 my_list，返回的迭代器包含了每个元素的索引和值。然后，在 for 循环中，通过解包将索引和值分别赋给变量 index 和 value，并进行打印。

需要注意的是，enumerate() 函数默认从索引 0 开始计数，但你也可以通过指定 start 参数来改变开始计数的值。例如：

my_list = ['apple', 'banana', 'orange']

for index, value in enumerate(my_list, start=1):
    print(f"Index: {index}, Value: {value}")

输出：

Index: 1, Value: apple
Index: 2, Value: banana
Index: 3, Value: orange

在这个示例中，指定了 start=1，因此索引从 1 开始计数。

24.列表元素的排素

Python 提供了 sorted() 函数和列表对象的 sort() 方法来实现排序。这两种方法都可以按照指定的顺序对列表进行排序，包括升序和降序。

使用 sorted() 函数

sorted() 函数返回一个新的已排序的列表，不会修改原始列表。

my_list = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_list = sorted(my_list)  # 升序排序
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

如果需要降序排序，可以通过传递 reverse=True 参数实现：

sorted_list_reverse = sorted(my_list, reverse=True)  # 降序排序
print(sorted_list_reverse)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

使用 sort() 方法

sort() 方法会就地修改原始列表，并返回 None。

my_list = [3, 1, 4, 1, 5, 9, 2, 6]
my_list.sort()  # 升序排序
print(my_list)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

同样地，可以通过传递 reverse=True 参数实现降序排序：

my_list = [3, 1, 4, 1, 5, 9, 2, 6]
my_list.sort(reverse=True)  # 降序排序
print(my_list)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

这两种方法都可以实现对列表元素的排序，具体使用哪种取决于需求：是否需要修改原列表以及是否需要返回新的排序列表。

25.创建类、属性、方法

在Python中，类（Class）是面向对象编程的基础，用于定义对象的属性和行为。属性（Attributes）是类中的变量，用来存储对象的状态。方法（Methods）是类中的函数，用来定义对象的行为。

以下是一个创建类、属性和方法的基本示例：

1. 定义一个类

要定义一个类，可以使用class关键字。

class Person:
    pass

2. 添加属性

属性可以在类的初始化方法（__init__）中定义。__init__方法在创建类的实例时被自动调用。

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

3. 添加方法

方法是定义在类中的函数。第一个参数通常是self，它指代当前实例。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

4. 创建类的实例

你可以通过调用类的名称并传递参数来创建类的实例。

person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

5. 访问属性和方法

你可以通过点号（.）访问实例的属性和方法。

print(person1.name)  # 输出: Alice
print(person1.age)   # 输出: 30

person1.greet()      # 输出: Hello, my name is Alice and I am 30 years old.
person2.greet()      # 输出: Hello, my name is Bob and I am 25 years old.

26.私有公有

• 公共属性和方法：没有下划线前缀，可以从类外部直接访问。
• 受保护的属性和方法：单个下划线前缀，应只在类内部或子类中访问。
• 私有属性和方法：双下划线前缀，不能从类外部直接访问（但可以通过名称改编访问）。

公共属性和方法

默认情况下，Python中的所有属性和方法都是公共的，即可以从类的外部访问。

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

    def greet(self):        # 公共方法
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

person = Person("Alice", 30)
print(person.name)         # 访问公共属性
person.greet()             # 调用公共方法

私有属性和方法

在Python中，通过在属性或方法名前加上双下划线（__）可以将其定义为私有的。私有属性和方法只能在类的内部访问，不能从类的外部直接访问。

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    def __secret(self):     # 私有方法
        print("This is a secret method.")

    def greet(self):        # 公共方法
        print(f"Hello, my name is {self.__name} and I am {self.__age} years old.")
        self.__secret()     # 类内部可以访问私有方法

person = Person("Alice", 30)
# print(person.__name)     # 试图访问私有属性，会引发AttributeError
person.greet()             # 通过公共方法间接访问私有属性和方法

虽然不能直接访问私有属性和方法，但可以通过“名称改编”（name mangling）来访问它们：

print(person._Person__name)  # 访问私有属性
person._Person__secret()     # 调用私有方法

受保护的属性和方法

在Python中，还有一个约定用于表示受保护的属性和方法，即在名称前加一个下划线（_）。受保护的属性和方法可以被子类访问，但不应从类的外部直接访问。这是一种弱访问控制机制，主要是提醒程序员这些属性和方法不应该在外部使用。

class Person:
    def __init__(self, name, age):
        self._name = name   # 受保护的属性
        self._age = age     # 受保护的属性

    def _protected_method(self):  # 受保护的方法
        print("This is a protected method.")

    def greet(self):             # 公共方法
        print(f"Hello, my name is {self._name} and I am {self._age} years old.")
        self._protected_method() # 类内部可以访问受保护的方法

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

    def show_id(self):
        print(f"Student ID: {self.student_id}")
        self._protected_method()  # 子类可以访问受保护的方法

student = Student("Bob", 21, "S12345")
student.greet()                 # 调用继承的方法
student.show_id()               # 调用子类的方法

双下划线方法

在Python中，双下划线前后加上下划线的形式（如__init__）被称为“双下划线方法”或“魔术方法”（magic methods）。这些方法在Python中有特殊的含义和用途，主要用于实现某些内置的行为和协议。以下是一些关键点：

魔术方法（Magic Methods）

• __init__方法：这是一个特殊的方法，称为构造方法。它在创建对象时被自动调用，用于初始化对象的属性。
• __str__方法：用于定义对象的字符串表示，当使用print函数或str()函数时调用。
• __len__方法：定义了当使用len()函数时的行为。
• __getitem__方法：定义了当使用索引操作时的行为。

这些方法之所以以双下划线开头和结尾，是为了与用户定义的方法区分开来，并防止命名冲突。

27.函数的参数

在Python中，函数参数可以有多种形式，每种形式有不同的用途和特点。以下是Python函数参数的主要类型及其用法：

1. 位置参数 (Positional Arguments)

这是最常见的参数类型，通过参数的位置来传递值。

def greet(name, age):
    print(f"Hello, my name is {name} and I am {age} years old.")

greet("Alice", 30)  # 位置参数

2. 关键字参数 (Keyword Arguments)

通过参数名称传递值，这使得调用函数时参数的顺序可以任意。

greet(age=30, name="Alice")  # 关键字参数

3. 默认参数 (Default Arguments)

函数定义时可以为参数提供默认值，这样在调用函数时可以选择性地传递这些参数。

def greet(name, age=25):
    print(f"Hello, my name is {name} and I am {age} years old.")

greet("Alice")        # 使用默认参数age=25
greet("Bob", 30)      # 覆盖默认参数

4. 可变参数 (Variable-Length Arguments)

可以使用*args和**kwargs来定义可变数量的参数。

*args (Non-keyword variable arguments)

用于传递任意数量的位置参数，函数内部接收到的是一个元组。

def greet(*names):
    for name in names:
        print(f"Hello, {name}!")

greet("Alice", "Bob", "Charlie")  # 传递多个位置参数

**kwargs (Keyword variable arguments)

用于传递任意数量的关键字参数，函数内部接收到的是一个字典。

def greet(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

greet(name="Alice", age=30, city="New York")  # 传递多个关键字参数

5. 强制关键字参数 (Keyword-Only Arguments)

在函数定义中使用*，强制要求某些参数必须以关键字方式传递。

def greet(name, *, age=25, city="Unknown"):
    print(f"Hello, my name is {name}. I am {age} years old and I live in {city}.")

greet("Alice", age=30, city="New York")  # 强制关键字参数

6. 类型提示 (Type Hints)

Python还支持在函数定义中使用类型提示，以提高代码的可读性和可维护性。类型提示并不会影响代码的运行，只是作为一种文档说明。

def greet(name: str, age: int = 25) -> None:
    print(f"Hello, my name is {name} and I am {age} years old.")

greet("Alice", 30)  # 使用类型提示

参数综合示例

以下是一个综合使用各种参数类型的示例：

def func(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2="default"):
    print(f"pos1: {pos1}, pos2: {pos2}")
    print(f"pos_or_kwd: {pos_or_kwd}")
    print(f"kwd1: {kwd1}, kwd2: {kwd2}")

func(1, 2, 3, kwd1="value1")  # 综合使用位置参数和关键字参数

在这个例子中：

• pos1 和 pos2 是仅限位置参数（使用/分隔）。
• pos_or_kwd 是位置或关键字参数。
• kwd1 和 kwd2 是仅限关键字参数（使用*分隔）。

s = input("shuru")
shuzi,daxie,xiaoxie,kongge,qita = 0,0,0,0,0

for i in range(len(s)):
    if s[i].isdigit():
        shuzi += 1
    elif s[i].islower():
        daxie += 1
    elif s[i].isupper():
        xiaoxie += 1
    elif s[i].isspace():
        kongge += 1
    else:
        qita += 1
print("shuzi%d\ndaxie%d\nxiaoxie%d\nkongge%d\nqita%d\n"%(shuzi,daxie,xiaoxie,kongge,qita))


s = input("shuru")
shuzi,daxie,xiaoxie,kongge,qita = 0,0,0,0,0

for i in s:
    if i >= '0' and i <= '9':
        shuzi += 1
    elif i >= 'A' and i <= 'Z':
        daxie += 1
    elif i >= 'a' and i <= 'z':
        xiaoxie += 1
    elif i == ' ':
        kongge += 1
    else:
        qita += 1
print("shuzi%d\ndaxie%d\nxiaoxie%d\nkongge%d\nqita%d\n"%(shuzi,daxie,xiaoxie,kongge,qita))


sum = 0
for i in range(1,21):
    fact = 1
    for p in range(1,i+1):
        fact = fact*p
    sum += fact
print(sum)


import random

# 生成一个包含 10 个随机数的列表
random_list = [random.randint(1, 100) for _ in range(10)]

# 对前 5 个元素进行降序排列
first_half_sorted = sorted(random_list[:5], reverse=True)

# 对后 5 个元素进行升序排列
second_half_sorted = sorted(random_list[5:])

# 合并两个排序后的子列表
sorted_list = first_half_sorted + second_half_sorted

# 输出结果
print("原始列表:", random_list)
print("前 5 个元素降序排列，后 5 个元素升序排列:", sorted_list)