h3 { background: rgba(42, 92, 170, 1); box-shadow: 0 1px 6px 1px rgba(10, 10, 0, 0.5); color: rgba(255, 255, 255, 1); font-size: 18px; font-weight: bold; height: 30px; padding: 8px 0 5px 10px; text-shadow: 2px 2px 3px rgba(34, 34, 34, 1) }
h4 { background: linear-gradient(90deg, rgba(208, 208, 208, 1) 0, rgba(255, 255, 255, 1) 100%); font-size: 5px; height: 25px; padding: 1px 0 5px 5px }

vscode使用python

导入三方库

  1. 说明
    有时候vscode并不能通过快捷键安装三方库，我们要自己通过pip安装，但是pip默认安装到python默认的site-packages文件夹下，而我们创建的项目是新建了个虚拟环境venv，python的环境和虚拟环境是隔离的，所以我们安装的时候要指定安装路径，同时还可以指定版本和仓库源

    pip install --target=D:\projectFiles\pythonFiles\tools\venv\Lib\site-packages opencv-python==4.2.0.34  -i  https://pypi.doubanio.com/simple

数据类型

字符串string

  1. 字符串拼接

    a = "天下"
b = a + "会"    # 天下会
c = a * 2       # 天下天下

  2. 长度

    a = "一二三四五六七八九十"
b = len(a)      # 10

  3. 包含判断in：还有个not in

    a = "一二三四五六七八九十"
b = "五" in a   # True

  4. 开头包含判断startswith：还有个endswith

    a = "一二三"
b = a.startswith("一")     # True
c = a.endswith("三")       # True

#指定开始位置
c = a.startswith("二",2)   # True

  5. 两端删除strip

    a = "一一二三一四五一一"
b = a.strip("一")          # 二三一四五；不限数量

  6. 计数count：可指定范围，规则和切片一致

    a = "一二二三"
b = a.count("二")          # 2
c = a.count("二", 2, 3)    # 1

  7. 替换replace

    a = "一二三一四五"
b = a.replace("一","1")    # 1二三1四五

  8. 根据索引查找find：

    a = r"一二三四五"
b = a.find("三")    # 2
b = a.find("六")    # -1；没找到

  9. 根据索引查找index：

    a = r"一二三四五"
b = a.index("三")   # 2
c = a.index("六")   # 报错；没找到

  10. 插入join

    a = "一二三"
b = "|".join(a)     # 一|二|三

  11. 分割split

    a = "一、二、三"
b = a.split("、")       # ['一', '二', '三']
b = a.split("、", 1)    # ['一', '二、三']；分割一次

  12. 大小写转化lower和upper

    a = "abcDEF"
b = a.lower()      # abcdef
c = a.upper()      # ABCDEF
  1. 方法组合使用 
    a = "一、二、三"
b = a.replace("、", "|").join("12")  # 1一|二|三2
  1. 切片：永远从左边作为起点 
    a = "一二三四五六七八九十"

# 从0开始，右开区间
b = a[2]          # 三
c = a[0:1]        # 一

# 取到最左最右
d = a[0:]         # 一二三四五六七八九十
f = a[:1]         # 一

# 步长
e = a[0:5:2]      # 一三五
g = a[5:0:-2]     # 六四二
h = a[::-1]       # 十九八七六五四三二一
  1. 格式化字符串 
    a = "8"
b = "夏天"
c = f"你好，{a}月的{b}"      # 你好，8月的夏天
  2. 转义 
    # 换行符
a = "一二三四五\n六七八九十"  # 两行显示

# 去转义
a = r"一二三四\n五六七八九十" # 转义符失效

列表list

  1. 长度len 
    lst1 = ["一", "二", "三"]
a = len(lst1)     # 3
  2. 最大最小值max和min：一般只能比较数值列表 
    lst1 = [1, 2, 3, 4, 5]
a = max(lst1)     # 5
a = min(lst1)     # 1
  3. 逆列表reverse 
    lst1 = ["一", "二", "三"]
lst1.reverse()
lst1              # ['三', '二', '一']
  4. 排序sort：这个可以设置复杂的规则 
    lst1 = [(2, 2), (3, 4), (4, 1), (1, 3)]

