python基礎-面向對象

来源:https://www.cnblogs.com/white-list/archive/2022/11/30/16846464.html
-Advertisement-
Play Games

1.面向對象 面向對象編程是在面向過程編程的基礎上發展來的,它比面向過程編程具有更強的靈活性和擴展性,所以可以先瞭解下什麼是面向過程編程: 面向過程編程的核心是過程,就是分析出實現需求所需要的步驟,通過函數一步一步實現這些步驟,接著依次調用即可,再簡單理解就是程式 從上到下一步步執行,從頭到尾的解決 ...


1.面向對象

  面向對象編程是在面向過程編程的基礎上發展來的,它比面向過程編程具有更強的靈活性和擴展性,所以可以先瞭解下什麼是面向過程編程:

  面向過程編程的核心是過程,就是分析出實現需求所需要的步驟,通過函數一步一步實現這些步驟,接著依次調用即可,再簡單理解就是程式

  從上到下一步步執行,從頭到尾的解決問題;

  而面向對象編程是把構成事物的整個需求按照特點、功能劃分,將這些存在共性的部分封裝成對象,創建對象的目的不是為了完成某一個步驟,

  而是為了描述某個事物在整個解決問題的步驟中的行為。     

  eg: 小明用美的洗衣機洗臟衣服,流程是怎樣的?

  面向過程的解決方法:

    1、執行加洗衣液方法;

    2、執行開啟洗衣機方法;

    3、執行加水方法;

    4、執行洗衣服方法;

    5、執行甩乾方法;

    6、取出衣服;

    以上就是將解決這個問題的過程拆成一個個方法,通過按順序執行方法來解決問題。

  面向對象的解決方法:

    1、可以先歸納出兩個對象:“美的洗衣機”對象和“小明”對象

    2、針對對象“美的洗衣機”加入一些它的方法:“自動註水方法”“洗衣方法”、“烘乾方法”

    3、針對對象“小明”加入他的方法:“加洗衣液方法”、“開啟洗衣機方法”、“取出衣服方法”

    4、然後執行,使用對象.動作 的方式,執行各步驟

    小明.加洗衣液

    小明.開啟洗衣機

    美的洗衣機.自動註水

    美的洗衣機.洗衣服

    美的洗衣機.烘乾

    小明.取出衣服

    解決同一個問題 ,面向對象編程就是先抽象出對象,然後用對象執行方法的方式解決問題。

 

2.類

  如果想通過面向對象編程,首先需要創建一個類(class),才能實例化(或叫具象化)對象;

  (洗衣例子中要先有人這個類,才能有“小明”對象、先有洗衣機類,才能有“美的洗衣機”這個對象)

  類可以理解成一個模板,通過它可以創建出無數個具體實例(對象);

  使用類的關鍵字class,來聲明類,首字母大寫,多個單詞時每個單詞首字母要大寫(駝峰命名法);

  eg: class MyName(object): 

      (object)可以不寫,object是python中的一個通用對象,添加它後可以使用更多的內置功能;

class Test(object):
    name = 'test'   # 定義一個類屬性

    def run(self):
        print(f'{self.name}在跑步!')


xiaoming = Test()  # 實例化一個對象xiaoming
print(xiaoming.name)  # 對象xiaoming可以調用類屬性
xiaoming.run()  # 對象xiaoming可以調用類方法
'''
test
test在跑步!
'''

  類的參數self

  可以看到類的方法中預設第一個參數是self,且是必填的;(python中的self關鍵字只用於類的方法中);

  self也是一個對象,它代表實例化變數(例子中的xiaoming)本身(xiaoming可以調用name屬性和run方法,都是self幫助找到的)

class Person(object):

    name = None  # 類屬性(也叫類實例化屬性)
    age = None

    def run(self):
        print('可以直接使用self調用類屬性')
        print('列印屬性:'+str(self.name))
        a = 'new'   # 類方法中定義的變數無self時,屬於方法中的局部變數
        print('列印局部變數:'+a)

    def work(self):
        print('利用self可直接調用類中其它類函數')
        self.run()

    def jump():
        print('不添加self參數,就不屬於類函數,就不可以被實例化的對象調用')


# 實例化一個對象xiaoming
xiaoming = Person()
# 可以直接調用類屬性(類實例化屬性)
print(xiaoming.name)  # None
# 也可為類屬性(類實例化屬性)重新賦值
xiaoming.name = 'xiaoming'
# 調用類方法, 調用時無需傳遞self參數值
xiaoming.work()
'''
利用self調用類中其它函數
可以直接使用self調用類屬性
列印屬性:xiaoming  (此時類屬性值已被實例化對象修改)
列印局部變數:new
'''
# print(xiaoming.a)  # AttributeError: 'Person' object has no attribute 'a'  方法中的局部變數不可被實例化對象調用

