• Python基本資料型別
  ===============

Python是一種弱型別的程式語言，所以無需在建立變數的時候指定資料型別，但是Python也有資料型別，在進行資料處理的時候就特別需要資料型別的判定。

print(type(123)) #<class 'int'> 整型
print(type(123.123)) #<class 'float'> 浮點型
print(type(123.)) #<class 'float'>浮點型
print(type('asd')) #<class 'str'> 字串型別
print
 
(type([1,2,3,4,'a'])) #<class 'list'> list型別
print(type((1,'asdas'))) #<class 'tuple'> tuple型別
print(type(set([1,23]))) #<class 'set'> set型別
print(type({'a':1,'b':2})) #<class 'dict'> dict型別

int, float和Java中的int, float型別一致，str相當於Java中的Sting型別，list， set相當於Java中的List，Set, 而tuple則和list型別相似，只是不能夠進行修改，dict相當於Java中的Map。Set可以用於過濾相同的資料，不會儲存相同的資料。

def func(a,b,c):
    print(a,b,c)
print(type(func)) #<class 'function'> 函式型別

class MyClass(object):
    pass
print(type(MyClass)) # <class 'type'> type型別
myClass = MyClass()
print(type(myClass)) # <class '__main__.MyClass'> MyClass型別

type()也可以判斷是否是函式型別，建立的類的型別是type型別，而類例項化之後的物件的型別則是該類。

注意事項：

• 如果顯示的資料中有單引號/雙引號，可以外邊包裹雙引號/單引號以此顯示，也可以用轉義字元進行顯示

• 如果換行符不利於讀程式碼，則可以用開始和結束分別三個單引號或者雙引號來進行換行

• 運算操作
  =====
  Python也像其他語言一樣有+、-、*、/、%，但是Python也有它特殊的操作符，//表示整除，所得的結果必定是個整數

• 字串的相關操作
  ==
  Python在文字處理要求很高，所以必須掌握文字處理的相關操作，而字串的處理更是首當其衝，Python也和其他語言一樣都封裝了一些方法進行字串的處理

• 去除空格

import string
# 去除空格
s = '  asdasd  asdasd  '
print(s.strip()) #asdasd  asdasd 去除兩邊的空格
print(s.lstrip()) #asdasd  asdasd 去除左側的空格
print(s.rstrip()) #  asdasd  asdasd去除右側的空格
print(s)		#  asdasd  asdasd 

• 字串的連結

# 字串的連結
s1 = 'asdasd'
s2 = 'asdsadsda'
print(s1 + s2) #asdasdasdsadsda

• 大小寫

# 大小寫
s = 'asdsasd dsDd'
print(s.upper()) #ASDSASD DSDD 全部轉化為大寫
print(s.upper().lower()) #asdsasd dsdd 全部轉化為小寫
print(s.capitalize())	#Asdsasd dsdd 首字母大寫

• 位置比較

# 位置比較
s1 = "asdsadasda"
s2 = "asdasdsad123"
print(s1.index('sd')) #1
try:
    print(s2.index('sdd'))
except ValueError:
    pass
# pythoin3裡面的cmp函式被移除
print(s1 == s2) #False
print(s1 < s2) #False
print(s1 > s2) #True
# 字串的長度
s = ''
if not s:
    print("Empty") #Empty
    
print(len(s1)) #10

• 字串的分割和連結

# 字串的分割和連線
s = 'asdasd,asd,asd,asd'
s1 = """"asdasd
asda
asdas
asdsa"""
splitted = s.split(',')
# 按照換行符分割字串
print(s1.split('\n'))
# 按行分割
print(s1.splitlines())
print(type(splitted))
print(splitted)
# 以分隔符#連結
print('#'.join(splitted))
# 判斷是否以某個字串開頭
print(s.startswith('a'))
# 判斷是否以某個字串結束
print(s.endswith('a'))
# 常用判斷
#  判斷是否是字元和數字
print('13221asdsas'.isalnum())
print('\tasdas123'.isalnum())
#  判斷是否是隻含有字母
print('asdasd'.isalpha())
print('a123sdasd'.isalpha())
#  判斷是否只含有數字
print('123213'.isdigit())
#  判斷是否只有空格
print('   '.isspace())
#  判斷是否都是小寫 數字不算
print('aasdasd1231'.islower())
#  判斷是否都是大寫  數字不算
print('AASAS123'.isupper())
print('AASAS123asdas'.isupper())
#  判斷首字母是否是大寫
print('Asdasd'.istitle())

