• 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