# 排序规则：单个元素处理
def takeSecond(elem):
    return elem[1]

# key表示单个元素处理规则，reverse表示降序排
lst1.sort(key=takeSecond,reverse=True)

lst1             # [(3, 4), (1, 3), (2, 2), (4, 1)]
  5. 合并：等同extend，但extend合并字符串会变成单字符 
    lst1 = ["一", "二", "三"]
a = lst1 + ["四", "五"]   # ['一', '二', '三', '四', '五']
  6. 添加元素append 
    lst1 = ["一", "二", "三"]
lst1.append("四")
lst1              # ['一', '二', '三', '四']
  7. 替换 
    lst1 = ["一", "二", "三"]
lst1[2] = "四"
lst1              # ['一', '二', '四']
  8. 元素插入insert 
    lst1 = ["一", "二", "三"]
lst1.insert(2, "四")
lst1              # ['一', '二', '四', '三']
  9. 插入join：和字符串的一样，这里只是把列表当作字符串 
    lst1 = ["一", "二", "三"]
a = "|".join(lst1)        # 一|二|三
  10. 判断包含in：还有not in 
    lst1 = ["一", "二", "三"]
a = "二" in lst1  # True
  11. 通过索引查元素 
    lst1 = ["一", "二", "三", "四", "五", [1, 2, 3]]
a = lst1[1]      # 二

#倒查
b = lst1[-2]     # 五

#多层查
c = lst1[5][1]   # 2
  12. 通过元素查索引index：没找到报错 
    lst1 = ["一", "二", "三"]
a = lst1.index("二")      # 1
  13. 通过索引删除：不给索引删除末尾 
    lst1 = ["一", "二", "三"]
a = lst1.pop(1)  # 二；返回删除的元素
lst1             # ['一', '三']
  14. 通过元素删除：有重复的就删除第一个 
    lst1 = ["一", "二", "三"]
lst1.remove("二")
lst1             # ['一', '三']
  15. 切片：和字符串的一致，略讲 
    lst1 = ["一", "二", "三", "四", "五"]
a = lst1[2:4]    # ['三', '四']

元组tuple：不可修改，查询和列表一样

  1. 代码 
    tup1 = (1,)      # 一个元素要加`,`

字典dict

  1. 根据key查询value：没查询到报错

    dic1 = {"No1":"1", "No2":"2", "No3":"3"}
a = dic1["No1"]            # 1

  2. 根据key查询valueget：没查询到返回None

    dic1 = {"No1":"1", "No2":"2", "No3":"3"}
a = dic1.get("No1")        # 1

  3. 根据key查询插入setdefault：查询到就返回value，没查到就插入None值键值对，也可设置Value插入

    dic1 = {"No1":"1", "No2":"2", "No3":"3"}
a = dic1.setdefault("No3")        # 3；查询到
b = dic1.setdefault("No4")        # None；查询到没有，返回插入的'No4': None的value
c = dic1.setdefault("No5", "5")   # 5；查询到没有，返回插入的'No5': 5的value
dic1             # {'No1': '1', 'No2': '2', 'No3': '3', 'No4': None, 'No5': '5'}

  4. 更新update：重复的会替换

    dic1 = {"No1":"1", "No2":"2", "No3":"3"}
dic1.update({"No3":"3.1", "No4":"3"})  # {'No1': '1', 'No2': '2', 'No3': '3.1', 'No4': '3'}

  5. 删除pop：没有对应的key会报错

    dic1 = {"No1":"1", "No2":"2", "No3":"3"}
dic1.pop("No3")
dic1             # {'No1': '1', 'No2': '2'}

  6. json文件转化成字典：不管有多少层，都会转化成字典的键值对，有重复的key，会取后者

    #下面这个是json1.json文件内容
"""
{ "user": {
    "No1": {
      "name": "zhangsan"
      },
    "No2": {
      "name": "lisi"
    },
    "No2": {
      "name": "lisi2"
    }
  }
}
"""

import json
with open("json1.json",mode="r+",encoding="utf-8") as f:
	rows = f.read()        # 读取整个json文档
