python面向对象与函数

已于 2023-07-04 10:33:35 修改
阅读量910 收藏
点赞数
文章标签： python
于 2020-12-07 14:10:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39122260/article/details/110806657
版权

封装

类和对象的关系：用类去创建一个对象

类

相同属性、方法的事物的统称，抽象的概念，比如制造洗衣机的图纸

定义类

  • 语法
#语法
class 类名():
    代码
    ......
    
class Washer():
    def wash(self):
        print('我会洗衣服')

对象

类创建出来的真实的事物，例如：洗衣机。

创建删除对象/实例

self：调用该函数的对象

#语法
对象名 = 类名()
del 对象名

# 1. 定义类
class Washer():
    def wash(self):
        print('我会洗衣服')
        # <__main__.Washer object at 0x0000024BA2B34240>
        print(self)

# 2. 创建对象
haier1 = Washer()
# <__main__.Washer object at 0x0000018B7B224240>
print(haier1)
# haier1对象调用实例方法
haier1.wash()

添加、获取对象属性

# 定义类
class Washer():
    pingpai = 123
    def print_info(self):
        # 类里面获取实例属性
        print(f'haier1洗衣机的宽度是{self.width}')
        print(f'haier1洗衣机的高度是{self.height}')
# 创建对象
haier1 = Washer()
# 添加实例属性
haier1.width = 500
haier1.height = 800
#获取属性
print(haier1.pingpai)
haier1.print_info()
print(haier1.width)

魔法方法-特殊功能的函数__xx__()

__init__()初始化对象属性
不带参数
class Washer():
    # 定义初始化功能的函数
    def __init__(self):
        # 添加实例属性
        self.width = 500
        self.height = 800

    def print_info(self):
        # 类里面调用实例属性
        print(f'洗衣机的宽度是{self.width}, 高度是{self.height}')

haier1 = Washer()
haier1.print_info()
带参数的
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def print_info(self):
        print(f'洗衣机的宽度是{self.width}')
        print(f'洗衣机的高度是{self.height}')
haier1 = Washer(10, 20)
haier1.print_info()
__str__()类的说明书，打印对象不显示内存地址，显示说明
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def __str__(self):
        return '这是海尔洗衣机的说明书'

haier1 = Washer(10, 20)
# 这是海尔洗衣机的说明书
print(haier1)
__del__()删除对象时，显示内容
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def __del__(self):
        print(f'{self}对象已经被删除')

haier1 = Washer(10, 20)

# <__main__.Washer object at 0x0000026118223278>对象已经被删除
del haier1

类的继承

查看子类继承的关系

print(类名.__mro__)

单|多继承

当一个类有多个父类，父类中有同名属性方法，默认使用第一个父类的同名属性方法

#语法
class 子类(父类1, 父类2):
    
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    pass

daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

多层继承

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
# 徒孙类
class Tusun(Prentice):
    pass
xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()

子类重写父类同名方法、属性

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
# 独创配方
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

子类调用父类同名方法、属性

super调用父类方法（适合单继承使用），可以逐一调用父类方法，并只执行一次

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
    def make_cake(self):
        # 如果是先调用了父类的属性和方法，父类属性会覆盖子类属性，故在调用属性前，先调用自己子类的初始化
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    # 调用父类方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
       #School.__init__(self)
       #School.make_cake(self)
    	#super调用父类方法（适合单继承使用），可以逐一调用父类方法，并只执行一次
        super().__init__()
        super().make_cake()

daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()

私有权限，__XXX

私有属性方法只能在类里面访问和修改

定义私有属性、方法

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        # 定义私有属性
        self.__money = 2000000
    # 定义私有方法
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)
    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
# 徒孙类
class Tusun(Prentice):
    pass
daqiu = Prentice()
# 对象不能访问私有属性和私有方法
# print(daqiu.__money)
# daqiu.__info_print()
xiaoqiu = Tusun()
# 子类无法继承父类的私有属性和私有方法
# print(xiaoqiu.__money)  # 无法访问实例属性__money
# xiaoqiu.__info_print()

获取和修改私有属性值get_xx、set_xx

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        self.__money = 2000000
    # 获取私有属性
    def get_money(self):
        return self.__money
    # 修改私有属性
    def set_money(self):
        self.__money = 500
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)
    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
# 徒孙类
class Tusun(Prentice):
    pass

