R用戶Python指南:面向對象編程

2021-03-02 Rcamp
本文為R用戶Python指南系列第8篇，Python代碼主要取自《Python編程：從入門到實踐》第9章，R代碼根據Python代碼複寫。本文使用rmarkdown和prettydoc模板生成格式，代碼塊中#之後的內容為注釋，##之後的內容為代碼輸出結果。本文使用的R包主要為stringr和R6，需預先加載。其中stringr主要用於處理字符串，R6主要用於創建R6類。

library(pacman)
p_load(stringr, R6)

學習內容：如何編寫類；如何使用屬性在類中存儲信息，以及如何編寫方法，以讓類具備所需的行為；如何編寫方法__init__()，以便根據類創建包含所需屬性的實例；如何修改實例的屬性，包括直接修改以及通過方法進行修改；使用繼承可簡化相關類的創建工作；將一個類的實例用作另一個類的屬性可讓類更簡潔；通過將類存儲在模塊中，並在需要使用這些類的文件中導入它們，可讓項目組織有序；學習python的標準庫，並見識使用模塊collections中的OrderedDict類的示例。1 創建和使用類在面向對象編程中，你編寫表示現實世界中的事務和情境的類，並基於這些類來創建對象。編寫類時，你定義一大類對象都有的通用行為。基於類創建對象時，每個對象都自動具備這種通用行為，然後可根據需要賦予每個對象獨特的個性。使用面向對象編程可模擬現實情境。根據類來創建對象被稱為實例化。1.1 創建Dog類R有S3類、S4類、RC類、R6類四種面向對象編程系統，其中R6類比較接近Python中的類。R6中的方法、屬性不能使用<-賦值, 只能使用=。Python使用class關鍵字創建類，R6使用R6Class()函數創建類。定義一個Dog類，具有name和age屬性，以及sit()和roll_over()方法。Python調用__init__()方法創建Dog實例時，每個與類相關聯的方法調用都自動傳遞實參self，它是一個指向實例本身的引用，讓實例能夠訪問類中的屬性和方法，以self為前綴的變量都可供類中的所有方法使用。R在R6Class()函數的initialize參數中初始化屬性。

class Dog:
"""一次模擬小狗的簡單嘗試"""

def __init__(self, name, age):
"""初始化屬性name和age"""
self.name = name
self.age = age

def sit(self):
"""模擬小狗收到命令時蹲下"""
print(f"{self.name} is now sitting.")

def roll_over(self):
"""模擬小狗收到命令時打滾"""
print(f"{self.name} rolled over!")

Dog <- R6Class("Dog", list(
name = NULL,
age = NA,
#初始化屬性name和age
initialize = function(name, age = NA) {
self$name <- name
self$age <- age
},
#模擬小狗收到命令時蹲下
sit = function() {
cat(str_glue("{self$name} is now sitting."), "\n")
},
#模擬小狗收到命令時打滾
roll_over = function() {
cat(str_glue("{self$name} rolled over!"), "\n")
}
))

1.2 根據類創建實例可將類視為有關如何創建實例的說明。Dog類是一系列說明，讓Python知道如何創建表示特定小狗的實例。Python通過向類傳遞屬性參數創建實例，R6通過$符號和new()方法向類傳遞屬性參數創建實例。

my_dog = Dog('Willie', 6)
print(f"My dog's name is {my_dog.name}.")
## My dog's name is Willie.
print(f"My dog is {my_dog.age} years old.")
## My dog is 6 years old.

my_dog <- Dog$new(name = "Willie", age = 6)
cat(str_glue("My dog's name is {my_dog$name}."), "\n")
## My dog's name is Willie.
cat(str_glue("My dog is {my_dog$age} years old."), "\n")
## My dog is 6 years old.

1.2.1 訪問屬性Python使用.訪問實例的屬性，R6使用$訪問實例的屬性。

my_dog.name
## 'Willie'
my_dog.age
## 6