dct1 = json.loads(rows)    # {'user': {'No1': {'name': 'zhangsan'}, 'No2': {'name': 'lisi2'}}}

# 字典转化成json：虽然内容还是和刚才的字典一样，但是已经不能使用字典的方法了
json1 = json.dumps(dct1)   # {"user": {"No1": {"name": "zhangsan"}, "No2": {"name": "lisi2"}}}

数据类型转化

  1. 转整数 
    # 字符串转整数
a = "123"
b = int(a)

# 小数转整数
a = 3.7
b = int(a)  # 3
  2. 转字符串 
    a = 123
b = str(a)
  3. 列表元组互转 
    a = ("一", "二", "三")
b = list(a)
c = tuple(b)
  4. 字典转列表 
    # 转化成键值对表、key表、value表
dic1 = {"No1":"1", "No2":"2", "No3":"3"}
a = list(dic1.items())     # [('No1', '1'), ('No2', '2'), ('No3', '3')]
b = list(dic1.keys())      # ['No1', 'No2', 'No3']
c = list(dic1.values())    # ['1', '2', '3']

数据类型判断

  1. 示例 
    isinstance("二", str)       # 返回True

计算

  1. 示例 
    a = 5/2    # 正常除：2.5
b = 5 % 2  # 取余：1
c = 5//2   # 取整：2
d = 3**2   # 平方：9

循环控制

if

  1. 代码：可以使用and、or和多个逻辑符0<a<10 
    if a == 2:
	a = 0
elif a == 3:
	a = 1
else:
	a = "其他"

for

  1. 示例：in后面可以跟list、tuple和string 
    for i in range(10):       # range函数和切片一样，分隔符是`,`
	a = i + 1
else：                    # else只有for循环“正常”结束才会执行，有break就不会执行。但如果只是接在for循环后面的普通语句，不管for循环是否正常结束都会执行。
	print("循环正常结束")
  2. break和continue 
    for i in range(10):
    print(i)
    if i > 5:
        break             # 跳出当前循环，执行循环下面的内容，不影响外层循环

for i in range(10):
    print(i)
    if i > 5:
        continue          # 跳过continue下面循环的内容，进行下次循环
	print("完整的一次")
  3. 注意：循环的列表不能变动，不然后按照第一次的列表进行，容易发生out of index。

while

  1. 示例 
    a = 1
while a <= 10:
	a = a + 1
else：
	a = 0

变量交换赋值：python内存结构和jsva差不多

  1. 示例：语法糖 
    a = 1
b = 2
a, b = b, a   # a=2, b=1

输入input：字符串数据类型

  1. 示例 
    a = input("请输入：")

打印print

  1. 打印结尾：任意字符串；默认是\n，即换行；\t表示不换行 
    for i in range(10):
	print(i, end="\t")
  2. 打印间隔：任意字符串 
    print("你好","朋友们","拜拜",sep="|")  # 你好|朋友们|拜拜

方法

基础结构

  1. 示例 
    def method1(a, b):
    """
    :param a: 加数1
    :param b: 加数2
    :return: 和
    """
    c = a + b
    return c
  2. 返回多个值：需要解构获取值 
    def method1(a, b):
    c = a + b
    d = a * b
    return c, d

e = method1(1,2)        # (3, 2)
f, g = method1(1,2)     # 解构：f：3  g：2

参数

  1. 方法参数默认值：默认值参照要放后面，不然传参不知道是重新赋值还是给的后面参数的值 
    def method1(a, b=2):
    c = a + b
    return c
  2. 可变参数：也可以叫元组参数 
    def method1(*b):        # b=(1, 2, 3)，是数组
    s = 0
    for i in b:
        s = s + i
    return s

f = method1(1, 2, 3)     # 6
  3. 关键字参数：字典参数 
    def method1(**b):
    c = b.get("name")
    d = b.get("age")
    return c, d

dict1 = {"name": "zhangsan", "age": "18"}
f = method1(**dict1)    # ('zhangsan', '18')，传参必须加`**`
  4. 参数注解：参数类型限定 
    def method1(a: int, b: str):
    f = a + 1
    g = b + "你好"

