一、Python介紹

Python 是一個高層次的結(jié)合了解釋性、編譯性、互動性和面向?qū)ο蟮哪_本語言。
Python 的設(shè)計具有很強的可讀性，相比其他語言經(jīng)常使用英文關(guān)鍵字，其他語言的一些標(biāo)點符號，它具有比其他語言更有特色語法結(jié)構(gòu)。
Python 是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。
Python 是交互式語言： 這意味著，您可以在一個Python提示符，直接互動執(zhí)行寫你的程序。
Python 是面向?qū)ο笳Z言: 這意味著Python支持面向?qū)ο蟮娘L(fēng)格或代碼封裝在對象的編程技術(shù)。
Python 是初學(xué)者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應(yīng)用程序開發(fā)，從簡單的文字處理到 WWW 瀏覽器再到游戲。

二、發(fā)展歷程

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷蘭國家數(shù)學(xué)和計算機科學(xué)研究所設(shè)計出來的。
Python 本身也是由諸多其他語言發(fā)展而來的,這包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的腳本語言等等。
像 Perl 語言一樣，Python 源代碼同樣遵循 GPL(GNU General Public License)協(xié)議。
現(xiàn)在 Python 是由一個核心開發(fā)團隊在維護，Guido van Rossum 仍然占據(jù)著至關(guān)重要的作用。

三、Python的特點

易于學(xué)習(xí)：Python有相對較少的關(guān)鍵字，結(jié)構(gòu)簡單，和一個明確定義的語法，學(xué)習(xí)起來更加簡單。
易于閱讀：Python代碼定義的更清晰。
易于維護：Python的成功在于它的源代碼是相當(dāng)容易維護的。
一個廣泛的標(biāo)準(zhǔn)庫：Python的最大的優(yōu)勢之一是豐富的庫，跨平臺的，在UNIX，Windows和Macintosh兼容很好。
互動模式：互動模式的支持，您可以從終端輸入執(zhí)行代碼并獲得結(jié)果的語言，互動的測試和調(diào)試代碼片斷。
可移植：基于其開放源代碼的特性，Python已經(jīng)被移植（也就是使其工作）到許多平臺。
可擴展：如果你需要一段運行很快的關(guān)鍵代碼，或者是想要編寫一些不愿開放的算法，你可以使用C或C++完成那部分程序，然后從你的Python程序中調(diào)用。
數(shù)據(jù)庫：Python提供所有主要的商業(yè)數(shù)據(jù)庫的接口。
GUI編程：Python支持GUI可以創(chuàng)建和移植到許多系統(tǒng)調(diào)用。
可嵌入: 你可以將Python嵌入到C/C++程序，讓你的程序的用戶獲得"腳本化"

四、第一個Python程序

1.創(chuàng)建python file
2.練習(xí)打印hello world

image.png

五、Python變量和數(shù)據(jù)類型

5.1. 變量的定義
在程序中，有時我們需要對2個數(shù)據(jù)進行求和，那么該怎樣做呢？
大家類比一下現(xiàn)實生活中，比如去超市買東西，往往咱們需要一個菜籃子，用來進行存儲物品，等到所有的物品都購買完成后，在收銀臺進行結(jié)賬即可
如果在程序中，需要把2個數(shù)據(jù)，或者多個數(shù)據(jù)進行求和的話，那么就需要把這些數(shù)據(jù)先存儲起來，然后把它們累加起來即可
在Python中，存儲一個數(shù)據(jù)，需要一個叫做變量的東西，如下示例:

num1 = 100 #num1就是一個變量，就好一個小菜籃子
num2 = 87  #num2也是一個變量
result = num1 + num2 #把num1和num2這兩個"菜籃子"中的數(shù)據(jù)進行累加，然后放到 result變量中

概念

