python要点

最新推荐文章于 2024-07-24 23:49:50 发布
最新推荐文章于 2024-07-24 23:49:50 发布
阅读量146 收藏 3
点赞数
文章标签： python 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ntones_Holve/article/details/130162285
版权

python学习要点

注：本笔记为学习“冰冷的希望”博主python基础知识所记，仅用作学习记录。

一、字符串

  1. 字符串索引左闭右开

    str[2:5],str的第3到第4个字符串

  2. 字符串查找，.find（’ '）

  3. 拼接字符串：字符串可以加、乘，不能除和减

    print('abc'+'123') #输出：abc123
print('*'*600) #输出：600个*

    字符串.join

    str_a = ','
str_b = str_a.join('123456')
print(str_b) #输出：1，2，3，4，5，6

  4. name = 'monsterholve'
age = 30
print('我是{}，今年{}岁'.format(name, age))
print('我是%s,今年%d岁' % (name, age))
print(f'我是{name},今年{age}岁') #python3.6以上版本支持

  5. 常用方法

    字符串常用方法总结

二、数据类型与常用内置函数

  1. 数据类型

    数据类型

  2. 常用内置函数

常用内置函数

三、列表

  1. 定义方法

    my_list = list()
my_list = ['monsterholve', 5, 52, ['lkjsd2'],'hkjsh']

    注：列表类型可以容纳包含其他所有类型数据，其中的[‘lkjsd2’]作为my_list的一个元素

  2. 元素操作

    • 增加元素，append、insert、extend

      • append：增加一个元素到列表末尾
      • insert：在指定位置前面插入一个元素
      • extend：在列表末尾扩展一个新的列表
      my_list.append('123') #输出：['monsterholve', 5, 52, ['lkjsd2'],'hkjsh', '123']
my_list.insert(3, '456') #输出：['monsterholve', 5, 52, '456', ['lkjsd2'],'hkjsh', '123']
my_list.extend(['12222', 'sfkjh']) # 输出：['monsterholve', 5, 52, '456', ['lkjsd2'], 'hkjsh', '123', '12222', 'sfkjh']

      注：列表中可以存在重复元素

    • 删除元素，pop、remove、del

      • pop：删除指定位置的元素，如果不指定index，默认删除列表末尾元素
      • remove：直接删除元素值
      • del：针对列表操作，可以删除列表索引元素，没有索引默认删除整个表
      my_list.pop(4) # 输出：['monsterholve', 5, 52, '456', 'hkjsh', '123', '12222', 'sfkjh']
my_list.remove(52)# 输出：['monsterholve', 5, '456', ['lkjsd2'], 'hkjsh', '123', '12222', 'sfkjh']
del my_list #删除整个列表
del my_list[1] #输出：['monsterholve', 52, '456', ['lkjsd2', 'dff'], 'hkjsh', '123', '12222', 'sfkjh']

      注：pop和del的操作对象不同，pop是操作列表元素，del是对列表操作

    • 修改元素，下标修改

      my_list[1] = 66

    • 查询元素，切片，index、max、min

      print(my_list[:-1]) # 输出：['monsterholve', 52, '456', ['lkjsd2'], 'hkjsh', '123', '12222']   打印列表第一个到倒数第二个。
print(my_list.count(52)) # 输出：1   .count(52)返回列表中52这个元素出现的次数

      • max：返回列表中元素的最大值 （针对只包含同一种元素的列表，如整数和字符串无法比较大小）

      • min：返回列表中元素的最小值

        my_list = [1, 2, 3, 4, 5]
print(max(my_list)) # 5
print(min(my_list)) # 1
a=1
b=4
print(max(my_list[a:b])) # 4

    • 统计

      （1）list.count( obj )
      返回某个元素在列表中出现的次数
      （2）len( list )
      返回列表的长度（有多少个元素）

  3. 列表推导式

    my_list1 = [i for i in range(0,10) if i % 2 == 0] #生成在0-9范围内能被2整除的数

四、元组

元组（Tuple）与列表（List）非常像，不过列表用方括号[ ]表示，元组用圆括号( )表示。元组与列表最大的区别就是：元组里的元素不能被更改！！！
也就是说，元组不能增、删、改，只能查。查询操作跟列表一样

