Python 函数、文件操作、面向对象-笔记3

最新推荐文章于 2024-01-29 15:09:13 发布

NO Exception?

最新推荐文章于 2024-01-29 15:09:13 发布

阅读量187

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/chentaishan/article/details/107477336

版权

python 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

1.函数说明文档help

def 函数名(参数):
""" 说明⽂文档的位置 """ 代码
......

help(函数名)

使用help方法会返回函数信息

2.函数打印图形

2.1打印线

def print_line():
    print('-' * 20)
print_line()

2.1打印多条线

def print_line():
    print('-' * 20)
def print_lines(num): i=0
    while i < num:
        print_line()
i += 1
print_lines(5)

3. 函数

修饰变量为全局变量，可供局部方法修改。

3.1函数返回值

可以返回多种类型数据

# 一个函数多个返回值的写法
def return_num():
    # return 1, 2   # 返回的是元组
    # return后面可以直接书写 元组 列表 字典，返回多个值
    # return (10, 20)
    # return [100, 200]
    return {'name': 'Python', 'age': 30}

3.2 缺省参数、不定长参数

def functionname([formal_args,] *args, **kwargs):

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为

4.文件操作

4.1文件打开

f = open('test.txt', 'w')  # f被称为文件操作符

4.2 文件访问模式

r  只读
w  只写
b	二进制打开，配合其他模式使用	
a	追加文件信息

4.3 文件关闭

f.close()

4.4文件读写

读取
read(3) 读取3个字符
read()读取所有内容
readline() 读取一行
readlines()读取所有行，返回一个列表对象
写入
write(‘this is content’) 向文件里写入内容

4.5文件其他操作

import os
# 重命名
 os.rename('test.txt','one.txt')
# 删除文件
 os.remove('test.txt')
# 创建文件夹
 os.mkdir('dic')
# 获取当前目录
dd = os.getcwd()
print('获取当前目录绝对路径')
print(dd)
# 改变默认目录
print('改变默认目录绝对路径')
os.chdir('../')
# 获取目录列表
os.listdir('./')
# 删除文件夹
os.remove('dic')

5.推导式

推导式(list comprehension)是有规律的创建不同的数据集合类型。

5.1 列表推导式

# 列表推导式
list = [ i for i in range(5)]
print(list)

# 带if 的列表推导式
list = [i for i in range(10) if i%2==0]
print(list)

# for 循环 嵌套
list = [(x,y) for x in range(1,3) for y in range(0,3)]
print(list)

结果：

[0, 1, 2, 3, 4]
[0, 2, 4, 6, 8]
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

5.2 字典推导式

# 字典推导式
list = ['name','age','sex']
list1 = ['zhangsan','33','男']
dic = {list[i]:list1[i]  for i in range(len(list))}
print(dic)

结果：

{'name': 'zhangsan', 'age': '33', 'sex': '男'}

5.3 集合推导式

# 集合推导式
list ={1,1,2,3,4}
list = {i**2 for i in list}
print(list)

结果：

{16, 1, 4, 9}

6.面向对象

封装
将属性和⽅方法书写到类的⾥里里⾯面的操作即为封装
封装可以为属性和⽅方法添加私有权限
继承
⼦子类默认继承⽗父类的所有属性和⽅方法
⼦子类可以重写⽗父类属性和⽅方法
多态
传⼊入不不同的对象，产⽣生不不同的结果

6.1私有属性和方法及私有属性的修改

私有属性：只需要在初始化时，在属性名前加__
私有方法：只需要在方法名前加__

类的私有属性和私有方法，都不能通过对象直接访问，但是可以在本类内部访问；
类的私有属性和私有方法，都不会被子类继承，子类也无法访问；
私有属性和私有方法往往用来处理类的内部事情，不通过对象处理，起到安全作用。

修改：
私有属性和方法只能通过普通方法（如get__xx() set_xx()）修改和获取数据。

class A(object):
    def __init__(self):
        """私有名称"""
        self.__name ='huhu'
    # 私有方法，只能通过自身调用
    def __chifan(self):
        print('红烧肉')
    def hi(self):
        # 私有方法
        self.__chifan()
    def getName(self):
        return self.__name
    def setName(self,name):
        self.__name = name

a = A()
print(a.getName())

