一天一点点，第四天Python基础

第一天：一天一点点。Python基础-CSDN博客

第二天：一天一点点，接上章Python基础-CSDN博客

第三天：一天一点点，第三天Python基础(循环语句)-CSDN博客

推导式

• 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
• 推导式是一种强大且简洁的语法，适用于生成列表、字典、集合和生成器。
• Python 支持各种数据结构的推导式：
  • 列表(list)推导式
  • 字典(dict)推导式
  • 集合(set)推导式
  • 元组(tuple)推导式

列表推导式

列表推导式的格式为：

[表达式 for 变量 in 列表 if 条件]

实例：

names = ["aaaa", "bbb", "cccc", "ddd", "eeee", "gggg"]
# name.upper():表达式部分，这里表示要放入新列表的元素将其转大写。.upper()字符串的一个方法转大写
# for name in names:循环遍历names列表,遍历出来的元素为name
# if len(name) > 3:判断遍历出的元素name的长度大于3的保留
new_names = [name.upper() for name in names if len(name) > 3]
print(new_names)# ['AAAA', 'CCCC', 'EEEE', 'GGGG']

# 计算1 ~ 30可以被3整除的数
nums = [num for num in range(1, 31) if num % 3 == 0]
print(nums)# [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

 字典推导式

# 字典推导式
list_three = [3, 6, 9, 12, 15]
# 将列表中的各元素为键，元素 / 3为值
new_dict = {key : key / 3 for key in list_three}
print(new_dict) # {3: 1.0, 6: 2.0, 9: 3.0, 12: 4.0, 15: 5.0}

# 提供4个数字以各数字为键，各数字的平方为值
new_dict2 = {key : key ** 2 for key in (2, 4, 6, 8)}
print(new_dict2)

集合推导式

# 集合推导式
# 判断不是abc的字符并输出
new_set = {x for x in 'adbecfgabcdefg' if x not in 'abc'}
print(new_set)# {'e', 'f', 'd', 'g'}
print(type(new_set))# <class 'set'>

元组推导式

• 元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。生成器后面会有

# 元组推导式
# 1 ~ 8放入元组中
new_tuple = (i for i in range(1, 9))
# 打印的生成器对象
print(new_tuple)# <generator object <genexpr> at 0x00000157ED21CE80>
# 可以使用tuple()转换成元组
print(tuple(new_tuple))# (1, 2, 3, 4, 5, 6, 7, 8)

面向对象

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

class MyClass: # 声明一个类
    i = '小徐掉头发'

    def fun(self):
        return "hello world"

my_class = MyClass()# 创建类实例
print(my_class.i)# 调用属性
print(my_class.fun())# 调用方法

•  类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用。当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上

• 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self

• 在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例

# Python面向对象
class Student():
    # 声明属性
    name = ''  # 姓名
    age = 0  # 年龄
    sex = ''  # 性别

    def __init__(self, name, age, sex): # 带参构造
        self.name = name
        self.age = age
        self.sex = sex

    def info(self):# 方法函数
        print(f"我叫{self.name}、性别{self.sex}、年龄{self.age}")

student = Student("小徐", 18, "男")# 创建对象实例
# 调用info方法
student.info()# 我是小徐、性别男、年龄18

继承

单继承

class People():# 创建父类
    name = '' # 姓名
    age = 0 # 年龄

    # 定义构造方法
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(f"{self.name}说:今年{self.age}岁")


class Student(People): # 继承People
    sex = ''

    def __init__(self, name, age, sex):
        People.__init__(self, name, age)# 调用父类的构造方法
        self.sex = sex

    def info(self): # 覆盖父类info
        print(f"{self.name}说：性别{self.age},{self.age}岁")


student = Student('小徐', 18, '男')# 创建student对象
student.info()# 调用student的info方法

多继承

好家伙多继承让我学到了。Java只能单继承说实话有点不适应

class People():
    name = ''
    age = 0

    # 定义构造方法
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(f"{self.name}说:今年{self.age}岁")


class Student(People):  # 继承People
    sex = ''

    def __init__(self, name, age, sex):
        People.__init__(self, name, age)
        self.sex = sex

    def info(self):
        print(f"{self.name}说：性别{self.age},{self.age}岁")


class Speaker():
    topic = ''
    name = ''

    def __init__(self, name, topic):
        self.name = name
        self.topic = topic

    def info(self):
        print(f"我叫{self.name}，我是一个Python小白。今天学习的内容是{self.topic}")


class Sample(Speaker, Student):
    a = ''

    def __init__(self, name, a, sex, age, topic):
        self.a = a
        Student.__init__(self, name, age, sex)
        Speaker.__init__(self, name, topic)


sample = Sample('小徐', '你干嘛', '男', 18, 'java.py')
sample.info()# 我叫小徐，我是一个Python小白。今天学习的内容是java.py

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

        以上面为例：调用sample.info()方法。但是继承的父类Student、Speaker中都有info()方法，那为什么会调用Speaker中的info方法呢？没错就是上面所说的会根据Sample(Speaker, Student)里面继承的父类从左至右查找先找到谁的用谁的。所以说如果想用Student类中的info()方法可以在继承的顺序将Student的位置更靠前。

        当然肯定还有其它方法让我们慢慢解锁吧！！！

方法重写

当父类的方法不能满足你的需求，可以在子类中重写父类的方法。例如：

class Parent():
    name = ''
    age = ''

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(f"我是{self.name},今年刚满{self.age}岁")


class Child(Parent):
    sex = ''

    def __init__(self, name, age, sex):
        self.sex = sex
        super().__init__(name, age)

    def info(self): # 重写父类info方法
        print(f"我是{self.name},是个小{self.sex}生,今年刚满{self.age}岁")


child = Child('小徐', 18, '男')
child.info() # 我是小徐,是个小男生,今年刚满18岁

类属性与方法

类的私有属性

• 两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.

class Private_Property():
    name = ''
    age = 0
    __height = 0.0 # 私有变量

    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.__height = height


private_property = Private_Property("小徐", 18, 2.8)
print(private_property.name) # 小徐
print(private_property.age) # 18
# print(private_property.__height) # 报错在外部无法引用

类的私有方法

• 两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.

class Private_Method():

    def method1(self):
        print("这是一个公开的方法")

    def __method2(self):
        print("这是一个私有的方法")

    def method3(self):
        print("我调用了__method2方法")
        self.__method2()

private_method = Private_Method()
private_method.method1()
# private_method.__method2 # 报错无法调用私有方法
private_method.method3() # method3里面调用__method2

    

OK啊兄弟们！！！今天到这吧。敬请期待下一期