整數(shù)
Python可以處理任意大小的整數(shù)，當(dāng)然包括負(fù)整數(shù)，在Python程序中，整數(shù)的表示方法和數(shù)學(xué)上的寫法一模一樣，例如：1，100，-8080，0，等等。
浮點數(shù)
浮點數(shù)也就是小數(shù)，之所以稱為浮點數(shù)，是因為按照科學(xué)記數(shù)法表示時，一個浮點數(shù)的小數(shù)點位置是可變的，比如，1.23x109和12.3x108是相等的。浮點數(shù)可以用數(shù)學(xué)寫法，如1.23，3.14，-9.01，等等。
整數(shù)和浮點數(shù)在計算機內(nèi)部存儲的方式是不同的，整數(shù)運算永遠(yuǎn)是精確的（除法難道也是精確的？是的?。?，而浮點數(shù)運算則可能會有四舍五入的誤差。
字符串
字符串是以''或""括起來的任意文本，比如'abc'，"xyz"等等。請注意，''或""本身只是一種表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c這3個字符。
布爾值
布爾值和布爾代數(shù)的表示完全一致，一個布爾值只有True、False兩種值，要么是True，要么是False，在Python中，可以直接用True、False表示布爾值（請注意大小寫），也可以通過布爾運算計算出來。
布爾值可以用and、or和not運算。
and運算是與運算，只有所有都為 True，and運算結(jié)果才是 True。A與B true true
or運算是或運算，只要其中有一個為 True，or 運算結(jié)果就是 True。
not運算是非運算，它是一個單目運算符，把 True 變成 False，F(xiàn)alse 變成 True。
空值
空值是Python里一個特殊的值，用None表示。None不能理解為0，因為0是有意義的，而None是一個特殊的空值。

代碼示例

a=1;
#浮點數(shù)
b=1.1;
#字符串
c="abc";
#boolean類型
d=True;
#空值
e=None;
print(a);print(b);print(c);print(d);print(e)
a=True and True   # ==> True
b=True and False   # ==> False
c=False and True   # ==> False
d=False and False   # ==> False
e=True or True   # ==> True
f=True or False   # ==> True
g=False or True   # ==> True
h=False or False   # ==> False
i=not True   # ==> False
j=not False   # ==> True
print(a,b,c,d,e,f,g,h,i,j)

標(biāo)識符

1、什么是標(biāo)識符？
開發(fā)人員在程序中自定義的一些符號和名稱
標(biāo)識符是自己定義的,如變量名 、函數(shù)名等
2、標(biāo)識符的命名規(guī)則
. 標(biāo)識符只能由字母、下劃線“_”、數(shù)字組成。
. 標(biāo)識符不能以數(shù)字開頭。
. 標(biāo)識符不能使用關(guān)鍵字
. 標(biāo)識符對大小寫敏感。
（建議:標(biāo)識符命名應(yīng)“見名知意”）
3、python中的關(guān)鍵字
'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'

Python中print語句

print() 方法用于打印輸出，最常見的一個函數(shù)。
語法:
print(*objects, sep=' ', end='\n', file=sys.stdout)
參數(shù):
objects -- 復(fù)數(shù)，表示可以一次輸出多個對象。輸出多個對象時，需要用 , 分隔。
sep -- 用來間隔多個對象，默認(rèn)值是一個空格。
end -- 用來設(shè)定以什么結(jié)尾。默認(rèn)值是換行符 \n，我們可以換成其他字符串。
file -- 要寫入的文件對象。
格式化輸出

方式一:使用百分號（%）字符串格式化

print("my name is %s, and my age is %d" %(name,age))
方式二：使用format字符串格式化

位置參數(shù)

print("my name is {}, and my age is {}".format(age,name))
關(guān)鍵字參數(shù)

print("my name is {name}, and my age is {age}".format(age=18,name="jack"))

注釋:位置參數(shù)("{0}".format())，關(guān)鍵字參數(shù)("{關(guān)鍵字}".format())

設(shè)置換行符號

input() 用來獲取控制臺的輸入。
語法：
input([prompt])

image.png

六Python條件循環(huán)和判斷

If語句

if 判斷條件：
    執(zhí)行語句……
else：
    執(zhí)行語句……

