Python入门笔记

简介

       最近我开始学习Python编程语言，因为我有C语言的基础，所以在学习过程中发现两者有很多相似之处。为了更好地掌握Python，我打算写一份学习笔记，并且会结合C语言的知识进行对比学习。

一.Python中的变量

       在Python中，变量本身确实没有类型，但变量所引用的对象（或值）是有类型的。Python是一种动态类型语言，这意味着变量的类型是在运行时根据赋给它的值来确定的，而不是在编写代码时静态声明的。因为Python提供了多种内置类型，如整数（int）、浮点数（float）、字符串（str）、列表（list）、元组（tuple）、字典（dict）等，以及用户可以自定义的类型（通过类和函数）。

x = 10  # x现在是一个整数  
x = "Hello"  # 现在x是一个字符串

整数	可以为任意大小、包含负数
浮点数	小数
字符串	以单引号 '、双引号"、三引号 ''' 或 """括起来的文本
布尔	True、False 两种值
空值	用 None 表示
变量	可变的
常量	不可变

---

       而在c语言中，C语言是静态类型语言，意味着变量在声明时必须指定其类型，并且在整个生命周期内，变量的类型不能改变。正因为是静态的类型，所以c语言在使用的时候需要声明变量的类型。

二.Python中的字符串   

       字符串是一种基本的数据类型，在Python中用引号括起来的都是字符串。（引号可以是单引号也可以是双引号）同时Python的字符串是以Unicode编码存储的。Python和C语言中的字符串在多个方面存在显著的区别。这些区别主要源于两种语言的设计理念、内存管理以及内置功能的差异。

"字符串"
'字符串'

 1.Python中字符串的编码

        Python2 中默认编码为 ASCII，假如内容为汉字，不指定编码便不能正确的输出及读取，比如我们想要指定编码为 UTF-8，Python 中通过在开头加入 # -*- coding: UTF-8 -*- 进行指定。

        Python3 中默认编码为 UTF-8，因此在使用 Python3 时，我们通常不需指定编码。

---

2.Python中字符串的内置函数

        看这篇文章：【python基础】python中常用字符串函数详解_python 字符串函数-CSDN博客

---

3.Python中字符串中使用变量

        字符串中使用变量的值。在这里我们使用两个变量表示名和姓，将这两个值合并显示姓名。

first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print{full_name}

ada lovelace

注意：在上面的示例里面我们看见前引号前加上了字母f，然后再将要插入的变量放在花括号里面。此时当Python显示字符串时，就会把每个变量替换为它的值。

---

最后,我们这里看一下不加f会怎么样:如果你不使用f前缀来定义字符串，并且尝试在其中嵌入大括号{}中的表达式，那么这些大括号和其中的内容将会被当作普通字符串的一部分来处理，而不会被当作需要被替换或计算的表达式。

name = "Alice"  
age = 30  
# 不使用f-string  
greeting = "Hello, {name}. You are {age} years old."  
print(greeting)

Hello, {name}. You are {age} years old.

4.Python中字符串中添加空白和删除空白

添加空白

在编程中，空白指任何非打印字符，如空格，制表符和换行符。

        在字符串里面添加制表符，可以使用字符组合\t.

>>>print("Python")
Python
>>>print("\tPython")
    Python

        在字符串里面添加换行符，可以使用字符组合\n.

>>>print("Languages:\nPython\nC\nJavaScript")
Languages:
Python
C
JavaScript

---

删除空白

strip()——删除字符串开头和结尾的所有空格

lstrip()——删除字符串开头的空格

rstrip()——删除字符串结尾的空格

s = "   Hello, World!   "  
print(s.strip())  # 输出: "Hello, World!"

s = "   Hello, World!   "  
print(s.lstrip())  # 输出: "Hello, World!   "

s = "   Hello, World!   "  
print(s.rstrip())  # 输出: "   Hello, World!"

三.Python中的运算符

常用的运算符

运算符	描述	示例
+	相加	a + b
-	相减	a - b
*	相乘	a * b
/	相除	a / b
%	取模	a % b
**	幂	a**b 表示 a 的 b 次幂
//	取整除	9 // 4 结果为 2
==	是否相等	a == b
!=	是否不等于	a != b
>	是否大于	a > b
>=	是否大于等于	a >= b
<=	是否小于等于	a <= b
=	简单的赋值运算符	a = b + c
+=	加法赋值运算符	a += b 等效于 a = a + b
-=	减法赋值运算符	a -= b 等效于 a = a - b
*=	乘法赋值运算符	a *= b 等效于 a = a * b
/=	除法赋值运算符	a /= b 等效于 a = a / b
%=	取模赋值运算符	a %= b 等效于 a = a % b
**=	幂赋值运算符	a **= b 等效于 a = a ** b
//=	取整除赋值运算符	a //= b 等效于 a = a // b
&	与	a & b
|	或	a | b
^	异或	a ^ b
~	取反	~a
<<	左移动	a << 3
>>	右移动	a >> 3
and	布尔类型与	a and b
or	布尔类型或	a or b
not	布尔类型非	not a
is	判断两个标识符是否引用同一个对象	a is b
is not	判断两个标识符是否引用不同对象	a is not b

---

运算符优先级

运算符	描述（由上至下对应优先级由高到低）
**	幂运算
~ + -	取反、正号、负号
* / % //	乘、除、取模、取整除
+ -	加法、减法
>> <<	右移、左移
&	与
^ |	异或、或
<= < > >=	比较运算符
== !=	是否等于、是否不等于
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

四.Python中的注释

单行注释

# 我是单行注释

多行注释

'''
我是多行注释
我是多行注释
'''

"""
我是多行注释
我是多行注释
"""

五.Python中的列表

        Python中的列表（List）是一种非常灵活的数据结构，用于存储一系列有序的项目（称为元素）。列表是Python中最常用的数据结构之一，它可以包含不同类型的元素，如整数、浮点数、字符串、甚至其他列表（即列表的嵌套）。

创建列表

可以使用方括号 [] 来创建列表，元素之间用逗号 , 分隔。

# 创建一个包含不同类型元素的列表  
my_list = [1, 2.5, "Hello", [1, 2, 3]]  
print(my_list)

---

访问列表元素

可以通过索引（从0开始的数字）来访问列表中的元素。

# 访问第一个元素  
print(my_list[0])  # 输出: 1  
  
# 访问最后一个元素（索引为-1）  
print(my_list[-1])  # 输出: [1, 2, 3]

---

修改列表

可以通过索引来修改列表中的元素。

# 修改第一个元素  
my_list[0] = 10  
print(my_list)  # 输出: [10, 2.5, 'Hello', [1, 2, 3]]

---

添加和删除元素

• 使用 append() 方法在列表末尾添加元素。
• 使用 insert(index, element) 方法在指定索引处插入元素。
• 使用 remove(element) 方法删除列表中首次出现的指定元素。
• 使用 del 语句删除指定索引的元素或删除整个列表。
• 使用 pop([index]) 方法删除并返回指定索引的元素（如果不指定索引，则默认为最后一个元素）。

# 在列表末尾添加元素  
my_list.append(4)  
print(my_list)  # 输出: [10, 2.5, 'Hello', [1, 2, 3], 4]  
  
# 在索引1处插入元素  
my_list.insert(1, "World")  
print(my_list)  # 输出: [10, 'World', 2.5, 'Hello', [1, 2, 3], 4]  
  
# 删除首次出现的指定元素  
my_list.remove("Hello")  
print(my_list)  # 输出: [10, 'World', 2.5, [1, 2, 3], 4]  
  
# 使用del删除指定索引的元素  
del my_list[1]  
print(my_list)  # 输出: [10, 2.5, [1, 2, 3], 4]  
  
# 使用pop删除并返回最后一个元素  
last_element = my_list.pop()  
print(last_element)  # 输出: 4  
print(my_list)  # 输出: [10, 2.5, [1, 2, 3]]

---

列表切片

可以使用切片语法来访问列表的一部分。

# 访问第2个到第4个元素（注意切片包含起始索引，不包含结束索引）  
print(my_list[1:4])  # 输出: [2.5, [1, 2, 3]]  
  
# 访问从第2个元素到列表末尾的所有元素  
print(my_list[1:])  # 输出: [2.5, [1, 2, 3]]  
  
# 访问从列表开始到第3个元素的所有元素  
print(my_list[:3])  # 输出: [10, 2.5, [1, 2, 3]]

---

列表推导式

列表推导式提供了一种简洁的方法来创建列表。

# 使用列表推导式创建平方数的列表  
squares = [x**2 for x in range(1, 6)]  
print(squares)  # 输出: [1, 4, 9, 16, 25]

range()函数：

range() 函数是 Python 中的一个内置函数，用于生成一个可迭代的数字序列，通常用于在 for 循环中。这个函数返回一个表示等差数列的 range 对象，但它本身不直接显示数字列表，而是在迭代时按顺序逐个产生数字。 

range() 函数的基本语法如下：

range(start, stop[, step])

• start（可选）: 序列的起始值，默认为 0。
• stop: 序列的结束值，但不包括这个值本身。
• step（可选）: 两个值之间的间隔，默认为 1。

生成 0 到 4 的整数序列（不包括 4） 

for i in range(5):  
    print(i)  
# 输出:  
# 0  
# 1  
# 2  
# 3  
# 4

 生成 2 到 8 的整数序列（不包括 8），步长为 2

for i in range(2, 9, 2):  
    print(i)  
# 输出:  
# 2  
# 4  
# 6  
# 8

---

列表的内置方法

Python的列表类型提供了许多内置方法，如 len()（获取列表长度）、sorted()（对列表进行排序，返回新列表）、reverse()（反转列表中的元素，原地修改）等。

# 列表的内置方法示例  
my_list = [3, 1, 4, 1, 5, 9, 2]  
  
# 反转列表  
my_list.reverse()  
print(my_list)  # 输出: [2, 9, 5, 1, 4, 1, 3]  
  
# 对列表进行排序（就地修改）  
my_list.sort()  
print(my_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]  
  
# 使用sorted()函数（不修改原列表）  
sorted_list = sorted(my_list, reverse=True)  
print(sorted_list)  # 输出: [9, 5, 4, 3, 2, 1]  
print(my_list)  # 输出: [1, 2, 3, 4, 5, 9]（原列表未变）

#确定列表的长度
len(my_list)

六.Python中的基本语句

1.条件语句

        条件语句允许程序根据条件（如比较或逻辑运算的结果）来执行不同的代码块。Python 中的条件语句主要有 if、elif（else if 的缩写）、和 else。

if x > 5:  
    print("x is greater than 5")  
elif x == 5:  
    print("x is equal to 5")  
else:  
    print("x is less than 5")

---

2.循环语句

        循环语句允许程序重复执行一段代码块直到满足特定条件。Python 中的循环语句主要有 for 和 while。

For 循环

for 循环用于遍历任何序列（如列表、元组或字符串）或其他可迭代对象。

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

While 循环

while 循环在给定条件为真时重复执行代码块。

x = 0  
while x < 5:  
    print(x)  
    x += 1

---

输入输出语句

Python 提供了内置的输入输出功能。

输入

使用 input() 函数从用户那里获取输入。

name = input("Enter your name: ")  
print("Hello, " + name + "!")

输出

使用 print() 函数向标准输出（通常是屏幕）打印信息。

print("Hello, World!")

---

导入语句

导入语句用于在 Python 文件中导入模块或模块中的特定函数、类等。

import math  
  
# 使用 math 模块中的 sqrt 函数  
print(math.sqrt(16))  
  
# 也可以只导入模块中的特定部分  
from math import sqrt  
  
print(sqrt(16))

---

表达式语句

Python 中的表达式语句通常指的是那些包含赋值、算术运算、比较运算等表达式的语句。它们可以是简单的也可以是复杂的。

# 简单的表达式语句  
a = 5 + 3  
  
# 复杂的表达式语句，结合了条件语句  
b = 10 if a > 5 else 0

---

break语句 

break 用在 for 循环和 while 循环语句中，用来终止整个循环。

str = 'Python'
for s in str:
    if s == 'o':
        break
    print(s)

P
y
t
h

---

continue语句 

        continue 用在 for 循环和 while 循环语句中，用来终止本次循环。

str = 'Python'
for s in str:
    if s == 'o':
        continue
    print(s)

P
y
t
h
n

---

pass语句

        pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性。

if True:
    pass

七.Python中的元组

        Python中的元组（Tuple）是一种内置的数据结构，用于存储不可变序列的数据项。元组一旦创建，就不能更改其内部元素的值（尽管可以更改元组中可变对象的内部状态，但不能将元组中的一个元素替换为另一个元素）。这使得元组成为一种用于存储数据集合的好方法，尤其是当你想要保护数据不被意外修改时。

创建元组

        元组可以通过在圆括号()中放置一系列逗号分隔的值来创建。如果元组只有一个元素，你需要在该元素后面加上逗号,，以区分它是元组而不是一个被圆括号包围的普通表达式。

# 创建一个空元组  
empty_tuple = ()  
  
# 创建一个包含多个元素的元组  
numbers = (1, 2, 3, 4, 5)  
  
# 创建一个只有一个元素的元组  
single_element = (42,)

---

访问元组元素

        可以使用索引（下标）来访问元组中的元素，索引从0开始。如果尝试访问不存在的索引，Python会抛出一个IndexError。

numbers = (1, 2, 3, 4, 5)  
print(numbers[0])  # 输出: 1  
print(numbers[4])  # 输出: 5  
  
# 尝试访问超出范围的索引  
# print(numbers[5])  # 这会引发 IndexError

---

元组的不可变性

        由于元组是不可变的，你不能像列表（List）那样直接修改元组中的元素。但是，如果元组中包含可变对象（如列表），那么你可以修改这些可变对象的内部状态。

# 创建一个包含列表的元组  
my_tuple = (1, 2, [3, 4], 5)  
  
# 修改元组中列表的内容  
my_tuple[2].append(6)  
print(my_tuple)  # 输出: (1, 2, [3, 4, 6], 5)  
  
# 但不能直接将元组中的一个元素替换为另一个元素  
# my_tuple[2] = [3, 4, 6, 7]  # 这会引发 TypeError

八.Python中的字典

        Python中的字典（dictionary）是一种非常灵活且强大的数据结构，用于存储键值对（key-value pairs）。在字典中，每个键（key）都是唯一的，而值（value）可以是任何数据类型，包括另一个字典。这使得字典成为存储复杂数据结构的理想选择。

创建字典

可以使用花括号{}来创建字典，键和值之间用冒号:分隔，而键值对之间用逗号,分隔。

# 创建一个简单的字典  
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}  
  
# 打印字典  
print(my_dict)

---

访问字典中的值

        可以通过键来访问字典中的值。如果键不存在，Python会抛出一个KeyError。为了避免这种情况，你可以使用get()方法，它允许你指定一个默认值，如果键不存在则返回这个默认值。

# 访问值  
print(my_dict['name'])  # 输出: John  
  
# 使用get方法访问值，如果键不存在，则返回None（或你指定的任何默认值）  
print(my_dict.get('email', 'No email provided'))  # 输出: No email provided

---

修改字典

        可以通过指定键来修改字典中的值。如果键不存在，则这个键会被添加到字典中。

# 修改值  
my_dict['age'] = 31  
  
# 添加新键值对  
my_dict['email'] = 'john@example.com'  
  
print(my_dict)

---

删除字典中的项

        可以使用del语句或pop()方法来删除字典中的项。del会删除指定的项，而pop()会删除指定的项并返回其值。

# 使用del删除项  
del my_dict['city']  
  
# 使用pop()删除项并返回其值  
email = my_dict.pop('email', 'Not found')  # 如果键不存在，pop()返回第二个参数作为默认值  
  
print(my_dict)  
print(email)  # 输出: john@example.com

---

遍历字典

可以遍历字典的键、值或键值对。

# 遍历键  
for key in my_dict:  
    print(key)  
  
# 遍历值  
for value in my_dict.values():  
    print(value)  
  
# 遍历键值对  
for key, value in my_dict.items():  
    print(f"{key}: {value}")

---

字典嵌套

1.字典列表

        首先，我们有三个字典元素。

person_1={'name':'zhangsan','age':18}
person_2={'name':'lisi','age':19}
person_3={'name':'wangwu','age':18}

        然后，这四个字典存储在列表中。

persons={person_1,person_2,person_3}

        最后，遍历输出它们。

for person in persons:
    print(persons)

        结果：

{'name':'zhangsan','age':18}
{'name':'lisi','age':19}
{'name':'wangwu','age':18}

2.在字典中存储列表

        我们创建一个字典，字典的第二个键的值为一个列表。

person={
        'name':'lisi',
        'cities':['xian','hefei','luoyang']
        }

        遍历输出它们.

for city in person['cities']:
    print(city)

        结果：

xian
hefei
luoyang

3.在字典中存储字典

        这里我们在字典里面存储两个字典。

users={'zhangsan':{'first':'xian',
                   'second':'luoyang'
                    },
       'lisi':{'first':'suzhou',
               'second:'wuxi'
                }
}

        遍历输出它们。

for name infor in users.items():
    print('name:':+name)
    print('cities:'+infor['first']+''+infor['second'])

        结果：

name: zhangsan
cities: xian louyang
name: lisi
cities: suzhou wuxi

九.Python中的函数

1.常用函数

print()函数

   print函数是一个非常基础且常用的内置函数，用于在控制台或终端输出信息。它可以输出字符串、数字、变量的值或者更复杂的数据结构。

基本用法

print("Hello, world!")

输出多个值

print("Hello,", "world!", "Python is fun.")

使用sep和end参数

• sep参数用于定义多个值之间的分隔符，默认是一个空格。
• end参数用于定义输出之后的结束字符，默认是换行符\n。

print("Hello,", "world!", "Python is fun.", sep="-")  
print("This is the end", end="!")  
print(" Really?")

 输出到文件

虽然print函数默认输出到控制台，但你也可以通过file参数将输出重定向到文件中。

with open("output.txt", "w") as f:  
    print("Hello, file!", file=f)

---

input函数

        input函数是一个内置函数，用于从用户那里获取输入。当用户执行包含input函数的程序时，程序会暂停执行，并等待用户在控制台或终端中输入一些文本。用户输入文本后，按下回车键，程序会继续执行，input函数会返回用户输入的文本字符串。

user_input = input("Please enter some text: ")  
print("You entered:", user_input)

        程序会输出提示信息“Please enter some text: ”，然后等待用户输入。用户输入文本并按下回车键后，输入的文本会被赋值给变量user_input，然后程序会继续执行，输出用户输入的文本。

---

 int函数

int函数是一个内置函数，用于将一个数值或字符串转换成整数。在使用函数input()时，Python将用户输入解读为字符串。如果参数已经是一个整数，int函数会返回该整数本身。如果参数是一个浮点数，int函数会返回该浮点数的整数部分，即去掉小数部分。如果参数是一个字符串，那么该字符串应该表示一个整数，int函数会将其转换成对应的整数。

基本用法

将浮点数转换为整数

num = 3.14  
print(int(num))  # 输出: 3

将字符串转换为整数

str_num = "123"  
print(int(str_num))  # 输出: 123

如果字符串不能转换为整数，会抛出ValueError异常

str_num = "abc"  
print(int(str_num))  # 抛出 ValueError: invalid literal for int() with base 10: 'abc'

2.自己编写函数

        函数是带名字的代码块，用于完成具体的工作，当要执行函数定义的特点任务，就可以去调用函数。

定义函数

        接下来演示最简单的函数结构，下面是一个打印问候语的简单函数，名为greet_user()。

def greet_user():
    print("Hello!")


greet_user()

Hello!

向函数传递信息

        函数的括号内可以添加指定的值用来向函数传递信息。

def greet_user(username)
    print(f"Hollow,{username.title()}!")

greet_user('jesse')

Holle,Jesse!

注意：在函数greet_user()的定义中，变量username是一个形参。在代码greet_user('jesse')中，值'jesse'是一个实参。

---

函数中的返回值

        在Python中，函数中的返回值是通过return语句来实现的。当函数执行到return语句时，它会停止执行并返回指定的值给调用者。如果函数中没有return语句，或者return语句后面没有跟任何值，那么函数默认返回None。

返回值的基本用法

def add(x, y):  
    return x + y  
  
result = add(3, 4)  
print(result)  # 输出: 7

返回多个值

Python允许函数返回多个值，这些值实际上是以元组的形式返回的。

def get_user_info(username):  
    # 假设从数据库或其他地方获取用户信息  
    name = "John Doe"  
    age = 30  
    return name, age  
  
name, age = get_user_info("johndoe")  
print(name)  # 输出: John Doe  
print(age)   # 输出: 30

返回字典

        在这个例子中，get_user_profile函数接受一个username参数，并返回一个包含用户信息的字典。这个字典包含了用户的用户名、姓名、年龄和电子邮件地址。函数返回这个字典后，你可以将其赋值给一个变量（在这个例子中是profile），然后访问字典中的任何键值对。

def get_user_profile(username):  
    # 假设从数据库或其他数据源获取用户信息  
    user_profile = {  
        'username': username,  
        'name': 'John Doe',  
        'age': 30,  
        'email': 'johndoe@example.com'  
    }  
    return user_profile  
  
profile = get_user_profile('johndoe')  
print(profile)  # 输出: {'username': 'johndoe', 'name': 'John Doe', 'age': 30, 'email': 'johndoe@example.com'}

3.将函数存储在模块中

     在Python中，将函数存储在模块中是一种组织和重用代码的有效方式。模块本质上是一个包含Python定义和声明的文件，文件名就是模块名加上.py后缀。将函数定义在模块中，可以使你的代码更加模块化，易于维护，并允许其他模块通过import语句来导入和使用这些函数。

以下是一个简单的示例，说明如何将函数存储在模块中：

创建一个模块

        首先，你需要创建一个包含函数的Python文件。比如，我们可以创建一个名为math_utils.py的文件，并在其中定义一些数学相关的函数。

# math_utils.py  
  
def add(x, y):  
    """Add two numbers"""  
    return x + y  
  
def subtract(x, y):  
    """Subtract two numbers"""  
    return x - y  
  
def multiply(x, y):  
    """Multiply two numbers"""  
    return x * y  
  
def divide(x, y):  
    """Divide two numbers, raising a ValueError if y is 0"""  
    if y == 0:  
        raise ValueError("Cannot divide by zero")  
    return x / y

导入并使用模块中的函数

        现在，假设你想在另一个Python脚本中使用math_utils.py模块中的函数。你可以在同一目录下（或指定路径下）创建一个新的Python文件，比如main.py，然后通过import语句来导入并使用这些函数。

# main.py  
  
import math_utils  
  
# 使用math_utils模块中的函数  
result_add = math_utils.add(5, 3)  
result_subtract = math_utils.subtract(5, 3)  
result_multiply = math_utils.multiply(5, 3)  
result_divide = math_utils.divide(5, 3)  
  
print(f"5 + 3 = {result_add}")  
print(f"5 - 3 = {result_subtract}")  
print(f"5 * 3 = {result_multiply}")  
print(f"5 / 3 = {result_divide}")

---

 导入特定的函数

        为了更简洁地引用模块中的函数，你也可以使用from...import...语法来导入特定的函数，而不是整个模块。  

# main.py 另一种写法  
  
from math_utils import add, subtract, multiply, divide  
  
# 直接使用函数名  
result_add = add(5, 3)  
result_subtract = subtract(5, 3)  
result_multiply = multiply(5, 3)  
result_divide = divide(5, 3)  
  
print(f"5 + 3 = {result_add}")  
print(f"5 - 3 = {result_subtract}")  
print(f"5 * 3 = {result_multiply}")  
print(f"5 / 3 = {result_divide}")

---

使用as给函数指定别名

        在Python中，当你从模块中导入函数时，可以使用as关键字为该函数指定一个别名。这样做的好处是，你可以避免在调用函数时与当前命名空间中的其他名称发生冲突，或者简单地为了代码的可读性和简洁性而使用更短的名称。

下面是一个使用as给函数指定别名的示例：

假设你有一个名为math_utils.py的模块，里面定义了一个函数add_numbers：

# math_utils.py  
  
def add_numbers(x, y):  
    return x + y

现在，在另一个Python脚本中，你想要导入add_numbers函数，但你想在调用时使用一个更短的名称，比如add。from math_utils import add_numbers as add语句从math_utils模块中导入了add_numbers函数，并将其重命名为add。之后，在main.py脚本中，你就可以使用add这个别名来调用原本名为add_numbers的函数了。

# main.py  
  
from math_utils import add_numbers as add  
  
# 现在你可以使用add作为add_numbers的别名  
result = add(5, 3)  
print(f"5 + 3 = {result}")

---

使用as给模块指定别名

        在Python中，当你导入模块时，同样可以使用as关键字为该模块指定一个别名。这样做的好处包括简化模块名的引用，避免命名冲突，以及提高代码的可读性。

下面是一个使用as给模块指定别名的示例：

假设你有一个名为my_long_module_name的模块，由于模块名较长，在代码中频繁引用可能会显得冗长。你可以使用as关键字在导入时为其指定一个较短的别名。

import my_long_module_name as short_name语句导入了my_long_module_name模块，并将其重命名为short_name。之后，在代码中你就可以使用short_name这个别名来引用原本名为my_long_module_name的模块了，包括访问该模块中定义的函数、类等。

# 导入模块并为其指定别名  
import my_long_module_name as short_name  
  
# 现在你可以使用short_name作为my_long_module_name的别名  
# 假设my_long_module_name中有一个名为my_function的函数  
result = short_name.my_function()  
  
# 如果my_long_module_name还包含了一个名为MyClass的类  
my_instance = short_name.MyClass()

---

导入模块中的所有函数

使用星号 * 运算符可让Python导入模块中的所有函数：

from pizza import *

make_pizza(16,'pepperoni')
make_pizza(12,'mushrooms','green peppers','extra cheese')

注意：import语句中的星号让Python将模块pizza中的每个函数都复制到这个程序文件中。但是使用不是自己写的大型模块时，不要使用这种导入方法。因为如果 模块中有函数的名称与当前项目中使用的名称相同，Python可能会遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有的函数。

十.Python中的类

1.类和对象

        在Python中，类（Class）是一种用于创建对象的模板或蓝图。通过定义类，你可以指定对象将拥有的属性和方法（即数据和行为）。类是面向对象编程（OOP）的核心概念之一，它允许你将数据和功能组合在一起，以创建可重用的、模块化的代码。

创建类

        使用类几乎可以模拟任何东西。接下来编写一个表示小狗的简单类Dog。它表示的不是特定的小狗，而是任何小狗。根据Dog类创建的每个实例都将储存名字和年龄，同时我们还要赋予每个小狗蹲下（sit()）和（roll_over()）的能力。

class Dog:
    """一次模拟小狗的简单尝试"""

    def __init__(self,name,age):
        """格式化属性name和age"""
        self.name = name
        self.age = age

    def sit(self):
        """模拟小狗收到命令时蹲下。"""
        print(f"{self.name} is now sitting.")

    def roll_over(self):
        """模拟小狗收到命令时打滚。"""
        print(f"{self.name} rolled over！")

在这里我们介绍一下方法__init__()

       类中的函数称为方法上面__init__()运用时，每当你根据Dog类创建新实例时，Python都会自动运行它。然后，我们将方法__init__()定义成包含三个形参：self，name和age。其中形参self是必不可少的，而且它必须在其他形参的前面。因为Python调用这个方法来创建Dog实例的时候，将自动传入实参self。每个和实例相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例可以访问类中的属性和方法。

注意：init的两边都有两个下滑线。

根据类创建实例 

接下来我们给name值'Buddy'，age值给3。然后，我们来调用这个实例：

# 创建一个Dog类的实例  
my_dog = Dog('Buddy', 3)  
  
# 调用实例的方法  
my_dog.sit()  # 输出: Buddy is now sitting.  
my_dog.roll_over()  # 输出: Buddy rolled over！

访问属性和调用方法

要访问实例的属性或方法，我们用句点表示法。

my_dog.name

my_dog.sit()
my_dog.roll_over()

2.继承

        在Python中，继承是一种面向对象编程（OOP）的特性，它允许我们定义一个类（称为子类或派生类）来继承另一个类（称为基类、父类或超类）的属性和方法。这意味着子类可以复用父类的代码，并且还可以添加或覆盖父类中的方法。

定义基类（父类）

首先，我们定义一个基类，它包含了一些基本的属性和方法。

class Animal:  
    def __init__(self, name):  
        self.name = name  
  
    def speak(self):  
        raise NotImplementedError("Subclass must implement abstract method")  
  
    def eat(self):  
        print(f"{self.name} is eating.")

在这个例子中，Animal类是一个基类，它有一个__init__方法来初始化对象的name属性，一个speak方法（这里使用了NotImplementedError来表示这是一个应该被子类实现的方法），以及一个eat方法。

定义子类（派生类）

然后，我们可以定义一些子类来继承Animal类，并实现或覆盖它的方法。

class Dog(Animal):  
    def speak(self):  
        return f"{self.name} says Woof!"  
  
class Cat(Animal):  
    def speak(self):  
        return f"{self.name} says Meow!"

这里，Dog和Cat类都继承了Animal类。它们各自实现了speak方法，但没有覆盖eat方法，所以它们会继承并使用Animal类中的eat方法。

使用继承

现在，我们可以创建Dog和Cat的实例，并调用它们的方法。

my_dog = Dog("Buddy")  
print(my_dog.speak())  # Buddy says Woof!  
my_dog.eat()           # Buddy is eating.  
  
my_cat = Cat("Whiskers")  
print(my_cat.speak())  # Whiskers says Meow!  
my_cat.eat()           # Whiskers is eating.

3.导入类

        在Python中，导入类（或任何其他模块中的定义，如函数、变量等）是一项基本且频繁的操作。这有助于代码的模块化、重用和组织。以下是一些关于如何在Python中导入类的笔记和示例。

从模块中导入类 

        假设你有一个名为mymodule.py的模块，它定义了一个名为MyClass的类。你可以通过以下方式从该模块中导入MyClass：

from mymodule import MyClass  
  
# 现在你可以直接使用MyClass了  
obj = MyClass()

导入模块后使用类

        另一种方法是导入整个模块，然后通过模块名来访问类：

import mymodule  
  
# 使用模块名来访问类  
obj = mymodule.MyClass()

 导入多个类

        如果你需要从一个模块中导入多个类，可以在import语句中一次性指定它们：

from mymodule import MyClass1, MyClass2  
  
obj1 = MyClass1()  
obj2 = MyClass2()

导入模块并使用别名

        有时，模块名可能会很长或者可能与你的代码中的其他名称冲突。你可以使用as关键字为模块指定一个别名：

import mymodule as mm  
  
obj = mm.MyClass()

导入类并使用别名

        同样地，你也可以为导入的类指定别名：

from mymodule import MyClass as MC  
  
obj = MC()

导入模块中的所有内容（不推荐）

        虽然可以使用*从模块中导入所有内容，但这通常不是一个好主意，因为它可能会导致命名冲突：

from mymodule import *  
  
# 现在可以直接使用mymodule中的所有公共名称，但这可能会导致命名冲突和代码可读性下降  
obj = MyClass()

导入嵌套类

        如果类嵌套在另一个类中，你需要使用点号（.）来访问它们：

from mymodule import OuterClass  
  
obj = OuterClass.InnerClass()  
  
# 或者  
from mymodule.OuterClass import InnerClass  
  
obj = InnerClass()

十一.Python中的文件和异常

        在Python中，文件和异常是两个非常重要的概念，它们分别用于处理数据的持久化存储和程序运行时的错误处理。

1.文件

        文件是存储在硬盘上的数据集合，可以是文本文件、图片、视频等。Python提供了内置的open()函数来打开文件，并返回一个文件对象，然后可以使用这个对象来读取或写入文件。

打开文件

使用open()函数打开文件，该函数的基本语法如下：

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

• file_name：要打开的文件名（包括路径，如果文件不在当前目录下）。
• mode：打开文件的模式，默认为'r'（只读）。其他常用模式包括'w'（只写，会覆盖文件）、'a'（追加）、'b'（二进制模式）、'+'（读写模式）等。

读取文件 

打开文件后，可以使用文件对象的read()、readline()或readlines()等方法来读取文件内容。

with open('example.txt', 'r') as file:  
    content = file.read()  # 读取整个文件内容  
    print(content)

写入文件

使用'w'或'a'模式打开文件后，可以使用write()或writelines()方法写入内容。

with open('example.txt', 'w') as file:  
    file.write('Hello, world!\n')  
    file.write('This is a new line.')

2.异常

异常是程序在运行时发生的错误，Python使用异常处理机制来捕获和处理这些错误。

捕获异常

使用try...except语句来捕获和处理异常。

try:  
    # 尝试执行的代码块  
    result = 10 / 0  
except ZeroDivisionError:  
    # 如果发生ZeroDivisionError异常，则执行这里的代码  
    print("Cannot divide by zero")

自定义异常

Python允许你通过继承内置的Exception类来创建自定义异常。

class MyCustomError(Exception):  
    def __init__(self, message="This is a custom error"):  
        self.message = message  
        super().__init__(self.message)  
  
try:  
    raise MyCustomError("Something bad happened")  
except MyCustomError as e:  
    print(e)

捕获多个异常

可以在一个except子句中捕获多个异常，或者为不同的异常编写多个except子句。

try:  
    # 尝试执行的代码块  
    pass  
except (ZeroDivisionError, TypeError) as e:  
    # 捕获ZeroDivisionError或TypeError异常  
    print(f"Caught an error: {e}")

finally子句

finally子句是可选的，它无论是否发生异常都会执行。这通常用于执行清理操作，如关闭文件或释放资源。

try:  
    # 尝试执行的代码块  
    pass  
except Exception as e:  
    # 异常处理代码  
    print(f"An error occurred: {e}")  
finally:  
    # 无论是否发生异常都会执行的代码  
    print("This will always be executed")