python数据分析--- ch8-9 python函数及类

2024-06-14 09:12
文章标签 python 函数 数据分析 及类 ch8

本文主要是介绍python数据分析--- ch8-9 python函数及类，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

python数据分析--- ch8-9 python函数及类

  • 1. Ch8--函数
    • 1.1 函数的定义
    • 1.2 形参与实参
      • 1.2.1 使用位置参数调用函数
      • 1.2.2 使用关键字参数调用函数
    • 1.3 参数的默认值
    • 1.4 可变参数(*)
      • 1.4.1 基于元组的可变参数(* 可变参数)
      • 1.4.2 基于字典的可变参数(** 可变参数)
    • 1.5 函数中变量的作用域
    • 1.6 函数类型
      • 1.6.1 理解函数类型
      • 1.6.2 lambda函数
      • 1.6.3练一练
  • 2. Ch9--类与对象
    • 2.1 面向对象
      • 2.1.1 定义类
      • 2.1.2 创建对象
    • 2.2 类的成员
      • 2.2.1 实例变量
      • 2.2.2 构造方法
      • 2.2.3 实例方法
      • 2.2.4 类变量
      • 2.2.5 类方法
    • 2.3 封装性
      • 2.3.1 私有变量
      • 2.3.2 私有方法
      • 2.3.3 使用属性
    • 2.4 继承性
      • 2.4.1 多继承性
      • 2.4.2 方法重写
    • 2.5 多态性
      • 2.5.1 继承与多态
      • 2.5.2 类型测试与多态

1. Ch8–函数

内容提要

1.1 函数的定义

def rec_s(length,width):s = length*widthreturn s

output
长方形面积为60

1.2 形参与实参

s = rec_s(10,6)
print("长方形面积为{}".format(s))

output
长方形面积为60

def circle_s(r,pi):s = pi*r*rreturn s

1.2.1 使用位置参数调用函数

在调用函数时传递的实参与定义函数时的形参顺序一致，这是调用函数的基本形式。

def circle_s(r,pi):print(f"当前圆的半径为{r}")print(f"圆周率为{pi}")s = pi*r*rreturn s

r0=7
pi0 = 3.14
s1 = circle_s(r0,pi0)
print("半径为{}的圆，它的面积是{}".format(r,s1))

output
当前圆的半径为7
圆周率为3.14
半径为7.0的圆，它的面积是153.86

r0=7
pi0 = 3.14
s1 = circle_s(pi0,r0)
print("半径为{}的圆，它的面积是{}".format(r,s1))

output
当前圆的半径为3.14
圆周率为7
半径为7.0的圆，它的面积是69.0172

1.2.2 使用关键字参数调用函数

在调用函数时可以采用“关键字=实参”的形式，其中，关键字的名称就是定义函数时形参的名称。

def circle_s(r,pi):print(f"当前圆的半径为{r}")print(f"圆周率为{pi}")s = pi*r*rreturn s

r0=7
pi0 = 3.14
s1 = circle_s(r=r0,pi=pi0)#调用函数
print("半径为{}的圆，它的面积是{}".format(r0,s1))

output
当前圆的半径为7
圆周率为3.14
半径为7的圆，它的面积是153.86

r0=7
pi0 = 3.14
s1 = circle_s(pi=pi0,r=r0)#调用函数
print("半径为{}的圆，它的面积是{}".format(r0,s1))

output
当前圆的半径为7
圆周率为3.14
半径为7的圆，它的面积是153.86

1.3 参数的默认值

def circle_s(r,pi=3.14):print(f"当前圆的半径为{r}")print(f"圆周率为{pi}")s = pi*r*rreturn s

s3 = circle_s(10)
print(s3)

output
当前圆的半径为10
圆周率为3.14
314.0

s4 = circle_s(10,3.14159)
print(s4)

output
当前圆的半径为10
圆周率为3.14159
314.159

