Python 简明教程

变量

Python 变量声明时不需要定义变量的类型，直接定义变量名，然后赋值即可使用。

message = "Hello World!"
x, y, z = 0, 1, 2

在定义变量时，需要满足如下的命名要求：

1. 变量名只能包含字母、数字和下划线。变量名能以字母或下划线开头，但不能以数字开头；
2. 变量命不能包含空格；
3. 不能使用 Python 的关键字作为变量名。

定义的变量名，最好能够满足：

1. 变量名尽量简洁和具有描述性；
2. 尽量避免使用小写字母 l 和大写字母 O，因为这两个字母和数字 1 和 0 很像；
3. 变量名建议全部小写，使用下划线分隔。

字符串

字符串就是一系列字符。在 Python 中使用引号括起来的都是字符串。引号可以是单引号或者双引号。

str1 = "This is a string."
str2 = 'This is a string too.'

单引号和双引号可以搭配使用，运行在复合场景下：

str1 = "I'm a student."
str2 = 'I like this "dog"'

在字符串中使用变量，在 f 字符串格式化下使用 {} 占位符：

first_name = "Zhang"
last_name = "San"
full_name = f"{first_name}{last_name}"
format_name = f"{full_name}.title()"

字符串常见的方法：

方法	作用	示例	输出结果
upper()	转大写	‘hello world’.upper()	HELLO WORLD
lower()	转小写	‘HELLO WORLD’.lower()	hello world
title()	英文单词，首字母大写	‘hello world’.title()	Hello World
rstrip()	删除右边空格	’ python '.rstrip()	<空格>python
lstrip()	删除左边空格	’ python '.lstrip()	python<空格>
strip()	删除左右两边空格	’ python '.strip()	python

整数和浮点数

不带小数点的数是整数 ，带小数点的数是浮点数。对于很大数字 ，可以使用下划线分隔，方便阅读（类似会计计数法）。

big_number = 13_000_000_000

数学算术符

算术运算	符号	示例	输出结果
加	+	1+2	3
减	-	3-1	2
乘	*	4*8	32
除	/	4/2	2
乘方	**	2**10	1024
模（余数）	%	4 % 3	1

请注意：

1. 任意两个数字相除时，结果总是浮点数，即使这两个数是整数且能整除；
2. 任意运算中，只要有一个操作数是浮点数，结果总是浮点数。

>>> 4/2
2.0
>>> 1 + 2.0
3.0

数学函数

函数	含义	示例	输出结果
min()	求最小值	min([1,2,3,4,5,6,7])	1
max()	求最大值	max([1,2,3,4,5,6,7])	7
sum()	求和	sum([1,2,3,4,5,6,7])	28

注释

使用 # 进行注释：

# 请说大家好
print("Hello everyone!")

