基础

关键字

• False
• True
• None
• and
• as
• assert
• break
• class
• continue
• def: 函数
• del
• elif
• else
• except
• finally
• for
• from
• global：全局
• if
• import
• in
• is
• lambda
• nonlocal
• not
• or
• pass
• raise
• return
• try
• while
• with
• yield

字面量

数字

• 整形 int
• 浮点数 double
• 负数 complex
• 布尔 bool

字符串

• string

列表

• List 有序可变

元组

• Tuple：有序不可变

集合

• Set 无序不重复

字典

• Dictionary

变量语法

变量名称 = 值

查看数据类型

type

name = "张三";
print("类型是", type(name))

类型转换

• int()：转为一个整形
• float()：转为一个浮点型
• str()：转为字符串

name = str(123)
print(name)
print(type(name))

字符串

格式化

name = "我的姓名是 %s"  % "张三"
print(name)

desc = "今天的天气 %s ,适合 %s" % ("真不错","学习")
print(desc)

精度控制(m.n)

money = 13.88
print("去除小数 %d" % money)
print("控制为一位小数是 %.1f(会四舍五入)" % money)
print("控制为两位小数是 %.2f" % money)
print("控制为两位小数是，前面7位 %7d.2f" % money)

money = 13.88
name = "张三"
print(f"快速格式划{name}，快速的时候不需要考虑精度{money}")

键盘输入

键盘输入获取的数据都是字符串类型

name =input("请输入姓名\n")
print("输入的姓名是",name)

流程语句 if

语法： if 条件： 条件成立操作事情 else： 不成立事情

name = 21;
if name== 20:
    print("已成年")
elif name == 21:
    print("超出年龄")
else:
    print("未成年")

循环语句

for

name = "我的名字叫张三";
for item in name:
    print(item)

range

• range(num)：从0开始到num（不包含num）
• range(num1,num2)：从num1开始到num2结束，不包含num2
• range(num1,num2,step)：从num1开始到num2结束，不包含num2,每一次的步长是step

for item in range(2,5):
    print(item)- 

注意这个i，按道理是获取不到的，但是还是能打印出

for i in range(5):
    print(i)

name = "zs"
print(f"name:{name} ")
print(i)

函数

语法： def 函数名(入参): 函数体 return 返回值

# 定义函数
def pr():
    print("pr")

# 调用
pr()

def sum(arg1,arg2):
   """
   :param arg1: 计算数1 
   :param arg2: 计算数2
   :return: arg1 + arg1
   """
   return arg1 + arg2

print("计算和是",sum(1,2))

多返回值

def calculateAddAndMinus(arg1, arg2):
    return arg1 + arg2, arg1 - arg2

addRes, minusRes = calculateAddAndMinus(2, 1)
print(f"addRes: {addRes}")
print(f"minusRes: {minusRes}")

关键字传参

函数调用时通过 key = value 方式传递

def printUserInfo(name, age):
    print(f"name: {name}, age: {age}")

printUserInfo(age=18, name="zs")
printUserInfo("list", age=20)

缺省参数

def printUserInfo(name="zs", age=20):
    print(f"name: {name}, age: {age}")

printUserInfo()
printUserInfo("lisi", age=30)

可变参数

"""
传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)中，args是元组类型，这就是置传递
"""
def printUserInfo(*info):
    print(f"传入的参数 ${info}")

printUserInfo("zs", 20)

关键字传递

"""
传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)中，args是元组类型，这就是置传递
"""
def printUserInfo(**info):
    print(f"传入的参数 ${info}")

printUserInfo(name="zs", age=20)

匿名函数

def testFun(calculate):
  print(calculate(1,2))

def calculate(x,y):
    return x+y

testFun(calculate)

lambda

def testFun(calculate):
    print(calculate(1, 2))

testFun(lambda x, y: x + y)

作用域

全局变量

number = 100

def printa():
    print("我是a")

def printb():
    print("我是b")

def printc():
    global number
    printa()
    printb()
    print(f"我是c，没有修改全局变量之前的数值{number}")

    number = 200
    print(f"修改之后的数值{number}")