def circle_s(pi=3.14,r):print(f"当前圆的半径为{r}")print(f"圆周率为{pi}")s = pi*r*rreturn s

output
File “C:\Users\SHEN HL\AppData\Local\Temp\ipykernel_9548\1344990216.py”, line 1
def circle_s(pi=3.14,r):
^
SyntaxError: non-default argument follows default argument

def circle_s(r,pi=3.14,name="求面积"):print(f"当前圆的半径为{r}，{name}")print(f"圆周率为{pi}")s = pi*r*rreturn s

print(circle_s(10))

output
当前圆的半径为10，求面积
圆周率为3.14
314.0

1.4 可变参数(*)

1.4.1 基于元组的可变参数(* 可变参数)

def sum1(*numbers):total =0for n in numbers:total+=nreturn total

print(sum1(10,20,20,40,50))

output
140

print(sum1(10,20))

output
30

1.4.2 基于字典的可变参数(** 可变参数)

def show_info(**info):print("-----show info-----")for k,v in info.items():print("{}--{}".format(k,v))

show_info(name='Tony',age=18,sex=True)

output
-----show info-----
name–Tony
age–18
sex–True

show_info(fruit='apple',price=15)

output
-----show info-----
fruit–apple
price–15

1.5 函数中变量的作用域

x=20
def print_value():x=10print(f"函数中x的取值为{x}")
print_value()
print(x)

output
函数中x的取值为10
20

x1=20
def print_value1():global x1x1=10print(f"函数中x1的取值为{x1}")

print_value1()
print(x1)

output
函数中x1的取值为10
10

print(type(print_value1))

output
<class ‘function’>

1.6 函数类型

Python中的任意一个函数都有数据类型，这种数据类型是被称为函数类型。function

1.6.1 理解函数类型

  • 1.一个函数可以作为另一个函数返回值使用
def add_calc(a,b):print("正在执行加法运算")return a+b
def sub_calc(a,b):print("正在执行减法运算")return a-bdef calc(opt):# opt="+"表示进行加法运算，opt="-"表示进行减法运算，if opt=="+":return add_calcelse:return sub_calc

opt = "+"
f1 = calc(opt)
print(type(f1))a = 10
b = 5
print("{}{}{}={}".format(a,opt,b,f1(a,b)))

output
<class ‘function’>
正在执行加法运算
10+5=15


opt = "-"
f1 = calc(opt)
# print(type(f1))a = 10
b = 5
print("{}{}{}={}".format(a,opt,b,f1(a,b)))

output
正在执行减法运算
10-5=5

  • 2.一个函数可以作为另一个函数参数使用。

过滤函数 filter()

def f1(x):return x>5
list1 = [1,4,7,8]
res = filter(f1,list1)
print(list(res))

output
[7, 8]

映射函数 map()

def f2(x):return x*2
res_map=map(f2,list1)
print(list(res_map))

output
[2, 8, 14, 16]

1.6.2 lambda函数

def calc2(opt):# opt="+"表示进行加法运算，opt="-"表示进行减法运算，if opt=="+":return lambda a,b:(a+b)else:return lambda a,b:(a-b)

f3=calc2("+")
print(type(f3))
print(f3(5,10))

output
<class ‘function’>
15

f4=calc2("-")
print(type(f4))
print(f4(5,10))

output
<class ‘function’>
-5

1.6.3练一练

def accer(v1,v2,t1,t2):a=(v2-v1)/(t2-t1)return a
a = accer(0,10,0,20)
print(f"加速度为{a}")

output
加速度为0.5

a1 = lambda v1,v2,t1,t2:(v2-v1)/(t2-t1)
print(f"加速度为{a1(0,10,0,20)}")

output
加速度为0.5

2. Ch9–类与对象

内容提要

2.1 面向对象

面向对象是一种编程思想，即按照真实世界的思维方式构建软件系统。

2.1.1 定义类

2.1.2 创建对象

class Car(object):#类体passCar()

