最近更新平面设计影视后期全站导航

您的位置: 首页> Python

Python 学习记录

匿名上传

发布时间:2025-11-11 10:15:02

Python 环境

anaconda 安装

是一个python解析器、大部分扩展包和依赖项，支持所有操作系统。

将安装目录，加入到环境变量。就可以使用 python了。

还有以下目录，也要加入环境变量

虚拟环境

有时候版本之间会有冲突，可以使用虚拟环境安装不同版本的Python。

入门

基本

help('keywords')

a = 10
i = type(a)
print(i)  # <class 'int'>
# 元组类型，不可变
g = (20, 30, 40, 20)
print(type(g))  # <class 'tuple'>
# set 类型，自动去重
k = {10, 10, 20, 20, 30}
print(k) # {10, 20, 30}
print(type(k)) # <class 'set'>

print(100 / 4) # 25.0 非整除
print(100 // 4) # 25 整除

password = input('请输入你的密码') # 返回 Str 类型
num = int(password) # 转换成 int
print(num) # 2323

password = input('请输入你的密码') # 返回 Str 类型
int(password) # 转换成整数
float(password) # 转换成浮点数
str(password) # 转换成字符串
bool(password) # 转换成 bool

# 自动推断是什么类型，进行转换。不能转换成字符串
eval(password)

# n 换行符，t 制表符
print('hellonword')  # hello
# word
print('1t2t3')  # 1	2	3

# 分隔符和结束符
print(10, 20, 30, sep='-', end='2') # 10-20-302

使用 : 进一步对数据进行处理，.2 表示保留两位小数

# 我的名字叫做小明，今年23岁！
name = '小明'
age = 23
print(f'我的名字叫做{name},今年{age}岁！')
# 蔬菜只要3.50元/斤
price = 3.5
print(f'蔬菜只要{price:.2f}元/斤')

另一种写法，单个和多个，.2f 是保留几位小数，%5d是用空格填充，补齐5个，%05d是用0填充补齐5个。

# 占位符，%s 字符串，%d 整数，%f 浮点数
name = 'zhangsan'
print('我的姓名是：%s' % name)

# 占位符，%s 字符串，%d 整数，%f 浮点数
name = 'zhangsan'
age = 22
print('我的姓名是：%s，年龄：%05d' % (name, age))

age = 15
if 0 <= age <= 24: # 这里是链式调用
    print('2')
else:
    print('1')

for i in range(5):
    print(i)  # 输出 0 到 4

for i in range(1, 6):
    print(i) # 输出 1 到 4

for i in range(1, 10, 2): # 随机9个，从1开始，步长 2
    print(i) # 1，3，5，7，9

如果正常执行完毕，循环中的else会执行，如果非正常，比如break，else不会执行

str = 'abcde'
for i in str:
    if i == 'c':
        continue
    print(i)
else:
    print('for循环结束了')

# while 表达式:
#     print()
# else:
#    print('while循环正常结束')

模块化

import 全部导入

import random

print(random.randint(1, 3))

form 按需导入

from random import randint # 从 random 中导入 randint

print(randint(1, 3))

容器

列表

list1 = ['刘备', '关羽']
# 添加
list1.append('张飞') # 尾部追加
# 修改
list1[1] = '关平'
# 删除
list1.remove('关平')
print(list1)
# 查询
print(list1[0])

# 遍历
for e in list1:
    print(e)

# 列表长度
list = [1, 2, 3]
print(len(list))  # 3
# 列表复制
print(list * 3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# 列表合并
list1 = [4, 5]
list2 = list1 + list
print(list2)  # [4, 5, 1, 2, 3]
# 判断元素是否存在
if 11 in list2:
    print('存在')
else:
    print('不存在') # 不存在

list1 = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# 普通切片
print(list1[0:2])  # [a,b]，参数3省略了，默认 1
# 3个参数
print(list1[1:3:1])  # [b,c]
# 步长不为 1
print(list1[0:6:2])  # [a,c,e]
# 没有开始和结束
print(list1[:]) # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
# 有开始，没结尾，一直获取到结尾
print(list1[1:]) # ['b', 'c', 'd', 'e', 'f', 'g']
# 有结尾没开头，从头开始截取
print(list1[:5]) # ['a', 'b', 'c', 'd', 'e']
# 步长为负，最后一个为 -1，倒数第二个为 -2，以此类推
print(list1[-2:-5:-1]) # ['f', 'e', 'd']

元组

不支持修改和删除，会报错。

tup = (1)
print(type(tup)) # <class 'int'>

tup1 = (1,)
print(type(tup1)) # <class 'tuple'>

词典

dict = {'name': 'jack'}

# 修改
dict['age'] = '18'

# 删除
del dict['age']

# 清空
dict.clear()

print(dict)

集合

# 集合，自动去重，无序

set = {10, 20, 20, 30, 40}
print(set)

字符串相关函数

查找

str = 'hello，python'
# 从头开始查询，查询到结尾
print(str.find('python')) # 6
# 从第 2 位开始查询
print(str.find('python', 2)) # 6
# 从第2位到第5位区间查询
print(str.find('python', 2, 5)) # -1

str = 'hello，python，hi python!!!'
print(str.rfind('python', 2, 24)) # 16

函数

函数的定义

def greent():
    print('green')

def greent():
    return 1,2,3,4

k = greent()
print(k) # (1, 2, 3, 4)，返回的是元组

带默认值的参数需要在最后面

def greent(age, name, phone=10086):
    print(age, phone, name)


greent(age=22, name='zhangsan')

元组，也叫不定长位置参数

def greent(*keys):
    print(keys) # 这是一个元组


greent('zhangsan', 22)

字典，不定长关键词参数

def greent(**keys):
    print(keys)  # 这是一个字典，{'name': 'zhangsan', 'age': 22}


greent(name='zhangsan', age=22)

混合使用

需要按照顺序

def greent(*args, **keys):
    print(keys) # {'name': 'zhangsan', 'age': 22}
    print(args) # (10, 29)


greent(10, 29, name='zhangsan', age=22)

解包

注意解包的时候，位置参数必须靠前，字典参数必须靠后，否则会报错

那这里的，* 是啥意思呢，其实一个 * 是解包为单个元素，两个 * 为解包为键值对。

def greent(*args, **keys):
    print(keys)  # {'name': 'zhangsan', 'age': 22}
    print(args)  # (10, 29)


# 传递列表和字典

list = [1, 2, 3, 4, 5]
dict = {'name': 'zhangsan', 'age': 22}

# 注意解包的时候，位置参数必须靠前，字典参数必须靠后，否则会报错
greent(*list, **dict)

变量

num = 10

def greent():
    # 这里的num是定义了一个新的变量
    num = 20

greent()
print(num) # 10

num = 10

def greent():
    # 声明引用全局变量
    global num
    # 此时是重新赋值给全局变量的num
    num = 20

greent()
print(num) # 20

三目表达式

a, b = 10, 20
max = a if a > b else b

print(max)

lambda 表达式

这就是定义了一个匿名函数，也就是lambda表达式，冒号左侧是参数，右侧是返回值。

f = lambda: 100

print(f()) # 100

面向对象

class Student(object):

    # 魔术方法，用于初始化成员属性，在类实例化的时候会触发
    def __init__(self, name, age):
        # 初始化两个成员属性
        self.name = name
        self.age = age

    # self 就等于this，表示这个对象，指向自己
    def eat(self):
        print('eat')


# 实例化一个类
stu = Student('zhangsan', 16)
print(stu.name)
print(stu.age)

打印类的时候，是调用了类的 str函数。我们可以重写它

class Student(object):

    # 魔术方法，用于初始化成员属性，在类实例化的时候会触发
    def __init__(self, name, age):
        # 初始化两个成员属性
        self.name = name
        self.age = age

    def __str__(self):
        return '这是str函数'


# 实例化一个类
stu = Student('zhangsan', 16)
print(stu)

class Student(object):

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

    # 析构函数
    def __del__(self):
        print('Student 被销毁了') # 删除对象时被触发了


# 实例化一个类
stu = Student('zhangsan')

# 删除对象
del stu

怎么调用

class Student(object):

    def __init__(self):
        pass
    
    # 调用函数
    def __call__(self, value = 0):
        print(22, value)

# 实例化一个类
stu = Student()

# 这里就是调用
stu()

私有属性，公有属性

带双下划线的变量是私有属性，不能在外面直接访问
不带双下划线的是共有属性，可以在任何地方访问

class Student(object):

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

    # 调用函数
    def __call__(self, value = 0):
        print(22, value)

    # 规范函数名称小写
    def get_age(self):
        return self.__age

# 实例化一个类
stu = Student('zhangsadn', 22)

# 访问共有属性
print(stu.name)

# 访问私有属性
print(stu.get_age())

class Student(object):

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

    # 规范函数名称小写
    def get_age(self):
        return self.__age

    def __func(self):
        return '这是私有方法'

# 实例化一个类
stu = Student('zhangsadn', 22)

stu.get_age()
stu.__func() # 不能调用，会报错

class Student(object):

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

    def eat(self):
        print('吃东西')

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


class Student2(Student):
    pass


# 会继承 init 魔术方法
stu = Student2('name2', 22)

stu.eat()
# stu.__set_name('2') # 私有方法不继承

Super 方法

使用 super() 调用父类的方法和属性

class Student(object):

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


class Student2(Student):
    # 扩展，加一个学号
    def __init__(self, name, age, number):
        super().__init__(name, age)
        self.number = number

# 会继承 init 魔术方法
stu = Student2('name2', 22, 11011)
print(stu.number) # 11011
print(stu.name) # name2

多继承

class Student(object):
    pass

class Student2(object):
    pass

# 同时继承两个类
class Student3(Student, Student2):
    pass

python 会优先选择距离自己更近的，比如上面的案例中，Student 更近，如果找到了方法，就不会再去 Student2中找。

class Student(object):
    def eat(self):
        print('Student')

class Student2(object):
    def eat(self):
        print('Student2')

# 同时继承两个类
class Student3(Student, Student2):
    pass


# 查看类的继承关系
#[<class '__main__.Student3'>, <class '__main__.Student'>, <class '__main__.Student2'>, <class 'object'>]
print(Student3.mro())