python入門篇：基本語法

第一個程式：helloworld！

helloworld幾乎是我們學習所有語言開始的第一個程式，
python如何去實作輸出helloworld呢？

print("helloworld")

不用printf！不用%s！不用分號！不用頭檔案！不用return 0 ！不用大括號！
輸入好之后，就可以運行，

python語法 - 基本資料型別

既然已經嘗試了輸出，我們當然還希望操作python的資料，下面我們就開始基本資料型別的學習，

1.1 變數的定義

變數的型別不需要宣告，使用的時候可以直接命名，
比如那我們剛剛的程式，我們在helloworld的輸出下面加一行

a = 4

然后我們對他進行輸出（ 不需要%d，不需要分號都可以不需要）

print(a)

就可以看到，程式正確的輸出了4，
python語言變數不需要提前宣告，也就是說，python語言中變數的型別是沒有規定的，
上一秒a還是整形，下一秒可以直接用字串來賦給他，a就變成了一個字串型別，

print("helloworld")
a = 4
print(a)
a = "helloworld"
print(a)

輸出為：
helloworld
4
helloworld

但是，這樣方便的python同樣有要求：那就是使用變數之前必須對該變數進行賦值，沒有賦值直接使用是不被允許的，
但是沒有賦值，卻用變數直接承接運算式是被允許的，

a = 4
b = 3
c = a + b
# 沒有對c進行初始化的情況下直接進行c = a + b 是允許的
# 井字號是python的單行注釋方法

1.2 連續賦值

python可以接受同時多個變數的賦值：

x, y, z = 1, 2, 3
a = b = 123

# 都是python語言允許的定義

1.3 python的基本輸入和輸出

python的輸出：print即可，print函式可謂來者不拒，不論要輸出整形浮點型雙精度字串串列集合等等等等，只要是變數，統統丟到函式當中即可，

數值型別可以直接輸出

#
print(1) 

字串型別可以直接輸出

#python的字串表達也非常簡單，但凡是用引號括起來的內容都是字串，都可以隨意輸出，
print("Hello World") 
#python中，為了方便輸入輸出的內容帶引號，字串的定義有四種方式：
a = "i love python!"
a = 'really!'
a = '''learning python is good for my hair!''' 
a = """人生苦短，我學python"""

一次輸出多個物件，物件之間用逗號分隔

a=1
b="Hello World"
print(a, b)

如果直接輸出字串，而不是用物件表示的話，可以不使用逗號

print("Duan""Yixuan")
print("Duan","Yixuan")
#運行結果如下：
#DuanYixuan
#Duan Yixuan
#可知，不添加逗號分隔符，字串之間沒有間隔

設定間隔符sep

print("www", "snh48", "com", sep=".")  # 設定間隔符
#運行結果如下：
#www.snh48.com

python的輸入同樣非常簡單，只需要input即可，不論輸入符號，數字，字母，都是允許的，

x = input()

練習

設定兩個整數變數a，b；鍵盤輸入a，b的值，列印出a+b
輸入：4 4
輸出：4+4=8

a=input()
b=input()
c=a+b
print(a,'+',b,'=',c)

這時候輸入4 4，列印的結果是4+4=44，這是為什么呢？
注意：這里input的所有內容都是字串型別，

print(type(x)) # 輸出x的型別，結果為：<class 'str'>

如果我們想進行“輸入x，計算x的平方”的程式應該怎么做呢？
這里提供兩種方法：

# 1.對x進行強制轉換 ： 
x = input()
x = int(x) * int(x)
print(x)

# 2.對輸入的內容進行去引號處理
x = input()
# eval去引號函式      在把引號去掉賦給變數之前，還會自動的根據括號的內容對變數的型別進行分配
print(type(eval(x)))
x = eval(x) * eval(x)
print(x)
# 如果輸入 5，則會輸出 int；如果輸入 5.5， 則會輸出  float；如果輸入[1， 2， 3]，就會輸出 list，等等
# 然而eval并不能拆字串

兩種方法都可以使用，但是我們平時使用eval函式更多一點
練習