my_dog$name
## [1] "Willie"
my_dog$age
## [1] 6

1.2.2 調用方法Python使用.調用類中的方法，R6使用$調用類中的方法。

my_dog.sit()
## Willie is now sitting.
my_dog.roll_over()
## Willie rolled over!

my_dog$sit()
## Willie is now sitting.
my_dog$roll_over()
## Willie rolled over!

1.2.3 創建多個實例

my_dog = Dog('Willie', 6)
your_dog = Dog('Lucy', 3)

print(f"My dog's name is {my_dog.name}.")
## My dog's name is Willie.
print(f"My dog is {my_dog.age} years old.")
## My dog is 6 years old.
my_dog.sit()
## Willie is now sitting.
print(f"\nYour dog's name is {your_dog.name}.")
##
## Your dog's name is Lucy.
print(f"Your dog is {your_dog.age} years old.")
## Your dog is 3 years old.
your_dog.sit()
## Lucy is now sitting.

my_dog <- Dog$new('Willie', 6)
your_dog <- Dog$new('Lucy', 3)

cat(str_glue("My dog's name is {my_dog$name}."), "\n")
## My dog's name is Willie.
cat(str_glue("My dog is {my_dog$age} years old."), "\n")
## My dog is 6 years old.
my_dog$sit()
## Willie is now sitting.

cat(str_glue("Your dog's name is {your_dog$name}."), "\n")
## Your dog's name is Lucy.
cat(str_glue("Your dog is {your_dog$age} years old."), "\n")
## Your dog is 3 years old.
your_dog$sit()
## Lucy is now sitting.

2 使用類和實例你可以使用類來模擬現實世界中的很多情景。類編寫好後，你的大部分時間都將花在使用根據類創建的實例上。你需要執行的一個重要任務是修改實例的屬性。你可以直接修改實例的屬性，也可以編寫方法以特定的方式進行修改。2.1 Car類

class Car:
"""一次模擬汽車的簡單嘗試"""

def __init__(self, make, model, year):
"""初始化描述汽車屬性"""
self.make = make
self.model = model
self.year = year

def get_descriptive_name(self):
"""返回整潔的描述性信息"""
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()

my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())
## 2019 Audi A4

Car <- R6Class("Car", list(
make = NULL,
model = NULL,
year = NA,
initialize = function(make, model, year) {
self$make <- make
self$model <- model
self$year <- year
},
get_descriptive_name = function() {
long_name <- str_glue("{self$year} {self$make} {self$model}")
return(str_to_title(long_name))
}
))

my_new_car <- Car$new("audi", "a4", 2019)
cat(my_new_car$get_descriptive_name())
## 2019 Audi A4

2.2 給屬性指定默認值為Car類添加1個命名為odometer_reading的屬性，其初始值總是為0。

class Car:

def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0

def get_descriptive_name(self):
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()

def read_odometer(self):
print(f"This car has {self.odometer_reading} miles on it.")

my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())
## 2019 Audi A4
my_new_car.read_odometer()
## This car has 0 miles on it.

Car <- R6Class("Car", list(
make = NULL,
model = NULL,
year = NA,
odometer_reading = 0,
initialize = function(make, model, year, odometer_reading) {
self$make <- make
self$model <- model
self$year <- year
},
get_descriptive_name = function() {
long_name <- str_glue("{self$year} {self$make} {self$model}")
return(str_to_title(long_name))
},
read_odometer = function() {
cat(str_glue("This car has {self$odometer_reading} miles on it."), "\n")
}
))

my_new_car <- Car$new("audi", "a4", 2019)
cat(my_new_car$get_descriptive_name(), "\n")
## 2019 Audi A4
my_new_car$read_odometer()
## This car has 0 miles on it.

2.3 修改屬性的值2.3.1 直接修改屬性的值將Car類的實例my_new_car的屬性裡程表讀數設置為23。

class Car:

def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0