daqiu = Prentice()
xiaoqiu = Tusun()
# 调用get_money函数获取私有属性money的值
print(xiaoqiu.get_money())
# 调用set_money函数修改私有属性money的值
xiaoqiu.set_money()
print(xiaoqiu.get_money())

多态-依赖于继承

调用不同子类对象的相同父类方法，产生不同的结果

一种使用对象的方式、子类重新父类的方法

类属性和方法属性

类属性

类属性可以使用 类对象 或 实例对象 访问

类属性只能通过类对象修改，不能通过实例对象修改

访问类属性

class Dog(object):
    tooth = 10
wangcai = Dog()
xiaohei = Dog()
print(Dog.tooth)  # 10
print(wangcai.tooth)  # 10
print(xiaohei.tooth)  # 10

修改类属性

class Dog(object):
    tooth = 10
wangcai = Dog()
xiaohei = Dog()
# 修改类属性
Dog.tooth = 12
print(Dog.tooth)  # 12
print(wangcai.tooth)  # 12
print(xiaohei.tooth)  # 12

方法属性

方法属性不能通过类访问

class Dog(object):
    def __init__(self):
        self.age = 5
    def info_print(self):
        print(self.age)
wangcai = Dog()
print(wangcai.age)  # 5
# print(Dog.age)  # 报错：实例属性不能通过类访问
wangcai.info_print()  # 5

普通方法、类方法、静态方法

普通方法

class Dog(object):
    def __init__(self):
        self.age = 5
    def info_print(self):
        print(self.age)
wangcai = Dog()
print(wangcai.age)  # 5
# print(Dog.age)  # 报错：实例属性不能通过类访问
wangcai.info_print()  # 5

类方法@classmethod-方法中获取处理类的私有属性

class Dog(object):
    __tooth = 10
    @classmethod
    def get_tooth(cls):
        return cls.__tooth

wangcai = Dog()
result = wangcai.get_tooth()
print(result)  # 10

静态方法@staticmethod-不需要对象和类属性时，可以使用

可以使用对象和类访问

不需要参数传递，减少内存消耗

class Dog(object):
    @staticmethod
    def info_print():
        print('这是一个狗类，用于创建狗实例....')
wangcai = Dog()
# 静态方法既可以使用对象访问又可以使用类访问
wangcai.info_print()
Dog.info_print()

查询对象和类的信息

#返回对象属性和值组成的字典
print(对象.__dict__)
#返回类内部所有属性和方法对应的字典
print(类名.__dict__)

定义函数

定义全局变量

思考：完成需求如下：一个函数完成两个数1和2的加法运算，如何书写程序？

#定义全局变量
a = 100
# 定义函数
def add_num1():
    #global声明a是全局变量
    global a
    result = a + 2
    print(result)

# 调用函数
add_num1()

定义参数

多个参数，返回一个值

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
	return name

user_info('TOM', 20, '男')

多个参数，返回多个值，不写格式默认返回元组

def user_info(a, b):
   #返回元组
	return (a, b)
   #返回列表
	return [a, b]
   #返回字典
	return {a, b}
    
user_info(1, 2)

多个参数，参数有默认值

def user_info(name, age, gender='男'):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
	return = name

user_info('TOM', 20)

不定长参数，包裹位置传递

def user_info(*args):
    print(args)

# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)

不定长参数，包裹关键字传递

def user_info(**kwargs):
    print(kwargs)

# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

闭包函数：外部函数的内部函数为闭包函数，保存外部函数变量在闭包函数中使用

函数嵌套

内部函数使用外部函数的变量或者参数

外部函数返回内部函数名

# 定义一个外部函数
def func_out(num1):
    # 定义一个内部函数
    def func_inner(num2):
        #修改外部函数变量
        #nonlocal num1
        #num1 = 10
        result = num1 + num2
        print("结果是:", result)
    return func_inner
# 创建闭包实例
f = func_out(1)
# 执行闭包
f(2)

装饰器函数、类装饰器-给已有函数增加额外功能-本质是闭包函数

不修改源函数代码、调用方式

只能装饰一个参数，类型为函数

通用装饰器

注意：装饰器装饰函数时，内部函数与被装饰函数都一样返回值、参数

def 函数1(func1):
    def inner1(*args, **kwargs):
        print('正在计算')
        result1 = func1(*args, **kwargs)
        return result1
    return inner1

def 函数2(func2):
    def inner2(*args, **kwargs):
        print('正在计算')
        result2 = func2(*args, **kwargs)
        return result2
    return inner2