print(f"没有修改全局变量之前的数值{number}")
print("调用之后")
printc()
print(f"调用完方法之后的全局变量值是{number}")

容器

list

语法： 变量名称 = [元素1，元素n]

starList = ["邓紫棋","刘亦菲"]
listName = []
listName2 = list()

print(len(starList))
print(starList)
print(starList[1])

starList.append("权志龙")

for item in starList:
    print(item)

元组

语法： 变量名 = () 变量名 = (元素1,)

list2 = ()
list = tuple("1",)

print(list[0])
print(type(list))

切片

分片的操作是返回一个新的

 list = [1,2,3,4,5,6,7,8]

# 从1到第4(不包含4)，步长是1，默认的步长就是1，可以省略
# slice1 = list[1:4:1]
slice1 = list[1:4]
print(slice1)

# 开头和结尾都可以省略，：表示从头到尾
slice2 = list[:]
print(slice2)

# 步长为3
slice3 = list[::3]
print(slice3)


# 倒叙，负数表示从右往左
slice4 = list[::-1]

集合 （不重复，无序）

语法： 变量名 = {元素1，元素n} 变量名 = set()

# 集合使用 {}
distinct = {"1","1"}
# 空集合
emptySet = set()

print(distinct)
print(len(distinct))

字典

语法： { key: value } 变量名 = dict()

map = {
    "name": "张三",
    "age": 18,
    "sex": "女"
}
emptyMap = dict()

print(f"map: {map}")
for item in map:
    print(f"key：{item} ，  value：{map.get(item)}")


print(f"name:{map["name"]}")

# 新增
map["birthday"] = "2024-01-11"
print(f"map: {map}")

# 修改
map["birthday"] = "2024-11-11"
print(f"map: {map}")

文件编码

• open(path,mode,encoding)
  • path: 文件地址
  • mode：打开模式
    • r：只读
    • w：打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件。
    • a：打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
  • encoding：文件编码

file = open(
    "D:/pythonworkspace/demo/demo/a.txt",
    "r",
    encoding="utf-8"
)

fileLines = file.readlines()

list = list()

for item in fileLines:
    list.append(item)
file.close()


writeFile = open(
    "D:/pythonworkspace/demo/demo/a-copy.txt",
    "w",
    encoding="utf-8"
)

for writeItem in list:
    writeFile.write(writeItem)

writeFile.flush()
writeFile.close()

异常

捕获

语法： try: except(没有写异常类型就是捕获所有，Exception是顶级异常，想): else: finally:

try:
    i = 5/0
except ZeroDivisionError as e:
    print("计算异常")
except (NameError,ZeroDivisionError) as e:
    print("计算异常，姓名异常")
except Exception as e:
    print("异常")
    print(e)
else:
    print("没有异常")
finally:
    print("出现异常之后还是会执行")

模块

语法： 【from 模块名】 import 【模块 | 类 | 变量 | 函数 | *】 【as 别名】 如果导入的时候使用的是 import * ，在提供方如果写了all，那么就只能使用all里面的提供的

"""
导入全部
from time import *

只用sleep方法
from time import sleep
"""

# 使用全部的方法
import time

print("开始")
"""
如果之导入了sleep那么就这么写
sleep(5)
"""
time.sleep(5)

print("结束")

包

• 从物理上看，包就是一个文件夹，在该文件夹下包含了一个init·py文件，该文件夹可用于包含多个模块文件从逻辑上看，包的本质依然是模块

第三方

pip install 包名称 pip install -i https://pypi.tuna.tsinghua.edu.cn/simple(使用国内的网址下载） 包名称

对象

语法： class 变量名称:

• 成员方法
  在对象中的成员方法必须第一个是self
  语法： def 方法名称(self,形参1，形参N):

class Student:
    name = None
    age = None
    sex = None

    def setName(self, name):
        self.name = name

    def getName(self):
        return self.name

    def toString(self):
        print(f"name: {self.name}, age: {self.age} , sex: {self.sex}")

student = Student()

student.name = "张三"
student.age = 19
student.sex = "女"