注：如果元组中只有一个元素，为避免优先级误解，需要加逗号，即

aa = tuple()
aa = (2,)
aa = (2, 3, 5)

五、字典

字典（Dictionary）是用花括号{ }表示的，里面的元素由键、值两部分组成，称为键值对。

  1. 定义

    键+值

    my_dict = dict()
my_dict = {'k0': 'v0'}

  2. 字典操作

    • 增加元素

      • 直接通过索引增加
      • .update（），如果原字典中有这个键，则更新键对应的值，如果没有，则增加该键和对应值
      • .setdefault()，设置默认值，如果原字典中没有这个键，则新增该键，并设置默认值，如果有这个键，则不起作用，不改变原键和值。
      my_dict['k1'] = 'v1'
my_dict.update({'k2': 'v2'})
my_dict.setdefault('k2', 'v3') # 字典内容不变
my_dict.setdefault('k3', 'v3')

    • 删除元素

      • del，可删除整个字典或删除指定键值 (注：del删除只需要指定键，不能含有值)
      • .pop(‘key’, ‘value’)，删除指定的键和值，若不指定值，如果字典中没有该键，则会报错，若指定了键和值，则即使不存在也不会报错（可理解为将其写入有删除了）
      • .popitem()，删除字典的最后一项键和值（注：popitem（）不带参数，加参数会报错）

    • 修改元素 (同列表修改前两项)

      • 直接通过索引增加
      • .update（），如果原字典中有这个键，则更新键对应的值，如果没有，则增加该键和对应值

    • 查询元素

      print(my_dict['k1'])
print(my_dict.get('k55', 'v555')) # 若key不存在，则返回给定的值（如v555），若key不存在且没有给定值，则返回None
print(my_dict.kays()) # 输出所有键
print(my_dict.values()) # 输出所有值
print(my_dict.items()) # 输出字典所有键-值

六、集合

集合（Set）是一种复合类型，用花括号{ }表示，无序（写入元素后会随机排序）并唯一地存放容器元素的类型。集合有点像字典，用set()方法创建，但集合却只有键没有值，并且键不能重复并且无序。集合有并、差、交、补、判断子集等操作。

my_list = list()
my_list = ['dafsadf', 1, 45, 1]
my_set = set(my_list) # {1, 45, 'dafsadf'} （这一顺序是随机产生的 多次输出顺序不定）
my_set2 = {4, 6, 9, 1}
my_set3 = my_set ^ my_set2 # 补 {4, 6, 9, 45, 'dafsadf'}
my_set3 = my_set | my_set2 # 并 {1, 4, 6, 'dafsadf', 9, 45}
my_set3 = my_set & my_set2 # 交 {1}
my_set3 = my_set - my_set2 # 差 {'dafsadf', 45}
my_set3 = my_set2 - my_set # 差 {9, 4, 6}
print(my_set <= my_set2) # 判断是否子集 False

my_set3.update([5555, 3333]) # 注意：直接输入数字报错，update更新的必须是一个可跌倒对象（Iterable）,如序列类型的list、str、tuple，映类型的dict，以及其他类型可迭代对象（具体可百度）
my_set3.update("4444", 'ffff', 'father') # {4, 3333, 6, 'e', 'r', 'h', '4', 5555, 'a', 'f', 't'} update更新字符串时，将其拆成一个一个的字符并且去重后，作为子集与已有集合合并
my_set3.add(3) # {'f', 'r', 3, 4, 3333, 6, 'a', 9, 5555, '4', 't', 'h', 'e'}
my_set3.remove(3333) # {'e', 3, 4, 6, 'f', 9, 'r', '4', 5555, 't', 'a', 'h'}
my_set3.pop() # {3, 4, 6, '4', 9, 't', 'r', 5555, 'f', 'a', 'e'} 删除集合中的第一个元素（这个元素是随机的，如上一个集合中'h'成为了第一个元素，并被删除）

小结（列表、元组、字典、集合对比）

在这里插入图片描述