output
<main.Car at 0x14ccc191250>

2.2 类的成员

2.2.1 实例变量

实例变量就是对象个体特有的“数据”，例如狗狗的名称和年龄等。

class Dog:def __init__(self,name,age):#前后是两个下划线self.name = nameself.age = age
d = Dog('球球',2)
print("狗狗名叫{}，{}岁啦".format(d.name,d.age))

output
狗狗名叫球球，2岁啦

2.2.2 构造方法

类中的init()方法是一个非常特殊的方法，用来创建和初始化实例变量，这种方法就是“构造方法”。

class Dog:def __init__(self,name,age,sex='雌性'):#前后是两个下划线self.name = nameself.age = ageself.sex = sexd1 = Dog('球球',2)
d2 = Dog('哈哈',1,'雄性')
d3 = Dog(age=3,sex='雄性',name='拖布')
print('{0}：{1}岁{2}。'.format(d1.name,d1.age,d1.sex))
print('{}：{}岁{}。'.format(d2.name,d2.age,d2.sex))
print('{}：{}岁{}。'.format(d3.name,d3.age,d3.sex))

output
球球：2岁雌性。
哈哈：1岁雄性。
拖布：3岁雄性。

2.2.3 实例方法

实例方法与实例变量一样，都是某个实例（或对象）个体特有的方法。

class Dog:def __init__(self,name,age,sex='雌性'):#前后是两个下划线self.name = nameself.age = ageself.sex = sex# 实例方法def run(self):print('{}在跑，running running ......'.format(self.name))def speak(self,sound):print('{}在叫，“{}”！'.format(self.name,sound))dog = Dog("球球",2)
dog.run()
dog.speak('旺 旺 旺')

output
球球在跑，running running …
球球在叫，“旺 旺 旺”！

2.2.4 类变量

类变量是属于类的变量，不属于单个对象。

class Account:interest_rate=0.0568 # 类变量利率def __init__(self,owner,amount):self.owner = ownerself.amount = amount
account = Account('Tony',80000.0)  
print('账户名：{}'.format(account.owner))
print('金额：{}'.format(account.amount))
print('利率：{}'.format(Account.interest_rate))

output
账户名：Tony
金额：80000.0
利率：0.0568

2.2.5 类方法

类方法与类变量类似，属于类，不属于个体实例。

class Account:interest_rate=0.0568 # 类变量利率def __init__(self,owner,amount):self.owner = ownerself.amount = amount@classmethoddef interest_by(cls,amt):return cls.interest_rate*amtinterest = Account.interest_by(120000.0)
print("计算利息：{0:.4f}".format(interest))

output
计算利息：6816.0000

class Dog:#类变量是属于类的变量，不属于单个对象。weight = 7.5#类变量animal = 'dog'#构造方法:类中的init()方法是一个非常特殊的方法，用来创建和初始化实例变量，def __init__(self,name,age):#实例方法，初始化实例变量self.name = nameself.age = age#实例方法与实例变量一样，都是某个实例（或对象）个体特有的方法。def sum1(self):#类方法，不含类变量return self.age*5def speak(self,sound):#类方法，包含实例变量和类变量return "{}在叫，{}".format(self.name,sound)#类方法与类变量类似，属于类，不属于个体实例。@classmethod #装饰器 类方法，不含实例变量def get_health(cls,weight):#cls表示当前类的类型if cls.weight>10.0:return "fat"else:return "health"@classmethod    def get_owner(cls,owner):return f"{cls.animal}的主人是{owner}"dog = Dog('球球',2)print("调用类方法1：",dog.sum1())
print("调用类方法2：",dog.speak("汪~汪~汪~"))print("查看类变量：",Dog.weight)
print("调用类方法3：",Dog.get_health(Dog.weight))
print("调用类方法4：",Dog.get_owner("壮壮"))