def get_descriptive_name(self):
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()

def read_odometer(self):
print(f"This car has {self.odometer_reading} miles on it.")

my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())
## 2019 Audi A4
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
## This car has 23 miles on it.

Car <- R6Class("Car", list(
make = NULL,
model = NULL,
year = NA,
odometer_reading = 0,
initialize = function(make, model, year, odometer_reading) {
self$make <- make
self$model <- model
self$year <- year
},
get_descriptive_name = function() {
long_name <- str_glue("{self$year} {self$make} {self$model}")
return(str_to_title(long_name))
},
read_odometer = function() {
cat(str_glue("This car has {self$odometer_reading} miles on it."), "\n")
}
))

my_new_car <- Car$new("audi", "a4", 2019)
cat(my_new_car$get_descriptive_name(), "\n")
## 2019 Audi A4

my_new_car$odometer_reading <- 23
my_new_car$read_odometer()
## This car has 23 miles on it.

2.3.2 通過方法修改屬性的值為Car類添加update_odometer方法。

class Car:

def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0

def get_descriptive_name(self):
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()

def read_odometer(self):
print(f"This car has {self.odometer_reading} miles on it.")

def update_odometer(self, mileage):
"""將裡程表讀數設置為指定值，禁止將裡程表讀數往回調"""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't rool back an odometer!")

my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())
## 2019 Audi A4
my_new_car.update_odometer(23)
my_new_car.read_odometer()
## This car has 23 miles on it.

Car <- R6Class("Car", list(
make = NULL,
model = NULL,
year = NA,
odometer_reading = 0,
initialize = function(make, model, year, odometer_reading) {
self$make <- make
self$model <- model
self$year <- year
},
get_descriptive_name = function() {
long_name <- str_glue("{self$year} {self$make} {self$model}")
return(str_to_title(long_name))
},
read_odometer = function() {
print(str_glue("This car has {self$odometer_reading} miles on it."))
},
update_odometer = function(mileage) {
if (mileage >= self$odometer_reading) {
self$odometer_reading <- mileage
} else {
cat("You can't rool back an odometer!", "\n")
}
}
))

my_new_car <- Car$new("audi", "a4", 2019)
cat(my_new_car$get_descriptive_name(), "\n")
## 2019 Audi A4

my_new_car$update_odometer(23)
my_new_car$read_odometer()
## This car has 23 miles on it.

2.3.3 通過方法對屬性的值進行遞增

class Car:

def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0

def get_descriptive_name(self):
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()

def read_odometer(self):
print(f"This car has {self.odometer_reading} miles on it.")