七、运算符

  1. 算数运算符

    算术运算符

  2. 比较运算符

    比较运算符

    注：<>是python2版本中的表达。

  3. 赋值运算符

    用“=”表示，此外还有+=、-=、*=、/=等赋值方式。例：a = a + 1等价于a += 1。

  4. 逻辑运算符

    and、or、not三种。对应且、或、非（取反）。

    print(5>4) # Ture
print(not 5>4) # False

  5. 成员运算符

    成员运算符判断某个值是否在字符串、列表等对象中，只有 in 和 not in 两种。

  6. 身份运算符

    身份运算符用于比较两个对象的存储单元，只有 is 和 is not 两种。

    **注意：**is 和 == 不一样，前者判断两个变量id是否相同，后者值判断两个变量的值是否相等。

    x = 100
y = 100
print(x == y)  # 输出：True
print(x is y)  # 输出：True
print(id(x), id(y))  # 输出：2578683661648 2578683661648

x = [1, 2, 3]
y = [1, 2, 3]
print(x == y)  # 输出：True
print(x is y)  # 输出：False
print(id(x), id(y))  # 输出：2578685027776 2578684997696

八、循环

  1. 九九乘法表打印

    for i in range(1, 10):
    for j in range(1, i + 1):
        print('%d x %d = %-2d' % (j, i, j * i), end='  ') # %d标识整数，2d表示两位整数，当整数位数不够时在左侧补空格，-2d表示当整数位数不够2位时在右侧补空格
        # print('{} * {} = {}'.format(j, i, i * j), end='     ' if 3 <= i <= 4 and j == 2 else '    ')
        # print('{} * {} = {}'.format(j, i, i * j), end='     ' if i in range(3, 5) and j == 2 else '    ')
    print()

九、函数

  1. 定义函数时：def 函数名(形参):

    def 函数名(参数):
	#（注意缩进）
    函数体
    return 返回值

  2. 调用函数时：函数名(实参)

  3. 参数

    函数参数

    上述参数*args、*kwargs用法举例

    def info(name, *args, **kwargs):
    print("name:", name)
    print("args:", args)
    print("kwargs:", kwargs)

info("pan", 18, "男", height=170, city="广西")

# 打印输出：
# name: pan
# args: (18, '男')
# kwargs: {'height': 170, 'city': '广西'}

  4. 返回值

    若执行完一个函数得到一个值（也可以是其他），可以将其返回。比如说定义一个加法函数，计算完之后返回计算结果，并把结果赋值给一个变量。返回值可以是变量、确定的值、列表等，还可以是一个函数，比如说返回函数本身，实现阶乘。

    注意
    1）如果不指定返回值，即不写return，则会默认返回一个None
    2）return后面的语句不会再执行
    3）函数可以嵌套调用，即函数里可以再调用其他函数

  5. 全局变量与局部变量

    # 定义全局变量
num = 200
def test():
    # global num 告诉解释器，函数内部使用的num就是外面的全局变量num
    global num
    num = 250  # 修改全局变量
    print('inner num=', num, id(num))

test()  # 函数调用
print('outer num=', num, id(num))

def func_outer():
    count = 0
    def func_inner():
        nonlocal count
        count += 1
        return count
    return func_inner

  6. 匿名函数

    如果你的函数的功能很简单，那就没必要那么麻烦定义一个函数了，可以直接使用lambda定义一个匿名函数。

    lambda [形参1], [形参2], ... : [单行表达式] 或 [函数调用]

    # 普通函数方式
def add(a, b):
    return a + b

print(add(10, 20))

# lambda方式
add = lambda a, b: a + b
print(add(10, 20))

    注意
    1）匿名函数只能实现简单的逻辑，不能使用循环、分支等语法
    2）匿名函数不需要return，会自动返回表达式的结果

十、类

类（Class）是用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

  1. 构造方法

    构造方法在创建类对象的时候，会自动执行，并将传入参数自动传递给init方法使用。

    class Person:  # 类名一般习惯首字母大写
    def __init__(self, name, age): # 相比一版函数，多了self参数，后面的位置参数根据需要设置
    self.name = name
    self.age = age

  2. 内置方法（魔法方法）

    构造方法（init）也是内置方法。除了__init__方法，还有其他一些以双下划线开头和结尾的方法，都属于内置的专有方法,如：

    __init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方