其中"判斷條件"成立時（非零），則執(zhí)行后面的語句，而執(zhí)行內(nèi)容可以多行，以縮進來區(qū)分表示同一范圍。
else 為可選語句，當(dāng)需要在條件不成立時執(zhí)行內(nèi)容則可以執(zhí)行相關(guān)語句，具體

#####If else 語句
age = 12
if age>18:
    print("年齡大于18")
else:
    print("年齡小于等于18")

age=20;
if age>18:
    print("年齡大于18")
if not age <=18:
    print("年齡大于18")
注意：Python代碼的縮進規(guī)則。具有相同縮進的代碼被視為代碼塊，上面的 print 語句就構(gòu)成一個代碼塊。如果 if 語句判斷為 True，就會執(zhí)行這個代碼塊。

If else else 多層嵌套方式

age=10;
if age >= 18:
    print ('adult')
else:
    if age >= 6:
        print ('teenager')
    else:
        if age >= 3:
            print ('kid')
        else:
            print ('baby')

if 語句的判斷條件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）來表示其關(guān)系。
For循環(huán)：重復(fù)執(zhí)行語句

for n in range(1, 20):
    print(n)

arr = [100, 90, 86, 80, 77]
for index in arr:
    print(index)

注意: b這個變量是在 for 循環(huán)中定義的，意思是，依次取出list中的每一個元素，并把元素賦值給 name，然后執(zhí)行for循環(huán)體

While 循環(huán)

Python 編程中 while 語句用于循環(huán)執(zhí)行程序，即在某條件下，循環(huán)執(zhí)行某段程序，以處理需要重復(fù)處理的相同任務(wù)。

while 判斷條件：
    執(zhí)行語句……

執(zhí)行語句可以是單個語句或語句塊。判斷條件可以是任何表達式，任何非零、或非空（null）的值均為true。當(dāng)判斷條件假false時，循環(huán)結(jié)束,while 循環(huán)不會迭代 list 或 tuple 的元素

元組

元組的格式

變量名=(,,,,)

訪問元組

通過索引取數(shù)據(jù)

aTuple=(23,35,56,34,11,21)
print(aTuple[2])
#56

查詢個數(shù)

count查詢出現(xiàn)的個數(shù)

查詢索引

index：查詢元素的索引，有對應(yīng)的元素返回對應(yīng)的索引，否則報錯

修改數(shù)據(jù)(不能修改)

aTuple=('b','c','d','e','f','g')
aTuple[1]=23
#TypeError: 'tuple' object does not support item assignment

類型轉(zhuǎn)換

aa = [23,34,45,56,67]
tuple(aa)
print(aa)
#[23, 34, 45, 56, 67]

列表轉(zhuǎn)換元組

aTuple=('b','c','d','e','f','g')
a = list(aTuple)
print(a)
#['b', 'c', 'd', 'e', 'f', 'g']

元組轉(zhuǎn)換列表

aa = [23,34,45,56,67]
tuple(aa)
print(aa)
#[23, 34, 45, 56, 67]

元組的循環(huán)取值

方式一：for

aTuple=('b','c','d','e','f','g')
for i in aTuple:
    print(i)

方式二：while

aTuple=('b','c','d','e','f','g')
i=0
while i < len(aTuple):
    print(aTuple[i])
    i=i+1

字典

字典的格式

變量名={key1:value,key2:value,,,}

字典的每個元素由2部分組成，鍵（key）:值（value）

根據(jù)鍵訪問值

有對應(yīng)key的

info = {"name":"wjh","age":18,"sex":"男"}
print(info["name"])

無對應(yīng)key的

info = {"name":"wjh","age":12,"sex":"男"}
print(info["name12"])

修改元素

字典的每個元素中的數(shù)據(jù)是可以修改的，只要通過key找到，即可修改,否則是新增

info = {"name":"wjh","age":12,"sex":"男"}
info["age"] =14
print(info)
#{'name': 'wjh', 'age': 14, 'sex': '男'}

有對應(yīng)的key則是修改數(shù)據(jù)，沒有對應(yīng)的key是新增數(shù)據(jù)