• 數字到字串

# 數字到字串
print(str(123))
print(str(231.123))
print(str(-1232))
print(str(-2312.123))
print(str(5.))

• 字串到數字

# 字串到數字
print(int('12321'))
print(float('1231.123'))
#  必須自己指定好型別 否則報錯ValueError
#   print(int('1232.1231'))
#  可以直接轉換為某個進位制
print(int('1111111111',2))

-單詞反轉

例如：已知字串是" I Love You " 反轉之後的是" You Love I "

# 單詞位置反轉  --略有缺陷空格不好處理
s = ' I Love China!  '
splitted = s.split(" ") 
print(len(s)) 
afterData = "" 
for i in range(0,len(splitted)): 
    if i == (len(splitted) - 1):
        afterData += splitted[len(splitted) - 1 - i]
    else:
        afterData += splitted[len(splitted) - 1 - i] + " "
print(len(afterData))
print(s)
print(afterData)

更好的處理方法：把相應的單詞進行反轉，然後再把整個句子反轉

def reverse(str_list, start, end):
    while start < end:
        str_list[start], str_list[end] = str_list[end], str_list[start]
     
        start += 1;
        end -= 1;
        
setence = " Hello World   , fine  !"
str_list = list(setence)

i = 0;
while i < len(str_list):
    if str_list[i] != ' ':
        start = i;
        end = start + 1;
        while (end < len(str_list)) and str_list[end] != ' ':
            end += 1;

        #  因為判斷的是下一位是不是‘ ’所以需要end - 1
        reverse(str_list, start, end-1)
        i = end
    else:
        i += 1;
reverse(str_list, 0, len(str_list)-1)
print(setence)
print(''.join(str_list))

-條件判斷（if/elif/else）

Python的if/else和其他語言相似，但是else if 則可以省略為elif。

# if判斷 elif
a = 100;
b = 200;
c = 300;
if c == a:
    print(a)
elif c == b:
    print(b)
elif c == c:
    print(c)
# None判斷
x = 1;
#  is 和 == 都行但是推薦is 如果不是None 可以用not  也可以是!=  is not None
if x is None:
    print("X is None");
if x != None:
    print("X is not None")
# 空值可False等價
x = ""
if not x:
    print('X = ""')

-傳參問題

• 可變引數(一元陣列list、tuple型別)

# 可變引數 *number 是一個tuple--元組 相當於只讀的陣列
def func(name, *numbers):
    print(name)  # Tom
    print(type(numbers)) # <class 'tuple'>
func('Tom',1,2,3,4)

• 可變引數（dict字典型別）

 # 傳入可變引數是字典 dict 可變引數只能在最後
def func(name, **kvs):
    print(name);  # Tom
    print(type(kvs)); # <class 'dict'>
    print(kvs) # {'china': '北京', 'uk': 'London'}
func("Tom",china = "北京", uk = "London") 

def func(name, *number, **kvs):
    print('name:',name)
    print('number:',number)
    print('kvs:',kvs)
    print("----------------------")
func(1)
func(1,2)
func(1,2,3,4)
func(1,china="北京")
func(1,2,3,4,china="北京")
>>> name: 1
	number: ()
	kvs: {}
	----------------------
	name: 1
	number: (2,)
	kvs: {}
	----------------------
	name: 1
	number: (2, 3, 4)
	kvs: {}
	----------------------
	name: 1
	number: ()
	kvs: {'china': '北京'}
	----------------------
	name: 1
	number: (2, 3, 4)
	kvs: {'china': '北京'}
	----------------------

• 函式作為引數

# 函式也可以作為引數
def cmp(x, y, cp = None):
    if cp:
        cp(x, y);
    else:
        print(x, y)
def cp(x, y):
    if x > y:
        print(x)
        return x;
    else:
        print(y)
        return y;
cmp(1,2)  # 1 2
cmp(1,2,cp) # 2