Error_666
0%

Python基础

发表于 更新于 分类于 ，
本文字数： 3.7k 阅读时长 ≈ 3 分钟

什么？你连基本的Python相关知识都不会？

顺序、判断、循环

  1. 变量类型

    1. int、float、str、bool
    2. list（列表）[1, 2, 3]
    3. tuple（元组）(1, 2, 3)
    4. set（集合）{1, 2, 3}
    5. dict（字典）{1: “python”, “acwing”: 2, 3: 4.0}

  2. 输入

    • 使用input()函数，input()函数可读入一行内容，返回类型为str。一般配合split()、map()函数使用。

      • a = (int)(input()) b = (int)(input())：读入两个整数，一个整数一行。
      • a, b = map(int, input().split())：读入两个空格隔开的整数。
      • split()会将一行字符串以空格作为分割符分开，返回一个字符串列表。map(func, var)会将func作用于var里的每个元素，返回作用后的var。
      • a = list(map(int, input().split())))：读入一行数存到列表a中

    • 当不知道读入的行数时，使用下列代码

      1
      2
      3
      from sys import stdin
      for line in stdin.readlines():
        print(line.strip()) # strip()是为了去掉行末的回车

  3. 输出

    • print(val1, val2, ..., end='')：输出多个内容默认用空格隔开，可自定义结尾字符
      • round(x, 1)：将x保留1位小数
      • print("x = %.2f, y = %.3f" % (x, y))：同样也可以用格式化输出（%分割，后面多个参数的话要用括号括起来）
      • 格式化输出想输出%的话，写%%

  4. if/while/for里的变量，在语句外可以访问

    • 例如

      1
      2
      3
      4
      5
      6
      if a > b:
          max_value = a
      else:
          max_value = b
          
      print(max_value)

  5. 条件表达式

    1. and、or、not：与或非
    2. max_value = a if a > b else b：三目运算符，max_value=a仅当a>b时成立，否则=b

  6. 运算

    1. a, b = b, a：交换两个数
    2. python支持链式运算，例如if a >= b >= c: ...

  7. for循环

    1. for c in "abc"：依次输出每个字符
    2. for i in range(r)：输出0, 1, ..., r - 1
    3. for i in range(l, r)：输出l, l + 1, ... , r - 1
    4. for i in range(l, r + 1, 2)：在[l, r]范围内，输出l, l + 2, l + 4, ...

列表

  • 初始化
    • 用循环 + append初始化
    • 直接初始化
      • a = [0 for i in range(3 + 1)]：a此时为[0, 0, 0, 0]
      • a = [i * i for i in range(3 + 1)]：a此时为[0, 1, 4, 9]
  • 切片
    • a[l:r]：返回a[l], a[l+1], ..., a[r-1]（l、r可缺省）
    • a[1:]：返回a[1], a[2], ... a[len(a) - 1]
    • a[1:3] = [2, 3]：等价于a[1]=2, a[2]=3
    • a[1:3] = [0]：等价于a[1]=0，把a[2]删掉
    • a[1:3] = []：等价于把a[1]、a[2]删掉
  • 复制
    • 不能用等号复制，用等号复制的话相当于新列表只是原列表的一个别名。修改新列表仍会对原列表产生影响。
    • 用切片复制即可，即b = a[:]
  • 列表的运算
    • 列表的加法可以将两个列表拼接起来，得到一个新列表。
    • 列表乘以一个整数，可以将若干个自身拼接起来，得到一个新列表。
    • 将列表中的每个元素加上一个1
      • a = [x + 1 for x in a]
  • 列表常用函数
    • len(a)：返回列表长度
    • a.append(x)：尾部插入x
    • a.insert(pos, x)：在pos处插入x
    • a.pop()：删除尾部最后一个元素
    • a.pop(pos)：删除下标为pos处的元素
    • a.reverse()：翻转
    • a.sort()：排序
      • a.sort(key=lambda x: (x[1], x[0]))：a是一个列表，列表里的元素也是列表（里头有2个数），想先按照第二关键字排序，相等再按照第一关键字排序，就这样写。（默认是从小到大，从大到小可以加一个负号）