a.setName('YY')
print(a.getName())

a.hi()

6.2 类属性和实例属性

类属性和修改

就是类对象所拥有的属性，它被该类的所有实例例对象所共有。
类属性可以使⽤用 类对象或实例例对象访问。

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

实例属性

要求每个对象为其单独开辟⼀一份内存空间来记录数据，所以他的访问是能是创建实例对象来访问数据。
而类属性为全类所共有，仅占⽤用⼀一份内存，更更加节省内存空间。

class Dog(object):
    def __init__(self):
        self.age = 5
    def info_print(self):
        print(self.age)
wangcai = Dog()
print(wangcai.age) # 5

6.3多态

多态指的是⼀一类事物有多种形态，(⼀一个抽象类有多个⼦子类，因⽽而多态的概念依赖于继承)。

定义:多态是⼀一种使⽤用对象的⽅方式，⼦子类重写⽗父类⽅方法，调⽤用不不同⼦子类对象的相同⽗父类⽅方法，可以产⽣生不不同的执⾏行行结果
好处:调⽤用灵活，有了了多态，更更容易易编写出通⽤用的代码，做出通⽤用的编程，以适应需求的不不断变化!

class Dog(object):
	def work(self): # ⽗父类提供统⼀一的⽅方法，哪怕是空⽅方法
	print('指哪打哪...')
class ArmyDog(Dog): # 继承Dog类
	def work(self): # ⼦子类重写⽗父类同名⽅方法
	print('追击敌⼈人...')
class DrugDog(Dog):
    def work(self):
print('追查毒品...')
class Person(object):
	def work_with_dog(self, dog): # 传⼊入不不同的对象，执⾏行行不不同的代码，即不不同的work函数
	dog.work()
	
ad = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)

6.4静态方法

需要通过装饰器 @staticmethod 来进⾏行行修饰，静态⽅方法既不不需要传递类对象也不不需要传递实例例对象 (形参没有self/cls)。
静态⽅方法也能够通过实例例对象和类对象去访问。

场景
当⽅方法中既不不需要使⽤用实例例对象(如实例例对象，实例例属性)，也不不需要使⽤用类对象 (如类属性、类⽅方法、创建实例例等)时，定义静态⽅方法
取消不不需要的参数传递，有利利于减少不不必要的内存占⽤用和性能消耗。

class Dog(object):
    @staticmethod
def info_print(): 
print('这是⼀一个狗类，⽤用于创建狗实例例....')

wangcai = Dog()
# 静态⽅方法既可以使⽤用对象访问⼜又可以使⽤用类访问 wangcai.info_print()
Dog.info_print()

6.5 类⽅法

需要⽤装饰器 @classmethod 来标识其为类方法，对于类方法，第一个参数必须是类对象，⼀般以cls 作为第⼀个参数。

场景
当⽅法中需要使用类对象 (如访问私有类属性等)时，定义类方法⼀般和类属性或者私有属性配合使⽤

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

7.魔法方法

7.1 _init_

负责初始化对象
_init_() ⽅方法，在创建⼀一个对象时默认被调⽤用，不不需要⼿手动调⽤用
_init_(self) 中的self参数，不不需要开发者传递，python解释器器会⾃自动把当前的对象引⽤用传递过去。

参数的__init__()
⼀个类可以创建多个对象，如何对不不同的对象设置不不同的初始化属性呢?

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

haier2 = Washer(30, 40)
haier2.print_info()

7.2 _new

创建对象

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

class A(object):
    def __init__(self):
        print("这是 init 方法")
	#有返回值
    def __new__(cls):
        print("这是 new 方法")
        return object.__new__(cls)

A()

7.3 str

str 打印输出对象的信息
重写该方法，当打印对象实例时，就会被调用

7.4 del

回收对象
当删除对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

7.4 mro

打印类的继承体系

7.6 dict

代表实体类的字典结构

NO Exception?

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Python 函数、文件操作、面向对象-笔记3

函数说明文档def 函数名(参数):""" 说明⽂文档的位置 """ 代码......help(函数名)使用help方法会返回函数信息函数打印图形打印线def print_line(): print('-' * 20)print_line()打印多条线def print_line(): print('-' * 20)def print_lines(num): i=0 while i < num: print_line()i +=
复制链接

扫一扫

专栏目录