python编程基础

1.变量和简单的数据类型

打印输出

字符串

数

python之禅：不要企图编写完美⽆缺的代码，⽽是要先编写⾏之有效的代码，再决定是对其做进⼀步的改进，还是转⽽编写新代码

1.1 字符串

1. 格式化打印

   • "{}".formate形式

   • f"{}"形式

   如下：

    ​

2. 大小写

   • 首字母大写：title()

   • 全大写：upper()

   • 全小写：lower()

   如下：

    ​

3. 字符串中使用变量

   • 方法：f"{}"

   • 又称f字符串，f为formate的首字母

   如下：

    a = '1'
    b = '2'
    c = f"{a} + {b}"

4. 转义字符

   • 使用\表示转义

5. 空白符号删除

   • 左边：lstrip()

   • 右边：rstrip()

   • 两边：strip()

6. 删除前后缀

   • 前缀：removeprefix(str)

   • 后缀：removesuffix(str)

   如下

    filename = 'python_notes.txt'
    print(filename.removesuffix('.txt'))    # 删除前缀：removprefix()
    ​
    # 结果为：python_notes

1.2 数

1. 运算符

   • 加减乘除：+ - * /注意/的结果为浮点数

   • 乘方：**

   • 整除：//结果为整数

2. 规则：

   • 大数：14_00_000_000可以用下划线进行分割，但是值不变

   • 常量：全大写表示常量

2.列表

1. 列表定义

   • list = []

   • 类似于c数组

2. 列表数据操作

   • 增：insert()、append()

   • 删：del语句、pop()、remove()

   • 改：list[index] = xx

   • 查：list[index]

   使用如下：

    list = ['西安', '武汉', '重庆', '长沙', '北京', '深圳', '杭州']
    list.insert(0, '成都')
    print(f"insert 【成都】， list = {list}")
    list.append('云南')
    print(f"append【云南】，list = {list}")
    ​
    list.pop(-3)
    print(f'pop(-3) = 杭州，list = {list}')
    list.remove('深圳')
    print(f'remove(深圳)，list = {list}')
    del list[0]
    print(f'del list[0] = 成都 list = {list}')
    ​
    list[-1] = '喀什'
    print(f'list[-1]=喀什 list = {list}')

3. 列表管理

   • list.sort()

   • sorted(list)

   • len(list)

   • reverse()

   用法：

    list = ['西安', '武汉', '重庆', '长沙', '北京', '深圳', '杭州']
    print(f"list len = {len(list)}")
    list.reverse()  # 反转列表
    print(f"list.reverse() = {list}")
    list.sort(reverse=True)
    print(f"list.sort(reverse) = {list}")
    print(f"sorted(list) = {sorted(list)}")
    print(f"sorted(list, reverse) = {sorted(list, reverse=True)}")

4. 切片

   • 使用:进行切片

   • 复制同样要用:

   如下；

    my_foods = ['pizza', 'falafel', 'carrot cake']
    friend_foods = my_foods[:]
    print(my_foods[0:3])
    ​

5. 列表操作：

   • 遍历

   • 数值列表

   如下：

    # 遍历1
    for index in range(0, len(friend_foods)):
        print(friend_foods[index])
    # 遍历2
    for food in my_foods:
        print(food)
    # 数值列表
    nums = list(range(0, 20))
    print(nums)

3.元组

1. 定义：

• 类似列表

• 元组不可修改

• 元组变量可重新赋值

2. 示例： 如下：

   # 元组定义
   foods = ('rice', 'ic-cread', 'kfc', 'noodles', 'dumplings')
 ​
   #元组重新赋值
   foods = ('noodles', 'dumplings', 'chRice', 'KFC', 'sichuancai')

4.if语句

1. 简单用法：

   如下：

    # xx1为条件表达书，xxx2为执行结果
    if xxx1 :
        xxx2

2. 多层转折 如下：

    # 多条件
    if xxx1 :
        xxx
    elif xxx2 :
        xxx
    else:
        xxx

5.字典

1. 定义：

   • 键

   • 值

   • 花括号

   定义如下：

    favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    }

2. 字典操作：

   • 访问

   • 修改

   • 增加

   • 删除

    # 字典访问
    print(favorite_languages['jen'])
    print(favorite_languages.get('jen'))
    # 字典修改
    favorite_languages['jen'] = 'c'
    # 字典增加
    favorite_languages['tump'] = 'java'
    # 字典删除
    del favorite_languages['tump']

