Python 学习记录

Python 环境

anaconda 安装

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

一直下一步，看到这里，不创建快捷方式，不加入环境，安装python3.13

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

虚拟环境

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

入门

基本

查看关键词

py 复制代码

help('keywords')

数据类型

py 复制代码

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'>

运算符

py 复制代码

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

输入操作

py 复制代码

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

转换函数

py 复制代码

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

制表符与输出

py 复制代码

# \n 换行符，\t 制表符
print('hello\nword')  # hello
# word
print('1\t2\t3')  # 1	2	3

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

格式化输出

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

js 复制代码

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

条件判断

py 复制代码

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

for 循环

js 复制代码

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

模块化

import 全部导入

js 复制代码

import random

print(random.randint(1, 3))

form 按需导入

js 复制代码

from random import randint # 从 random 中导入 randint

print(randint(1, 3))

容器

列表

增删改查

py 复制代码

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

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

其他函数操作

py 复制代码

# 列表长度
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('不存在') # 不存在

切片

py 复制代码

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']

元组

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

py 复制代码

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

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

词典

py 复制代码

dict = {'name': 'jack'}

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

# 删除
del dict['age']

# 清空
dict.clear()

print(dict)

集合

py 复制代码

# 集合，自动去重，无序

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

函数

函数的定义

py 复制代码

def greent():
    print('green')

返回值

py 复制代码

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

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

关键值传参 + 默认参数

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

py 复制代码

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


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

不定长传参

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

py 复制代码

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


greent('zhangsan', 22)

字典，不定长关键词参数

py 复制代码

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


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

混合使用

需要按照顺序

py 复制代码

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


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

解包

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

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

py 复制代码

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)

变量

全局变量，定义在函数外面。

局部变量，定义在代码块中，比如函数。

py 复制代码

num = 10

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

greent()
print(num) # 10

函数内引用全局变量

py 复制代码

num = 10

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

greent()
print(num) # 20

lambda 表达式

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

py 复制代码

f = lambda: 100

print(f()) # 100

面向对象

类的定义

py 复制代码

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函数。我们可以重写它

py 复制代码

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)

析构函数

py 复制代码

class Student(object):

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

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


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

# 删除对象
del stu

call 函数，对象被调用时触发

怎么调用

py 复制代码

class Student(object):

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

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

# 这里就是调用
stu()

私有属性，公有属性

私有的是不能被继承的，公有的才可以被继承

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

py 复制代码

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())

公共方法和私有方法

py 复制代码

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() # 不能调用，会报错

继承

py 复制代码

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() 调用父类的方法和属性

py 复制代码

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

多继承

python 是支持多继承的

py 复制代码

class Student(object):
    pass

class Student2(object):
    pass

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

如果继承的两个类具有共同的属性和方法，那优先用谁的呢。

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

查看类的继承关系

py 复制代码

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())