# 實例化另一個對象xiaohong
xiaohong = Person()
print(xiaohong.name)  # None # 對象xiaohong並不會使用到對象xiaoming修改的類屬性(類實例化屬性)值;對象修改的類屬性(類實例化屬性),只能作用於對象本身
xiaohong.jump()  # 非類函數無法被對象調用,直接報錯
'''
Traceback (most recent call last):
  File "D:\python_exercise\test_calss.py", line 44, in <module>
    xiaohong.jump()
TypeError: Person.jump() takes 0 positional arguments but 1 was given
'''
# 可以看到報錯信息是函數無參數值,卻被傳遞了一個,說明對象在調用方法時,自動傳遞了self參數,所以直接報錯了

 

3.類的構造函數

  類中的一種預設函數,用來將類實例化的同時,將參數傳入類中;(類似於函數執行時,可以傳一些參數)

  def __init__(self, a, b):

    self.a = a      # 類實例化對象的屬性

    self.b = b

  此時self.a和self.b就可以在類的各個類函數中使用了;

class Person(object):

    def __init__(self, name):
        self.name = name  # self.聲明的變數是類實例屬性

    def run(self):
        print(f"{self.name}在跑")


test = Person('x')
test.run()  # x在跑

'''
此時已經見過了類中可定義的多種變數
類下直接定義的變數,屬於類屬性、又屬於類實例化對象屬性 (可被實例化後的對象直接引用)
構造函數中self.開頭定義的屬性,屬於類實例化對象屬性,不屬於類屬性(可被實例化後的對象直接引用)(工作中多用,且多在構造函數中提前定義好)
類函數中a=''定義的變數,屬於局部變數,既不屬於類實例化對象屬性,也不屬於類屬性(不可被實例化後的對象直接引用)
'''

 

4.對象的生命周期

  一個對象從出生到消亡的過程;

  實例化對象後,會調用內置函數__init__, 此時對象生命開始,該對象會被記憶體分配一個記憶體塊;

  對象不再使用類中的方法屬性時、或整個腳本結束執行時,對象會自動調用內置函數__del__通知記憶體管家,從記憶體中釋放占用的記憶體塊,對象生命結束;

  無論是數字、字元串、列表、元組等對象,生命周期皆是如此;

  python中會讓對象自動調用__del__的操作,無需在程式中書寫;

 

  __def__所有這種書寫形式的方法,都是類的內置函數,定義類時書寫object(class Name(object)),就可以調用這些內置函數了。

 

5.私有函數和私有變數

  私有:獨有的、不公開;

  無法被實例化後的對象調用的類中的函數和變數,就是私有函數、私有變數;

  類的內部可以在類函數中調用私有函數和私有變數;

  使用場景:某一方法只希望內部業務調用使用,不希望被使用者調用;

  定義方法:在類函數、類變數前添加__ (兩個下劃線);

class Cat(object):

    def __init__(self, name):
        self.name = name
        self.__sex = 'boy'  # 私有類實例化屬性

    def run(self):
        # 類函數可以調用私有函數
        self.__run(self.__sex)

    # 私有函數
    def __run(self, sex):
        # 私有函數可以使用類實例化屬性
        print(f'{self.name},是個{sex},它在跑!')


cat = Cat('ll')
cat.run()  # ll,是個boy,它在跑!
# 對象不可調用私有函數,直接報錯
# cat.__run()  # AttributeError: 'Cat' object has no attribute '__run'

# 也有可調用的方法,但既然創建了私有函數、私有變數,建議遵守使用規則
print(dir(cat))  # 列印所有類的內置函數,就可以看到私有函數的調用名了
'''
['_Cat__run', '_Cat__sex', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', 
'__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'run']
'''
cat._Cat__run('girl')  # ll,是個girl,它在跑!
print(cat._Cat__sex)  # boy

 

6.python中封裝

  python中封裝的概念:

    我們在類中把某些屬性和方法隱藏起來、定義為私有,只能在類的內部使用,外部無法訪問,或者留下少量的介面(函數)供外部訪問,就是封裝的概念;

    這樣做的目的是為了保護隱私、明確區分內外。

 