添加元素

info = {"name":"anfly","age":12,"sex":"男"}
info["gender"] ="屬雞"
print(info)
#{'name': 'anfly', 'age': 12, 'sex': '男', 'gender': '屬雞'}

刪除元素

del,clear() ---- 清空

del (刪除指定的元素)

刪除整個字典

info = {"name":"anfly","age":12,"sex":"男"}
del info
print(info)
#NameError: name 'info' is not defined

刪除某個元素

info = {"name":"anfly","age":12,"sex":"男"}
del info["name"]
print(info)
#{'age': 12, 'sex': '男'}

clear清空

info = {"name":"anfly","age":12,"sex":"男"}
info.clear()
print(info)
#{}

查詢長度

len():查詢鍵值對的個數(shù)

info = {"name":"anfly","age":12,"sex":"男"}
print(len(info))
#3

字典中循環(huán)

取出字典中的key

info = {"name":"anfly","age":12,"sex":"男"}
for i in info.keys():
    print(i)

取出字典中的value

info = {"name":"anfly","age":12,"sex":"男"}
for i in info.values():
    print(i)

取出字典中的key和value

方式一：

info = {"name":"anfly","age":12,"sex":"男"}
for i in info.keys():
    print(i,info[i])

方式二：

info = {"name":"anfly","age":12,"sex":"男"}
for k,v in info.items():
    print(k,v)

集合和函數(shù)

集合

集合的特征

集合是無序的，集合中的元素是唯一的，集合一般用于元組或者列表中的元素去重

集合的格式

變量名=set()
變量名.add(元素)
# 必須不能初始化值

添加元素

add

nums = {11,24,45,96,28}
nums.add(42)
print(nums)
#{96, 42, 11, 45, 24, 28}

update

nums = {11,24,45,96,28}
nums2=["anfly","tom"]
nums.update(nums2)
print(nums)
#{96, 'anfly', 11, 45, 24, 28, 'tom'}

刪除元素

remove，pop，discard

remove

使用remove刪除集合中的元素 如果有直接刪除 如果沒有程序報錯
該元素存在

nums = {11,24,45,96,28}
nums.remove(24)
print(nums)
#{96, 11, 45, 28}

該元素不存在

nums = {11,24,45,96,28}
nums.remove(245)
print(nums)
#KeyError: 245

pop

使用pop刪除是隨機刪除集合中的元素 如果集合沒有元素程序報錯
有元素

nums = {11,24,45,96,28}
nums.pop()
print(nums)
#{11, 45, 24, 28}

無元素

nums = {}
nums.pop()
print(nums)
#TypeError: pop expected at least 1 arguments, got 0

discard

使用discard刪除 如果元素存在直接刪除 如果元素不存在不做任何操作
該元素存在

nums = {11,24,45,96,28}
nums.discard(24)
print(nums)
#{96, 11, 45, 28}

該元素不存在

nums = {11,24,45,96,28}
nums.discard(242)
print(nums)
#{96, 11, 45, 24, 28}

集合的交集和并集

交集

使用&連接多個集合,得到相同的元素
存在相同元素

set1 = {"anfly","tom","haha"}
set2 = {"anfly","susala"}
set3= set1 & set2

print(set3)
存在相同元素

set1 = {"anfly","tom","haha"}
set2 = {"anfly2","susala"}
set3= set1 & set2
print(set3)

并集

使用|連接多個集合,得到全部集合中全部的元素

公共方法

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
new_set = set1 | set2
print(new_set)
#{1, 2, 3, 4, 5, 6}

運算符

image

函數(shù)

什么是函數(shù)

在開發(fā)程序時，需要某塊代碼多次，但是為了提高編寫的效率以及代碼的重用，所以把具有獨立功能的代碼塊組織為一個小模塊，這就是函數(shù)

函數(shù)定義和調(diào)用

def 函數(shù)名():
    執(zhí)行語句
函數(shù)名()    #調(diào)用函數(shù)

