初學者編程指南|如何開始編程

通過
beplay2018官网優秀的學習團隊
-
3264
編程

作為一個非技術背景的人，“編程”這個詞本身就足以讓你脊背發涼!所以，你一定在想“我為什麼要努力學習編程”?

嗯，程序員在世界各地都有很高的需求，計算機程序員的平均工資是每年10萬美元。隨著人工智能的出現和許多工作被自動化的威脅，你根本不用害怕，因為作為計算機程序員，你將幫助自動化任務!此外，在接下來的幾十年裏，仍然有許多係統仍然需要人類的智能，再加上編寫代碼的能力，這使得這成為一個非常安全的工作選擇。

現在，我們知道了編程的重要性，讓我們來了解它到底是什麼!

為了回答這個問題，讓我問一個問題!人類如何相互交流?我們人類使用共同的語言相互交流，不是嗎?

同樣地，如果我們必須和計算機說話，我們需要學習一種計算機能理解的語言!這就是編程語言的用武之地。

所以，簡單地說，我們通過用計算機能理解的語言與它對話來解決現實世界的問題。

讓我們以計算器為例!

當你在計算器中輸入1234 * 4321。它會馬上告訴你，結果是' 5,332,114 '。計算器是怎麼做乘法運算的呢?

這是可能的，因為你寫了一個簡單的程序，把兩個數字相乘，計算器可以理解。

同樣，當你問Siri太陽和地球之間的距離是多少時，它會立即回答:“距離是14863萬公裏。”

這怎麼可能呢?

這是可能的，因為有一個程序在後台運行，它接收音頻輸入，將其轉換成“SIRI”能理解的語言，處理信息並輸出。

編程人員工資統計

根據領英的數據，美國計算機程序員的平均年薪為10萬美元，印度為80萬盧比。

而且，擁有編程技能的人可以在任何組織的任何地方工作。

你可以成為一名UI/UX開發人員，負責在網站和應用程序上應用交互和視覺設計原則。根據Glassdoor的數據，美國UI/UX開發人員的平均年薪為7.5萬美元，印度為60萬美元。

或者，您可以是後端開發人員，並確保用戶通過前端係統請求的數據或服務通過編程方式交付。後端開發人員的平均工資在美國是每年9萬美元，在印度是每年80萬美元。

如果你既喜歡前端也喜歡後端，為什麼不成為一個全棧開發人員，處理從UI到後端數據庫的所有事情呢?全棧開發人員的平均年薪在美國為11.5萬美元，在印度為130萬盧比

最好的部分是，您不必局限於傳統的軟件開發角色。如果你喜歡與數據打交道，並且有分析思維，你可以成為一名數據科學家或機器學習工程師。

當涉及到數據科學領域的薪酬時，他們可以達到30萬美元。

好吧，這應該是一個足夠好的動機讓你開始學習編程!

前三種編程語言

  • Python
  • Java
  • c++

Python編程

Python是一種可以幫助我們做很多很酷的事情的語言，比如:

  • Web開發
  • 遊戲開發
  • 機器學習&
  • 計算機視覺

現在，讓我們繼續，看看Python的一些基礎知識:

如何安裝Python:

你可以從這個鏈接安裝python:https://www.python.org/downloads/

由於Python是一種獨立於平台的語言，您可以下載它並在任何操作係統上運行。因此，無論你使用的是Linux、Windows還是Mac係統，你都可以下載並運行python。

Python IDE:

IDE代表集成開發環境，這些IDE使編碼任務非常容易。讓我們來看看一些最常用的Python ide:

JetBrains Pycharm:

你可以從這個網站下載Pycharm:https://www.jetbrains.com/pycharm/

蟒蛇Python:

這是安裝anaconda的站點:https://www.anaconda.com/

現在我們已經安裝了Python和Python ide，讓我們繼續學習Python的一些基礎知識:

Python中的變量:

編程語言處理數據。這裏出現的問題是，如果我們想重用這些數據，我們該如何存儲這些數據呢?

假設你在處理組織中員工的數據你需要存儲員工的名字，你會怎麼做呢?

這就是變量的作用。變量是存儲值的臨時存儲空間。

假設我們創建了一個名為“employee_name”的變量。然後，我們可以繼續將值“John”存儲在變量中。一段時間後，我可以將值替換為“Sam”。再過一段時間，我會把它換成“Matt”。

讓我們看看如何在python中創建變量:

var1 = " Sam "

var1 = " Matt "

var1 = " John "

由於變量是一個臨時存儲空間，我們可以改變變量“var1”中存儲的值。

Python中的數據類型:

每個變量都與一個數據類型相關聯:

  • Int:當我們處理諸如10、- 30,500這樣的整數時，我們實際上是在處理Int類型的數據。
  • 浮點數:當我們處理小數點數字(如3.14，-6.54)時，我們處理的是浮點數據類型
  • Boolean:布爾數據類型，包含True和False兩個值
  • 字符串:當我們說諸如“我的名字是Julia”或“這是Sparta”這樣的語句時，我們正在處理字符串類型的數據。

Python中的操作符:

Python中的操作符，顧名思義，可以幫助我們對數據執行不同類型的操作。

讓我們從算術運算符開始:

算術運算符:

算術運算符幫助我們進行簡單的算術運算，如加、減、乘、除。

一個= 10

b = 20

a + b

a - b

a / b

a * b

關係運算符:

關係操作符幫助我們找到操作數之間的關係。

< b

a >

a = =

一個!= b

Python中的字符串:

字符串是包含在單引號(' ')、雙引號(" ")或三引號(" ' " ')中的字符序列。

a = ' Hello World '

b = "這是斯巴達"

c = " '我是

會

到法國

明天

“‘

從字符串中提取單個字符:

代碼的解釋:

在這裏，我們首先創建一個名為“my_string”的字符串變量，並將值“My name is John”賦給它。在字符串中，每個單獨的字符位於特定的下標處，下標值從0開始。

因此，如果我們必須提取字符串' M '中的第一個字符，那麼，我們必須給出這樣的命令:

my_string [0]

由於索引從0開始，第一個字符' M '的索引值將為0。

現在，讓我們看看如何從字符串中提取最後一個字符:

我們必須發出這樣的命令:

My_string[-1]從該字符串中提取最後一個字符。

現在，讓我們看看一些字符串函數:

我們可以使用len()方法來查找字符串中出現的字符數。在這裏，當我們將' my_string '對象傳遞給len()方法時，我們看到總共有15個字符。

在lower()方法的幫助下，我們可以將字符串中的所有字符轉換為小寫字母

類似地，在upper()方法的幫助下，我們可以將字符串中的所有字符轉換為大寫字母。

Python中的數據結構:

Python中有四種主要的數據結構，分別是:

  • 元組
  • 列表
  • 字典&
  • 集

．Python中的元組:

Tuple是一個由圓括號()括起來的有序元素集合。元組也是不可變的，這意味著，一旦你在python中創建了一個元組，你就不能修改它。

下麵是在Python中創建元組的方法:

tup1 = (1 a,真的)

現在，讓我們看看如何從元組中提取單個元素:

在這裏，我們創建了一個名為“tup1”的元組，並在其中存儲了6個值。元組的索引也是從0開始，所以如果我們必須從這個元組中提取第一個元素，我們將給出這樣的命令:

tup1 [0]

類似地，我們可以使用下麵的命令從元組中提取最後一個元素:

tup1 [1]

現在，我們還可以繼續使用下麵的命令從這個元組中提取前三個元素:

tup1 [1:4]

現在，讓我們看看如果嚐試修改一個元組會發生什麼:

我們得到錯誤:' tuple '對象不支持項賦值。當我們試圖修改一個tuple時，由於tuple是不可變的，我們得到這個錯誤。

基本操作:

讓我們看看如何求出元組的長度:

在這裏，我們創建了一個新的元組“tup1”。如果我們想要找出元組中存在的元素的數量，我們隻需要使用len()方法:

這裏，我們使用len(tup1)，結果是6，這意味著元組中有6個元素。

現在，讓我們看看如何連接兩個元組:

在這裏，我們創建了兩個元組“tup1”和“tup2”。在tup1中，我們存儲了值1、2和3。在tup2中，我們存儲了值4、5和6。現在，如果我們必須連接tup2和tup1的值，我們所要做的就是使用這個命令:

tup1 + tup2

現在，讓我們看看如何重複元組元素:

最初，我們創建了一個元組“tup1”，其中隻有兩個元素:“sparta”和300。現在，如果我們想重複元素，我們所要做的就是將元組與數值相乘。

這裏，我們使用這個命令:tup1 * 3。使用這個命令，我們可以重複元組中的元素3次。

從元組中查找最小值和最大值:

要從一個元組中找到最小值，我們隻需要使用這個命令:min(tup1)。類似地，要從元組中找出最大值，我們需要使用以下命令:

馬克斯(tup1)

Python中的列表:

List是包含在[]中的元素的有序集合。列表也是可變的。這意味著一旦創建了一個列表，我們就可以隨時修改它。

下麵是創建列表的方法:

L1 = [1， ' a '，True]

從列表中提取單個元素:

從列表中提取元素也是一個類似的過程。這裏我們從這個列表中提取第二個元素。因為它是第二個元素，我們使用這個命令:

l1 [1]

在這裏，我們看到我們正在提取一係列元素。如果我們想從這個列表中提取第二，第三和第四個元素，我們使用這個命令:

l1 [2:5]

由於外部極限是排他性的，這就是為什麼我們隻提取到第4個索引的元素。

修改列表:

在這裏，我們創建了一個列表，其中元素“1”出現在第0個索引處。現在，我們用下麵的命令在第0個索引處添加一個新元素:

L1 [0] = 100

在使用這個命令之後，我們看到元素‘100’現在存儲在索引0處，其餘的元素已經向上移動了一個位置。

現在讓我們看看如何將一個新元素添加到列表的末尾:

如果我們想在列表末尾添加一個元素，可以使用append()方法。下麵我們使用這個命令:

l1.append(“斯巴達”)

在這個命令的幫助下，我們能夠在列表的末尾添加單詞“Sparta”。

在上麵的例子中，我們從列表中取出最後一個元素。我們使用這個命令:

l1.pop ()

在使用該命令之前，列表中的最後一個元素是“c”，在使用pop()方法之後，我們能夠彈出最後一個元素，我們看到列表中的最後一個元素現在是“3”

在上麵的例子中，我們顛倒了列表中的元素。我們使用這個命令:

l1.reverse ()

使用此命令後，我們看到列表中的元素顛倒了。

在上麵的例子中，我們對列表中的元素進行排序。我們正在使用這個命令:

l1.sort ()

在使用這個命令之前，我們可以看到，列表中的元素是按字母順序排列的。使用命令後，元素將按字母順序排序。

列表的基本操作:

這裏我們創建了兩個列表。第一個列表l1包含以下三個元素:1 2 3

第二個列表l2包含這三個元素:" a " " b " " c "現在如果我們想連接這兩個列表，我們隻需要輸入:l1 + l2

在上麵的例子中，我們重複列表中出現的元素。最初，列表中出現的元素是1、" a "和True。然後我們繼續使用下麵的命令:

l1 * 3

因為我們將列表乘以3，所以我們看到元素重複了三次。

Python字典:

Dictionary是包含在{}內的鍵-值對的無序集合。字典是一種可變數據結構。這意味著一旦我們創建了字典，就可以隨時修改它。

下麵是創建字典的方法:

水果={“橙色”:“蘋果”:10日20}

在這裏，我們創建了一個名為“Fruit”的新字典，它由兩個鍵值對組成。第一個鍵是apple，它的值是10。第二個鍵是橙色，它的值是20。

從字典中提取鍵和值:

在這裏，我們創建了一個名為fruit的字典，它有四個鍵值對。

  • 第一個鍵是Apple，它的值是10
  • 第二個鍵是“Orange”，它的值是20
  • 第三個鍵是“Banana”，它的值是30
  • 第四個鍵是“Guava”，它的值是40

創建字典後，使用以下命令提取鍵:

fruit.keys ()

這個命令為我們提供了所有鍵的列表。

類似地，如果我們想提取所有的值，我們可以使用這個命令:

fruit.values ()

修改字典:

在這個例子中，我們有一個名為“fruit”的字典，它有四個鍵值對。現在，我們使用下麵的命令添加一個新的鍵值對:

fruit["芒果"]= 50

這樣我們就添加了一個新的鍵值對，其中鍵為“Mango”，值為50

現在讓我們看看如何修改一個現有鍵的值:

最初，在這個字典中，我們有一個鍵值對“Apple”:10。現在，當我們使用這個命令時:

fruit["蘋果"]= 100

我們將值從10更新為100。

詞典功能:

在這裏，我們創建了兩個字典:

  • 第一個字典是fruit1，它有兩個鍵值對:“apple”-10和“Orange”:20
  • 第二個字典是fruit2，它同樣有兩個鍵值對:“Banana”-30和“Guava”:40

如果我們想要連接fruit2和fruit1的元素，我們可以使用這個命令:

fruit1.update (fruit2)

使用這個命令後，我們看到fruit2的元素被添加到了字典fruit1的末尾。

在上麵的例子中，我們用這個命令彈出一個元素:

fruit.pop(“橙色”)

在pop()方法中，我們傳入我們想要彈出的鍵。由於，我們傳入“Orange”，我們看到“Orange”:20的鍵值對已經從字典中彈出。

在Python中設置:

Set是包含在{}內的無序且無索引的元素集合。“Set”的一個重要特性是，其中不允許重複值。

這是如何創建一個集合:

S1 ={3， "斯巴達"，True}

Set操作:

最初，我們創建了一個集合“s1”，它由以下元素組成:1，“a”，True, 2，“b”，False。現在，如果我們想向這個集合添加一個新元素，我們可以使用add()方法。我們正在使用這個命令:

s1.add(“Hello”)

使用上述命令後，我們看到已經成功地將一個新元素“Hello”添加到集合中。此外，如果仔細觀察結果，您會注意到輸出中的元素序列與我們在創建它時所給出的不相同。這是因為set是無序和無索引的元素集合，這就是不維護插入序列的原因。

在上麵的例子中，我們一次將多個元素添加到集合中。為此，我們使用這個命令;

s1.update([10年,20年,30])

在update()方法的幫助下，我們可以將元素列表添加到現有集合中。盡管正如您在結果中看到的那樣，插入的順序將完全是隨意的。

現在，讓我們看看如何從集合中移除一個元素:

在集合“s1”上，我們使用下麵的命令:

s1.remove(“b”)

我們在結果中看到，我們能夠成功地從整個集合中刪除元素“b”。

集合的並與交:

在這裏，我們創建了兩個集合“s1”和“s2”。s1中有元素1,2,3。而s2中有“a”、“b”和“c”。

現在，如果我們想要這兩個集合的並集，我們可以使用這個命令:

s1.union (s2)

聯合運算符給出了s1中的所有元素以及s2中的所有元素。

Python中的If條件:

如果Python中的條件用於根據條件做出決定。

讓我們通過這個例子來理解if條件的概念。這裏我們有一個條件，即“如果下雨”，我們就不能玩，必須坐在室內，否則如果不下雨，我們就可以愉快地出去玩。

現在，讓我們看看如何在Python中使用if條件:

一個= 10

b = 20

if b>a:打印(" b大於a ")

代碼的解釋:

這裏我們聲明了兩個變量:a和b。變量a初始化值為10，變量v初始化值為20。之後，我們使用if語句，用下麵的命令檢查變量b中的值是否大於變量a中的值:

if b>a:打印(" b大於a ")

如果條件滿足，則繼續打印結果。

else if在Python中:

現在，讓我們看看如何在Python中使用else if比較兩個以上的數字:

一個= 10

b = 20

c = 30

if (a>b) & (a>c):打印(" a是最大的")elif (b>a) & (b>c):打印(" b是最大的")else:打印(" c是最大的")

代碼的解釋:

這裏我們聲明了三個變量a、b和c。變量a初始化值為10，變量b初始化值為20，變量c初始化值為30。

在這之後，我們開始使用if語句來檢查變量a的值是否大於變量b和變量c:

if (a>b) & (a>c):打印(“a是最大的”)

由於變量a的值小於b和c，因此將跳過此命令。

然後，我們繼續使用elif命令檢查變量b的值是否大於a和c:

elif (b>a) & (b>c):打印(“b是最大的”)

在這裏，這個elif語句的值也是False，所以這個語句塊也將被跳過。

最後，如果上麵的兩個語句被求值為value，我們將繼續執行並使用以下命令打印“C is the greatest”:

else: print("C是最大的")

Python中的for循環:

循環語句用於多次重複一個任務。

讓我們通過這個例子來更好地理解循環的概念。想象一下，你隻能用一個杯子把一桶水裝滿。所以，你會拿一杯水，然後把它倒進桶裏，然後你會檢查桶裏是否裝滿了水。然後，我們再拿一杯水倒進桶裏。同樣，我們將檢查桶是否滿。這個過程將在桶沒有裝滿水的情況下繼續進行，這就是循環的工作方式。

現在，讓我們看看如何在Python中使用for循環:

水果中的I = ["apple"，"mango"，"banana"]: print(I)

在這裏，我們首先創建一個名為水果的列表，其中有三個元素:“apple”，“mango”和“banana”。然後，我們使用for循環輸出列表中的各個元素，使用下麵的命令:

水果中的I: print(I)

數字模式問題:

1

2 - 2

3 3 3

4 4 4 4

55 55 55 5

讓我們繼續，看看如何打印這種數字模式:

Depth = 6 for number in range(Depth): for I in range(number): print(number, end=" ") print(" ")

代碼的解釋:

首先，我們初始化一個名為“depth”的變量，並通過以下命令為其賦值6:

深度= 6

繼續，我們有一個嵌套的for循環。我們有外部的for循環來設置這個模式中的行深度或行數。當我們使用命令:for range(depth)中的number時，這有助於我們獲得一個0-5的數字列表。因為深度值是6，這意味著6是排他性的，這就是為什麼範圍從0到5。

然後，使用下麵的命令設置內部for循環:for i in range(number)。

在內部的for循環中，number的初始值為0，這就是為什麼我們跳過第一行。然後我們回到外層的for循環，數值變成了1。一旦數值為1，我們進入內循環並打印1。

在這個數字值再次增加並變成2之後，我們進入內部循環並打印2。

類似地，我們回到外層循環，這個時間數值變成3。在這之後，在for循環中，我們輸出33 33。

進一步，我們再次回到外部循環，然後“number”的值變成4，我們用內部循環打印4 4 4 4 4。

最後，我們將打印5 5 5 5 5。

增量數字模式問題:

1

1 2

1 2 3

1 2 3 4

1 2 3 4 5

現在，讓我們繼續，看看如何用python在每一行中都有一個數字序列:

對於range(1, Depth)中的number, Depth = 6:對於range(1, number + 1)中的I, print(I, end=' ') print("")

代碼的解釋:

我們首先將depth的值初始化為6。然後，我們用下麵的命令設置外部for循環:for number in range(1, depth)。在這個命令的幫助下，我們創建了一個從1到5的數字範圍。然後，我們繼續使用下麵的命令來設置內部的for循環:for i in range(1, number + 1)。在for循環中，我們使用下麵的命令打印數字:print(i, end= ' ')。

最初，在外部for循環中number的值是1，所以我們進入內部for循環並輸出1。

然後在外層的for循環中，number的值變成2，所以我們進入內部的for循環，打印1 2。

類似地，我們回到外部循環，這裏的數值變成了3，所以這一次我們進入內部循環並打印1 2 3。

繼續，在外循環中的“number”的值變為4，因此在內循環中我們打印

1 2 3 4

在最後的迭代中，我們打印出:1 2 3 4 5

恒星的金字塔模式問題:

＊

* *

* * *

* * * *

* * * * *

讓我們看看它的代碼:

Def菱形(n): for m in range(0, n): for I in range(0, m+1): print("* "，end="") print("\r") n = 5菱形(n)

代碼的解釋:

我們首先用命令定義一個名為“diamond”的方法:def diamond(n)。

我們用下麵的命令來設置外部的for循環:“for m in range(0, n)”。然後，我們繼續使用下麵的命令來設置內部的for循環:" for i in range(0, m+1) ":

最初，在外部的for循環中，' m '的值為0，因此我們進入for循環並打印*。

然後，外部for循環中的' m '值變為1，這一次我們進入內部循環並打印* *。

類似地，在外循環中的m值變為2，因此，我們進入內循環並打印

* * *。

接下來，' m '的值在外部循環中增加，變為3，因此，在內部循環中，我們打印* * * *。

在最後的迭代中，我們打印出* * * * *。

數字倒半金字塔型問題:

1 1 1 1 1 1

2 2 2 2

3 3 3

4個4

5

讓我們為它編寫代碼:

打印(a, end=' ')打印('\r')打印('\r')

代碼的解釋：

我們從初始化兩個變量開始。我們設row的值為5 a的值為0。之後，我們用下麵的命令設置外部for循環:

對於range(row, 0， -1)中的I:

這個外部的for循環，給出了從5到1的降序數字。在外層的for循環中，我們將a的值加1。之後，我們使用下麵的命令設置內部for循環:for j in range(1, i + 1)。

在第一次迭代中，外部for循環中的' i '值為5，因此在內部for循環中，我們輸出:

1 1 1 1 1 1

在第二次迭代中，外部for循環中的' i '值為4，因此在內部for循環中，我們輸出:

2 2 2 2

在第三次迭代中，外部循環中的' i '的值減為3，然後，在內部循環中輸出:

3 3 3

在第四次迭代中，外部循環中的' i '的值減為2，因此這一次在內部循環中，我們打印:

2 - 2

最後，在最後一次迭代中，我們打印出1。

數字降序倒半金字塔型問題:

55 55 55 5

4 4 4 4

3 3 3

2 - 2

1

讓我們看看實現這個模式的代碼:

對於I，深度= 5(深度，0，-1):n = I (j，範圍(0,I):打印(n, end=' ')打印("\r")

代碼的解釋:

我們首先將depth的值初始化為5。然後使用外部的for循環，生成一個從5到1的降序數字列表。在外層for循環中，我們將n的值設置為i。之後，我們使用下麵的命令開始內部for循環:

對於j在range(0, i)中的取值:

在第一次迭代中，在外循環中' i '的值為5，因此在內循環中，我們輸出:5 5 5 5 5 5

在第二次迭代中，外部循環中的' i '的值減為4，因此我們進入內部循環並打印4 4 4 4 4

然後在第三次迭代中，' i '的值變成3，所以在內循環中，我們打印:3 3 3 3

在第四次迭代中，' i '的值變成2，這一次我們用內循環打印出22個2。

最後，在最後一次迭代中，' i '的值變成1，我們打印出1。

數字逐行遞減的半金字塔模式問題:

1

2 1

３ ２ １

4 3 2 1

5 4 3 2 1

讓我們看看它的代碼:

Size = 6 for row in range(1, Size): for column in range(row, 0， -1): print(column, end=' ') print("")

代碼的解釋:

首先，我們將變量size的值設置為6。然後，使用下麵的命令設置外部for循環:for row in range(1, size)。使用這個外部for循環，我們生成一個從1到5的數字列表。然後，我們用下麵的命令設置內部循環:

在第一次迭代中，外層循環中的row值為1，因此我們進入內部的for循環並打印1。

然後在第二次迭代中，在外循環中row的值為2，所以這一次我們進入內循環並打印:2 1

在這之後，在第三次迭代中，row的值在外層循環中變為3，因此在內層循環中，我們繼續打印:3 2 1

繼續，在第四次迭代中，row的值在外層循環中變為4，所以這一次，在內層循環中我們打印:4 3 2 1

最後，在最後的迭代中，我們繼續打印:5 4 3 2 1

Python中的OOPs概念:

當你環顧四周時，你看到了什麼?你看到了很多東西，不是嗎?

如果你看到你麵前有一台筆記本電腦，它是什麼?嗯，這是一個真實世界的物體!

同樣，如果路上有一輛車?那是什麼?汽車又是一個真實世界的物體!

現在，如果你在街上看到一隻狗，你會認為它是什麼?你猜對了，這又是一個物體!

現在，如果您必須在編程世界中表示這些真實的實體，那麼您將需要麵向對象的編程語言。這就是Python來拯救的地方!Python是使用最廣泛的麵向對象編程語言，它也非常容易學習。

那麼，讓我們來理解python中的麵向對象編程

Python中的麵向對象編程包括兩個主要組件:

  • 類
  • Objects(This is obvious )

讓我們從類~

您可以將類視為現實世界實體的模板/藍圖。讓我們通過這個例子來更好地理解類的概念:

如果我們上一門叫做“電話”的課。您可以將此視為現實世界實體電話的模板。

這個類有兩個相關的東西:屬性和行為。

類“Phone”將具有某些相關的屬性，例如:

  • 顏色
  • 成本&
  • 電池壽命

類似地，類' Phone '將具有某些關聯的行為，例如:

  • 你可以打電話
  • 你可以看視頻&
  • 你可以玩遊戲

當您將這些屬性和行為組合在一起時，您得到的就是一個類!

現在，讓我們學習物體!

簡單地說，您可以將對象視為類的特定實例。

如果" Phone "是我們的類，那麼" Apple "， " Motorola "和" Samsung "就是這個類的具體實例，換句話說，這些就是對象“電話”類。

現在我們已經介紹了麵向對象編程的基礎知識，接下來將深入研究使用Python的OOP。

讓我們繼續用python創建第一個類:

def play_game(self):打印(“正在打遊戲”)

代碼的解釋:

在這裏，我們創建了一個名為“Phone”的新類。要創建一個新類，我們使用關鍵字' class '，並在它後麵加上class-name。按照慣例，類名應該以大寫字母開頭。

在類內部，我們創建了兩個用戶定義函數:

Make_call()和play_game()。

make_call()方法隻是打印“打一個電話”而play_game()方法隻是打印“正在玩遊戲”。

現在我們已經創建了類，我們必須繼續創建類的對象:

p1=Phone() p1.make_call() p1.play_game()

代碼的解釋:

我們正在使用命令創建一個名為p1的新對象:p1=Phone()。現在，如果我們必須調用類中存在的方法，我們必須使用'。的運營商。

要從Phone類調用make_call()方法，我們使用:p1.make_call()。類似地，要從Phone類調用play_game()方法，我們使用:p1.play_game()。

現在，讓我們繼續往類的方法中添加參數:

set_color(self,color): self。Color = Color def set_cost(self,cost): self。show_color(self):返回self。show_cost(self):返回自身。def play_game(self):打印(“正在玩遊戲”)

代碼的解釋:

在Phone類中，我們創建了6個方法:

  • set_color ()
  • set_cost ()
  • show_color ()
  • show_cost ()
  • make_call ()
  • play_game ()

set_color():這個方法有兩個參數:self和color。代碼本身。Color = Color，我們可以將顏色設置為屬性' Color '。

set_cost():該方法還接受兩個參數:self和cost。用代碼:self。Cost = Cost，我們可以為屬性' Cost '設置一個Cost值。

show_color():使用這個方法，我們隻是返回手機的顏色。

show_cost():使用這個方法，我們將返回手機的成本。

make_call():使用這個方法，我們隻是打印出:“Making a phone call”。

play_game():使用這個方法，我們打印出:" Playing Game "

現在我們已經創建了類，是時候實例化類並調用方法了:

p2=Phone() p2.set_color("blue") p2.set_cost(100) p2.show_color() p2.show_cost()

代碼的解釋:

我們首先實例化類Phone: p2=Phone()。一旦我們有了對象，就該繼續調用對象的方法了。

通過使用p2.set_color(" blue ")，我們將值" blue "傳遞給屬性color。

類似地，通過使用p2.set_cost(100)，我們將值100傳遞給屬性cost。

現在，我們已經為屬性分配了顏色和代價，是時候返回值了。

通過使用p2.show_color()，我們繼續打印出手機的顏色。

類似地，通過使用p2.show_cost()，我們繼續打印出電話的成本。

類中的構造函數:

構造函數是類中的一種特殊類型的方法，借助它，我們可以在對象實例化期間直接將值賦給屬性。

讓我們通過下麵的例子來理解構造函數的概念:

class雇員:def __init__(自我，姓名，年齡，工資，性別):self.name = name自我。年齡=年齡本身。工資=工資本身。性別=性別def employee_details(self): print(“員工的姓名是”，self. Name) print(“員工的年齡是”，self. Age) print(“員工的工資是”，self. Salary) print(“員工的性別是”，self.gender)

代碼的解釋:

在這裏，我們創建了一個名為Employee的新類。在Employee類中，我們有兩個方法:

  • __init__ ()
  • employee_details ()

__init__()方法是類中的構造函數。在__init__方法的幫助下，我們能夠為名字、年齡、工資和性別賦值。

通過使用self.name = name，我們為name賦值。類似地，通過使用self。Age = Age，我們為Age賦值。然後使用self。Salary = Salary，我們為Salary指定值。最後，我們通過:self為性別賦值。性別=性別。

然後，在employee_details()方法的幫助下，我們隻打印出姓名、年齡、工資和性別的值。

現在，我們已經使用構造函數創建了一個類，是時候創建一個對象並在這個對象的幫助下實例化值了:

e1 = Employee('Sam'，32,85000，'Male') e1.employee_details()

代碼的解釋:

通過使用這個命令:e1 = Employee(' Sam '，32,85000， ' Male ')，我們正在創建一個Employee類e1的對象，並實例化名稱、年齡、工資和性別的值。

我們傳入值' Sam '作為名字，32作為年齡，85000作為工資，' male '作為性別。

然後，我們使用下麵的命令打印出員工的詳細信息:

e1.employee_details ()

繼承:

通過繼承，一個類可以派生另一個類的屬性。

考慮一下這個例子:你有一些與你父親相似的特征，而你父親有一些與你祖父相似的特征。這就是所謂的遺傳。或者換句話說，你也可以說，你從你父親那裏繼承了一些身體特征，你父親從你祖父那裏繼承了一些身體特征。

現在，我們知道了繼承到底是什麼，讓我們看看如何在python中實現繼承:

class Vehicle: def __init__(self,mileage, cost): self.mileage =裏程。成本=成本def show_details(self):打印(“我是一輛車”)打印(“裏程的車輛是”，self. Mileage)打印(“成本的車輛是”，self.cost)

代碼的解釋:

在這裏，我們正在創建父類Vehicle。這個類有兩個方法:

  • __init__ ()
  • show_details ()

在__init__()方法的幫助下，我們隻是為裏程和成本分配值。然後，在' show_details() '的幫助下，我們打印出車輛的裏程和車輛的成本。

現在，我們已經創建了類，讓我們繼續為它創建一個對象:

v1 =車輛(500,500)v1.show_details()

代碼的解釋:

我們首先創建一個Vehicle類的實例。Vehicle類包含兩個參數，基本上是裏程和成本的值。一旦我們分配了值，就可以繼續使用v1.show_details()方法打印出詳細信息。

現在，讓我們繼續創建子類:

class Car(Vehicle): def show_car(self): print("I am a Car ") c1 = Car(200,1200) c1.show_details() c1.show_car()

代碼的解釋:

我們從創建子類Car開始。這個子類繼承自父類Vehicle。

這個子類有它自己的方法' show_Car() '，它隻打印出' I am car '。一旦我們創建了子類，就該實例化該類了。我們使用命令:

c1 = Car(200,1200)，創建一個Car類的對象c1。

現在，在c1的幫助下，我們調用方法c1.show_details()。盡管show_details隻屬於' Car '類的一部分，但我們能夠調用它，因為' Car '類繼承自' Vehicle '類，而show_details()方法是Vehicle類的一部分。

最後，我們使用c1.show_car()來打印' I am car '。

現在，讓我們看看如何在繼承過程中重寫__init__方法:

class Vehicle: def __init__(self,mileage, cost): self.mileage =裏程。成本=成本def show_details(self):打印(“我是一輛車”)打印(“裏程的車輛是”，self. Mileage)打印(“成本的車輛是”，self.cost)

代碼的解釋:

我們再次使用__init__()和show_details()方法創建相同的父類“Vehicle”。

現在，讓我們重寫子類Car中的init方法:

class Car(Vehicle): def __init__(self,mileage,cost, tires,hp): super().__init__(mileage,cost) self。輪胎=輪胎本身。hp =hp def show_car_details(self): print("I am a car") print("Number of tires are "，self. tires) print("Value of horse power is "，self.hp)

代碼的解釋:

這裏的子類Car本身有一個__init__()方法。__init__()方法有5個參數:

  • 自我
  • 裏程
  • 成本
  • 輪胎
  • 惠普

在__init__()方法內部，我們使用super()方法為父類傳遞參數。因此，mileage和cost進入父類的__init__()方法。

一旦我們傳遞了父類的參數，我們就為' tires '和' hp '分配了值。

通過使用self。輪胎=輪胎，我們為' tires '分配值。類似地，通過使用self。HP = HP，我們將值傳遞給' HP '。

然後，我們有另一個名為show_car_details()的方法，在該方法的幫助下，我們隻是打印出汽車中的輪胎數量和汽車的馬力。

現在，讓我們繼續創建car類的一個實例:

c1 = Car(20,12000,4,300) c1.show_details() c1.show_car_details()

代碼的解釋:

我們首先創建car類的對象。這包含4個參數:

  • 40是汽車的裏程
  • 這輛車的價格是一萬二
  • 4表示輪胎數量
  • HP表示汽車的馬力值

然後，我們繼續調用c1.show_details()，它來自父類。類似地，我們調用來自子類的c1.show_car_details()。

多重繼承:

在多重繼承中，子類繼承自多個類。

讓我們看一個例子來理解多重繼承的概念:

class Parent1(): def assign_string_one(self,str1): self。Str1 = Str1 def show_string_one(self):返回self。str1類Parent2(): def assign_string_two(self,str2): self。Str2 = Str2 def show_string_two(self):返回self。派生(Parent1, Parent2): def assign_string_three(self,str3): self。Str3 = Str3 def show_string_three(self):返回self. Str3

代碼的解釋:

我們首先創建第一個父類“Parent1”。這個父類有兩個方法:

  • assign_string_one ()
  • show_string_one ()

在assign_string_one()的幫助下，我們打印出屬性str1的值。然後，在show_string_one()的幫助下，我們隻是打印出屬性str1的值。

一旦我們定義了第一個類，我們繼續創建第二個父類:“Parent2”。這個類同樣有兩個方法:

  • assign_string_two ()
  • show_string_two ()

在assign_string_two()的幫助下，我們打印出了屬性str2的值。然後，在show_string_two()的幫助下，我們隻是打印出屬性str2的值。

最後，我們繼續創建我們的子類:“Derived”。這個“Derived”類同時繼承了“Parent1”和“Parent2”。

這個“Derived”類同樣有兩個方法:

  • assign_string_three ()
  • show_string_three ()

在assign_string_three()的幫助下，我們打印出屬性str3的值。然後，在show_string_three()的幫助下，我們隻是打印出屬性str3的值。

現在，我們已經準備好了所有的類，讓我們繼續為“Derived”類創建一個對象:

d1 = Derived() d1.assign_string_one("one") d1.assign_string_two("two") d1.assign_string_three("three") d1.show_string_one() d1.show_string_two() d1.show_string_three()

代碼的解釋:

我們使用以下命令為類" Derived "創建對象d1: d1 = Derived()。然後，通過調用assign_string_one()為str1賦值。類似地，通過調用assign_string_two()為str2賦值，最後通過調用assign_string_three()為str3賦值。

一旦我們賦值，我們打印出str1, str2和str3的值。

在多層繼承中，我們有親子孫輩關係。

讓我們通過一個例子來更好地理解這一點:

class Parent(): def assign_age(self,age): self.name = name def show_name(self):返回self.name class Child(Parent): def assign_age(self,age): self.nameshow_age(self):返回自己。年齡類GrandChild(Child): def assign_gender(自我，性別):自我。show_gender(self):返回self.name

代碼的解釋:

我們從第一堂課“家長”開始。這個類有兩個方法:

  • assign_name ()
  • show_name ()

在assign_name()的幫助下，我們為name屬性分配值。然後，在show_name()的幫助下，我們返回name的值。

一旦我們創建了“父”類，我們就創建了“子”類。這個“子”類繼承自“父”類。

這個類同樣有兩個方法:

  • assign_age ()
  • show_age ()

在assign_age()的幫助下，我們為age屬性分配了一個值。然後，在show_age()的幫助下，我們打印出age的值。

最後，我們有“GrandChild”類。這個類繼承自“Child”類。

在這個類中，我們有兩個方法:

  • assign_gender ()
  • show_gender ()

在assign_gender()的幫助下，我們為“gender”分配了一個值。在show_gender()的幫助下，我們返回了gender的值。

現在我們已經創建了類，讓我們繼續為GrandChild類創建一個對象:

g1 = GrandChild() g1.assign_name("Sam") g1.assign_age(25) g1.assign_gender("Male") g1.show_name() g1.show_age() g1.show_gender()

代碼的解釋:

在這裏，我們使用下麵的命令為' GrandChild '類創建對象' g1 ':

g1 = GrandChild()。

一旦我們創建了對象，我們繼續並為名稱、年齡和性別分配值。

最後，我們打印出姓名、年齡和性別的值。

Python Numpy

Numpy是python中的一個庫。Numpy代表數字Python，是數字和科學計算的核心庫。

它由多維數組對象和一組處理這些數組的例程組成。

讓我們看一些關於如何使用bumpy創建一維和多維數組的例子:

這是我們如何創建一個一維數組:

類似地，我們可以繼續創建一個多維數組:

如果我們想初始化一個隻有0的numpy數組，我們可以使用' zeros() '方法:

現在，讓我們看看如何在一個範圍內初始化一個numpy數組:

Python熊貓:

Pandas代表Panel Data(麵板數據)，是數據操作和數據分析的核心庫。

它由用於數據操作的一維和多維數據結構組成。

  • 一維數據結構稱為係列&
  • 多維數據結構稱為數據框架。

數據框架是任何數據科學項目的麵包和黃油。所以，如果你想擅長數據科學，那麼你一定要善於使用數據框架。

現在，讓我們看幾個例子，看看如何使用Pandas創建Series對象和Dataframe。

我們必須從導入pandas庫開始，使用“import pandas as pd”。

然後，要創建一個Series對象，我們將使用命令- " pd.Series() "。這將幫助我們從列表創建一個係列對象。

現在，類似地，讓我們創建一個數據框架:

這裏，我們從字典中創建一個數據框架。如你所見，字典中的“鍵”已經表示為數據幀中的列名，而“值”則表示為數據幀中的“行”/“記錄”。

Python中的Seaborn:

Seaborn是python中的庫，用於創建漂亮的圖形和圖表。它也很容易學習和使用這個庫。讓我們看一些使用海運包的圖形示例。

我們將首先創建一個線形圖:

  1. 進口海運作為SNS
  2. 從matplotlib導入pyplot作為PLT
  3. fmri = sns.load_dataset (fmri)
  4. fmri.head ()
  1. sns.lineplot (x = "計算" y =“信號”,data = fmri)
  2. plt.show ()

現在，類似地，讓我們繼續創建一個條形圖:

  1. sns.barplot (x = " is_legendary " y =“速度”,data =口袋妖怪)
  2. plt.show ()

現在，讓我們繼續在虹膜數據集上創建一個散點圖:

  1. 虹膜= pd.read_csv('虹膜.csv ')
  2. iris.head ()
  1. sns.scatterplot (x = " Sepal.Length " y =“Petal.length”,data =虹膜)
  2. plt.show ()

以上就是關於Python的全部內容，現在讓我們進入列表中的下一種語言:“Java”

Java編程語言:

Java也是一種免費、開源、跨平台兼容、麵向對象的編程語言。

讓我們看看如何安裝java:

要安裝java，我們必須去這個網站下載jdk:https://www.oracle.com/java/technologies/javase-downloads.html

Jdk代表Java Development Kit，它提供了編寫、編譯和執行Java代碼的所有工具。

Eclipse Java:

Java最廣泛使用的IDE是Eclipse。你可以下載eclipse從這個網站．

第一個Java程序:

包javatutorial;public class JavaTutorial {public static void main(String[] args) {// TODO自動生成的方法存根System.out. out。println(“這是斯巴達!”);}}

代碼的解釋:

我們首先創建一個名為“JavaTutorial”的類。因為Java是一種麵向對象的編程語言，所以所有東西都必須在類中。一旦我們創建了我們的主類，我們繼續在裏麵創建我們的主函數。最後，在main函數中，我們隻打印出“This is sparta !”

Java中的If語句:

包javatutorial;public class JavaTutorial {public static void main(String[] args) {// TODO自動生成方法stub int marks = 65;if(標記<50){係統。println(“你考試不及格”);} else if(marks>=50 && marks<60){係統。println("You have got D grade");} else if(marks>=60 && marks<75){係統。println("You have got C grade");} else if(marks>=75 && marks<90){System.out.}println("You have got B grade");} else if(marks>=90 && marks<100){System.out.}println("You have A grade");} else {System.out。println(“無效分數”); } }

代碼的解釋:

在本例中，我們首先將值65賦值給“marks”變量。然後，我們從第一個if語句開始:

if(標記<50){係統。println(“你考試不及格”);｝

在第一個if語句中，我們檢查marks的值是否小於50，如果結果為true，我們繼續打印“You have failed the exam.”。如果這個條件不滿足，那麼我們繼續執行下麵的else If語句:

else if(marks>=50 && marks<60){係統。println("You have got D grade");｝

使用這個else if語句，我們檢查marks的值是否在50到65之間。如果這個結果為真，我們繼續打印“你的成績是D”。如果這個也失敗了，我們轉到下一個else If語句:

else if(marks>=60 && marks<75){係統。println("You have got C grade");｝

使用這個else if語句，我們檢查分數是否在60到75之間，如果這個值為True，我們打印出“你的分數是C”。如果失敗，我們轉到下一個If語句:

else if(marks>=75 && marks<90){係統。println("You have got B grade");｝

在這裏，我們正在檢查，如果分數在75到90之間，如果這個評估為True，我們打印出“你得到了B級”。如果這也失敗了，我們再次轉到下一個else If語句:

else if(marks>=90 && marks<100){係統。println("You have A grade");｝

在這裏，我們正在檢查，如果分數在90到100之間，如果這是真的，我們打印出:

“你得了A”。

最後，如果上述所有條件都失敗，那麼我們隻需使用else語句並打印“Invalid Score”。

Java中的While循環:

包javatutorial;public class JavaTutorial {public static void main(String[] args) {// TODO自動生成方法stub int x=1;while(x<=4) {System.out.println(x);x + +;}}}

代碼的解釋:

首先給變量x賦值1，然後開始while循環，其中的條件是x是否小於或等於4。如果condition的值為true，則進入循環並執行循環中出現的任何內容。

最初，x的值為1，由於1小於4，我們進入循環並將值1打印到控製台。然後，x的值增加到2。我們再次檢查2是否小於或等於4，因為這也是為真，我們再次進入循環並打印出2。重複這個過程，直到得到:1 2 3 4。

Java中的模式問題:

＊

* *

* * *

* * * *

* * * * *

包javatutorial;public class JavaTutorial {public static void main(String[] args) {// TODO自動生成方法stub int n =5;(int i = 0;我< n;我為(+ +){int j = 0; < =我;j + +) {System.out.print(“*”);} System.out.println ();}}}

代碼的解釋:

我們首先將變量n的值初始化為5。然後是外層的for循環，從0開始，一直到4。當外部for循環中的i值為0時，我們進入內部for循環並打印*。然後，i的值增加到1。這一次，我們進入內部的for循環並打印* *。類似地，i的值增加到2，然後我們進入內循環並打印* * *。一直到i的值變為5。

c++編程:

c++是一種獨立於機器的、編譯類型的、麵向對象的編程語言。它還支持直接訪問內存的指針。c++被用於Ubuntu和Windows等操作係統的開發。它不僅是操作係統，而且是用於開發瀏覽器(如chrome和firefox)的語言。

c++程序的基本語法:

使用命名空間std;#include  int main(){cout<<"Hello World";返回0;｝

代碼的解釋:

在這裏，我們首先包含庫:iostream。這個庫提供了所有的輸入和輸出函數。然後是主函數。必須記住，程序執行從main開始，並在main結束。在main函數中，我們繼續打印“Hello world”。

這篇關於頂級編程語言的博客結束了，我們在這裏學習了Python、java和c++。

相關文章更多來自作者

留下回複

請輸入您的評論!
請在這裏輸入您的姓名