7.類的裝飾器

  裝飾器也是一種函數;

  它可以接收函數作為參數;且可以返回一個函數;

  接收一個函數,內部對其進行處理,然後返回一個新函數,動態的增強函數功能;

# 簡單梳理下裝飾器的大概由來

# 有一個業務函數print_test()
def print_test(info):
    print('業務函數'+info)
'''
此時想在執行業務函數前後增加日誌輸出,
且有多個類似的業務函數需要完成同樣的操作,
可以編寫另一個公用函數,以業務函數為參數,業務函數前後完成相應日誌輸出
'''
def add_info(func, info):
    print('開始的日誌')
    func(info)
    print('結束的日誌')

# 執行add_info
add_info(print_test, 'test')
'''
開始的日誌
業務函數test
結束的日誌
'''
# 但是這樣改變了原有的print_test(info)完成業務操作的寫法,可以藉助裝飾器寫法優化下
def add_info_new(func):
    def wrapper(*args, **kwargs):
        print('列印開始的日誌')
        func(*args, **kwargs)
        print('列印結束的日誌')
    return wrapper

print_test = add_info_new(print_test)
print_test('test')
'''
列印開始的日誌
業務函數test
列印結束的日誌
'''
# python中可以藉助@語法糖,優化上面print_test = add_info_new(print_test)的寫法

@add_info_new
def print_test_final(info):
    print('藉助語法糖的業務函數'+info)

print_test_final('test')
'''
列印開始的日誌
藉助語法糖的業務函數test
列印結束的日誌
'''

# 裝飾器調用時,也可以傳遞參數,對業務處理進行再次的判斷
def add_print_args(handle):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print('依舊執行前列印日誌')
            func(*args, **kwargs)
            print('依舊執行後列印日誌')
            if handle:
                print('額外處理')
        return wrapper
    return decorator


@add_print_args(handle=True)
def print_test_args(info):
    print('列印一下'+info)

print_test_args('test')
'''
依舊執行前列印日誌
列印一下test
依舊執行後列印日誌
額外處理
'''