3. 字典遍历

   • 键值遍历

   • 键遍历

   • 值遍历

   注意：key()、value()的返回值是一个list！

    # items()遍历
    for name, language in favorite_languages.items():
        print(f'name = {name}, language = {language}')
    # key()遍历，可缺省，favorite_languages.key()返回值是list
    for name in favorite_languages:
        print(f'name = {name}')
    # value()遍历，不可缺省
    for language in favorite_languages.values():
        print(f'language = {language}')
    # key(), value()返回值都是list
    if 'python' in favorite_languages.values():
        print('True')

4. 补充

   • get()方法防止报错

   如下：

    # 使用get()方法取出key=jen的value，如果key=jen不存在，则返回none
    print(favorite_languages.get('jen'))

5.2 特定顺序遍历字典

1. 方法：

   • key()方法

   • sorted()函数对list进行排序

   示例：

    # 排序遍历
    for name in sorted(favorite_languages.keys()):
        print(name)

2. 集合

   • value()

   • set()剔除重复项

   示例：

    # value排序遍历
    for language in set(favorite_languages.values()):
        print(language.title())

   注意，集合同样用花括号创建，其定义方式如下：

    # 集合
    langeSet = ['python', 'c', 'rust']

5.3 嵌套

1. 列表嵌套列表 方法：

  # 与二维数组类似
  nums = []
  for index in range(0, 10):
      nums.append( list(value * 2 for value in range(10, 20)))

  for num in nums:
      print(num)

2. 列表嵌套字典 方法：

  for ailen_number in range(0, 30):
      new_alien = {'color' : 'yellow', 'points' : 5, 'speed' : 'slow'}
      aliens.append(new_alien)

  # ----------------------------------------------
  # {'color': 'yellow', 'points': 5, 'speed': 'slow'}
  # {'color': 'yellow', 'points': 5, 'speed': 'slow'}
  # ...

3. 字典嵌套列表 方法：

favorite_nums = {
    'LiXiang' : [1, 3],
    'LiuXiang' : [1, 1, 1, 1],
    'YaoMin' : [1],
}

4. 字典嵌套字典 方法：

cities = {
    'xian':{'country' : 'china', 'population' : '10000', 'fact' : 'good city'},
    'chengdu':{'country' : 'china', 'population' : '10000', 'fact' : 'good city'},
}

6.用户输入与while循环

6.1 用户输入

1. 获取用户输入 利用input()函数，如下：

    # 汽车租赁
    car = input('what cat you want to rent?\t')
    print(f"Let me see if i can find you a {car}")

2. 获取整数输入 利用int()，如下：

    num = int( input("有多少人用餐？\n") )

   int()将获取的字符型输入，转换成int型

6.2 while循环

1. 用法 和c一样：

    material = ''
    while material != 'quit':
        material = input('输入配料\n')
        print(f"将{material}加入配料中\n")

2. 注意： True、False首字母大写，否则无法识别

7. 函数

7.1 函数的使用

1. 定义 使用def声明，表明参数和冒号，如下：

   def favorite_book(book):
       print(f'my favorite book is {book.title()}')

2. 列表副本 传入副本，则值不会被改变，如下：

   def favorite_book(books[:]):
       print(books)

3. 参数默认值 函数定义时写好就行

   def make_album(name, album, num = None):
       return {'name':name, 'album':album, 'num':num}

4. 不固定参数 固定参数放前面，最后一个带星号的参数表示不固定的参数，如下：

   def add_material(*args):
       print('your fodd add:')
       for arg in args:
           print(f'{arg}')

5. 字典参数 两个星号表示传入一个名为该值的字典，如下所示：

    def build_profile(first, last, **user_info):
        """创建⼀个字典，其中包含我们知道的有关⽤户的⼀切"""
        user_info['first_name'] = first
        user_info['last_name'] = last
        return user_info
    ​
    user_profile = build_profile('Li', 'XiaoLong', age=18, sex='man')
    ​
    print(user_profile)

   传参方式和使用方式如上述代码

7.2 module定义及引入

1. 引入 多种方式，但是不推荐使用*引入所有的，如下：

    # 1
    import model as m 
    m.function(xxx, xxx)
    ​
    # 2
    from model import function_1
    function_1(xxx, xxx)
    ​
    # 3 不推荐此种方式
    from model import *
    function_1(xxx, xxx)