使用 """ 定义文档字符串的注释，通常用于描述函数是做什么的，Python 将其生成到相关程序文档中。

def print_name(name):
    """打印姓名"""
    print(name)

列表

列表由一系列按特定顺序排序排列的元素组成，所以列表是有序集合。列表用方括号（[ ]）表示，使用逗号进行分隔。

bicycles = ['trek', 'cannondale', 'redline', 'spcialized', 'merida']

访问元素

列表的下标索引从 0 开始，通过使用 [索引] 的方式访问列表的元素：

print(bicycles[0]) #trek
print(bicycles[1]) #cannondale

使用负数索引来倒序访问列表元素：

print(bicycles[-1]) #spcialized
print(bicycles[-2]) #redline

删除元素

删除列表中元素方法有三种：

1. del 删除指定索引的元素；
2. pop 删除列表末尾的元素或指定索引的元素；
3. remove 删除指定某个值的元素。

del bicycles[0]
del bicycles[1]
bicycles.pop()
bicycles.pop(0)
bicycles.remove('merida')

remove 删除元素只删除第一次遇到的元素，若列表中有多个值，则需要使用循环的方式删除。

修改元素

通过索引的方式修改列表的值：

cars = ['BWM', 'BYD', 'Audi', 'Honda']
cars[0]='Hummer'

添加元素

末尾追加元素使用 append()，任意位置添加使用 insert()：

cars.append('Jeep')
cars.insert(0, 'Kia')

列表排序

使用 sort 进行永久排序，使用 sorted 进行临时排序：

cars.sort() #正序
cars.sort(reverse=True) #倒序

使用 reverse 让列表倒序：

cars.reverse()

列表长度

使用 len() 获取列表的长度：

len(cars)

遍历列表

使用 for-in 遍历列表：

for car in cars:
    print(car)

数值列表

使用 range() 函数创建生成一系列数，然后通过 list() 函数将 range() 函数的结果转换成列表。

for value in range(1,10)
    print(value) # 1 2 3 4 5 6 7 8 9 10

for value in range(1,10,2)
    print(value) # 1 3 5 7 9

numbers = list(range(1,10)) # [1,2,3,4,5,6,7,8,9,10]

列表解析是将 for 循环和创建新元素的代码合并成为一行，并自动附加新元素：

squares=[value**2 for value in range(1,10)]

切片

列表中的部分元素成为切片。切片使用冒号（:）进行衔接元素：

players = ['Ming', 'Hong', 'San', 'Si', 'Hua']
print(players[0:2]) # Ming Hong San
print(players[:1]) # Ming Hong
print(players[3:]) # Si Hua
print(players[-1]) # Hua
print(players[-2:]) # Si Hua

可以使用 for-in 循环遍历切片：

for player in players:
    print(player)

想要复制切片可以使用 [:] 语法：

new_players = players[:] # 创建了一个 players 的副本

元组

列表是可变的，想要创建不可变的列表，可以使用元组。元组使用圆括号 ( )定义，通过索引访问元组中的元素。

phones = ('Vivo', 'Xiaomi', 'Huawei', 'iPhone')
print(phones[0])

for phone in phones:
    print(phone)

字典

字典是一系列键值对。每个键都与一个值对应。字典使用花括号（{ }）定义，键与值之间使用冒号进行分隔，键值对之间使用逗号分隔。

student = ('first_name':'San', 'last_name':'Zhang')
student_scores = ('first_name':'San', 'last_name':'Zhang', 'scores':[90, 89, 95, 89]) # 值是列表
student_info = ('first_name':'San', 'last_name':'Zhang', 'info': {'age':'20', 'english': 98}) # 值是字典

访问、修改和删除

通过使用 [键] 的方式，访问字典的值或者修改字典的值：

print(student['first_name'])
student['first_name'] = 'Li'

删除字典的键值对使用 del 方法：

del student['first_name']

通过 [键] 的方式访问字典存在一个弊端：如果指定的键不存在，则会报错。为了避免报错，可以使用 get() 方法指定当键不存在时返回的默认值：

student.get('gender', 'male')

新增键值对

想要新增键值对，可以采用如下的方式：

student['age'] = 20

有时候，可以先创建一个空字典，必要时在添加键值对：

book={}
book['name'] = 'Romeo and Juliet'

遍历字典

遍历字典所有键值对使用 items() 方法，遍历所有键使用 keys() 方法，遍历所有值使用 values() 方法。

user = {
    'username': 'san.zhang',
    'password': '123456789',
    'last_login' : '2024-02-24 09:45:00'
}

# 遍历键值对
for key, value in user.items():
    print(f'key={key},value={value}}')

# 遍历所有的键
for key in user.keys():
    print(f'key={key}')

# 遍历所有的值
for value in user.values():
    print(f'value={value}')

选择结构

条件测试

一个语句要么返回 True，要么返回 False，这个语句就是条件测试语句，也称为布尔表达式。

条件测试	含义	示例	输出结果
==	相等	1 == 2	False
!=	不相等	1 != 2	True
>	大于	1 > 2	False
<	小于	1 < 2	True
>=	大于等于	1 >= 2	False
<=	小于等于	1 <= 2	True
in	判断元素是否在列表中	1 in [1,2,3,4,5]	True
not in	判断元素不在列表中	1 not in [1,2,3,4,5]	False

当多个条件组合时，可以使用 and 或者 or 连接两个条件测试语句：

条件测试	含义	示例	输出结果
and	并且	1 != 2 and 2 !=3	True
or	或者	1 > 2 or 2 < 3	False

if-elif-else

选择结构有三种形式：

1. 只有一个 if 构成的选择结构；
2. if-else 组成选择结构；
3. if-elif-else 组成的复合选择结构，其中 elif 可以不限个数。复合结构下，else 可以根据情况省略。

age = 19

# 只有一个 if 构成的选择结构
if age < 18
    print('未成年')

# if-else 组成选择结构
if age < 18
    print('未成年')
else 
    print('成年人')

# if-elif-else 组成的复合选择结构
if age < 1
    print('婴儿')
elif age < 19
    print('青少年')
elif age < 30
    print('青壮年')
elif age < 60
    print('中年人')
else # 根据情况可以省略
    print('老年人')

if 可以判空列表

当列表元素个数为 0 时，我们称之为空列表。使用 if 语句可以判断列表是否为空：

users=[]
if users:
    print('The list of user is empty.')
else:
    print(users)

后续提到的 while 循环同样也可以判断列表。

循环结构

循环结构有两种：for-in 循环和 while 循环。for-in 循环需要搭配列表或者字典等场景使用，而 while 循环相对独立一些。while 循环会不断运行，直到条件不满足为止。

count = 0
while count <= 10 # 只要满足这个条件，就会不断执行
    print(count)
    count += 1

退出循环可以使用 break，停止本次循环接续下一次循环可以使用 continue：

count = 0 
while count <= 10
    if count in [1,3,5,7]
        continue # 当 count 为 1 3 5 7 时，跳过后面语句，执行下一次循环
    if count == 9
        break # 当 count 等于 9 时，提前结束循环

在使用 for-in 循环时，不应当修改列表或者字典的元素，否则会导致 Python 难以跟踪其中的元素。想要一边遍历，一边操作元素可以使用 while 循环。

users = ['Alice', 'Bob', 'Duo']
confirmed_users = []

while users:
    print(users)
    user = users.pop()
    print(f'Popped this user {user} from users.')
    confirmed_users.append(user)

print(f'confirmed users: {confirmed_users }')

用户输入

获取终端用户的输入的字符串使用 input() 方法。

message = input('Tell me something, and I will repeat it back to you: ')
print(message)

# 因为 input 读取到的始终是一个字符串，因此需要使用 int() 函数将字符串转换成数值
age = input('Your age: ')
age = int(age)
if age < 18:
    print('未成年')
else
    print('成年人')

函数

函数是带名字的代码块，使用 def 关键字定义一个函数，使用圆括号定义函数接收的参数。

# 定义函数
def greet_user():
    print("Hello!")

# 调用函数
greet_user() 

形参与实参

函数定义的参数称为形式参数（形参），调用函数传递的参数称为实际参数（实参）。在函数定义时，可以先定义形式参数。

def greet_user(name):
    print(f'Hello, {name}!')

greet_user('Li Hua')

根据参数的位置可以将实参分成：位置实参和关键字实参。位置实参要求实参与形参的顺序相同：

def greet_user(first_name, last_name):
    print(f"Your name is {first_name} {last_name}")

greet_user('San', 'Zhang')

关键字实参通过让参数名与值关联，所以可以让实参与形参的顺序不同：

def greet_user(first_name, last_name):
    print(f"Your name is {first_name} {last_name}")

greet_user(first_name = 'San', last_name = 'Zhang')
greet_user(last_name = 'Zhang',first_name = 'San')

参数默认值

在定义形参时，可以为形参设置一个默认值，调用时可以传可不传：

def greet_user(first_name, last_name, school = 'No.2 Middle School'):
    print(f"Your name is {first_name} {last_name} and your school is {school }")

greet_user('San', 'Zhang', 'No.1 Middle School')
greet_user('Si', 'Li')

函数返回值

在函数中，使用 return 语句让函数返回某个值。

def full_name(first_name, last_name):
    return f'{first_name} {last_name}'

full_name = full_name('San', 'Zhang')
print(full_name)

引用参数传递

函数的形式参数为列表、字典等时，传递的方式为引用传递。

def modify(numbers):
    numbers.append(4)  # 在函数内部修改列表

numbers= [1, 2, 3]
modify(numbers)
print(numbers)  # 输出 [1, 2, 3, 4]

通过使用切片的方式，可以实现不改变实参的列表元素：

def modify(numbers[:]):
    numbers.append(4)  # 在函数内部修改列表

numbers= [1, 2, 3]
modify(numbers)
print(numbers)  # 输出 [1, 2, 3]

任意参数

无法确认参数个数时，可以使用任意参数。使用 * 表示元组，使用 ** 表示字典。

def print_number(*numbers):
    print(numbers)

print_number(1)
print_number(1, 2)
print_number(1, 2, 3)
print_number(1, 2, 3, 4)
print_number(1, 2, 3, 4, 5)

def print_name(**names):
    print(names)

print_name(first_name = 'San', last_name = 'Zhang')

元组中的元素不可修改。

导入外部依赖

在一个文件中引入另外一个模块的函数，有三种导入方法：

1. 导入整个模块；
2. 导入模块中的所有函数和变量；
3. 导入模块中的某个函数或变量；

# 导入整个模块
import module_name

# 导入模块中的所有函数和变量
from module_name import *

# 导入模块中的某个函数或变量
from module_name import function_name, variable_name

第 1 种方式和第 2 种方式的区别在于：第 1 种方式在调用导入模块的函数时，需要使用 模块名.函数名 的方式调用函数。而第 2 种方式直接使用函数名调用。因此，第 1 种方式可以避免函数名重复定义，第 2 种则无法避免（污染了当前环境）。因此，推荐使用第 1 种方式导入函数。

导入后的函数或者模块，可以通过 as 关键字设置别名：

import module_name as a
from module_name import * as b

类

现实世界的对象可以抽象成类。类使用 class 关键字定义，类由属性、方法（在类中称函数为方法）构成。类的命名使用驼峰命名法。

class Dog:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def set_age(self, age):
        self.age = age
    
    def site(self):
        print(f'{self.name} is now sitting')

    def roll_over(self):
        print(f'{self.name} rolled over!')

__init__() 是类的构造方法，所有实例化对象时都会调用该方法。形参 self 必不可少，且必须位于所有参数前面。这是因为 Python 在实例化对象时，会自动传入 self 参数。self 参数是一个指向实例本身的引用，让实例可以访问到类中的属性和方法。name 和 age 是类中的属性，通过 self 参数获取该属性值。site() 和 roll_over() 称为方法。

当类创建完成后，实例化出该类的对象，然后调用对象的方法：

my_dog = Dog('小黑', 2)
my_dog.site()
my_dog.roll_over()

your_dog = Dog('小白', 1)
your_dog .site()
your_dog .roll_over()

属性值

在构造方法中可以给类的属性值设置默认值。

class Dog:

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.color = 'Black'

    def set_age(self, age): 
        self.age = age
    
    def site(self):
        print(f'{self.name} is now sitting')

    def roll_over(self):
        print(f'{self.name} rolled over!')

my_dog = Dog('小黑', 2)
my_dog.age = 3 # 修改属性值
my_dog.set_age(4) # 通过方法修改属性值

继承

一个类继承另外一个类时，将自动获取到另外一个类的所有属性和方法。原生的类成为父类，新的类成为子类。子类可以定义自己的属性和方法。在继承时，子类创建前需要创建父类。通常，在子类的构造方法中需要调用父类的构造方法。

class Car:

    def __init__(self, color, brand):
        self.color = color
        self.brand = brand

    def drive(self, driver_name):
        print(f'{driver_name} is driving a {self.brand} car.')

class ElectricCar(Car): # 继承父类

    def __init__(self, color, brand):
        super().__init__(color, brand) # 调用父类的构造函数

    def drive(self, driver_name): # 重写父类的函数
        print(f'{driver_name} is driving a {self.color} {self.brand} car. And this car is a eletric car.')
		

car = ElectricCar('White', 'Tesla')
car.drive('Bob')

文件操作

打开文件使用 open() 函数，关闭文件使用 close() 函数，读文件使用 read()、 readline() 和 readlines()函数，写文件使用 write() 函数或者 writelines()，自动关闭文件使用 with-as 语句。

# 只读模式打开文件
file = open('a.txt', 'r')

# 写模式打开文件（若文件不存在，则会自动创建）
file = open('a.txt', 'w')

# 追加模式打开文件（若文件不存在，则会自动创建）
file = open('a.txt', 'a')

# 读整个文件
content = file.read()

# 读一行
line = file.readline()

# 读取所有行并存储到列表中
lines = file.readlines()

# 写入字符串到文件
file.write('Hello, World!')

# 写入多行字符串到文件
lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
file.writelines(lines)

# 关闭文件
file.close()

# 自动关闭文件
# 在 with 代码块结束时，文件会自动关闭，无需手动调用 file.close()
with open('a.txt', 'r') as file
    print(file.read())

JSON 文件处理

导入 json 模块后，可以处理 json 格式的文件。使用 json.dump() 保存一个 json 文件到本地磁盘，使用 json.load() 读取一个 json 文件。

import json

numbers = [1, 2, 3, 4, 5]

filename = 'numbers.json'
with open(filename, 'w') as wf:
    json.dump(numbers, wf)

with open(filename, 'r') as rf
    new_numbers = json.load(rf)
    print(new_numbers)

异常处理

程序运行发生的错误称为异常。异常的处理使用 try-except-else语句处理。其中，else 语句可以省略。

try:
    with open('a.txt', 'r') as f:
        contents = f.read()
except:
    print("Read failed.")
else:
    print("Read successful.")

当异常发生时，也可以不做任何处理，这种行为称为静默失败。静默失败使用 pass 关键字标记。

try:
    with open('a.txt', 'r') as f:
        contents = f.read()
except:
    pass # 静默失败
else:
    print("Read successful.")

None

None 是一个特殊的类型，表示空值或者缺失值。None 通常用于表示一个变量没有被赋予任何值。使用 None 可以更好地处理变量赋值和状态判断。

# 可以直接将变量赋值为 None。赋值为 None 的变量会被清空变量的内容，释放内存并标记为未使用。
x = None

# 检查是否为 None，可以使用 is 关键字
if x is None:
    print('X is a None.')
else:
    print(x)

# 如果函数没有明确返回任何值，则默认返回 None。
def greet_user:
    return None

单元测试

单元测试用于测试某个函数不存在问题。通过导入 unittest 模式，测试类继承 unittest.TestCase 来执行单元测试。

import unittest

def add(a, b):
    return a + b

class CalculatorTest(unittest.TestCase):  # 继承测试类
    def test_add(self):  # 测试方法
        self.assertEqual(add(1, 2), 3)

if __name__ == '__main__':
    unittest.main()

断言方法

判断程序运行的结果是否与期待的结果相等，称之为断言。

方法	含义	示例	输出结果
assertEqual(a, b)	判断是否相等	assertEqual(1, 2)	False
assertNotEqual(a, b)	判断是否不相等	assertNotEqual(1, 2)	True
assertTrue(x)	判断是否为 True	assertTrue(1 == 2)	False
assertFalse(x)	判断是否为 False	assertFalse(1 == 2)	True
assertIn(item, list)	判断元素是否在列表中	assertIn(3, [1, 2, 3 , 4])	True
assertNotIn(item, list)	判断元素是否不在列表中	assertNotIn(3, [1, 2, 3, 4])	False

setUp 和 tearDown

unittest 支持在每个测试方法执行前后执行一些准备和清理操作，可以使用 setUp 和 tearDown 方法。

class TestStringMethods(unittest.TestCase):

    def setUp(self):
        # 在每个测试方法执行前调用
        pass

    def tearDown(self):
        # 在每个测试方法执行后调用
        pass

以上就是“Python 简明教程”的全部内容，希望对你有所帮助。
​
​关于Python技术储备

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、Python练习题

检查学习结果。

六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

最后祝大家天天进步！！

上面这份完整版的Python全套学习资料已经上传至CSDN官方，朋友如果需要可以直接微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】。