#多个装饰器由内向外执行
@函数2
@函数1
def add_num():
    print('哈哈哈哈')

一个装饰器用于多个被装饰函数，并判断

def 判断函数名(判断参数名):
    def 函数(func):
        def inner(*args, **kwargs):
            if 判断参数名 == "+":
                print("--正在努力加法计算--")
            elif 判断参数名 == "-":
                print("--正在努力减法计算--")
            result = func(*args, **kwargs)
            return result
        return inner
	return 判断函数名
@判断函数名("+")
def add(a, b):
    result = a + b
    return result
@判断函数名("-")
def sub(a, b):
    result = a - b
    return result
result = add(1, 2)
print(result)
result = sub(1, 2)
print(result)

类装饰器

class 类名():
    def __init__(self, func):
        self.__func = func
    # __call__方法，让对象像函数一样可以调用。
    def __call__(self, *args, **kwargs):
        print("请先登陆...")
        #调用函数
        self.__func()
@类名
def comment():
    print("发表评论")
comment()

property属性—把一个方法当做属性进行使用

装饰器方式

class Person(object):
    def __init__(self):
        self.__age = 0
    # 装饰器方式的property, 把age方法当做属性使用, 表示当获取属性时会执行下面修饰的方法
    @property
    def age(self):
        return self.__age
    # 把age方法当做属性使用, 表示当设置属性时会执行下面修饰的方法
    @age.setter
    def age(self, new_age):
        if new_age >= 150:
            print("成精了")
        else:
            self.__age = new_age
# 创建person
p = Person()
print(p.age)
p.age = 100
print(p.age)
p.age = 1000

类属性方式

class Person(object):

    def __init__(self):
        self.__age = 0

    def get_age(self):
        """当获取age属性的时候会执行该方法"""
        return self.__age

    def set_age(self, new_age):
        """当设置age属性的时候会执行该方法"""
        if new_age >= 150:
            print("成精了")
        else:
            self.__age = new_age
    # 类属性方式的property属性
    age = property(get_age, set_age)
# 创建person
p = Person()
print(p.age)
p.age = 100
print(p.age)
p.age = 1000

调用函数

真实数据为参数

函数名(参数1, 参数2, 参数3)

函数返回值拆取

拆包：元组

def return_num(a, b):
    return a, b

num1, num2 = return_num(100, 200)
print(num1)  # 100
print(num2)  # 200

拆包：字典

dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1

# 对字典进行拆包，取出来的是字典的key
print(a)  # name
print(b)  # age

print(dict1[a])  # TOM
print(dict1[b])  # 18

公共函数

len()：显示全部元素个数

# 1. 字符串
str1 = 'abcdefg'
print(len(str1))  # 7

# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1))  # 4

# 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1))  # 5

# 4. 集合
s1 = {10, 20, 30}
print(len(s1))  # 3

# 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1))  # 2

max()：最大数

list1 = [10, 20, 30, 40]
print(max(list1))  # 40

min()：最小数

list1 = [10, 20, 30, 40]
print(min(list1))  # 10

enumerate():把可变例对象，进行for循环安装一对一元组形式输出

enumerate(遍历对象, start=第一个数字对应的开始标符)
list1 = [10, 20, 30, 40]
for i in enumerate(list1, start=1):
    print(i)
#(1, 10)
#(2, 20)
#(3, 30)
#(4, 40)

range()：遍历生成数字

range()生成的序列不包含end数字

range(开始数字, 结束数字, 步长)
# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
    print(i)

# 1 3 5 7 9
for i in range(1, 10, 2):
    print(i)

# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
    print(i)

abs()数字求绝对值计算

abs(-10)  # 10

round()数字四舍五入计算

round(1.2)  # 1
round(1.9)  # 2

map(func, lst)，将lst序列中数放入func方法中运行，根据需求转换并返回结果

#计算`list1`序列中各个数字的2次方。
list1 = [1, 2, 3, 4, 5]
def func(x):
    return x ** 2

result = map(func, list1)
print(result)  # <map object at 0x0000013769653198>
#转换成列表
print(list(result))  # [1, 4, 9, 16, 25]

reduce(func，lst)将lst序列中数先传入2个在func函数中运行，结果替换为下次第一个参数，累积计算并返回结果

reduce()传入的参数func必须接收2个参数。

#计算list1序列中各个数字的累加和。
import functools
list1 = [1, 2, 3, 4, 5]