def update_odometer(self, mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't rool back an odometer!")

def increment_odometer(self, miles):
"""將裡程表讀數增加制定的量"""
self.odometer_reading += miles

my_used_car = Car('subaru', 'outback', 2015)
print(my_used_car.get_descriptive_name())
## 2015 Subaru Outback
my_used_car.update_odometer(23_500)
my_used_car.read_odometer()
## This car has 23500 miles on it.
my_used_car.increment_odometer(100)
my_used_car.read_odometer()
## This car has 23600 miles on it.

Car <- R6Class("Car", list(
make = NULL,
model = NULL,
year = NA,
odometer_reading = 0,
initialize = function(make, model, year, odometer_reading) {
self$make <- make
self$model <- model
self$year <- year
},
get_descriptive_name = function() {
long_name <- str_glue("{self$year} {self$make} {self$model}")
return(str_to_title(long_name))
},
read_odometer = function() {
cat(str_glue("This car has {self$odometer_reading} miles on it."), "\n")
},
update_odometer = function(mileage) {
if (mileage >= self$odometer_reading) {
self$odometer_reading <- mileage
} else {
cat("You can't rool back an odometer!", "\n")
}
},
increment_odometer = function(miles) {
self$odometer_reading = self$odometer_reading + miles
}
))

my_used_car = Car$new('subaru', 'outback', 2015)
cat(my_used_car$get_descriptive_name(), "\n")
## 2015 Subaru Outback

my_used_car$update_odometer(23500)
my_used_car$read_odometer()
## This car has 23500 miles on it.

my_used_car$increment_odometer(100)
my_used_car$read_odometer()
## This car has 23600 miles on it.

3 繼承編寫類時，並非總是要從空白開始。如果你要編寫的類是另一個現成類的特殊版本，可使用繼承。一個類繼承另一個類時，它將自動獲得另一個類的所有屬性和方法；原有的類稱為父類，而新類稱為子類。子類繼承了其父類的所有屬性和方法，同時還可以定義自己的屬性和方法。3.1 子類的方法__init__()Python通過super()方法繼承父類的屬性，R6通過R6Class()函數的inherit參數創建子類並繼承父類的屬性。

class ElectricCar(Car):
"""電動車的獨特之處"""

def __init__(self, make, model, year):
"""初始化父類的屬性"""
super().__init__(make, model, year)

my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
## 2019 Tesla Model S

ElectricCar <- R6Class("ElectricCar", inherit = Car)
my_tesla <- ElectricCar$new("tesla", "model s", 2019)
cat(my_tesla$get_descriptive_name())
## 2019 Tesla Model S

3.2 給子類定義屬性和方法

class ElectricCar(Car):
def __init__(self, make, model, year):
"""初始化父類的屬性，再初始化電動汽車特有的屬性"""
super().__init__(make, model, year)
self.battery_size = 75

def describe_battery(self):
"""列印一條描述電瓶容量的消息"""
print(f"This car has a {self.battery_size}-kWh battery.")

my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
## 2019 Tesla Model S
my_tesla.describe_battery()
## This car has a 75-kWh battery.

ElectricCar <- R6Class("ElectricCar", inherit = Car) # 繼承父類
ElectricCar$set('public', 'battery_size', 75) # 添加屬性
ElectricCar$set('public', 'describe_battery', function() {
cat(str_glue("This car has a {self$battery_size}-kWh battery."), "\n")
}) # 添加方法
my_tesla = ElectricCar$new('tesla', 'model s', 2019)
cat(my_tesla$get_descriptive_name(), "\n")
## 2019 Tesla Model S
my_tesla$describe_battery()
## This car has a 75-kWh battery.

3.3 重寫父類的方法對於父類的方法，只要它不符合子類模擬的實物的行為，都可以進行重寫。

class Car:

def __init__(self, make, model, year):
"""初始化描述汽車屬性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0

def get_descriptive_name(self):
"""返回整潔的描述性信息"""
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()

def read_odometer(self):
"""列印汽車裡程"""
print(f"This car has {self.odometer_reading} miles on it.")

def update_odometer(self, mileage):
"""將裡程表讀數設置為指定值"""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't rool back an odometer!")

def increment_odometer(self, miles):
"""將裡程表讀數增加制定的量"""
self.odometer_reading += miles

def fill_gas_tank(self):
print("All cars need a gas tank!") # 父類的方法

class ElectricCar(Car):
def __init__(self, make, model, year):
"""初始化父類的屬性，再初始化電動汽車特有的屬性"""
super().__init__(make, model, year)
self.battery_size = 75

def describe_battery(self):
"""列印一條描述電瓶容量的消息"""
print(f"This car has a {self.battery_size}-kWh battery.")

def fill_gas_tank(self):
print("This car doesn't need a gas tank!") # 重寫父類的方法

Car <- R6Class("Car", list(
make = NULL,
model = NULL,
year = NA,
odometer_reading = 0,
initialize = function(make, model, year, odometer_reading) {
self$make <- make
self$model <- model
self$year <- year
},
get_descriptive_name = function() {
long_name <- str_glue("{self$year} {self$make} {self$model}")
return(str_to_title(long_name))
},
read_odometer = function() {
cat(str_glue("This car has {self$odometer_reading} miles on it."), "\n")
},
update_odometer = function(mileage) {
if (mileage >= self$odometer_reading) {
self$odometer_reading <- mileage
} else {
cat("You can't rool back an odometer!", "\n")
}
},
increment_odometer = function(miles) {
self$odometer_reading = self$odometer_reading + miles
},
fill_gas_tank = function() {
cat("All cars need a gas tank!", "\n")
}
))

ElectricCar <- R6Class("ElectricCar", inherit = Car)
ElectricCar$set('public', 'battery_size', 75)
ElectricCar$set('public', 'describe_battery', function() {
cat(str_glue("This car has a {self$battery_size}-kWh battery."), "\n")
})
ElectricCar$set('public', 'fill_gas_tank', function() {
cat("This car doesn't need a gas tank!", "\n")
})

my_tesla = ElectricCar$new('tesla', 'model s', 2019)
cat(my_tesla$get_descriptive_name(), "\n")
## 2019 Tesla Model S
my_tesla$fill_gas_tank()
## This car doesn't need a gas tank!

3.4 將實例用作屬性

class Battery:

def __init__(self, battery_size = 75):
self.battery_size = battery_size

def describe_battery(self):
print(f"This car has a {self.battery_size}-kWh battery.")

def get_range(self):
"""列印一條消息，指出電瓶的續航裡程"""
if self.battery_size == 75:
rng = 260
elif self.battery_size == 100:
rng = 315
print(f"This car can go about {rng} miles on a full charge.")

class ElectricCar(Car):

def __init__(self, make, model, year):
"""初始化父類的屬性，再初始化電動汽車特有的屬性"""
super().__init__(make, model, year)
self.battery = Battery() # 將Battery()實例化並將該實例賦給屬性self.battery

my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
## 2019 Tesla Model S
my_tesla.battery.describe_battery()
## This car has a 75-kWh battery.
my_tesla.battery.get_range()
## This car can go about 260 miles on a full charge.

Battery <- R6Class("Battery", lock_objects = F, list(
battery_size = NA,
initialize = function(battery_size = 75) {
self$battery_size <- battery_size
},
describe_battery = function() {
cat(str_glue("This car has a {self$battery_size}-kWh battery."), "\n")
},
get_rng = function() {
if (self$battery_size == 75) {
assign("rng", 260, envir = .GlobalEnv)
} else if (self$battery_size == 100) {
assign("rng", 315, envir = .GlobalEnv)
}
cat(str_glue("This car can go about {rng} miles on a full charge."), "\n")
}
))

ElectricCar <- R6Class("ElectricCar", inherit = Car)
ElectricCar$set('public', 'battery', Battery$new())

my_tesla = ElectricCar$new('tesla', 'model s', 2019)
cat(my_tesla$get_descriptive_name(), "\n")
## 2019 Tesla Model S
my_tesla$battery$describe_battery()
## This car has a 75-kWh battery.
my_tesla$battery$get_rng()
## This car can go about 260 miles on a full charge.

4 Python標準庫Python通過import關鍵字導入庫，通過from和import關鍵字導入庫中的特定函數；R通過library()加載包，通過::在不加載包的情況下使用包中的函數，如purrr::is_empty()。

from random import randint
randint(1, 6)
## 3

sample(1:6, size = 1)
## [1] 1

from random import choice
players = ['charles', 'martina', 'michael', 'florence', 'eli']
first_up = choice(players)
first_up
## 'eli'

players = c('charles', 'martina', 'michael', 'florence', 'eli')
first_up = sample(players, size = 1)
first_up
## [1] "charles"

相關焦點

  • Python面向對象程式語言
    Python (發音:[ 'paiθ(ə)n; (US) 'paiθɔn ]n.蟒蛇，巨蛇 )，是一種面向對象的解釋性的電腦程式設計語言，也是一種功能強大而完善的通用型語言，已經具有十多年的發展歷史面向對象————Python即支持面向過程的編程也支持面向對象的編程。在「面向過程」的語 言中，程序是由過程或僅僅是可重用代碼的函數構建起來的。在「面向對象」的語言中，程序是由數據和功能組合而成的對象構建起來的。與其他主要的語言如 C++和Java相比，Python以一種非常強大又簡單的方式實現面向對象編程。
  • Python基礎知識——python面向對象的解釋型計算機程式語言
    python面向對象的解釋型計算機程式語言。屬於解釋型的　Java　（說一句翻譯一句），把寫好的高級語言程序給用戶，同時用戶還需要有一個翻譯軟體，來翻譯並執行高級語言程序。（程序＋翻譯器）翻譯軟體：一種稱為虛擬機，一種稱為解釋器ｃ語言，ｃ++語言，Go語言　屬於編譯型的寫好程序，通過編譯器把程序編程機器能執行的程序（含有機器碼），把程序給用戶即可。
  • 史上最全 Python 面向對象編程
    作者：浪子燕青    來自：http://www.langzi.fun/Python面向對象編程.html面向對象編程和函數式編程
  • Python面向對象編程的基本概念
    九道門商業數據分析學院提供介紹在學習面向對象的編程時。我決定深入了解它的歷史，結果令人著迷。術語「面向對象程序設計」（OOP）是艾倫·凱（Alan Kay）在1966年讀研究生時提出的。名為Simula的語言是第一種具有面向對象編程功能的程式語言。它是在1967年開發的，用於製作仿真程序，其中最重要的信息稱為對象。
  • opencv-python獲取圖像:面向對象與面向過程
    下面是分別用面向過程與面向對象的編程方法實現讀取本地圖像和打開攝像頭兩段代碼：# -*- coding: utf-8 -*-"""面向過程的編程方法，用函數把解決問題的步驟一步一步實現。運行環境：win10系統 python==3.6 opencv-contrib-python== 4.1.0第一行「# -*- coding: utf-8 -*-」 告訴Python解釋器，按照UTF-8編碼讀取原始碼"""import
  • 一篇非常全的Python 面向對象編程
    .html面向對象編程和函數式編程（面向過程編程）都是程序設計的方法，不過稍有區別。根據需要，決定是否寫一個main函數作為程序入口面向對象編程中，將函數和變量進一步封裝成類，類才是程序的基本元素，它將數據和操作緊密地連結在一起，並保護數據不會被外界的函數意外地改變。類和和類的實例（也稱對象）是面向對象的核心概念，是和面向過程編程、函數式編程的根本區別。
  • 史上最全Python面向對象編程
    類和和類的實例(也稱對象)是面向對象的核心概念，是和面向過程編程、函數式編程的根本區別。面向對象編程和函數式編程(面向過程編程)都是程序設計的方法，不過稍有區別。面向過程編程：1. 導入各種外部庫2. 設計各種全局變量3. 寫一個函數完成某個功能4.
  • 轉載 | 史上最全 Python 面向對象編程
    面向對象編程和函數式編程（面向過程編程）都是程序設計的方法，不過稍有區別。類和和類的實例（也稱對象）是面向對象的核心概念，是和面向過程編程、函數式編程的根本區別。並不是非要用面向對象編程，要看你的程序怎麼設計方便，但是就目前來說，基本上都是在使用面向對象編程。面向對象是通過定義class類來定義，這麼說面向對象編程就是只使用 class 類，在 class 類中有封裝，繼承的功能，並且還可以構造要傳入的參數，方便控制。
  • 史上最全 Python 面向對象編程技巧!
    面向對象編程和函數式編程（面向過程編程）都是程序設計的方法，不過稍有區別。面向過程編程：1. 導入各種外部庫2. 設計各種全局變量3. 寫一個函數完成某個功能4. 寫一個函數完成某個功能5. 寫一個函數完成某個功能6. 寫一個函數完成某個功能7.
  • python面向對象,小白從零開始,python基礎入門,你會了嗎?
    Python，是一種面向對象的解釋型電腦程式設計語言，以簡單、易學、速度快等優點，是大部分想進入IT行業的從業人的選擇。IEEE發布2017年程式語言排行榜：Python超過JAVA程式語言排名第一。所以Python非常熱門的程式語言!
  • python面向對象三大特徵
    大概所有變成初學者初學者最頭疼的第一道坎就是面向對象的理解封裝從封裝本身去理解 就是把小貓小狗用袋子裝起來，然後把袋子的小口封上私有化方法：方法的私有化可以保護好一些核心的代碼，可以添加條件，是別人不能不滿足條件的更改，進行代碼的保護，python
  • R用戶Python指南:文件和異常
    本文為R用戶Python指南系列第9篇，Python代碼主要取自《Python編程：從入門到實踐》第10章，R代碼根據Python代碼複寫。本文使用rmarkdown生成格式，代碼塊中#之後的內容為注釋，##之後的內容為代碼輸出結果。本文使用的R包主要為stringr、readr和jsonlite，需預先加載。
  • R 的面向對象編程系統(S3、S4系統介紹)
    R 的面向對象編程R 語言中有四套面向對象編程系統：我們所熟悉的
  • 第16 p,PYthon中的用戶交互,Python GUI編程
    大家好，我是楊數Tos，這是《從零基礎到大神》系列課程的第16篇文章，第二階段的課程：Python基礎知識：PYthon中的用戶交互、Python GUI編程實現方式介紹。
  • 高級篇PLC的面向對象編程
    繼承」，甚至於它根本就不具備面向對象程式語言的特點，但面向對象編程的基本概念就是類和類的實例（即對象），我們只需要使用這種概念就可以了。如果大家從面向對象編程的角度去理解，則可以很好的理解這種設計模式。
  • python入門——面向對象編程基礎到進階之枚舉類Enum
    ## 文章目錄 面向對象編程 @property 使用枚舉類 # 面向對象編程 ## @property 為了避免實例對象屬性的值被隨意修改
  • 【Python基礎】可迭代對象&迭代器對象及其實現
    首選確保for循環的in後面是一個可迭代對象，這樣就能通過python內置函數iter()得到一個迭代器對象（iterator）這裡拋出了異常，因為數字不是一個可迭代對象那麼問題來了，　為什麼列表和字符串是可迭代對象? 因為這些對象滿足了特殊的接口：
  • 年薪30萬+的python編程難不難?好學嗎?
    python翻譯成中文就是蟒;蚺蛇的意思。在計算機專業裡面Python是一門課程，專門學習計算機編程的課程，是一種跨平臺的電腦程式設計語言。一種高級，熱門的程式語言。那python好學嗎？先來了解下python這門計算機語言的特點：1、語法簡略和傳統的 C/C++、Java、C# 等言語比較，Python 對代碼格局的要求沒有那麼嚴厲，這種寬鬆使得用戶在編寫代碼時比較舒暢，不用在細枝末節上花費太多精力。
  • 十六本python入門學習書籍推薦,python入門新手必看
    隨著人工智慧時代的到來，python程式語言一步登天衝到編程排行榜第一名，因此更多朋友想轉行學習python程式語言的朋友，可以一起看一下：python入門新手必看的十六本python入門學習書籍1、python基礎教程司維所著圖書：本書包括Python程序設計的方方面面，首先從Python
  • 來一點Python面向對象第一級進階的東西
    它首先被程序語言的設計領域所採用,並在Lisp和面向對象方面取得了成績。python面向對象中的反射:通過字符串的形式操作對象相關屬性.python中的一切事物都是對象(都可以使用反射)四個可以實現自省的函數下列方法適用類和對象(一切皆對象,類本身也是一個對象）hasattrdefhasattr(*args, **kwargs):# real signature unknown""" Return