Python—快速入门

简介

Python 作为一门解释型语言，在运行时逐行解释执行代码，无需编译成二进制文件，这一点和 JavaScript 类似。它属于弱类型语言，变量类型无需提前声明，赋予了代码极高的灵活性。正因这些特性，Python门槛较低，新手很容易上手。

变量声明

没有关键字修饰变量名，如下：

# 变量声明
name = "Alice"  # 字符串
age = 25 # 数字
is_student = True # 布尔类型


# 一次性定义多个变量
x, y, z = 1, 2, 3
# 列表
fruits = ["apple", "banana", "cherry"]

字符串三引号 可以按照自然书写的方式输出

# 字符串三引号 可以换行
message = """
Hello, my name is Alice.
I am 25 years old.
I am a student.
"""

基本任何一门语言都有字符串模板，python的字符串需要在字符串前加f

# 字符串模板 前面加f 可以使用变量
template = f"Hello, my name is {name}. I am {age} years old."
print(template)

控制语句

条件控制语句

根据条件的真假来执行不同的代码块，最常用的条件控制语句是if语句。

num = 10
if num > 0:
    print("这个数字是正数")
else:
    print("这个数字不是正数")

条件真假判断

# 在Python中，条件的真假是通过布尔值来表示的。以下是一些常见的条件判断：
# and: 且 ，对应java中的&&
# or: 或 ，对应java中||
# not: 非 ，对应java中!
# 下面是一个例子，演示了如何使用and和or来组合多个条件：

x = 5
y = 10
if x > 0 and y < 20:
    print("x大于0且y小于20")
else:
    print("x不大于0或y不小于20")

if x > 0 or y < 20:
    print("x大于0或y小于20")
else:
    print("x不大于0且y不小于20")

if not x > 0:
    print("x不大于0")

循环语句

常用有for和 while循环语句

'''
for循环的基本语法如下：
for 变量 in 可迭代对象:
    # 循环体

while 条件:
    # 循环体
    # 循环体中的代码会被重复执行
    # 每次循环，条件会被判断
'''
# 遍历数组
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

sum = 0
i = 1
while i <= 10:
    sum += i
    i += 1
print(sum)

循环控制语句，有break和continue关键字

# break: 跳出循环
# continue: 跳过当前循环，继续下一次循环

for i in range(1, 10):
    if i == 5:
        break
    print(i)

for i in range(1, 10):
    if i == 5:
        continue
    print(i)


# 可以一行判断，何必多行
done = False
if done:
    a = 1
else:
    a = 2
print(a)
# 一行判断  【值 if 条件为真 else  值 】
a = 1 if done else 2
print(a)

集合

主要有以下数据集合

• 列表（List）：有序的可变序列，可以包含任意类型的元素。
• 元组（Tuple）：有序的不可变序列，可以包含任意类型的元素。
• 字典（Dictionary）：无序的可变集合，由键值对组成。
• 集合（Set）：无序的可变集合，不允许重复元素。

List

# List
# 列表是Python中最常用的数据集合之一，它是有序的可变序列，可以包含任意类型的元素。
# 语法如下：
# 下面是一个简单的例子，演示了如何使用列表：
fruits = ["apple", "banana", "cherry","lemon","grape"]
print("---------------list-----------------")
print(fruits , len(fruits)) # 打印列表和列表的长度
print(fruits[0]) # 访问列表中的元素
# 反向访问
print(fruits[-1]) # 访问列表中的最后一个元素 grape
print(fruits[1:3]) # 访问列表中的元素，从索引1到索引3（不包括索引3）
print(fruits[2:]) # 访问列表中的元素，从索引2到列表末尾

fruits[0] = "orange" # 修改列表中的元素
fruits.append("grape") # 在列表末尾添加元素
fruits.remove("banana") # 删除列表中的元素
# 遍历
names = ""
for fruit in fruits:
    names += fruit + ","
print(names)

Dict

# 字典 Dict 对应java中的Map，语法与JavaScript的字面量对象和相似
# 字典是Python中另一个常用的数据集合，它是无序的可变集合，由键值对组成。
# 语法如下：
# 下面是一个简单的例子，演示了如何使用字典：
person = {"name": "Alice", "age": 25, "is_student": True}
print("---------------dict-----------------")
print(person)
print(person["name"]) # 访问字典中的元素
print(person.get("age")) # 访问字典中的元素
person["age"] = 26 # 修改字典中的元素
person["city"] = "New York" # 添加字典中的元素
del person["is_student"] # 删除字典中的元素
print(person)

Set

# 集合 Set 对应java中的Set
# 集合是Python中另一个常用的数据集合，它是无序的可变集合，不允许重复元素。
# 语法如下：
# 下面是一个简单的例子，演示了如何使用集合：
# animals = set(["cat", "dog", "fish", "cat"])
# 或者 简化为
animals = {"cat", "dog", "fish", "cat"}