def func(a, b):
    return a + b
result = functools.reduce(func, list1)
print(result)  # 15

filter(func, lst)筛选lst序列中数，根据需求转换并返回结果

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
    return x % 2 == 0
result = filter(func, list1)
print(result)  # <filter object at 0x0000017AF9DC3198>
print(list(result))  # [2, 4, 6, 8, 10]

递归

函数内部自己调用自己，必须有出口

lambda 表达式

一个函数有一个返回值，只有一句代码，可以使用 lambda简化

#语法
lambda 参数列表 ： 表达式
无参数
fn1 = lambda: 100
print(fn1())
一个参数
fn1 = lambda a: a
print(fn1('hello world'))
默认参数
fn1 = lambda a, b, c=100: a + b + c
print(fn1(10, 20))
可变参数-返回元组：*args-元组
fn1 = lambda *args: args
print(fn1(10, 20, 30))
可变参数-返回字典：**kwargs-字典
fn1 = lambda **kwargs: kwargs
print(fn1(name='python', age=20))
带判断的lambda
fn1 = lambda a, b: a if a > b else b
print(fn1(1000, 500))

喜欢的亲可以关注点赞评论哦！以后每天都会更新的哦！本文为小编原创文章；
文章中用到的文件、安装包等可以加小编联系方式获得；
欢迎来交流小编联系方式VX:CXKLittleBrother
进入运维交流群