字符串

  • ord(c)：返回一个字符的ascii码
  • chr(a)：返回一个ascii码对应的字符
  • 注意，虽然字符可以跟整数相互转化，但在Python中字符不能参与数值运算
  • 使用""直接赋值，使用""" """可以赋值多行
  • 字符串不能修改，切片也不像列表一样支持写操作
  • 字符串支持加法、乘法、比较运算
  • 常用函数
    • len(s)：返回字符串长度
    • s.split(sep)：返回一个字符串列表。如果给出了sep就按sep分隔；如果没给出，则会按空格分隔，但连续的空格会被视为单个分隔符，而且会忽略首尾的空白字符。
    • s.strip()：返回将首尾的空白字符删除后的结果
    • s.replace(old, new)：将s中所有的old子串都改成new
    • s.find("abc")：查询某个子串在s中第一次出现的下标；如果不存在，则返回-1。
    • s.lower()：将所有大写字母变成小写。
    • s.upper()：将所有小写字母变成大写。
    • s.join(a)：a是一个字符串列表，这个函数返回将a中的字符用s作为分隔符拼接起来的结果。
    • s.startswith(prefix)：判断prefix是否为s的前缀。
    • s.endswith(suffix)：判断suffix是否为s的后缀。

元组

  • 元组跟列表类似，只是不支持动态添加、删除元素，以及不能修改元素。其余用法类似。

  • 元组需要用小括号括起来（也可以不加），中间的元素用逗号隔开。如果初始化只包含一个元素的元组，需要在该元素后添加逗号。

  • 元组的解包

    1
    2
    3
    4
    5
    6
    7
    8
    9
    t = 12345, 54321, "Hello!"
    x, y, z = t # 将元组t解包，将元组内的三个值按顺序赋值给x、y、z

    a, b = b, a # 这句话本质也是元组解包，就是将元组(b, a)解包，分别赋值给a, b

    def cal(x, y):
        return x + y, x * y # 函数的返回值本质也是元组的解包

    a, b = cal(a, b)

集合

  • 创建集合用花括号或set()函数。创建空集合只能用set()，不能用{}，因为{}创建的是空字典。

  • 初始化

    1
    2
    3
    4
    5
    6
    7
    basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}  # 会自动去除重复元素
    print(basket)  # 重复的元素已经去除了

    a = [1, 2, 1, 3, 1]
    b = set(a)  # 将列表转化成集合，一般是为了去重。
    c = list(b)  # 将集合转化回列表
    print(b, c)

  • 常用函数

    • len(a)：返回集合中的元素数量
    • a.add(x)：向集合中添加一个元素
    • a.remove(x)：删除集合中的x，如果集合中没x则报错
    • a.discard(x)：删除集合中的x，如果集合中x不存在也不会管
    • x in a：判断x是否在a中
    • x not in a：判断x是否不在a中

字典

  • 创建字典用花括号或dict()函数。

  • 初始化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    tel = {'jack': 4098, 'sape': 4139}  # 创建一个字典
    print(tel)  # 输出 {'jack': 4098, 'sape': 4139}

    a = dict()  # 创建一个空字典
    a[123] = "abc"  # 在字典中插入一个key-value对
    a[456] = "def"  # 在字典中插入一个key-value对
    print(a)  # 输出 {123: 'abc', 456: 'def'}

    b = list(a)  # 将字典的关键字转化成列表
    print(b)  # 输出[123, 456]

  • 常用函数

    • len(a)：返回字典中键值对个数
    • a[x]：获取关键字x对应的值，如果x不存在，会报异常
    • a.get(x)：获取关键字x对应的值，如果x不存在，不会报异常
    • a.get(x, y)：获取关键字x对应的值，如果x不存在，会返回默认值y
    • del a[x]：删除关键字x对应的元素对
    • x in a：字典中是否有x关键字
    • x not in a：字典中是否没有x关键字
    • a.keys()：返回字典中所有关键字，以列表形式
    • a.values()：返回字典中所有值，以列表形式
    • a.items()：返回字典中所有键值对，以列表形式，每对键值对是一个元组