print(f"name: {student.name}, age:{student.age}, sex: {student.sex}")

• 构造方法
  使用 __init__

class Student:
    name = None
    age = None
    sex = None

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

• 类内置方法
  • __init__：构造方法
  • __str__：字符串
  • __lt__：小于，大于符号比较
  • __le__：小于等于
  • __eq__：==

class Student:
    name = None
    age = None
    sex = None

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

    def __str__(self):
        return f"Student: name:{self.name} age:{self.age} sex:{self.sex}"


from domain.Student import Student

student = Student("zs",18,"男")

print(student) 

• 私有方法
  语法：在前面增加 __

class Student:
    name = None
    age = None
    sex = None

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

    def __str__(self):
        return f"Student: name:{self.name} age:{self.age} sex:{self.sex}"

    def __test(self):
        print("私有方法")

• 继承
  • 单继承 语法： class 变量名称(父类名称):

    class Student:
        name = None
        age = None
        sex = None
  
        def __init__(self, name, age, sex):
            self.name = name
            self.age = age
            self.sex = sex
            self.__test()
    
        def __str__(self):
            return f"Student: name:{self.name} age:{self.age} sex:{self.sex}"
    
        def __test(self):
            print("私有方法")
  
    class Student_v2(Student):
        birthday: None
  
  

  • 多继承 语法： class 变量名称(父类名称1,父类名称2):

类型注解

就是标注变量是什么类型的

• 变量语法：变量名称:数据类型 = 值

name:str = "123"   

• 容器

name:str = "123"
List: list = list()
list2: list[str] = ["zs"]
map: dict  = dict()

• 函数

def add(arg: str) -> str:
    return "add" 

• union 联合类型

from typing import Union

Map: dict[Union[int, str]] = {"name": "zs", "age": 1} 

闭包

def outer(logo):
    def inner(msg):
        print(f"<{logo}>{msg}</{logo}>")

    return inner

fun = outer("高亮")
fun("你好")


# 案例2
def outer(logo):
    def inner(msg):
        # 需要修改logo 的话需要使用 nonlocal
        nonlocal logo
        logo = "更改"
        print(f"<{logo}>{msg}</{logo}>")
    return inner

name = "高亮"
fun = outer(name)
fun("你好")

name = "李四"
fun("你好")

装饰器

思想就是不修改原有的方法

from time import sleep

def sleeping():
    print("开始睡觉")
    sleep(5)
    print("睡醒了")

def play():
    print("开始玩游戏")
    sleep(5)
    print("游戏玩好了")

def sleepingBefore(fun):
    print("准备开始睡觉了")
    fun()
    print("睡醒了之后")

sleepingBefore(play)

第二种写法
from time import sleep

def play():
    print("开始玩游戏")
    sleep(5)
    print("游戏玩好了")

def sleepingBefore(fun):
    print("准备开始睡觉了")
    fun()
    print("睡醒了之后")

@sleepingBefore
def sleeping():
    print("开始睡觉")
    sleep(5)
    print("睡醒了")

# sleepingBefore(play)

多线程

• thread
  • group：暂时无用，未来功能预留
  • target：执行目标任务
  • args：元组的方式执行任务传参
  • kwargs：已字典方式任务传参
  • name：线程名

import threading
from time import sleep


def sing(msg):
    while True:
        print(msg)
        sleep(1)


def dancing(msg):
    while True:
        print(msg)
        sleep(1)


if __name__ == '__main__':

    singThread = threading.Thread(target=sing,args=("张三唱歌",), name="唱歌")


    dancingThread = threading.Thread(target=dancing,kwargs={"msg":"跳舞"})

    singThread.start()
    dancingThread.start()

    # sing()
    # dancing()

正则

• match：从头开始匹配
• search：从整个字符串匹配，找到第一个后停止
• findall：匹配整个字符串

import re

msg = "python pattern python"
res = re.match("python", msg)
print(f"匹配到的字符索引区间：{res.span()}")
print(f"匹配到的字符：{res.group()}")

resAll = re.findall("python", msg)
print(resAll)

for item in resAll:
    print(item)