print("---------------set-----------------")
print(animals)
animals.add("bird") # 添加集合中的元素
animals.remove("fish") # 删除集合中的元素
print(animals)  # 集合中的元素是无序的，所以每次打印出来的顺序可能不同
print(len(animals)) # 获取集合中的元素个数
# 遍历
names = ""
for animal in animals:
    names += animal + ","
print(names)

Tuple

# 元组 Tuple 对应java中的List，但是是不可变的
# 元组是Python中另一个常用的数据集合，它是有序的不可变序列，可以包含任意类型的元素。

# 元组的基本语法如下：
# 下面是一个简单的例子，演示了如何使用元组：
# 元组的元素是不可变的，所以不能修改元组中的元素
fruits = ("apple", "banana", "cherry")
print("---------------tuple-----------------")
print(fruits)
print(fruits[0]) # 访问元组中的元素
print(fruits[1:3]) # 访问元组中的元素，从索引1到索引3（不包括索引3）
print(fruits[2:]) # 访问元组中的元素，从索引2到元组末尾
# fruits[0] = "orange" # 修改元组中的元素，会报错

函数

定义

函数是一段可重复使用的代码块，用于完成特定的任务。是通过def关键字来定义的。 函数的基本语法如下：

def 函数名(参数列表):
    # 函数体
    # 函数体中的代码会被重复执行
    # 每次调用函数时，会执行函数体中的代码

def add(a, b):
    """
    计算两个数的和
    :param a: 第一个数
    :param b: 第二个数
    :return: 两个数的和
    """
    return a + b
# 调用函数
result = add(1, 2)
print(result)

全局变量 和 局部变量

• 全局变量：是在函数外部定义的变量，在函数内部可以访问和修改。
• 局部变量：是在函数内部定义的变量，只能在函数内部访问和修改。

x = 10 # 全局变量
def add(a, b):
    """
    计算两个数的和
    :param a: 第一个数
    :param b: 第二个数
    :return: 两个数的和
    """
    y = 20 # 局部变量
    return a + b + x + y
# 调用函数
result = add(1, 2)
print(result) # 33
# print(y) # 报错，y是局部变量，只能在函数内部访问和修改

# 在函数内修改全局变量
z = 10 # 全局变量
def add(a, b):
    """
    计算两个数的和
    :param a: 第一个数
    :param b: 第二个数
    :return: 两个数的和
    """
    # 在其他编程语言
    # z = 20 # 尝试修改全局变量 发现不生效
    global z # 声明z是全局变量
    z = 20 # 修改全局变量
    return a + b + z
# 调用函数
result = add(1, 2)
print(result) # 23
print(f"def add(a, b): 中的z是{z}") # 20

如果要在函数内修改全局变量，需要在函数内用global 修饰才会生效。

类

类class 类是面向对象编程的基本概念之一，它是一种抽象的数据类型，用于描述具有相同属性和方法的对象集合。类的定义使用class关键字，类的属性和方法可以在类的内部定义。

class 类名:
# 类的属性
# 类的方法

其实只要我们有了函数之后，作为一个程序语言，也不缺啥了， 那为什么还要搞一个 类Class 出来呢？永远记住，搞出这个东西来，永远都只有一个目的，就是让用语言觉得更省事， 更方便地处理一些具体问题。
那是发什么，才让工程师想要发明 class 这种用法呢？答案也很简单， 就是工程师们想要在程序中描述具体的一个物体了。 比如一只猫有哪些特征，它能做哪些动作。 工程师想出了一个在代码中设置猫特征和动作的办法， 这就有了 class 类的概念。

例子：

class Animal:
    # 类的属性
    name = "Tom"
    age = 3
    color = "white"

    # 构造函数
    # 构造函数是一个特殊的方法，用于初始化类的实例。在Python中，构造函数的名称是__init__。
    # 构造函数的基本语法如下：
    # def __init__(self, 参数列表):
    def __init__(self, name, age, color = "white"):
        self.name = name
        self.age = age
        self.color = color
        print("猫的名字是：", self.name)
        print("猫的年龄是：", self.age)
        print("猫的颜色是：", self.color)

    # 类的方法
    # 参数self是一个约定俗成的名称，用于表示当前对象的引用
    def eat(self):
        print("动物吃食物 self.name = ", self.name)
    # __表示私有方法，只能在类的内部访问和修改
    def __sleep(self):
        print("动物睡觉")
    # _表示弱私有方法，外部可以访问
    def _play(self):
        print("动物玩游戏")

创建对象实例化：

# 参数列表中的参数顺序和构造函数中的参数顺序必须一致。
# animal = Animal("Tom", 3, "white")

# 参数列表中的参数顺序和构造函数中的参数顺序可以不一致，但是必须指定参数的名称。
animal = Animal( age=3, name="Tom", color="white")

animal.eat()
# animal.__sleep() # 报错，私有方法只能在类的内部访问和修改
animal._play() # 不报错 ，是一个弱私有方法
# cat.name # 猫的名字是： Tom

继承：