__slots__：可以指定类的参数，指定后超出的参数无法传入，会报错

  3. 私有方法和私有属性

    在一个类里定义属性（变量）或者方法的时候，若以双下划线开头，声明是私有属性或方法，不能在类的外部被使用或直接访问。

  4. 继承

    可以用A类继承于B类，这样B类所具有的属性和方法A类也有，比如说student类继承于human类，则human的name、age、say()等内容student类不用自己定义就有了，而且还能重写父类的方法。

    class human: # 定义一个类
    def __init__(self, name="someone", age=20):
        self.name = name  # 类属性name
        self.age = age # 类属性age
    def say(self): # 类方法，所有的类方法都至少有一个参数self
        print("hello")
    def think(self,a=1,b=2):
        print(a+b)

class student(human):  # 继承语法 class 类名 （父类）：
    def __init__(self, school="sxu", major="chem"): # 初始化类student
        super().__init__("pan", 25) # 调用父类human的初始化方法
        self.school = school
        self.major = major
    def think(self,a=1,b=2): # 重写think()方法，父类用加法，这里用乘法
        print(a*b)

stu = student() # 实例化类得到对象stu
print(stu.name) # stu也有父类的name属性
print(stu.school)
print(stu.major)
stu.major = "python" # 修改major属性
print(stu.major)
stu.think(2, 3)
    • **多继承：**一个类可以继承多个父类。（如果父类有同名方法或属性，先继承的优先级高于后继承的）
    class 类名 （父类1，父类2，...）:
    类内容体     # （如果没有新内容，用pass代替）

    • 复写父类属性和方法

      直接将父类中的属性和方法重写一次即可。

    • 调用父类重名成员

      方式1：父类名.成员变量/父类名.成员方法(self)

      方式2：super().成员变量/super().成员方法 ()

  5. 多态

    指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态。（同样的行为（函数），传入不同的对象，得到不同的状态）。

    堕胎常作用在继承关系上：以父类做定义声明，以子类做实际工作，用以获得同一行为，不同状态。

  6. 类方法与静态方法

    • 类属性：直接在类内容体中输入不带’self.'的变量即为类的属性。

    • 类方法：用装饰器@classmethod装饰方法，用cls代替self。

    • 静态方法：如果不需要传实例或类时，可以直接定义为静态方法，用@staticmethod装饰

      class Person(object):
    count = 0  # 类属性
    def __init__(self, name):
        self.name = name
        Person.count += 1
    @classmethod      # 类方法
    def say(cls):
        print('我被实例化{}次'.format(cls.count))
    @staticmethod   # 静态方法
    def read():
        print('我在阅读')

Tips:捕获异常、主动抛异常、调试程序

  1. 捕获异常

    try:
    print('尝试执行代码')
    1/0
except Exception as e:
    print('捕获到异常：{}'.format(e))
else:
    print('没有异常')
finally:
    print('都会执行')

  2. 主动抛异常

  3. 调试程序

十一、文件处理

  1. 文件读写

    • 写入

      使用open()函数打开一个文件，write()函数写入内容，最后使用close()函数关闭已打开的文件。

      推荐with open()这种写法，比较简洁，而且避免了因为出错或其他原因导致不能close()文件的情况。

      text = "this is a text"