output
调用类方法1： 10
调用类方法2： 球球在叫，汪汪汪~
查看类变量： 7.5
调用类方法3： health
调用类方法4： dog的主人是壮壮

2.3 封装性

封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。

2.3.1 私有变量

为了防止外部调用者随意存取类的内部数据（成员变量）内部数据（成员变量）会被封装为“私有变量”。私有变量，则在变量前加上双下画线()。

class Account:__interest_rate=0.0568 # 类私有变量：利率,变量前加两个下划线def __init__(self,owner,amount):self.owner = owner # 实例变量self.__amount = amount # 私有实例变量def desc(self):return "{0}的存款金额为：{1}，利率为：{2}。".format(self.owner,self.__amount,Account.__interest_rate)

account = Account('Tom',2000000)
account.desc()

output
‘Tom存款金额为：2000000，利率为：0.0568。’

print(account.owner)
# print(account.amount) # 私有变量无法调用
# print(account.__amount) # 私有变量无法调用
# print(account.__interest_rate) # 私有变量无法调用

output
Tom

---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)~\AppData\Local\Temp\ipykernel_20524\3225480601.py in <module>2 # print(account.amount)3 # print(account.__amount)
----> 4 print(account.__interest_rate)AttributeError: 'Account' object has no attribute '__interest_rate'

2.3.2 私有方法

私有方法与私有变量的封装是类似的，在方法前加上双下画线()就是私有方法了。

class Account:__interest_rate=0.0568 # 类私有变量：利率def __init__(self,owner,amount):self.owner = ownerself.__amount = amountdef __get_info(self): # 私有方法return "{0}的存款金额为：{1}，利率为：{2}。".format(self.owner,self.__amount,Account.__interest_rate)def desc(self):print(self.__get_info())

account = Account('Tom',2000000)
account.__get_info()

output
---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)~\AppData\Local\Temp\ipykernel_20524\1516856393.py in <module>1 account = Account('Tom',2000000)
----> 2 account.__get_info()AttributeError: 'Account' object has no attribute '__get_info'

account.desc()

output
Tom的存款金额为：2000000，利率为：0.0568。

2.3.3 使用属性

为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set(赋值)和get(取值)方法访问。

class Dog:def __init__(self,name,age):#前后是两个下划线self.name = nameself.__age = age# 实例方法def run(self):print('{}在跑，running running ......'.format(self.name))@property #只读的属性变量def age(self):return self.__age@age.setter #此时age可以修改，age为属性的名字def age(self,age):self.__age = agedog = Dog('球球',2)
print("{}年龄：{}岁".format(dog.name,dog.age))dog.age = 3 #年龄未修改
print("{}修改后年龄：{}岁".format(dog.name,dog.age))

output
球球年龄：2岁
球球修改后年龄：3岁

class Dog:def __init__(self,name,age):#前后是两个下划线self.name = nameself.__age = age# 实例方法def run(self):print('{}在跑，running running ......'.format(self.name))def get_age(self):return self.__agedef set_age(self,age):self.__age = agedog = Dog('球球',2)
print("{}年龄：{}岁".format(dog.name,dog.get_age()))dog.set_age(3)
print("{}修改后年龄：{}岁".format(dog.name,dog.get_age()))

output
球球年龄：2岁
球球修改后年龄：3岁

2.4 继承性

  • 1.继承性也是面向对象重要的基本特性之一。在现实世界中继承关系无处不在。
  • 2.例如猫与动物之间的关系：猫是一种特殊动物，具有动物的全部特征和行为，即数据和操作。在面向对象中动物是一般类，被称为“父类”；猫是特殊类，被称为“子类”。特殊类拥有一般类的全部数据和操作，可称之为子类继承父类。

class Animal:def __init__(self, name):self. name = name #namedef show_info(self):return "动物名字：{0}".format(self.name)def move(self):print("动一动..")class Cat(Animal): #括号继承父类Animaldef __init__(self, name, age):super().__init__(name)#继承父类的nameself.age = agecat = Cat('Tom',2)
cat.move()
print(cat.show_info())