2. 模考的定义 函数拆分，单独功能，放到py文件中就行：

    # ptint_model.py
    def show_completed_model(completed_models):
        # 显⽰打印好的所有模型
        print("\nThe following models have been printed:")
        for completed_model in completed_models:
            print(completed_model)
    ​
    # 引入
    # import print_model as pm
    # pm.show_completed_model(xxx)

7.3 编程规范

1. 命名 给函数指定描述性名称，容易理解

2. 默认参数赋值 注意等号两边没有空格，如下规范：

    def make_shirt(size, words='xxx'):
        xxxx

3. 函数注释 函数注释紧跟在函数定义后面，并采用文档字符串的格式，如：

    def make_shirt(size, words):
        """
    ​
        :param size: 尺码
        :param words: 印字
        :return: 返回列表
        """

4. 形参过长处理 使用如下方式，注意缩进一个tab

    def function_name(
            parameter_0, parameter_1, parameter_2,
            parameter_3, parameter_4, parameter_5):
        function body...

5. 导包注意 放到文件开头，或者紧跟着放到文件头注释后 此外，不建议使用*把module的所有函数全部倒过来，这样容易冲突从而导致同名函数覆盖

8.类

类、继承、模板、导入

8.1 类的定义及使用

1. 面向对象编程 现实世界的实例，抽象为类。将类实例化为具体的对象，这样的编程过程即面向对象编程。 举例：将猫、狗共性抽象为动物类animal（共性概括），然后从animal实例化（具体化）为cat、dog等等。其中从抽象到具体的的过程即实例化。

2. 类 一类具象事务的共性概括，例如大橘、狸花、三花的共性特征都是猫，那么就可以将这一类事务抽象概括共性为猫类（cat）

3. 创建类 使用class进行定义，如下：

   class Cat:
       """对猫进行抽象"""
       def __init__(self, name, type='狸花'):
           self.name = name
           self.type = type
       def get_name(self):
           """获取猫的名字"""
           print(self.name)

4. 类的创建规则

   • 首字母大写

   • 定义类后，紧紧接着进行注释说明

   • 使用__init__()进行构造

5. 对__init__()的说明

   • 前后两个下划线

   • self形参不能少，且必须位于其他形参前面

   • 类的属性都在该方法中

6. 对象实例化 调用类通过__init__()方法进行实例化，如下：

    cat = Cat('mao', '大橘')

7. 属性访问 两种方式，一种是通过实例化的对象直接访问，另一种是通过内置方法进行访问（推荐），如下：

    cat = Cat('mao', '大橘')
    print(cat.type) # 1直接访问
    cat.get_name()  # 2通过内置方法访问

8.2 继承

1. 继承概述 如果一个类和另一个类有共性，但存在另一个类所没有的特性，我们可以使用继承，这样就不用重新构造一个类了。 被继承的类称为父类，继承的类称为子类

2. 继承使用 将父类括起来放在子类后面，表示继承，如下Cat类继承自Animal：

    class Animal:
        """对动物进行模拟"""
        def __init__(self, name, type='狸花'):
            self.name = name
            self.type = type
        def get_name(self):
            """获取猫的名字"""
            print(self.name)
    ​
    class Cat(Animal):
        """对猫进行抽象"""
        def __init__(self, name, type, age):
            super().__init__(name, type)
            self.age = age

3. 关于super()函数 super()可以用来调用父类的方法，如上面就是用super调用了父类的构造方法