类

类的属性

  1. 说明
    类中的属性实际上就是类中的变量，实例化后通过实例.变量名获取值。类属性始终只有一个，不同实例化获取的也是该值
  2. 示例 
    class Human:
     name = "张三"

# 调用属性
person1 = Human()  # 切记！实例化必须带括号，不然相当于给类重命名了
person1.name       # 张三

# 修改(增加)属性：不影响其他实例化对象的属性
person2 = Human()
person2.name = "李四"
person2.weight = "100kg"

person3 = Human
person3.name       # 张三

构造函数（init）

  1. 说明
    类的属性主要为类中的方法提供参数，这样就尽量减少了类内部对外的依赖。但是如果这些参数通过一个个修改类属性的方式传进去其实并不便捷和安全，因此通过创建一个统一的参数传入口就显得比较好。下面做个比较。
  2. 构造器：
    • 说明：构造函数（构造器）是在类实例化自动运行的一个函数，其参数可通过实例化类传入，__init__中的下划线表示该方法私有，不可被外部调用。最后就是该函数不能使用return。
    • 示例： 
      """ 修改属性传参入类 """
class Human:
  name = "张三"

def run(self, fast):
  print(self.name + "跑得" + fast)

someone = Human()
someone.name = "李四"
someone.run("非常快")

      init方法刨除上面说的特性，就是一个普通函数，这里就相当于在函数里面进行属性设定了

      """ 通过构造函数传参 """
class Man:
  def __init__(self, name):
     self.Name = name

  def run(self, fast):
     print(self.Name + "跑得" + fast)

someone = Man("李四")
someone.run("非常快")

self关键字

  1. 说明
    当参数还没实例化的时候，类内部要代替实例调用类属性或者方法就需要self。
  2. 示例 
    class Man:
  name = "张三"

  def run(self, fast):
     print(self.name + "跑得" + fast)
  3. self作为类方法参数的意义
    • 所有的类内部方法第一个参数都是self，主要是因为内部实现方式导致的。当我们调用一个类方法，形如zhangsan.run("很快")，我们知道，这个run方法在类中定义大致是run(self, fast),当我们调用run之后，python实际运行的是Human.run(zhangsan, "很快")，这个Human是类名，也就是说，self起占位的作用。

子类

基础结构

  1. 示例 
    # 可继承init方法、改写父类方法
class Chinese(Human):
    def run(self, fast):
        return f"中国人{self.name1}跑得{fast}"


someone = Chinese("张三")
someoneRun = someone.run("快")    # 中国人张三跑得快
print(someoneRun)

调用父类方法super关键字

  1. 示例 
    # super()调用父类方法，和java一样，参数要子类方法提供
class Chinese(Human):
    def work(self, good, fast):
        super().run(fast)
        return f"中国人工作{good}，还跑得{fast}"


someone = Chinese("张三")
someoneRun = someone.work("好", "快")

异常处理

  1. 不限定错误类型 
    a = "你好"
try:
    b = a + 123
except:                # 报错就执行下面的语句
    print("有错误！")
  2. 限定错误类型 
    a = "你好"
try:
    print(c)  # NameError       # 有一个错误就不再检查下面的
    b = a + 123   # TypeError
except(TypeError, NameError):   # 限定错误类型，否则还是报错
    print("有错误！")
  3. 打印错误 
    a = "你好"
try:
    print(c)
    b = a + 123 
except TypeError as f:     # 打印错误
    print(f)
else:
    print("其他异常！")
finally:
    print("异常排除结束")    # 用于执行固定语句，如关闭连接等

读写文件

  1. 示例 
    # 打开文件读取所有行，一行为一个列表元素
with open("text.txt", mode="r+", encoding="utf-8") as f:
    rows = f.readlines()[1:]  # ['第二行\n', '第三行']；[1:]表示第二行到末尾行

# 打开文件逐个列表元素写入
with open("test2.txt", mode="r+", encoding="utf-8") as g:
    for i in rows:
        g.write(i)  # 会覆盖
版权声明：本文为阿根的园子原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/taokara/p/16269415.html