含义小哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
FTP服务搭建与配置
chunyang315的博客
03-29 319
xshell使用xftp传输文件 在弹出的界面中选择需要的版本 第一个为免费，第2个为收费。填写信息，其中License type需要选择为Evaluation 登录邮箱去找下载地址。 Dear user, Thank you for your interest in Xftp 5. We have prepared your evaluation package. If you did...
xftp和linux ftp,FTP服务搭建与配置--xftp、pure-ftpd
weixin_36399948的博客
05-07 760
一 xshell使用xftp传输文件上一篇文章介绍的传输方式都是命令行的方式，不太直观，我们可以使用xftp的方式，这是需要安装一个插件的，我们按下ctrl+alt+f，弹出如下页面我们直接点击[下载Xftp...]按钮，弹出下面下载xftp的页面，我们填写好信息后，点击submmit按钮提交成功：过一会儿，我们就会收到邮件，我们需要到之前信息中填写的邮箱中去找到下载链接通过下载链接我们就可以下载...
SFTP共享配置
最新发布
beck_li的博客
06-13 902
一、 SFTP相关命令及配置 1 1、 SFTP相关命令 1 2、 配置内容说明 1 二、SFTP实例 2 1、配置root帐号登录SFTP 2 1.1 备份sshd配置文件 2 1.2 修改sshd配置文件 2 1.3 重启sshd服务 2 1.4 使用其他电脑登录sftp验证 2 2、配置限制ssh登录的sftp用户 2 2.1创建活动目录 2 2.2新建用户 3 2.3 配置sshd配置文件 3 2.3修改sshd配置文件 3 1.5 重启sshd服务 3 1.6 使用其他电脑登录sftp验证 3
Linux安装配置FTP(pure-ftpd)
Bertram的博客
06-21 3521
ftp安装
Linux下PureFTPd配置安装（完整版）
风的专栏
02-03 7476
网上关于pureftp的安装教程很多，但是试了以后发现很多其实都不完善，很容易出错，自己安装摸索以后总结如下： 首先安装之前最好用netstat -ntl来查看ftp默认的21端口是不是已经被占用了，同时也可以用ps -ef 指令查看开启了哪些服务，看一下有没有类似sftp或者是vsftp的服务，如果开启，用killall sftp指令把这个服务kill掉 1.下载pureftp，我下
python面向对象
09-13
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它基于“对象”的概念，将数据和...在视频课程“Python面向对象精彩讲解”中，会详细阐述这些概念，并通过实例演示如何在实际开发中应用它们。
Python面向对象编程基础解析（二）
12-24
上一篇文章我们已经介绍了部分Python面向对象编程基础的知识，大家可以参阅：Python面向对象编程基础解析（一），接下来，我们看看另一篇。 封装 1.为什么要封装？ 封装就是要把数据属性和方法的具体实现细节隐藏...
python面向对象课件
11-12
面向对象编程（Object-Oriented Programming，简称OOP）是Python编程中的核心概念之一，它是一种编程范式，强调通过创建对象来组织代码，使得程序更易于理解和维护。本课件详细介绍了Python中的面向对象特性，包括类...
Python面向对象编程基础
12-22
Python设计之初就是一门面向对象的语言，正因为如此，在Python中创建一个类的对象是很容易的，学过C++和Java的同学对面向对象应该比较了解，在面向对象编程中万物皆对象。更多具体的详细的信息大家可以查阅专业的...
Python面向对象程序设计构造函数和析构函数用法分析
09-19
主要介绍了Python面向对象程序设计构造函数和析构函数用法,结合具体实例形式分析了Python面向对象程序设计中构造函数与析构函数的概念、原理、功能及相关使用技巧,需要的朋友可以参考下
使用pure-ftpd搭建ftp服务
pcct的专栏
01-18 2883
十三周五次课（1月18日） 15.4 xshell使用xftp传输文件 15.5 使用pure-ftpd搭建ftp服务 测试ftp • yum install -y lftp • lftp ftpuser1@127.0.0.1 • 执行命令ls，看是否正常输出 • 若不正常查看日志/var/log/messages和/var/log/secure • windows下安装filez
inux下pure-ftpd安装图文教程
cuker919的专栏
07-09 183
现在有很多人购买VPS都是自用，上面只有自己的网站，大部分人可能都没有安装FTP服务器程序，都是用SFTP传输文件，甚至直接使用root帐 户传输，这样就带来了一些麻烦和安全问题，虽然在之后可以用chown、chgrp命令来改变文件属性，但是总归是要登录服务器进行这些操作，浪费时间和 精力，而且个人感觉SFTP的速度没有FTP快，所以，架设一个FTP服务器还是很有必要的。推荐使用pure-ft...
Linux学习总结（四十九）xftp 和pure-ftpd
weixin_34226706的博客
05-13 132
1.xftp 介绍 xftp安装在windos上，可以和linux系统互传文件，它支持sftp协议，是一款轻量级且比较安全的文件传输软件。 xftp安装后默认是关联到xshell上面的，因此使用非常方便。我们用xshell连接linux系统后，只要安装好xftp，就可以直接单击xhell快捷方式一栏的新建文件传输，或者直接按快捷键ctrl+alt+f 来打开xftp打开xftp后我们会看到，服务都...
pureftp的安装和使用
十月鱼的博客（本博客不再更新，作者迁移至：http://wiki.51centos.com）
10-20 3783
一、pureftpd的安装 1.编译参数会随版本不同而不同 tar zvxf pure-ftpd-1.0.46.tar.gz ./configure \ 编译参数 \后面不能有空格，前面是-- --prefix=/usr/local/pureftpd/ \ --with-language=simplified-chinese \ --with-everything 2.
轻松搞定linux下pure-ftpd的安装，绝对可用
热门推荐
fanhenghui的专栏
11-29 1万+
背景:最近需要在服务器上安一个ftp服务器，之前也使用wdcp安过，结果由于mysql数据库修改了，不知道什么莫名问题怎么也连不上，后来又使用了vsftpd，也是糊里糊涂的安好了，没怎么搞懂。最近又有新的需求要装个ftp，网上找了好多教程都没有成功，走了不上弯路，特此记录以供自己和后人参考。 1.如果你是基于最小化安装的linux系统，需要执行如下命令，安装必要的库，如果是安装过的可以跳过此步骤
FTP服务器之pure-ftpd常见问题及解决方法
weixin_34244102的博客
04-13 4835
2019独角兽企业重金招聘Python工程师标准>>> ...
[FTP] Pure-FTPd SSL/TLS 配置方法
乡村的博客
02-12 1492
一、准备 & 安装 启用 Pure-FTPd SSL/TLS 连接方式在安装时需要检查以下两项： 1、系统中是否已经安装了 openssl 和 openssl-devel 包？ 2、在编译 Pure-FTPd 的时候需要加载 --with-tls 二、证书制作 在成功安装好 Pure-FTPd 后，我们需要制作一张 SSL 证书供 Pure-FTPd 使用。 编译安装后的 Pure-FTPd 默认的证书存储位置为：/etc/ssl/private/pure-ftpd.pem，该文件会在 Pure-F
Python面向对象构造函数
10-29
Python面向对象中的构造函数是指在创建对象时自动执行的函数，它的名称为__init__。当我们实例化一个对象时，Python会自动调用该类的__init__方法，从而完成对象的初始化。在__init__方法中，我们可以对对象的属性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

含义小哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值