# 类的继承
# 类的继承是面向对象编程的一种重要概念，它允许我们创建一个新类，该类继承自一个或多个已有的类。
# 下面是一个简单的例子，演示了如何定义一个类的子类：
class Dog(Animal):
    """
    狗类
    """
    # 类的属性
    name = "Dog"
    age = 5
    color = "black"
    # 构造函数
    def __init__(self, name, age, color = "black"):
        super().__init__(name, age, color)
        print("狗的名字是：", self.name)
        print("狗的年龄是：", self.age)
        print("狗的颜色是：", self.color)
    # 类的方法
    def eat(self):
        print("狗吃食物")

    def sleep(self):
        # 调用父类的方法
        self.__sleep()
        print("狗睡觉")
    def play(self):
        self._play()
        print("狗玩游戏")

dog = Dog("Ali", 5, "black")
dog.play()

模块

一般来说，如果你的工程在一个脚本文件中就能写完搞定，那么就不用搞module这种概念， module主要是为了一个相对比较大的工程，涉及到多个文件之间的互相调用关系。 如果一个文件写所有的代码可能成千上万行，阅读起来一点也不友善， 所以我们更长是将大项目的长代码拆开成多个模块，用文件夹和多文件的方式管理起来，方便后期维护。 这就有了 module 模块的程序代码管理方式。

src
|__ files
|	|__ file.py
|__ module.py

file.py

def create_file(filename, content):
    """
    创建一个文件
    :param filename: 文件名
    :param content: 文件内容
    :return: None
    """
    with open(filename, "w") as file:
        file.write(content)

def read_file(filename):
    """
    读取一个文件
    :param filename: 文件名
    :return: 文件内容
    """
    with open(filename, "r") as file:
        return file.read()

module.py

# as 是一个关键字，用于给模块起一个别名。
import files.file as fs  # 导入模块

# 全量导入
# from files.file import *  # 导入模块中的所有内容
# 部分导入
# from files.file import create_file, read_file  # 导入模块中的部分内容

# 调用模块中的函数
fs.create_file("hello.txt", "hello world")

file_content = fs.read_file("hello.txt")
print(file_content)

异常处理

为了保证程序出错了，能够继续向下执行，异常处理是至关重要。语法：

"""
try-except 异常处理
try:
    可能会出现异常的代码
except:
    出现异常后的处理代码    （如果出现异常，就执行这里的代码）
else:
    没有异常时执行的代码    （如果没有异常，就执行这里的代码）
finally:
    无论是否出现异常，都会执行的代码    （不管是否出现异常，都会执行这里的代码）

"""

基本使用

# 1. 基本用法
try:
    print(1/0)
except:
    print("出现异常")
else:
    print("没有异常")
finally:
    print("无论是否出现异常，都会执行的代码")

#2.处理多个异常，其中BaseException是所有异常的基类

try:
    print(1/0)
    # print(a)
except ZeroDivisionError as e:
    print(e)
except NameError:
    print("变量未定义")
else:
    print("没有异常")
finally:
    print("无论是否出现异常，都会执行的代码")

# 3. 手动抛出异常    raise
name = input("请输入你的名字：")
if name == "admin":
    raise BaseException("管理员不能登录")

生成器

首先来看一个例子：

 items = []
 for i in range(5):
     items.append(i)
 for item in items:
     print(item)

在遍历的过程中都会将i 缓存到items数组中，然后再去遍历这个数组做一些逻辑，这种场景开发中应该很常见的。如果缓存的数据量比较大，消耗的内存也会随之升高。

下来我们可以通过生成器来避免这种情况的发生，通过生成器函数来达到节省内存的效果。

定义一个函数，函数中包含yield关键字，那么这个函数就变成了一个生成器函数;当调用生成器函数，会得到一个生成器对象。

# 1. 生成器函数，用yield来定义生成器函数
def gen():
    yield 1
    yield 2
    yield 3
# 2. 调用生成器函数，会得到一个生成器对象
# 调用生成器对象的__next__方法，会依次获取生成器中的值 1.2.3
g= gen()
print(g.__next__())
print(g.__next__())
print(g.__next__())

用生成器函数优化后：

# 可以使用生成器来解决这个问题, 去除了数组缓存
def get_item():
    for i in range(5):
        yield i
for item in get_item():
    print(item)

除了生成器函数，还有生成器类：

# 定义生成器类

class NeedReturn:
    def __init__(self, init_value=0):
        self.tmp = init_value
        self.item = 0

    # 当我在外面 for 循环进行迭代时，我返回什么， 这里返回self自己 继续迭代
    def __iter__(self):
        return self

# 每次迭代的时候，我的函数会放出来什么元素
    def __next__(self):
        while True:
            if self.item == self.tmp:
                self.tmp *= 2
                return self.item
            self.item += 1
            if self.item == 300:
                raise StopIteration

for i in NeedReturn(10):
    print(i)

到这里Python的基本知识点就完成了，对于一些简单的脚本是完全够用的。

如果再深入的话，可以去学习了解下：

• 多线程多进程
• 数据三剑客 Numpy、Pandas、Matpotlib
• 数据采集 — 爬虫