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: 多模块(.py)中全局变量的导入

python: 多模块(.py)中全局变量的导入

文章目录 global关键字可变类型和不可变类型数据的内存地址单模块(单个py文件)的全局变量示例总结 多模块(多个py文件)的全局变量from x import x导入全局变量示例 import x导入全局变量示例 总结 global关键字 global 的作用范围是模块(.py)级别： 当你在一个模块（文件）中使用 global 声明变量时，这个变量只在该模块的全局命名空
阅读更多...
hdu1171（母函数或多重背包）

hdu1171（母函数或多重背包）

题意：把物品分成两份，使得价值最接近 可以用背包，或者是母函数来解，母函数（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v） 其中指数为价值，每一项的数目为（该物品数+1）个 代码如下： #include<iostream>#include<algorithm>
阅读更多...
【Python编程】Linux创建虚拟环境并配置与notebook相连接

【Python编程】Linux创建虚拟环境并配置与notebook相连接

1.创建 使用 venv 创建虚拟环境。例如，在当前目录下创建一个名为 myenv 的虚拟环境： python3 -m venv myenv 2.激活 激活虚拟环境使其成为当前终端会话的活动环境。运行： source myenv/bin/activate 3.与notebook连接 在虚拟环境中，使用 pip 安装 Jupyter 和 ipykernel： pip instal
阅读更多...
【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程（Gaussian Process，简称GP）是一种概率模型，用于描述一组随机变量的联合概率分布，其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数（或核函数） 1.3 核函数1.4 高斯过程回归（Gauss
阅读更多...
【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

系列文章目录 监督学习：参数方法 【学习笔记】 陈强-机器学习-Python-Ch4 线性回归 【学习笔记】 陈强-机器学习-Python-Ch5 逻辑回归 【课后题练习】 陈强-机器学习-Python-Ch5 逻辑回归（SAheart.csv） 【学习笔记】 陈强-机器学习-Python-Ch6 多项逻辑回归 【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch7 判别分析 【学
阅读更多...
nudepy，一个有趣的 Python 库！

nudepy，一个有趣的 Python 库！

更多资料获取 📚 个人网站：ipengtao.com 大家好，今天为大家分享一个有趣的 Python 库 - nudepy。 Github地址：https://github.com/hhatto/nude.py 在图像处理和计算机视觉应用中，检测图像中的不适当内容（例如裸露图像）是一个重要的任务。nudepy 是一个基于 Python 的库，专门用于检测图像中的不适当内容。该
阅读更多...
pip-tools：打造可重复、可控的 Python 开发环境，解决依赖关系，让代码更稳定

pip-tools：打造可重复、可控的 Python 开发环境，解决依赖关系，让代码更稳定

在 Python 开发中，管理依赖关系是一项繁琐且容易出错的任务。手动更新依赖版本、处理冲突、确保一致性等等，都可能让开发者感到头疼。而 pip-tools 为开发者提供了一套稳定可靠的解决方案。 什么是 pip-tools？ pip-tools 是一组命令行工具，旨在简化 Python 依赖关系的管理，确保项目环境的稳定性和可重复性。它主要包含两个核心工具：pip-compile 和 pip
阅读更多...
C++操作符重载实例(独立函数)

C++操作符重载实例(独立函数)

C++操作符重载实例，我们把坐标值CVector的加法进行重载，计算c3=c1+c2时，也就是计算x3=x1+x2，y3=y1+y2，今天我们以独立函数的方式重载操作符+（加号），以下是C++代码： c1802.cpp源代码： D:\YcjWork\CppTour>vim c1802.cpp #include <iostream>using namespace std;/*** 以独立函数
阅读更多...
HTML提交表单给python

HTML提交表单给python

python 代码 from flask import Flask, request, render_template, redirect, url_forapp = Flask(__name__)@app.route('/')def form():# 渲染表单页面return render_template('./index.html')@app.route('/submit_form',
阅读更多...
函数式编程思想

函数式编程思想

我们经常会用到各种各样的编程思想，例如面向过程、面向对象。不过笔者在该博客简单介绍一下函数式编程思想. 如果对函数式编程思想进行概括，就是f(x) = na(x) , y=uf(x)…至于其他的编程思想，可能是y=a(x)+b(x)+c(x)…，也有可能是y=f(x)=f(x)/a + f(x)/b+f(x)/c… 面向过程的指令式编程 面向过程，简单理解就是y=a(x)+b(x)+c(x)
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2