python部分知识点(3)

1、 *args  **kwargs 不固定参数，接收任意多个参数

# 接收不固定参数, 接收任意多个参数
def func(*args, **kwargs):
    for i in args:
        print(i)
    for key, value in kwargs.items():
        print((key, value))

func(1, 2, 2, a=2, b=3)

2、值传递和引用传递(地址传递)

值传递：形参的值发生改变，实参的值不变
引用传递：形参的值发生改变， 实参的值也跟着改变

在python中，是根据数据类型来区分值传递和引用传递的
值传递：不可变的数据类型，数字、字符串、布尔、元组
引用传递： 可变的数据类型，列表、字典、集合

def fun1(args):
    args += args
    print(f'形参的结果是：{args}')


# 以字符串为例
print('值传递----')
str_demo = 'cc'
fun1(str_demo)
print(f'实参的结果是：{str_demo}')  # cc

# 以列表为例
print('引用传递----')
lis_demo = [1, 2, 3]
fun1(lis_demo)
print(f'实参的结果是：{lis_demo}')  # [1, 2, 3, 1, 2, 3]

'''
结果是：
值传递----
形参的结果是：cccc
实参的结果是：cc
引用传递----
形参的结果是：[1, 2, 3, 1, 2, 3]
实参的结果是：[1, 2, 3, 1, 2, 3]
'''

3、lambda表达式，适用于函数代码简短的

# 函数名(变量名) = lambda [参数列表] : 表达式（函数代码 + return返回值）
# 不传参
def fun():
    return 100

res = lambda: 100
print(res())


# 传参
def fun1(x, y):
    return x + y

fun1_lambda = lambda x, y: x + y
print(fun1_lambda(1, 2))

# 带默认参数的
fun2 = lambda a, b, c=100: a + b + c
print(fun2(1, 2))

# 不定长参数
fun2 = lambda *args: args
print(fun2(1, 2, 3))  # (1, 2, 3)

fun3 = lambda **kwargs: kwargs
print(fun3(a=1, b=2))  # {'a': 1, 'b': 2}

# 三目运算符
fun4 = lambda a: "大于2" if a > 2 else "小于2"
print(fun4(3))

4、使用open()函数打开文件, close()函数关闭文件

打开文件之后，可以调用文件对象本身拥有的属性获取当前文件的部分信息，其常见的属性为：
`name`：返回文件的名称。
`mode`：返回打开文件时，采用的文件打开模式。
`encoding`：返回打开文件时使用的编码格式。
`closed`：判断文件是否己经关闭。
要手动关闭文件，不关闭不会自动回收

f = open('python.txt')
print(f.name, f.mode, f.encoding, f.closed)  # python.txt r cp936 False
f.close()

5、read()函数读文件

# read()函数读文件
f = open('python.txt', mode='r', encoding='utf-8')
print(f.read(2))  # 加参数可以指定读取的字符数
f.close()

# 二进制的模式读写, +就是写，rb+ 以二进制的读写
f = open('demo.txt', mode='rb+')
print(f.read())
f.close()

6、readline()函数读取一行，readlines()函数读取整个文件

f = open('python.txt', mode='r', encoding='utf-8')
print(f.readline())  # 一行
print(f.readlines())  # 整个文件，得到一个列表
print('内容为：')
for i in f.readlines():  # 会有回车
    print(i)
f.close()

7、write()函数将文本写入文件， mode的值为：`r+`、`w`、`w+`、`a` 或 `a+` ，不然会报错

# 最好加个编码， encoding, utf-8支持中文
f = open('test.txt', mode='w', encoding='utf-8')
f.write("666, cc")
# 将列表写入文件, 和readlines是逆向的
lis = ['csdn博客\n', 'python开发']
f.writelines(lis)
f.close()

8、使用with open打开文件，会自动关闭

with open('test.txt', mode='r', encoding='utf-8') as f:
    print(f.read())

9、seek()函数移动光标位置

with open('test.txt', mode='r+', encoding='utf-8') as f:
    f.seek(0)  # 移动到起始位置
    f.write('你好')

10、os模块常用函数使用

import os
# 参数1：旧文件名， 参数2：新文件名
os.rename('./python.txt', './linux.txt')
# time.sleep(20)  # 睡眠20s
os.remove('./linux.txt')  # 删除文件

# os.mkdir()创建文件夹
os.mkdir('test')

# os.getcwd()获取当前文件夹的名称
print(os.getcwd())  # D:\pythonSt

# os.chdir()切换目录
os.chdir('D:/')

# os.listdir() 列出指定文件夹下的文件名
print(os.listdir())


# os.rmdir()删除空文件夹
os.rmdir('test')

11、类方法

class Demo:
    def __init__(self):
        print("构造方法")

    @classmethod
    def info(cls):
        print("类方法")


Demo.info()  # 类方法可以直接用类名调用, 也可以让对象调用
demo = Demo()  # 实例化对象时先调用构造方法
demo.info()

12、静态方法

静态方法与实例方法之间有几个重要的区别：
1、参数传递： 静态方法不需要接收类或实例作为第一个参数，因此不需要self或cls参数。
2、访问属性： 静态方法不能直接访问类或实例的属性，因为它们不接收self或cls参数。
3、调用方式： 静态方法可以通过类名直接调用，而实例方法需要通过类的实例调用。

class Demo1:
    def __init__(self):
        self.name = "cc"
        print("构造方法")

    # 静态方法
    @staticmethod
    def info():
        # print(self.name)  # 访问不了，不接受self参数
        print("静态方法")


Demo1.info()
demo1 = Demo1()
demo1.info()

13、魔术方法，__init__ 、__str__、__del__等等这些被赋予特殊意义的方法

class Person:
    # 在实例化对象时执行
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("实例化对象")

    # 打印对象时执行
    def __str__(self):
        print("打印对象")
        return self.name

    # 删除对象时执行
    def __del__(self):
        print("删除对象")


p = Person('cc', 19)  # 实例化对象
print(p)  # 打印对象 cc
del p  # 删除对象

14、python类的封装，属性/方法：公共、保护、私有

class Person:
    def __init__(self, name, age, height):
        self.__name = name
        self.__age = age
        self._height = height

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

    def get(self):
        self.__info()


p = Person('cc', 19, 180)
# print(p.name)  # 报错, 私有变量调用不了
print(p._height)

15、python类的继承，子类重写父类的方法，super调用父类的构造函数

class Animal:
    def __init__(self):
        print("父类的构造方法")
    def eat(self):
        print("吃饭")

    def play(self):
        print('玩耍')


class Cat(Animal):
    # 使用super()方法调用父类构造函数
    def __init__(self):
        super().__init__()
    # 重写父类的方法
    def eat(self):
        print("猫吃饭")
    def study(self):
        print("猫学习")


c = Cat()
c.eat()
c.play()
c.study()
# 调用父类中被子类重写的方法, 父类.重写的方法(子类对象)
Animal.eat(c)