4. 父类方法重写 重写父类同名方法即可如在Cat类重写get_name(()方法：

        def get_name(self):
            """重写父类方法"""
            return self.name

8.3 组合

1. 组合概述 将类的某一部分进行提取，将大类再划分为不同小类，这样大类和小类组合后，减少代码行数，使得整个代码的主逻辑更加清晰。 核心：简化代码，关注核心逻辑

2. 组合示例 由于要对电动车电池进行详细描述，因此可以将电池单独抽象为一个类，如下：

    class Car:
        """模拟车"""
        def __init__(self, name, type):
            self.name = name
            self.type = type
        def show_name(self):
            print(self.name)
    ​
    class Battery:
        """电池类"""
        def __init__(self, type, size=60):
            self.size= size
            self.type = type
        def get_battery_size(self):
            """显示电池容量"""
            print(self.size)
    ​
    class EletricCar(Car):
        """电动车类，继承自Car"""
        def __init__(self, name, type):
            super().__init__(name, type)
            self.battery = Battery('Li', 128)
    ​
    car = EletricCar('LiXiang', 'SUV')
    car.battery.get_battery_size()

   上述代码，将电池单独抽离出来，这样使得ElectricCar类属性更加清晰，代码更加易懂。 调用时，通过链式调用即可完成对相关属性的访问

3. 组合的注意点

   • 属性抽象为类，该类要在使用之前被声明

   • 类的属性通过实例化，来调用被抽象的类

   • 链式调用，实现对属性类的属性进行访问

8.4 类的导入

1. 概述 类可以放到模板中，然后通过import进行导入，这样会简化主函数的工作流程，使得主逻辑清晰易懂

2. 模块与类 将具有相关性的类集中放置在一个模块中（.py文件）中，使用时利用improt进行导入即可，如下： 我们可以将上面的类统一放到car.py模块中：

    class Car:
        """模拟车"""
        --snip - -
    ​
    class Battery:
        """电池类"""
        --snip--
    ​
    class EletricCar(Car):
        """电动车类，继承自Car"""
        --snip--

   当要调用时，使用impot进行调用即可

3. 模块类的调用 使用import进行导入，注意尽量是使用那个类进行单独调用，尽量不要使用import *容易导致充满覆盖的情况，推荐如下：

    from car import EletricCar as Elec

   其中as为EletricCar创建别名为Elec，这样就可以用别名来创建实例了

8.5 python标准库

1. 随机生成整数 使用randint()可以，用法如下：

    from random import randint
    randint(1,6)    #随机生成一个位于1-6（含）之间的数

2. 从列表中随机选数 使用choice()，可以从列表or元组中随机选其中一个元素。

3. 注意： 在创建与安全相关的应用程序，不要使用random。

8.6 类的编程风格

1. 命名规范 驼峰命名法：

   • 类名的每个单词的首字母都要大写，且不使用下划线

   • 实例名和模块名都采用全小写，单词之间加上下划线

2. 代码组织规范 可以使用空行组织代码，规则如下：

   • 类的方法，可以用一个空行来分隔

   • 模块的类，可以使用两个空行来分隔

3. 模块导入规范 先库后其他，通过一个空行进行区分：

   • 先导入标准库的模块

   • 空行

   • 再导入自己编写的模块

9.文件和异常

文件的读写

异常的处理

9.1 读取文件

1. 使用Path进行读取 如下：

    from pathlib import Path
    ​
    path = Path('test.txt')
    contents = path.read_text()
    print(contents)

2. 文件读取流程 四步，如下：

   • 导入Path

   • 获取文件路径

   • 读取文件内容

   • 打印文件内容

3. 按行读取 使用splitlines()方法将：

    from pathlib import Path
    ​
    path =  Path('10.1_python_note.py')
    content = path.read_text(encoding='utf-8')
    ​
    lines = content.splitlines()
    for line in lines:
        print(li

   其中encoding='utf-8'指出，以utf-8的方式对文件进行读取

9.2 写入文件

1. 将内容写入文件 使用write_text()将内容写入指定文件，如下：

    from pathlib import Path
    ​
    path =  Path('10.1_python_note.py')
    contents = "hello world"
    path.write_text(contents)

   写入流程：

   • 指定文件路径

   • 指出文件内容

   • 写入内容到文件

2. 数值写入 注意，python只能将字符串写入文本文件，如果要将数值数据存储到文本文件中，需要先使用str()将其转换为字符串格式

3. 写入注意事项 如果文件已存在，write_text()会将文件内容进行覆盖，预备写入的内容并不会追加到文本中。

9.3 异常

1. 异常 程序执行过程中发生的错误，称之为异常。发生异常后，会显示一个traceback用以显示异常报告。

2. 异常处理 当程序报错，使用异常处理可以使程序继续运行而非直接结束。 再python中，可以通过try-excpt代码块进行异常处理。

3. 使用try-except代码块 当可能发生错误时，可以使用该代码快使其告诉python如何来处理异常，以分母为0的异常处理为例：

    try:
        print(4/0)
    except ZeroDivisionError:
        print('error')

   这里，当分母为0时，程序会打印出error

4. 使用else代码块 当try中代码成功执行后，才能执行else中的代码，如下：

    try:
        result = first/last
    except ZeroDivisionError:
        print('error, last is zero')    # 友好消息
    else:
        print(result)

   当代码中last不为0时，则会使用print打印输出相除的结果。否则则会打印输出error, last is zero，通常将这样的提示称之为“友好消息”

5. 静默失败 除了提示友好消息外，还可以对失败异常静默处理，如下：

    ​
    try:
        result = first/last
    except ZeroDivisionError:
        pass
    else:
        print(result)

   使用pass语句，当发生异常后，程序不做任何处理。

9.4 数据存储

1. 采用json存储数据 用户提供的信息，python处理时不外乎使用字典、列表等进行暂存，但是想要对缓存数据进行长期存储时，则可以使用json格式存储至指定文件。

2. json文件的写入 使用json.dumps()将数据转换为json格式，然后使用write_text()进行写入，如下：

   from pathlib import Path
   import json
 ​
   nums = [1, 3, 4, 9, 8]
   path = Path('files/hello.json')
   contents = json.dumps(nums)
   path.write_text(contents)

3. json文件读取 使用json.loads()将json数据转换为对应的数据结构，如下：

   from pathlib import Path
   import json
 ​
   path = Path('files/hello.json')
   contents = path.read_text()
   nums = json.loads(contents)
   print(nums)

4. json文件格式写入流程

• 导包

• 确定写入文件位置

• 确定写入数据

• 将写入数据转换为json格式

• 使用write_text()进行写入

5. json文件格式数据读取流程

• 导包

• 确认文件位置

• 读取json文件数据

• 转换json数据格式为对应的数据结构

• 对数据进行操作

6. Path类的方法 可以使用exits()方法判断文件是否存在，如果文件存在则说明文件中存储的又数据信息，这时候则不能直接对文件进行写入，否则会对其进行覆盖。

9.5 重构

1. 概述 重构是指，将已经能够正确运行的代码，划分为一系列完成具体工作的函数来进行改进的过程，称之为重构。 代码重构的过程，就是将diamagnetic向着更清晰、更易理解、更易扩展的方向努力，使主函数逻辑处理更加清晰。

2. 代码示例 如下：

    from pathlib import Path
    import json
    def greet_user():
        """问候⽤户，并指出其名字"""
        path = Path('username.json')
        if path.exists():
            contents = path.read_text()
            username = json.loads(contents)
            print(f"Welcome back, {username}!")
        else:
            username = input("What is your name? ")
            contents = json.dumps(username)
            path.write_text(contents)
            print(f"We'll remember you when you come back, {username}!")greet_user()

3. 代码重构 将其划分为一系列完成具体工作的函数，改造结果如下：

    from pathlib import Path
    import json
    ​
    def get_stored_username(path):
        """如果存储了⽤户名，就获取它"""
        if path.exists():
            contents = path.read_text()
            username = json.loads(contents)
            return username
        else:
            return None
    ​
    def get_new_username(path):
        """提⽰⽤户输⼊⽤户名"""
        username = input("What is your name? ")
        contents = json.dumps(username)
        path.write_text(contents)
        return username
    ​
    def greet_user():
        """问候⽤户，并指出其名字"""
        path = Path('username.json')
        username = get_stored_username(path)
        if username:
            print(f"Welcome back, {username}!")
        else:
            username = get_new_username(path)
            print(f"We'll remember you when you come back, {username}!")
    ​
    greet_user()

4. 示例说明 重构后的代码，每一项都执行一个单一的清晰的任务，这样的代码明显更容易理解了，也更容易拓展了。

5. 注意 不要盲目的追求极致的重构，先写出能运行的代码，然后再逐步改进

10.测试代码

测试代码可以批量化，通过pytest确保修改后的程序其功能达到预期

10.1 pytest库

1. 简介 第三方包，需要通过pip进行安装，该包用于测试

2. 安装pytest 使用pip进行安装，先对pip进行更新，然后安装pytest

    python -m pip install --upgrade pip
    ​
    python -m pip install --user pytest

10.2 测试代码

1. 编写测试代码 测试代码需要按照一定的命名规则，主要如下：

   • 测试文件名称：必须以test_开头

   • 测试函数名称：必须以test_开头

   • 测试函数名称长度：比典型的函数名更长，更具有描述性

   • 做出断言：使用asssert做出断言

2. 测试运行 编写完成测试代码后，在终端使用pytest运行所有测试，对于终端输出的结果描述，如下图：

3. 未通过的测试 对于未通过的测试，会i显示对应的错误信息，如下：