with open("test.txt", "w", encoding="utf-8") as f:
    f.write()

      关于open()函数的三个参数

      （1）文件名。可以指定绝对路径，若不写路径则保存在该.py文件所在目录
      （2）操作模式。操作模式有很多，常用的有w、a、r、wb、rb等

      操作模式说明
      w打开一个文件只用于写入。如果该文件已经存在则打开文件，原有内容会被删除。如果该文件不存在，创建新文件
      a打开一个文件用于追加。如果该文件已经存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件
      r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式
      +打开一个文件进行更新（可读可写）
      wb以二进制格式打开一个文件用于写入。一般用于非文本文件，如图片等
      rb以二进制格式打开一个文件用于只读。一般用于非文本文件，如图片等
      w、r可分别与b、+进行组合

      （3）编码。常用编码有utf-8、gbk等，编码问题可以会导致乱码。

    • 读取

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

      关于读取内容的方式：

      1、f.read()，一次性读取所有内容，若文件很大可能会导致内存不够用，故可以指定一个参数（每次读写的大小），比如说f.read(1024)
      2、f.readline()，只能读取一行
      3、f.readlines()，读取所有行，返回一个列表

      with open("test.txt", "r", encoding="utf-8") as f:
    #print(f.readlines())
    for line in f.readlines(): # 遍历列表
        print(line)

  2. 上下文管理器

    可以避免文件打开后忘记关掉的情况，上下文管理器会自动将文件关闭：当使用with语句时，会调用上文方法__enter__()，with语句结束时会自动调用下文方法__exit__()进行关闭。

    class OptFile(object):
    def __init__(self, path, mode, encoding):
        self.path = path
        self.mode = mode
        self.encoding = encoding

    def __enter__(self):  # 调用上文方法
        self.f = open(self.path, self.mode, encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb): #调用下文方法
        if exc_type:
            print("exc_type:", exc_type)
            print("exc_val:", exc_val)
            print("exc_tb:", exc_tb)
        print("OptFile closed")
        self.f.close()
        return True

    def read_file(self, length=None):
        # 1 / 0  # 故意制造错误
        return self.f.read(length)

with OptFile(r"C:\Users\admin\Desktop\kspc.txt", "r", "utf-8") as f:
    print(f.read_file())

  3. JSON和CSV

    参考冰冷的希望的博客内容：JSON和CSV

  4. OS模块

    os是python的内置模块，用于查看或操作硬盘的文件以及文件夹。

    OS模块

    递归获取某个文件夹里所有文件：

    import os
def listdir(path, to_save_list: list):
    if not os.path.exists(path):
        return
    for file in os.listdir(path):
        file_path = os.path.join(path, file)
        if os.path.isdir(file_path):
            listdir(file_path, to_save_list)
        else:
            to_save_list.append(file_path)
if __name__ == '__main__':
    dir_path = r"C:\Users\admin\Desktop"
    my_file_list = list()
    listdir(dir_path, my_file_list)
    for f in my_file_list:
        print(f)