函数

  • 函数内定义的变量为局部变量，只能在函数内部使用。当需要修改用全局变量时，需要用global关键字在函数内声明全局变量。
  • 传参时，传数/str是值传递，列表是引用传递。

类

  • 类中函数的第一个参数都是self，用来调用类本身的变量和函数。当调用类中函数的时候，第一个参数self不需要自己传递，Python会自动传递这个参数。

  • 例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    class Hero:
        hero_count = 0  # 类变量

        def __init__(self, name, level=10):  # 构造函数
            self.name = name
            self.level = level
            print("Hero %s has been created." % name)
            Hero.hero_count += 1

        def __str__(self):  # 定义str()函数的效果
            return "Hero: %s" % self.name

        def greet(self):  # 问候
            print("%s: Hi!" % self.name)

        def move(self):  # 移动
            print("%s: Move!" % self.name)

        def get_level(self):  # 获取这个英雄的等级
            return self.level

        def next_level(self):
            return self.get_level() + 1  # 调用类中的其他函数


    zeus = Hero("Zeus")
    athena = Hero("Athena", 6)
    zeus.greet()
    athena.move()
    print(zeus.name, athena.get_level(), athena.next_level())
    print(str(zeus), athena)
    print(Hero.hero_count)

  • 每个类可以创建任意多实例。例如上面的Hero类，可以创建zeus和athena等实例。类变量由所有实例共享，一般通过类名访问，例如Hero.hero_count。实例变量与每个具体的实例绑定，一般通过具体实例来访问，例如zeus.name。

  • 子类可以继承父类的变量和函数。self可以调用自身和父类中的变量和函数，如果子类和父类的变量或函数重名，优先使用子类的变量和函数。super()可以优先调用父类中的函数。

  • 例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    class Hero:
        hero_count = 0  # 类变量

        def __init__(self, name, level=10):  # 构造函数
            self.name = name
            self.level = level
            print("Hero %s has been created." % name)
            Hero.hero_count += 1

        def __str__(self):  # 定义str()函数的效果
            return "Hero: %s" % self.name

        def greet(self):  # 问候
            print("%s: Hi!" % self.name)

        def move(self):  # 移动
            print("%s: Move!" % self.name)

        def get_level(self):  # 获取这个英雄的等级
            return self.level

        def next_level(self):
            return self.get_level() + 1  # 调用类中的其他函数


    class Zeus(Hero):
        hero_name = "Zeus"

        def __init__(self, level):
            super().__init__(Zeus.hero_name, level)  # 通过super()调用父类的构造函数

        def greet(self):
            print("%s: Hi!(from child class)" % self.name)  # 使用的是父类的`name`


    class Athena(Hero):
        hero_name = "Athena"

        def __init__(self, level):
            super().__init__(Athena.hero_name, level)  # 通过super()调用父类的构造函数

        def greet(self):
            print("%s: Hi!(from child class)" % self.name)  # 使用的是父类的`name`


    zeus = Zeus(6)
    athena = Athena(8)
    print(zeus.name, athena.level, Hero.hero_count)
    print(str(zeus), str(athena))
    zeus.greet()
    athena.greet()
    print(zeus.get_level())

  • 模块可以自定义，自己新建一个文件夹，里头可以写若干个.py文件，但是一定要有一个空的__init__.py文件，这样Python才知道这个文件夹是一个模块。导入函数可以写：from 文件夹名.文件名 import 函数名

包管理

  • 使用conda进行包管理，以下命令使用Anaconda控制台打开
  • conda env list：查看当前有哪些虚拟环境（*号是当前所处环境）
  • conda activate 环境名：进入某个虚拟环境
  • conda list：查看当前虚拟环境内安装了哪些包
  • conda install 包名：在当前虚拟环境内安装一个包
  • conda create -n xxx python=x.x：创建一个虚拟环境
  • conda remove -n xxx --all：删除一个虚拟环境
  • conda config --show channels：显示目前包含的源
  • conda config --remove-key channels：恢复默认源
  • 下列添加常用清华源
    • conda config --add channels http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    • conda config --add channels http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
    • conda config --add channels http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
    • conda config --add channels http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/pro
    • conda config --add channels http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2