a=input()
b=input()
c=eval(a)+eval(b)
print(a,'+',b,'=',c)

1.3.1 輸入輸出陳述句格式拓展

1. python允許在input括號內通過加字串的格式來對輸入內容進行描述

x = input("please input a integer:")
print(x)

2. python的print輸出函式自動計入回車，取消回車的方式是：

print("I don't want an enter",end='')
print("no enter")
# 實際上，end=做的事情是將等號后面的字串加到每一次輸出的末尾，默認為回車，

3. 此下，給出了其他可用的輸出格式，大家課后自己學習

#將輸出內容用雙引號括起來，變數用{}來表示，雙引號后呼叫format函式,format中變數用，隔開，
print("{} is a pig,{} is niubi".format("XXX","XXX"))  # 這樣輸出時，大括號的順序和format順序一一對應
print("{1} is a pig,{0} is niubi".format("XXX","XXX"))  # 這樣輸出時，大括號順序按照填寫內容進行對應
print("{:.2f}".format(12345.6789)) #format格式列印 小數點后2位
print("{:20f}".format(12345.6789)) #format格式列印 占20位字符

#1.填充對齊寬度
print("{0:~^20}".format(bstring))
#print("{0:           =        ^      20}".format("bstring"))      ^居中，>右對齊，<左對齊
   #      |           |         |      |       |      |
   #     引導符     填充物      居中   寬度    格式化  目標字串
print("{0:*>20}".format("bit"))
print("{:20}".format("aa"))  # 將aa放于左邊，自動補齊剩余空格
# 2.逗號(千分符，用于財務記賬)   點精度(浮點數小數精度或字串最大輸出長度，{:.2f})
#   型別
print("{:,.2f}".format(12345.6789))    # 1 .整數部分放置千分符分割；2.精度補為兩位

print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))  # 用二進制，Unicode編碼，十進制，八進制，大小寫十六進制表示括號內的數值

print("{0:e},{0:E},{0:f},{0:%}".format(3.14))  # 用小寫大寫的科學記數法表示，用通常的浮點數表示，用百分數表示

python語法 - 分支陳述句，回圈陳述句

2.1 分支陳述句

在進行python程式的撰寫時，應該格外注意格式的書寫，
因為python是沒有大括號的語言，所以能夠判斷python語段范圍的只有縮進，
python的分支運算式為：

if <陳述句段>:
	# 必須縮進，否則會報錯，而且只能縮進一次
	<陳述句段>

age=int(input("請輸入你的年齡:"))
if 0<=age<6:
    print("at a kindergarten")
elif 6<=age<=12:
    print("at primary school")
elif 12<age<=15:
    print("at a junior school")
elif 15<age<=18:
    print("at a high school")
else:
    print("be an adult")

我們來小小的實踐一下：
判斷輸入是否是偶數

a = eval(input())
if a % 2 == 0 :
	print('yes!')
elif a % 2 == 1:
	print('no!')
# 或者也可以直接else：

2.2for回圈陳述句

與分支陳述句相同，回圈陳述句中的縮進同樣非常重要，
python的回圈運算式為：

for <回圈判斷>:
	# 必須縮進，否則會報錯，而且只能縮進一次
	<陳述句段>

其中，回圈判斷的格式為：

	i in <范圍>

只要是能夠進行回圈遍歷操作的，都用 i in … 來修飾即可
這個范圍可以是一個串列（相當于c語言的陣列）：

list = [1, 2, 3]
for i in list:
	print(i)
	# 則i會遍歷整個串列

也可以是一個整數：

for i in range(45):# 則i會分別被賦值為0， 1， ...， 44
	print(i,end='  ')	

range函式
range(start, stop[, step])

range(10) # 從 0 開始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(1, 11) # 從 1 開始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(0, 30, 5) # 步長為 5
[0, 5, 10, 15, 20, 25]
range(0, -10, -2) # 負數
[0, -2, -4, -6, -8]

for i in range(10) :
    print(i)
for i in range(2, 10) :
    print(i)