定義了函數(shù)之后，就相當(dāng)于有了一個具有某些功能的代碼，想要讓這些代碼能夠執(zhí)行，需要調(diào)用它
調(diào)用函數(shù)很簡單的，通過 函數(shù)名() 即可完成調(diào)用
每次調(diào)用函數(shù)時，函數(shù)都會從頭開始執(zhí)行，當(dāng)這個函數(shù)中的代碼執(zhí)行完畢后，意味著調(diào)用結(jié)束了
當(dāng)然了如果函數(shù)中執(zhí)行到了return也會結(jié)束函數(shù)

位置參數(shù)

def 函數(shù)名(參數(shù)1,參數(shù)2):
    代碼塊
函數(shù)名(值1,值2)

關(guān)鍵字參數(shù)

def 函數(shù)名(參數(shù)1,參數(shù)2):
    代碼塊
函數(shù)名(參數(shù)1=值1,參數(shù)2=值2)

缺省參數(shù)

在形參中默認(rèn)有值的參數(shù)，稱之為缺省參數(shù)

def printinfo(name,age=20):
    print("name:",name)
    print("age:",age)
printinfo(name="anfly")
#name: anfly
#age: 20

調(diào)用函數(shù)時，缺省參數(shù)的值如果沒有傳入，則取默認(rèn)值（形式參數(shù)），如果傳入，則取實際參數(shù)
缺省參數(shù)一定要位于位置參數(shù)的最后面

不定長參數(shù)

有時可能需要一個函數(shù)能處理比當(dāng)初聲明時更多的參數(shù), 這些參數(shù)叫做不定長參數(shù)，聲明時不會命名。

def printinfo(*args,**kwargs):
    print("args:",args)
    print("kwargs:",kwargs)
printinfo(參數(shù))

注意：加了星號（）的變量args會存放所有未命名的變量參數(shù)，args為元組
而加*的變量kwargs會存放命名參數(shù)，即形如key=value的參數(shù)， kwargs為字典

參數(shù)位置順序

def fun(位置參數(shù),*args,缺省參數(shù),**kwargs):
    代碼塊
fun(參數(shù)值)

注意:?如果很多個值都是不定長參數(shù)，那么這種情況下，可以將缺省參數(shù)放到 args的后面， 但如果有kwargs的話，*kwargs必須是最后的

函數(shù)返回值

def sum():
    代碼塊
    return 值
sum()