Ntones_Holve
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python复习要点.pdf
02-29
复习要点 、Python基础知识 版本问题 输入/输出：input() 格式化输出 、基础数据类型 、运算符 、表达式：合法性 、序列： 、程序结构 if for 循环、while循环，break、continue 、函数 ...
Python期末复习知识要点
06-15
自己整理的Python期末考试知识点
python要点——干货
qq_46698164的博客
04-04 428
python要点1. Python语言1.1 Python语言的基本概念1.2Python 的特色1.3Python的发展及应用2.搭建环境2.1Python的解释器2.2搭建Python环境2.3Python的交互模式2.4 pip工具的使用2.5 Python的第一个程序3.PyCharm的安装和配置3.1PyCharm的安装3.2 PyCharm的简单配置 1. Python语言 1.1 P...
Python——Python要点
weixin_51927215的博客
01-17 175
Python要点1、Python环境安装过程2、pip工具使用解决方法2.1、下载出现pip版本过低的问题2.2、下载超时解决方法2.3、还可以直接去pycharm中直接下载2.4、安装pycharm3、检查Python解释器是否配置成功 1、Python环境安装过程 2、pip工具使用解决方法 2.1、下载出现pip版本过低的问题 需要我们升级pip版本 1. 按 win+R 键进入交互环境 2. 输入命令 python -m pip install --upgrade pip 3. 如果下载.
Python要点学习
wangjin2891的专栏
07-04 499
Python学习要点： 1、基本数据类型 2、如何自定义数据结构 3、if  for  while 语句 4、系统调用如何使用 5、多线程如何操作 一、python数据类型 1.1、字符串 a、使用单引号(') 用单引号括起来表示字符串，例如： str='this is string'; print str; b、使用双引号(") 双引号中的字符串
python要点对照表
weixin_46075797的博客
05-21 135
图片截取自视频，可对照要点学习
01-python要点
weixin_46491509的博客
04-04 586
01-python要点1 python语言1.1 python语言的基本概念1.2 python的特色1.3 python的发展及应用2 python搭建环境 1 python语言 1.1 python语言的基本概念 1.2 python的特色 简单 易于学习 自由且开放 跨平台 可嵌入性 丰富的库 1.3 python的发展及应用 2 python搭建环境 ...
python command详解_Python要点解析
weixin_39540834的博客
12-21 1084
Design PatternSingleton Design PatternSingleton provides you with a mechanism to have one, and only one, object of a given type and provides a global point of access.这个模式的要点在于只创建一个实例，并为此提供全局接口。Hence, ...
python编程要点
程序的尽头是数学，一日不推导赶不上买买提
08-03 114
ref https://www.python.org/dev/peps/pep-0008/ https://www.python.org/dev/peps/pep-0020/
python学习日记【python要点】
学python的小小小小白
08-10 137
python要点python语言python语言的特色：Python的应用：搭建环境python环境搭建pip工具介绍pip工具的使用pycharm安装和配置 python语言 python语言的特色： 简单、易于学习、自由且开放、跨平台、可拓展性、可嵌入性、丰富的库 Python的应用： 常规软件开发、科学计算、自动化运维、自动化测试、WEB开发、网络爬虫、数据分析、人工智能 搭建环境 python环境搭建 详见>>>python环境搭建 pip工具介绍 python有两个著名的包管理工
Python核心编程-Python要点
大余的技术博客
08-21 774
1 Python语言 1.1 Python语言的概念 Python 是一种极少数能兼具、简单与 功能强大的编程语言。你将惊异于发现你正在使用的这门编程语言是如此简单，它专注于如何解决问题，而非拘泥于语法与结构。 官方介绍： Python 是一款易于学习且功能强大的编程语言。 它具有高效率的数据结构，能够简单又有效地实现面向对象编程。Python 简洁的语法与动态输入之特性，加之其解释性语言的本质，使得它成为一种在多种领域与绝大多数平台都能进行脚本编写与应用快速开发工作的理想语言。 Python 的创造者
Python要点及其环境搭建+Pycharm简单使用教程
Jackey_Song的博客
12-04 2328
Python要点及其环境搭建Python语言概述Python环境搭建pip工具的使用PyCharm的安装和配置PyCharm的简单配置使用Pycharm编程 Python语言概述 Python 是一种极少数能兼具简单与功能强大的编程语言。你将惊异于发现你正在使用的这门编程语言是如此简单，它专注于如何解决问题，而非拘泥于语法与结构 官方对Python的介绍：Python 是一款易于学习且功能强大的编程语言。 它具有高效率的数据结构，能够简单又有效地实现面向对象编程。Python 简洁的语法与动态输入之特性，
python基础要点-02
12-21
【Python基础要点】 Python是一种备受推崇的编程语言，它的设计哲学强调代码的可读性和简洁的语法，使得Python成为初学者入门和专业人士进行复杂任务的理想选择。Python的创始人吉多·范罗苏姆以英国喜剧团体"巨蟒...
2024年Python面试题要点
03-06
2024年Python面试题要点
Python学习要点-综合文档
05-14
Python学习要点Python学习要点(0x00) 说明:次要点仅支持Python3.4版本,部分内容与Python2.7不同 Python解释器 0. Cpython这个解释器是用C语言写出来的,故叫Cpython。
随机数种子的作用
帆的博客
07-23 1141
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
Java-Lambda
lizhiwei21的博客
07-21 502
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
使用9种方法隐藏和显示元素
lulei5153的博客
07-21 207
【代码】使用9种方法隐藏和显示元素。
提取autocad2024图形中图块的属性的代码-统计选中图块长度属性的总长度
最新发布
VB973490770的专栏
07-24 155
阀门位号：XV-123。
python安装要点
12-15
Python安装要点： 1.选择合适的Python版本：在安装Python之前，需要确定自己需要的Python版本，常见的有Python 2和Python 3版本。目前Python官方已经停止对Python 2的支持，推荐安装Python 3版本。 2.下载安装包：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值