for i in range(0, 10, 2) :
    print(i)
for i in range(0,-10,-2) :
    print(i)

2.3 while回圈陳述句

列印1到10的數字

x=1
while x<=10:
	print(x,end=' ')
	x+=1

練習
求1-2+3-4+5 … 99的所有數的和

s=0
for i in range(100) :
   if i % 2 ==0 :
       s-=i
   else:
       s+=i
print(s)

python語法 - 組合資料型別

3.1 集合

python的集合概念與數學概念上的集合非常相像，就是一群有相同意義的資料的集合，在python中常用于資料去重，
python的語法表達中，集合的表達形式為：大括號{}

b = 2
a = {1, 'python', b}
# 集合來者不拒，大多數資料型別都可以直接包含到集合當中

集合中不能有相同的元素.如果出現相同的元素，集合會直接將相同的其他項洗掉，只保留一項，而且，當集合中包含變數時，集合會直接判斷變數的內容是否與集合內容重復，集合沒有順序

以下給出集合的操作，同學們課后掌握

#-------------------------集合運算子-------------------------#
c = {1,2,3,4,5} ; d = {4,5,6,7,8}
#1.求并集: |
print('1.1 ',c|d)
#2.求集合的差(取前不取后): -
print('1.2 ',c-d)   #輸出包含在c中但不在d中的元素
#3.求交集: &
print('1.3 ',c&d)
#4.求兩集合中不同的元素: ^
print('1.4 ',c^d)
#5.比較兩個元素的包含關系
print('1.5 ',c>=d)
e = {1,2,3}
print('1.6 ',c>=e)
#-------------------------增強運算子-------------------------#
c |= d  #更新集合c，包括c，d中的所有元素
print('2.1 ',c)
c -= d  #同上，講c，d運算過后的結果賦值給c
print('2.2 ',c)

#------------------------集合處理方法------------------------#
c = {1,2,3,4,5}
#!! 1.如果x不在集合中，將x增加到c
c.add(6)
print('3.1 ',c)

c = {1,2,3,4,5}
#!! 2.如果x在集合中，移除x; 如果x不在集合中，不報錯
c.discard(5)
print('3.2 ',c)

c = {1,2,3,4,5}
#!! 3.如果x在集合中，移除x;如果x不在集合中，報錯
c.remove(5)
print('3.3 ',c)

c = {1,2,3,4,5}
#!! 4.移除所有元素
c.clear()
print('3.4 ',c)

c = {1,2,3,4,5}
#5.為用戶隨即回傳一個集合中的元素并且在幾何中洗掉這個元素，如果集合為空則報錯
f = c.pop()
print('3.5 ',f,c)

c = {1,2,3,4,5}
#6.回傳一個集合的副本
d = c.copy()
print('3.6 ',d)

c = {1,2,3,4,5}
#!! 7.回傳集合元素個數
f = len(c)
print('3.7 ',f)

c = {1,2,3,4,5}
#!! 8.判斷x是否在集合中
a = 5 in c
print('3.8 ',a)

c = {1,2,3,4,5}
#9.判斷x是否不在集合中
a = 5 not in c
print('3.9 ',a)

c = (1,2,3,4,5,5,5)
#10.將其他型別轉化為集合型別
c = set(c)
print('3.10 ',c)

練習
集合a={5，6，4，8，9}
b，c為兩個變數，用戶輸入決定其內容
將b添加到集合a中，如果集合a中包含變數c，將c從集合a中洗掉

a = {1,2,3,4,5}
b=input("請輸入b的值")
c=input("請輸入c的值")
a.add(eval(b))
a.discard(eval(c))
print(a)

3.2 串列

串列的概念非常接近于我們C/C++中的陣列，它的內容可以重復，有固定的順序，串列定義只需要中括號即可，用逗號分隔

a = [1, 2, 'hello!']
# 或者可以用下面的方法快速定義
b = [i for i in range(10)]

對于串列a，我們有可以對其進行遍歷，也可以訪問串列的下標

a = [1, 2, 'hello!']
#遍歷串列
for i in a:
	print(i)