output
动一动…
动物名字：Tom

2.4.1 多继承性

可能存在多父类的类方法冲突

class Horse: # 马def __init__(self, name):self.name = name #namedef show_info(self):return"马名字：{0}".format(self.name)def run(self):print("马跑...")class Donkey:# 驴def __init__(self, name):self.name = name #namedef show_info(self):return"驴名字：{0}". format(self.name)def run(self):print("驴跑...")def roll(self):print("驴打滚...")class Mule(Horse, Donkey): # 骡子def __init__(self, name, age):super().__init__(name)self.age = age

# python默认的规则是多个父类的情况下，哪个父类在前面，有冲突时先继承哪个父类对应的方法
m = Mule('骡宝莉',1)
m.run() # 继承类Horse方法
m.roll() # 继承父类Donkey方法
print(m.show_info()) # 继承父类Horse方法

output
马跑…
驴打滚…
马名字：骡宝莉

2.4.2 方法重写

class Horse:def __init__(self, name):self.name = name #namedef show_info(self):return"马名字：{0}".format(self.name)def run(self):print("马跑..")class Donkey:def __init__(self, name):self.name = name #namedef show_info(self):return"驴的名字：{0}".format(self.name)def run(self):print("驴跑..")def roll(self):print("驴打滚..")class Mule(Horse, Donkey):def __init__(self, name, age):super().__init__(name)self.age = age #agedef show_info(self): # 重写父类方法 方法的覆盖或重写return "骡: {0}，{1}岁。".format(self.name, self.age)

m= Mule('骡宝莉', 1)
m.run()#继承父类的Horse()方法
m.roll()#继承父类的Donkey()方法
print(m.show_info())#子类Mule自己方法

output
马跑…
驴打滚…
骡: 骡宝莉, 1岁。

2.5 多态性

  • 1.“多态”指对象可以表现出多种形态。
  • 2.例如，猫、狗、鸭子都属于动物，它们有“叫”和“动”等行为，但是“叫的方式不同，“动”的方式也不同。

    ”一龙生九子，九子各不同“

2.5.1 继承与多态

在多个子类继承父类，并重写父类方法后，这些子类所创建的对象之间就是多态的。
这些对象采用不同的方式实现父类方法。

class Animal:def speak(self):print('动物叫，但不知道是哪种动物叫！')class Dog(Animal):def speak(self):print('小狗：旺旺旺...')class Cat(Animal):def speak(self):print('小猫：喵喵喵...')an1 = Dog()
an2 = Cat()
an1.speak()
an2.speak()

output
小狗：旺旺旺…
小猫：喵喵喵…

2.5.2 类型测试与多态

  • 1.鸭子类型测试指：若看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为鸭子。
  • 2.Python支持鸭子类型测试，Python解释器不检查发生多态的对象是否继承了同一个父类，只要它们有相同的行为（方法），它们之间就是多态的。
# 设计一个函数start(),它接收具有“叫"speak()方法的对象：
def start(obj):obj.speak()# 定义几个类，都有speak()方法：   
class Animal:def speak(self):print('动物叫，但不知道是哪种动物叫！')
class Dog(Animal):def speak(self):print('小狗：旺旺叫...')
class Cat(Animal):def speak(self):print('小猫：喵喵叫..')
class Car:def speak(self):print('小汽车：嘀嘀叫...')# start()可以接收所有speak()方法对象，代码如下：        
start(Dog())
start(Cat())
start(Car())

output
小狗：旺旺叫…
小猫：喵喵叫…
小汽车：嘀嘀叫…

这篇关于python数据分析--- ch8-9 python函数及类的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1059980。

相关文章

Python MySQL如何通过Binlog获取变更记录恢复数据

Python MySQL如何通过Binlog获取变更记录恢复数据