多個return

  def create_nums(num):
      print("---1---")
      if num == 100:
          print("---2---")
          return num+1  # 函數(shù)中下面的代碼不會被執(zhí)行，因為return除了能夠?qū)?shù)據(jù)返回之外，還有一個隱藏的功能：結(jié)束函數(shù)
          print("return執(zhí)行之后不會繼續(xù)執(zhí)行")
  print(“1231223")
      else:
          print("---3---")
          return num+2
      print("---4---")
  result1 = create_nums(100)
  print(result1)  # 打印101
  result2 = create_nums(200)
  print(result2)  # 打印202

注意:一個函數(shù)中可以有多個return語句，但是只要有一個return語句被執(zhí)行到，那么這個函數(shù)就會結(jié)束了，因此后面的return沒有什么用處

返回多個數(shù)據(jù)

    shang = a//b    #取模
    yushu = a%b    #取余
    return shang, yushu  #默認(rèn)是元組
result = divid(5, 2)
print(result)
# 輸出(2, 1)

總結(jié):return后面可以是元組，列表、字典等，只要是能夠存儲多個數(shù)據(jù)的類型，就可以一次性返回多個數(shù)據(jù)

函數(shù)類型

無參數(shù)，無返回值的函數(shù)

此類函數(shù)，不能接收參數(shù)，也沒有返回值，一般情況下，打印提示燈類似的功能，使用這類的函數(shù)

def printMenu():
    print('--------------------------')
    print('      xx涮涮鍋 點菜系統(tǒng)')
    print('')
    print('  1.  羊肉涮涮鍋')
    print('  2.  牛肉涮涮鍋')
    print('  3.  豬肉涮涮鍋')
    print('--------------------------')

無參數(shù)，有返回值的函數(shù)

此類函數(shù)，不能接收參數(shù)，但是可以返回某個數(shù)據(jù)，一般情況下，像采集數(shù)據(jù)，用此類函數(shù)

def getTemperature():
    # 這里是獲取溫度的一些處理過程
    # 為了簡單起見，先模擬返回一個數(shù)據(jù)
    return 24

有參數(shù)，無返回值的函數(shù)

此類函數(shù)，能接收參數(shù)，但不可以返回數(shù)據(jù)，一般情況下，對某些變量設(shè)置數(shù)據(jù)而不需結(jié)果時，用此類函數(shù)

有參數(shù)，有返回值的函數(shù)

此類函數(shù)，不僅能接收參數(shù)，還可以返回某個數(shù)據(jù)，一般情況下，像數(shù)據(jù)處理并需要結(jié)果的應(yīng)用，用此類函數(shù)

# 計算1~num的累積和（案例需實際演示）
def calculateNum(num):
    result = 0
    i = 1
    while i<=num:
        result = result + i
        i+=1
    return result

函數(shù)的嵌套

一個函數(shù)里面又調(diào)用了另外一個函數(shù)，這就是所謂的函數(shù)嵌套調(diào)用

def testb():
    print("testb start")
    print("testb testb  執(zhí)行")
    print("testb end")
def testa():
    print("testa start")
    testb()
    print("testa end")

注意：如果函數(shù)A中，調(diào)用了另外一個函數(shù)B，那么先把函數(shù)B中的任務(wù)都執(zhí)行完畢之后才會回到上次 函數(shù)A執(zhí)行的位置

匿名函數(shù)

lambda函數(shù)也叫匿名函數(shù)，即函數(shù)沒有具體的名稱

g = lambda x :x+1
print(g(1))

def g(x):
    return x + 1
print(g(1))

注意:lambda函數(shù)可以賦值給變量，默認(rèn)是返回的，所以不用再加return關(guān)鍵字

變量

局部變量

定義
局部變量，就是在函數(shù)內(nèi)部定義的變量
局部變量，就是在函數(shù)內(nèi)部定義的變量
約束
其作用范圍是這個函數(shù)內(nèi)部，即只能在這個函數(shù)中使用，在函數(shù)的外部是不能使用的

def test1():
    a = 120
    print("我是局部變量a:",a)
    a = 240
    print("修改之后的局部變量a:",a)
def test2():
    a =360
    print("我是test02函數(shù)中的局部變量a",a)
test1()
test2()

注意:局部變量的作用，為了臨時保存數(shù)據(jù)需要在函數(shù)中定義變量來進行存儲
當(dāng)函數(shù)調(diào)用時，局部變量被創(chuàng)建，當(dāng)函數(shù)調(diào)用完成后這個變量就不能夠使用了

全局變量

定義
在函數(shù)外邊定義的變量叫做全局變量
約束
全局變量能夠在所有的函數(shù)中進行訪問

a = 100
def test1():
    print(a)  # 雖然沒有定義變量a但是依然可以獲取其數(shù)據(jù)
def test2():
    print(a)  # 雖然沒有定義變量a但是依然可以獲取其數(shù)據(jù)
# 調(diào)用函數(shù)
test1()
test2()

全局變量和局部變量名字相同

a = 100  #全局變量
def test1():
    a= 300
    print("修改后的a:",a)
def test2():
    print(a)
# 調(diào)用函數(shù)
test1()
test2()

注意:函數(shù)中的變量修改不會導(dǎo)致全局變量改變

全局變量的修改

global的使用

a = 100  #全局變量
def test1():
    global a   #將a變成全局變量
    a= 300
    print("修改后的a",a)
def test2():
    print(a)
# 調(diào)用函數(shù)
test1()
test2()

注意:在函數(shù)中出現(xiàn)global 全局變量的名字 那么這個函數(shù)中即使出現(xiàn)和全局變量名相同的變量名 = 數(shù)據(jù) 也理解為對全局變量進行修改，而不是定義局部變量