'''
使用裝飾器後,被裝飾函數的元信息會被修改,例如__name__, doc等
'''
print(print_test_args.__name__)
# wrapper  (這裡也很好理解,已經被返回成新的裝飾函數了)
'''
若想保存元信息不變,
可以使用wrap庫,from functools import wraps
wraps也是一個裝飾器,它是把原函數元信息拷貝到了裝飾器函數中
'''
from functools import wraps
def add_print_wrap(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print('執行前列印')
        func(*args, **kwargs)
        print('執行後列印')
    return wrapper

@add_print_wrap
def print_test_wrap(info):
    print('業務函數'+info)

print_test_wrap('test')
print(print_test_wrap.__name__)
'''
執行前列印
業務函數test
執行後列印
print_test_wrap
'''

'''
類裝飾器
通過內置函數__call__處理額外操作
'''
class AddPrint(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print('開始的列印foo')
        self.func(*args, **kwargs)
        print('結束的列印foo')

@AddPrint
def print_test_foo(info):
    print('業務函數'+info)

print_test_foo('test')
'''
開始的列印foo
業務函數test
結束的列印foo
'''

'''
類裝飾器也可以通過傳參做額外操作
'''
class Foo(object):
    def __init__(self, handle):
        self.handle = handle

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            print('執行前操作')
            func(*args, **kwargs)
            print('執行後操作')
            if self.handle:
                print('額外操作')
        return wrapper

@Foo(handle=True)
def print_test5(info):
    print('業務操作'+info)

print_test5('test')
'''
執行前操作
業務操作test
執行後操作
額外操作
'''

  

8.幾種內置的常見裝飾器

  @classmethod

  將類的函數定義為可以不經過實例化而直接被調用;此時可以不實例化,直接調用該方法;

class Foo(object):

    def __init__(self, a):
        self.a = a

    def run(self):
        print('run')

    @classmethod
    def jump(cls):
        print('jump')
    # 此時self被替換成cls,代表類本身

# Foo.run()
'''
Traceback (most recent call last):
  File "D:\python_exercise\test5.py", line 21, in <module>
    Foo.run()
TypeError: Foo.run() missing 1 required positional argument: 'self'
因為正常我們實例化的時候,python會自動幫我們將self參數傳遞進去
此時沒有實例化,所以報錯沒有傳self參數
'''
Foo.jump()  # jump
# 類函數就可以不用實例化直接調用了

  cls函數不可引用self函數

class Foo(object):

    def __init__(self, a):
        self.a = a

    def run(self):
        print('run')

    @classmethod
    def jump(cls):
        print('jump')
        cls.run()

Foo.jump()
'''
TypeError: Foo.run() missing 1 required positional argument: 'self'
'''

  self函數可以引用cls函數

class Foo(object):

    def __init__(self, a):
        self.a = a

    def run(self):
        print('run')
        self.jump()

    @classmethod
    def jump(cls):
        print('jump')

foo = Foo('test')
foo.run()
foo.jump()   # 實例化對象也可使用cls函數
'''
run
jump
jump
'''

  @staticmethod

  將類函數定義為可以不經過實例化而直接被調用,且該函數不需要傳遞self或cls,且無法在該函數內調用其它類函數或類變數;

class Foo(object):

    def __init__(self):
        pass

    def run(self):
        print('run')
        self.jump()

    @staticmethod
    def jump():
        print('jump')

Foo.jump()  # jump
foo = Foo()
foo.jump()  # jump (也可以通過對象調用)
foo.run()  # static函數也可以被其它類函數調用
'''
run
jump
'''

  @property

  將類函數的調用免去括弧,類似於調用屬性;

class Foo(object):

    @property
    def run(self):
        print('run')


foo = Foo()
foo.run  # run

  同樣使用這種調用方法,需要傳參時,有自己的寫法;

class Foo(object):

    @property
    def run(self):
        print('run')

    @run.setter
    def run(self, info):
        print(info)


foo = Foo()
foo.run = 'test info'  # test info

 

9.類的繼承

  通過繼承,子類可以擁有父類所有的屬性和方法;

  父類不具備子類自有的屬性和方法;

  定義方法 class Child(Parent):  Child類繼承Parent類;

class Parent(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def walk(self):
        print(f'{self.name}在行走')


class Child(Parent):
    def run(self):
        self.walk()    # 子類可以調用父類的方法
        print(f"{self.name}在跑步")   # 子類可以直接調用父類的屬性


child = Child('ll', 13)   # 繼承父類後,父類的初始化參數子類也要傳遞
child.walk()  # ll在行走 (子類實例化對象可以調用父類的方法)
child.run()
'''
ll在行走
ll在跑步
'''

  

10.類的多態

  子類繼承父類後,對於父類中的同一功能可以表現出多狀態變化(多種執行方式、結果等),且是通過子類對父類方法的重寫實現的;

class Parent(object):
    def __init__(self, name):
        self.name = name

    def walk(self):
        print('父類在行走')


class Child(Parent):

    def walk(self):
        print('子類在行走')


child = Child('兒子')
child.walk()  # 子類在行走

'''
為什麼要繼承
為了使用已經寫好的類中的方法

為什麼要多態
為了保留子類中和父類名稱相同的函數的功能
'''

 

11.python中的super函數

  在子類重新書寫父類方法時,此時想既保留父類方法的邏輯、同時增加新邏輯,就可以藉助super函數;

  用法:super(當前類,self(類的實例)).父類的方法();python3.0時代,super()中兩個參數可以省略;

class Parent(object):
    def __init__(self, name):
        self.name = name
        print('父類構造函數'+self.name)


class Child(Parent):
    def __init__(self, name, age):
        super(Child, self).__init__(name)
        self.age = age
        print('子類新的構造函數'+str(self.age))


child = Child('xiaoming', 23)
'''
父類構造函數xiaoming
子類新的構造函數23
'''
# 例子中子類對於父類中的構造函數參數進行了擴充,在工作中很常用

 

12.類的多重繼承

  子類可以繼承多個父類;

  class Child(Parent, Parent2, Parent3...):

class Father(object):
    def run(self):
        print('父親跑')

    def walk(self):
        print('父親走')


class Mother(object):
    def run(self):
        print('母親跑')

    def sing(self):
        print('母親唱')


class Child(Father, Mother):
    pass


child = Child()
child.sing()  # 母親唱
child.run()  # 父親跑 (多個父類有重名方法時,優先繼承寫在第一位的類)
print(Child.__mro__)  # (<class '__main__.Child'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class 'object'>)
'''
__mro__ 方法可以列印類的繼承鏈
'''

  

13.類的幾個高級函數

  __str__  返回類的描述信息;

class Test(object):
    pass


test = Test()
print(test)  # <__main__.Test object at 0x00000298AC9264D0>


class Test2(object):
    def __str__(self):
        return 'this is a test class'


test2 = Test2()
print(test2)  # this is a test class

  __getattr__ 當調用的屬性或方法不存在時,會返回該方法定義的信息;

class Test(object):
    pass


test = Test()
print(test.a)  # 調用類的屬性不存在時,會直接報錯
'''
Traceback (most recent call last):
  File "D:\python_exercise\test7.py", line 14, in <module>
    print(test.a)
AttributeError: 'Test' object has no attribute 'a'
'''

class Test2(object):
    def __getattr__(self, item):
        return f'{item}不存在'


test2 = Test2()
print(test2.a)  # a不存在

  __setattr__  攔截當前類中不存在的屬性和值,並做處理;

class Test(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __setattr__(self, key, value):
        print(key, value)
        # 列印所有的屬性字典
        print(self.__dict__)
        self.__dict__[key] = value
        print(self.__dict__)


test = Test('xiao', 32)
test.sex = 'boy'
print(test.sex)
'''
name xiao
{}
{'name': 'xiao'}
age 32
{'name': 'xiao'}
{'name': 'xiao', 'age': 32}
sex boy
{'name': 'xiao', 'age': 32}
{'name': 'xiao', 'age': 32, 'sex': 'boy'}
boy
'''
# 可以看到每一次生成新的屬性,都會調用__setattr__方法,無論是在構造函數,還是在實例對象test.sex = 'boy'
test.name = 'new_xiaoming'
# 也可修改原屬性的值
'''
{'name': 'new_xiaoming', 'age': 32, 'sex': 'boy'}
'''

  __call__  將實例化對象直接變成函數使用;

class Test(object):
    def __call__(self, *args, **kwargs):
        print(f'call 函數開始: {args[0]}')


test = Test()
test('test')  # call 函數開始: test
# eg: 編寫一個可以通過 對象.a.b.c() 執行的類
class Test(object):
    def __init__(self, args=''):
        print('------')
        self.args = args
        
    def __getattr__(self, item):
        print('開始的item:'+item)
        print('self.args:'+self.args)
        if self.args:
            item = f'{self.args}.{item}'
        print('後來的item:'+item)
        return Test(item)
    
    def __call__(self, *args, **kwargs):
        print('ttttt')
        
        
test = Test()
test.a.b.c()  # ttttt
'''
------
開始的item:a
self.args:
後來的item:a
------
開始的item:b
self.args:a
後來的item:a.b
------
開始的item:c
self.args:a.b
後來的item:a.b.c
------
ttttt
'''

 

總結

  


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 序言 各位好啊,我是會編程的蝸牛,作為java開發者,我們每天都要和開發工具打交道。我以前一開始入門java開發的時候,就是用的eclipse,雖然感覺有點繁瑣,但好在還能用。後來偶然間發現了IDEA,然後就漸漸被IDEA所吸引了,不過最近在做一些老項目的開發,大概是十幾年的那種技術,我發現用IDE ...
  • 前言 本文是博主從事後端開發以來,對公司、個人項目的經驗總結,包含代碼編寫、功能推薦、第三方庫使用及優雅配置等,希望大家看到都能有所收穫 博主github地址: https://github.com/wayn111 一. 優雅的進行線程池異常處理 在Java開發中,線程池的使用必不可少,使用無返回值 ...
  • 重構項目目錄 celery_task: logs:項目運行時/開發時日誌目錄包 luffapi:項目同名文件夾 apps:項目所有應用的集合文件夾 libs:第三方類庫的保存目錄[第三方組件、模塊] - 包 media:用戶提交的文件目錄文件夾 settings:配置目錄,包含開發時的配置文件和上線 ...
  • 話說在前面,我不是小黑子~ 我是超級大黑子😏 表弟大周末的跑來我家,沒事幹天天騷擾我,搞得我都不能跟小姐姐好好聊天了,於是為了打發表弟,我決定用Python做一個小游戲來消耗一下他的精力,我思來想去,決定把他變成小黑子,於是做了一個坤坤打籃球的游戲,沒想到他還挺愛玩的~ 終於解放了,於是我把游戲寫 ...
  • 使用腳本自動跑實驗(Ubuntu),將實驗結果記錄在文件中,併在實驗結束之後將結果通過郵件發送到郵箱,最後在windows端自動解析成excel表格。 ...
  • 大家好,我是陶朱公Boy。 前言 上一篇文章《關於狀態機的技術選型,最後一個真心好》我跟大家聊了一下關於”狀態機“的話題。從眾多技術選型中我也推薦了一款阿裡開源的狀態機—“cola-statemachine”。 於是就有小伙伴私信我,自己項目也考慮引入這款狀態機,但網上資料實在太少,能不能系統的介紹 ...
  • 一、Kafka存在哪些方面的優勢 1. 多生產者 可以無縫地支持多個生產者,不管客戶端在使用單個主題還是多個主題。 2. 多消費者 支持多個消費者從一個單獨的消息流上讀取數據,而且消費者之間互不影響。 3. 基於磁碟的數據存儲 支持消費者非實時地讀取消息,由於消息被提交到磁碟,根據設置的規則進行保存 ...
  • 10瓶毒藥其中只有一瓶有毒至少需要幾隻老鼠可以找到有毒的那瓶 身似浮雲,心如飛絮,氣若游絲。 用二分查找和二進位位運算的思想都可以把死亡的老鼠降到最低。 其中,二進位位運算就是每一隻老鼠代表一個二進位0或1,0就代表老鼠存活,1代表老鼠死亡;根據數學運算 23 = 8、24 = 16,那麼至少需要四 ...
一周排行
    -Advertisement-
    Play Games
  • 一:背景 1. 講故事 年前遇到了好幾例托管堆被損壞的案例,有些運氣好一些,從被破壞的托管堆記憶體現場能觀測出大概是什麼問題,但更多的情況下是無法做出準確判斷的,原因就在於生成的dump是第二現場,借用之前文章的一張圖,大家可以理解一下。 為了幫助更多受此問題困擾的朋友,這篇來整理一下如何 快狠準 的 ...
  • 前言 .NET6 開始,.NET Croe API 項目取消了 Startup.cs 文件,在 Program.cs 文件的 Main 函數中完成服務的註冊和中間件管道的管理。但當我們項目引入更多包的時候,Program.cs 文件也會看起來很臃腫。 而且,我們不只會有一個後端項目,為了方便快速創建 ...
  • 目錄 背景 get 與 post 的區別 所有介面都用 post 請求? 背景 最近在逛知乎的時候發現一個有趣的問題:公司規定所有介面都用 post 請求,這是為什麼? 看到這個問題的時候其實我也挺有感觸的,因為我也曾經這樣問過我自己。在上上一家公司的時候接到一個項目是從零開始搭建一個微服務,當時就 ...
  • *以下內容為本人的學習筆記,如需要轉載,請聲明原文鏈接 微信公眾號「englyf」https://mp.weixin.qq.com/s/2GFLTstDC7w6u3fTJxflNA 本文大概 1685 個字,閱讀需花 6 分鐘內容不多, 但也花了一些精力如要交流, 歡迎關註我然後評論區留言 謝謝你的 ...
  • 在新版本的pandas中,上述代碼會引起警告,建議改成SQLAlchemy connectable(engine/connection),後續代碼將引入這種升級的連接方式。 ...
  • 幾乎所有的高級編程語言都有自己的垃圾回收機制,開發者不需要關註記憶體的申請與釋放,Python 也不例外。Python 官方團隊的文章 https://devguide.python.org/internals/garbage-collector 詳細介紹了 Python 中的垃圾回收演算法,本文是這篇 ...
  • 如果您想查找高於或低於平均值的數字,可以不必計算該平均值,就能查看更高或更低的值。通過Java應用程式,可以自動突出顯示這些數字。除了快速突出顯示高於或低於平均值的值外,您還可以查看高於或低於的值的個數。現在讓我們看看如何在 Java應用程式中實現此操作。 引入jar包 導入方法1: 手動引入。將  ...
  • 第一種方式:使用{} firstDict = {"name": "wang yuan wai ", "age" : 25} 說明:{}為創建一個空的字典對象 第二種方式:使用fromkeys()方法 second_dict = dict.fromkeys(("name", "age")) #valu ...
  • 在golang中可以使用a := b這種方式將b賦值給a,只有當b能進行深拷貝時a與b才不會互相影響,否則就需要進行更為複雜的深拷貝。 下麵就是Go賦值操作的一個說明: Go語言中所有賦值操作都是值傳遞,如果結構中不含指針,則直接賦值就是深度拷貝;如果結構中含有指針(包括自定義指針,以及切片,map ...
  • 本文結合京東監控埋點場景,對解決樣板代碼的技術選型方案進行分析,給出最終解決方案後,結合理論和實踐進一步展開。通過關註文中的技術分析過程和技術場景,讀者可收穫一種樣板代碼思想過程和解決思路,並對Java編譯器底層有初步瞭解。 ...