#訪問下標
for i in range(len(a)):
	print(a[i])

這里給出list的操作，希望大家不要嘗試全部背誦，可以把這篇博客當作百科書，隨用隨查

len(a)  # 回傳串列元素個數
a.append('dove')  # append用于單個元素的加入,在最后添加
a.insert(0,'hello')  # insert的兩個引數：要插入的順序，要插入的內容

a.extend(['i','love','dove']) # extend用于整個串列的加入
a.index(123)  #從第一個元素遍歷，輸出第一次出現123這個元素的位置
a.index(123,1,3)  #從第一個到第三個元素中，第一次出現123這個元素的位置
a.count(123)  # 序列中出現123的次數

a.sort()  # 排序 從小到大
a.reverse() # 逆序輸出
a.clear()  # 清空串列
del a[2]  # 指定洗掉a下標為2的元素

練習
輸出商品串列，用戶輸入序號，顯示用戶選中的商品，
商品 li = [“手機”, “電腦”, “滑鼠墊”, “游艇” ]
a. 允許用戶添加商品
b. 用戶輸入序號顯示內容

li = ["手機", "電腦", "滑鼠墊", "游艇" ]
mer = input("請輸入您想加入的商品:")
li.append(mer)
print("商品現有",li)
wan = int(input("請輸入序號："))
print(li[wan])

3.3 元組

元組就是不能夠修改的list，一般很少使用，下面給出方法

#將一些值用逗號分隔
a=1,2,3
print(a)

#常用做法 小括號
a=(1,2,3)

#呼叫函式tuple:它將一個序列作為引數，并將其轉換為元組
a=tuple([1,2,3])
b=tuple("abc")
print(a,b,sep='\n')

#特殊情況：表示只包含一個值的元組
a=42,
b=(42,)
print(a,b,sep='\n')

3.4 字典

字典型別是很特殊的一種型別，它的元素是一對資料，也可以叫一組關系 用大括號{}
每一個元素表示為 <鍵>:<值>元素之間用逗號隔開，
我們在知道鍵的情況下，可以通過索引找到對應的值

zidian = {'outside':'green','inside':'blue'}
print(zidian['outside'])

同樣，在C/C++中對陣列的操作，在python中對list的操作同樣可以類比，只不過在表達上有些許區別而已，以下給出字典的操作

#字典型別操作函式和方法
dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('0.最初定義的字典變數',dic)
del  dic[1]
print('1.洗掉第一項',dic)
print('2.判斷鍵“1”是否在字典中(已在上一步洗掉)',1 in dic)

dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('3.回傳所有鍵的資訊',dic.keys())
print('4.回傳所有值的資訊',dic.values())
print('5.回傳所有鍵值對的資訊',dic.items())

dic = dict(((1,'mcx'),(2,'zyc'),(3,'ch'),(4,'ylx'),(5,'ljw'),(6,'wb'),(7,'dsp')))   
print('5+.利用dict創建一個字典',dic)
print('6.若存在該鍵,則回傳對應的值，否則回傳<default>',dic.get(6,'wb'))
print('7.若存在該鍵,則去除并回傳對應的值，否則回傳<default>',dic.pop(6,'wb'))
print('8.隨機取出一個鍵值對并以元組形式回傳',dic.popitem())

print('9.洗掉所有鍵值對',dic.clear())
dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('10.回傳字典元素個數',len(dic))

字典型別在進行對應資料處理時非常重要，但對于前期學習的同學們，能夠熟練掌握list就已經足夠，因為list就是C/C++陣列的超級加強版
練習
將這三個字典都存盤在一個名為 people 的串列中，
a={‘name’:‘laosun’,‘phone’:13032435356,‘sex’:1}
b={‘name’:‘laozheng’,‘phone’:13038659870,‘sex’:1}
c={‘name’:‘laosong’,‘phone’:13032867908,‘sex’:2}
遍歷這個串列，將其中每個人的所有，資訊都列印出來，
輸出第一個人的名字，第二個人的電話號碼，第三個人的性別