《PythonMySQL如何通过Binlog获取变更记录恢复数据》本文介绍了如何使用Python和pymysqlreplication库通过MySQL的二进制日志（Binlog）获取数据库的变更记录... 目录python mysql通过Binlog获取变更记录恢复数据1.安装pymysqlreplicat
阅读更多...
利用Python编写一个简单的聊天机器人

利用Python编写一个简单的聊天机器人

《利用Python编写一个简单的聊天机器人》这篇文章主要为大家详细介绍了如何利用Python编写一个简单的聊天机器人,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 使用 python 编写一个简单的聊天机器人可以从最基础的逻辑开始，然后逐步加入更复杂的功能。这里我们将先实现一个简单的
阅读更多...
基于Python开发电脑定时关机工具

基于Python开发电脑定时关机工具

《基于Python开发电脑定时关机工具》这篇文章主要为大家详细介绍了如何基于Python开发一个电脑定时关机工具,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1. 简介2. 运行效果3. 相关源码1. 简介这个程序就像一个“忠实的管家”，帮你按时关掉电脑，而且全程不需要你多做
阅读更多...
Python实现高效地读写大型文件

Python实现高效地读写大型文件

《Python实现高效地读写大型文件》Python如何读写的是大型文件,有没有什么方法来提高效率呢,这篇文章就来和大家聊聊如何在Python中高效地读写大型文件,需要的可以了解下... 目录一、逐行读取大型文件二、分块读取大型文件三、使用 mmap 模块进行内存映射文件操作（适用于大文件）四、使用 pand
阅读更多...
python实现pdf转word和excel的示例代码

python实现pdf转word和excel的示例代码

《python实现pdf转word和excel的示例代码》本文主要介绍了python实现pdf转word和excel的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价... 目录一、引言二、python编程1，PDF转Word2，PDF转Excel三、前端页面效果展示总结一
阅读更多...
Python xmltodict实现简化XML数据处理

Python xmltodict实现简化XML数据处理

《Pythonxmltodict实现简化XML数据处理》Python社区为提供了xmltodict库,它专为简化XML与Python数据结构的转换而设计,本文主要来为大家介绍一下如何使用xmltod... 目录一、引言二、XMLtodict介绍设计理念适用场景三、功能参数与属性1、parse函数2、unpa
阅读更多...
Python中使用defaultdict和Counter的方法

Python中使用defaultdict和Counter的方法

《Python中使用defaultdict和Counter的方法》本文深入探讨了Python中的两个强大工具——defaultdict和Counter,并详细介绍了它们的工作原理、应用场景以及在实际编... 目录引言defaultdict的深入应用什么是defaultdictdefaultdict的工作原理
阅读更多...
Python中@classmethod和@staticmethod的区别

Python中@classmethod和@staticmethod的区别

《Python中@classmethod和@staticmethod的区别》本文主要介绍了Python中@classmethod和@staticmethod的区别,文中通过示例代码介绍的非常详细,对大... 目录1.@classmethod2.@staticmethod3.例子1.@classmethod
阅读更多...
Python手搓邮件发送客户端

Python手搓邮件发送客户端

《Python手搓邮件发送客户端》这篇文章主要为大家详细介绍了如何使用Python手搓邮件发送客户端,支持发送邮件,附件,定时发送以及个性化邮件正文,感兴趣的可以了解下... 目录1. 简介2.主要功能2.1.邮件发送功能2.2.个性签名功能2.3.定时发送功能2. 4.附件管理2.5.配置加载功能2.6.
阅读更多...
使用Python进行文件读写操作的基本方法

使用Python进行文件读写操作的基本方法

《使用Python进行文件读写操作的基本方法》今天的内容来介绍Python中进行文件读写操作的方法,这在学习Python时是必不可少的技术点,希望可以帮助到正在学习python的小伙伴,以下是Pyth... 目录一、文件读取：二、文件写入：三、文件追加：四、文件读写的二进制模式：五、使用 json 模块读写
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2