people=[]
a={'name':'laosun','phone':13032435356,'sex':1}
b={'name':'laozheng','phone':13038659870,'sex':1}
c={'name':'laosong','phone':13032867908,'sex':2}
people.append(a)
people.append(b)
people.append(c)
print(people)
for k in people:
    print(k)
people[0]['name']    
people[1]['phone']
people[2]['sex']

python語法 - 字串

考慮到字串的重要地位，以及python中字串的特殊形式，我們字串單獨拿出來講，

4.1 字串的定義

字串的定義我們在最上面就已經解釋過，直接利用單引號/雙引號/三連單引號，雙引號括起來，就已經做好了一個字串，python的字串非常“寬松”，即，基于python的保護機制，在使用字串時完全不用考慮越界，超范圍等等C語言中很麻煩的問題

a = 'I love esta'
b = ' I love'
print(a + b) # 如果想進行字串連接的操作，直接 + 就可以

4.2 字串的各種操作

在C語言中，字串其實是利用陣列去模擬的一種便捷陣串列達，而python中，字串更像一個變數，因此對字串的操作十分自由，

a = 'I love esta'
b = 'I love'
print(a + b) # 上文已經講過，加法代表兩個字串連接
c = '人類的本質是復讀機'
print(c*5) # 直接乘法代表字串重復多少次
d = '人類'
print(d in c) # 利用in判斷d是否是后者的子串

a.upper()  # 將字串的所有字母改為大寫
a.lower()  # 將字串的所有字母改為小寫 
a.split(' ') # 將字串根據括號內的內容-分隔開，回傳保存在串列中
a.count('e')
a.replace('esta','Esta')

除了字串整體的操作，python還支持字串的切片，

a = 'I love esta'
print(a[0])  # 回傳第一個字符
print(a[-1]) # 回傳最后一個字符
print(a[3:6])# 獲取字串切片，左閉右開
print(a[1:9:2])  #指從第一位開始，到第九位之前，每隔兩個取一個
print(a[::-1])  #字串的逆序

fstring="esta"
print(fstring.center(20,"="))  #將目標字串放在寬度為20的居中位，其余用=填充
print("|".join(estring))  #將目標字串夾在join括號內字串的出最后一位的字符后邊

python語法 - 函式

python的函式定義同樣十分簡單，python定義函式時，不需要考慮參量的型別，回傳值型別等等問題，直接使用def就可以定義函式；同樣，函式必須縮進，

def hello():     #引數括號中可以寫入你的引數
    print('hello!')
        
def hello2(a):   #這里我們想要調入一個串列，但我們不用事先說明他是個串列
    print(a)
    
hello2([1,2,3]) # 當然也是沒有任何問題的
hello2("hi,I'm a string!") #字串也沒有問題
#回傳引數的函式
def add(a,b):
	return a+b
add(4,4)
# 雖然python很好用，但是要注意，你傳入的內容應該符合函式的操作！

此外，python還接受這樣的操作：

def hello(name,greeting='Hello',punctuation='!'):#提前定義變數的值
    print('{},{}{}'.format(greeting,name,punctuation))
hello('python','Hi','^_^')
hello('python',punctuation='^_^')
hello('python',greeting='Glad to see you')


#星號收集余下的位置引數并存放在一個元組中
def print_params1(title,*params):
    print(title,end=' ')
    print(params)
print_params1('Params:',1,2,3)   

#收集關鍵字引數需要**,得到的為一個字典
def print_params2(**params):
    print(params)
print_params2(x=1,y=2,z=3)
#1、拆分序列*
def add(x,y):
    return x+y
params=1,2
print(add(*params))

def mutiply(x,y,z):
    return x+y*z
params1=[2,3]
print(mutiply(1,*params1))   #星號部分必須位于引數串列末尾

#2、拆分字典**
def hello(greeting="Hello",name='World'):
    print(greeting+',',name)
dic={'name':'MMS','greeting':'Glad to see you'}
hello(**dic)

參考文獻：Magnus Lie Hetland. Python基礎教程（第3版）. 人民郵電出版社