1. 基本数据类型

一、整型

    在python3中只有int，包含了long；而python2中有long类型。python2中是没有布尔类型的，它用0表示false，用1表示true。到python3中，把true和false定义成关键字，但他们值还是1和0。可和数字相加。
 

1. 案例
    (1)将i转换为二进制，统计最小有效位数
    i = 128
    i.bit_length()
    结果：128 - 10000000 -> 8
         20  - 10100 -> 5
      
2. 内置type()函数可以查看数据类型
    (1)解包操作
    a, b, c, d = 10, 5.5, true, 4+3j
    >>> <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
  
3. isinstance 判断数据类型
    a = 111
    isinstance(a, true)
    >>>true
    
4. isinstance 和 type()区别
    (1)type() 不会认为子类是一种父类类型
    (2)isinstance() 会认为子类是一种父类类型
   
5. isinstance类中使用
    >>> class a:
    ...     pass
    ...
    >>> class b(a):
    ...     pass
    ...
    >>> isinstance(a(), a)
    true
    >>> type(a()) == a
    true
    >>> isinstance(b(), a)
    true
    >>> type(b()) == a
    false

二、浮点型

1. 定义
    python提供了三种浮点值：内置的 float、complex；标准库得decimal.decimal类型。float存放双精度浮点数，受精度限制，进行相等性比价不可靠。
    科学计数：10 用e代替   1.23e10    0.000012——>1.2e-5。 整数和浮点数在计算机存储方式不同，int永远是精确的

2. 案例
    
    (1)自定义精度，导入标准库
    from decimal import *
    getcontext()
    getcontext().prec = 50
    a = decimal(2) / decimal(3)
    print(a)
    结果：
    0.66666666666666666666666666666666666666666666666667

三、布尔型

1. 相关类型转换
    str  => int       int(str)        
    int  => str       str(int)        
    int  => bool      bool(int).  0是false 非0是true        
    bool => int       int(bool)   true是1, false是0        
    str  => bool      bool(str)  空字符串串是false,  不空是true        
    bool => str       str(bool)  把bool值转换成相应的"值"

2. 总结
    (1)想要转化成什么类型就用这个类型括起来    
    (2)true => 1 | false => 0    
    (3)可以当做false来用的数据: 0 "" [] {} () none

四、字符串

1. 字符串操作

1. 注意点
    字符串进行修改时候, upper/lower/replace 操作后都需要将修改后的值赋值给原始对象,才可以把原来的字符串进行修改;因为字符串是不可变数据类型

2. 相关操作

实例: my_string = 'hellp niux join'
    
(1)大小写转换
    print(my_string)
    print(my_string.swapcase())
    结果:
    hellp niux join
    hellp niux join

(2)首字母大写
    print(my_string.capitalize())
    结果:hellp niux join

(3)居中空白填充
    print(my_string.center(20, '-'))
    结果:--hellp niux join---

(4)全部字母大写
    print(my_string.upper())
    结果:hellp niux join

(5)全部字母小写
    print(my_string.lower())
    结果:hellp niux join

(6)判断是否全部是大写字母
    print(my_string.isupper())
    结果:false

(7)判断是否全部是小写字母
    print(my_string.islower())
    结果:false

(8)每个用(特殊字符或数字)隔开的单词首字母大写
    print(my_string.title())
    结果:hellp niux join
    
(9)全部小写字母小写,与lower类似;但一些非英文字符也可变为小写
    print(my_string.casefold())
    结果:hellp niux join

(10)判断是以xxx结尾的
    print(my_string.endswith('join'))
    结果:true

    还可以切片,判断从[]1-10)这段里是否以i结尾
    my_string.endswith('i', 1,10)
    
(11)判断是以xxx开头的
    print(my_string.startswith('fj'))
    结果:false
    my_string.startswith('i', 1,10)

(12)判断字符串中是否含有空白; 空白->空白符包含：空格、制表符(\t)、换行(\n)、回车(\r）等
    a. 如果字符串中只包含空格,则返回true,否则false
    b. 实例
        str = "     "
        str.isspace() - true
        str = "run example" - false
    c. print (' \t\r\n'.isspace()) # true
       print ('\0'.isspace()) # false
       print (' a '.isspace()) # false
    d. 空字符串不算空白
       >>> print("".isspace())  false

(13)判断字符串中是否含有数字
    print(my_string.isdigit())
    结果:false

(14)判断字符串是否由字母组成;如果字符串至少有一个字符并且所有字符都是字母则返回 true,否则返回 false
    str = "runoob"
    print (str.isalpha())
    结果:true

    str = "runoob example....wow!!!"
    print (str.isalpha())
    结果:false

    汉字也返回true
    >>> str = '哈哈'
    >>> print(str, str.isalpha())
    >>> true

(15)如果 string 至少有一个字符并且所有字符都是字母或数字则返回 true,否则返回 false
    str = "runoob2016" # 字符串没有空格
    print (str.isalnum())
    true

    str = "www.runoob.com"
    print (str.isalnum())
    false

(16)判断只包含十进制字符;这种方法只存在于unicode对象中
    str = "runoob2016"
    print (str.isdecimal())
    false
    
    str = "23443434"
    print (str.isdecimal())
    true

(17)返回指定长度的字符串,原字符串右对齐,前面填充0
    s = '101'
    print(s.zfill(8))
    结果:00000101

(18)返回指定长度的字符串,原字符串右对齐,前面填充自定义字符
    s = '101'
    print(s.rjust(8,'+'))
    +++++101
(19)返回指定长度的字符串,原字符串左对齐,前面填充自定义字符
    s = '101'
    print(s.ljust(8,'+'))
    101+++++

2. 字符串切片

1. 切片
    my_str = "python?伟大的蟒蛇语言"
    my_str[0] -> 'p'
    my_str[100] -> indexerror: string index out of range
    my_str[-1] -> -1表示倒数第一个; 言
    my_str[-2] -> -2表示倒数第二个; 语

2. 语法(切片是左闭右开)
    str[ start : end : step]   # 从start开始截取. 截取到end位置. 但不包括end,step是步长（默认是1：从左往右；-1从右往左）
    my_str[0:3] ->不包含索引3的值    'pyt'
    my_str[4:]  ->表示从索引4-切到最后    'on?伟大的蟒蛇语言'
    my_str[-1:-5] -> 空字符串; 原因:这个步长还是 1 说明向有切,但是右边不存在-5
    my_str[-1:] -> 同上,步长为 1 只能获取索引 -1 的值 '言'
    my_str[-5:] -> 的蟒蛇语言
    my_str[:-1] -> 从第一个取到倒数第一个(不包含)  'python?伟大的蟒蛇语'
    my_str[:] -> 原样输出
    my_str[1:5:2] ->从第一个开始取, 取到第5个,每2个取1个;1:5=> ytho => yh     1, 1+2  'yh'
    my_str[:5:2] -> 从头开始到第五个. 每两个取一个 'pto'    
    my_str[-1:-5:-1] ->步长是-1. 这时就从右往左取值了; '言语蛇蟒'
    my_str[-5::2] -> '的蛇言'
    my_str[-5::-3] -> 从倒数第5个开始. 到第一个. 每3个取一个, '的?hp'

3. 反转字符串
    str_new = '12345'
    str_rev = str_new[::-1]
    结果: '54321'

3. 字符串关键

1. len()
    - 返回对象（字符、列表、元组等）长度或项目个数
    my_str = "python?伟大的蟒蛇语言"
    print(len(my_str))
    >>>14

2. find()    - 找不到返回 -1
    - 检测字符串中是否包含子字符串 str
    
    语法:str.find(str, beg=0, end=len(string))
        -str 指定检索的字符串
        -beg 开始索引,默认0
        -end 结束索引,默认字符串长度
    语法:str.rfind(str, beg=0, end=len(string))
        -用法与str.find一致，这个得到的是结束的(最大的)索引值
    
    (1) 案例
        my_str = "great minds have purpose,others have wishes minds"
        print(my_str.find('minds'))
        结果: 6 (返回字符串中第一个被找到字符串的第一个元素索引)
        
        print(my_str.find('a', 5, 10)) # 从5-10元素开始查a; -1
        
        print(my_str.rfind('minds',1)) # 从索引1->末尾  显示最后一个字符串的第一个元素索引 46

3. index()    - 找不到报错
    - 检查字符串中是否包含子字符串 str
    
    语法:str.index(str, beg=0, end=len(string))
    - 找不到抛出异常:valueerror: substring not found
    my_str.index('english')

4. strip()   - 默认去除空白 \t \n \r 空格
    - 移除字符串头尾指定的字符（默认为空格）或字符序列;注意,该方法只能删除开头或是结尾的字符，不能删除中间部分的字符;strip() 处理的时候，如果不带参数，默认是清除两边的空白符

    (1)案例
    my_str = "   hello   "
    print(my_str.strip())    -> 'hello'

    my_str = "+++hel+++lo+++"
    print(my_str.strip('+'))    -> 'hel+++lo'

    addr = '[e-mail]'
    addr1 = addr.strip('12') 
    解析:以上例子因为 1 在 [e-mail] 的左边第一个，所以删除了继续判断，2 也存在，所以也删除。
    结果为:[e-mail]

    addr = '[e-mail]'
    addr1 = addr.strip('23') 
    解析:此时 2 不是第一个字符，所以无法继续
    结果为：[e-mail]
    
    s2 = '*f*jei%'
    print(s2.strip('*%'))
    解析:从左侧检索* 在'*%'中删.中间跳过;右侧% 也在'*%'中删
    
    s2.lstrip('*')    # f*jei%
    s2.rstrip('%')    # *f*jei

5. count()    
    - 统计字符串中某个字符出现的次数
    
    语法:str.count(sub, start= 0,end=len(string))

    (1)案例
    my_str = 'www.runoob.com'
    print(my_str.count('o'))     -> 3
    
    my_str = 'www.runoob.com'
    print(my_str.count('run'))    -> 1; 它是以 'run'整体去查询

6. replace()
    -把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max,则替换不超过 max 次
    
    语法:str.replace(old, new[, max])
    -返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次
    -old -- 将被替换的子字符串。
    -new -- 新字符串，用于替换old子字符串。
    -max -- 可选字符串, 替换不超过 max 次

    (1) 案例
    str = "www.w3cschool.cc"
    print ("菜鸟教程旧地址：", str)
    print ("菜鸟教程新地址：", str.replace("w3cschool.cc", "runoob.com"))
    str = "this is string example is ....wow!!!"
    print(str.replace("is", "was")) # 不加参数，全部替换
    print (str.replace("is", "was", 2)) # 替换前两个
    /结果：
    菜鸟教程旧地址： www.w3cschool.cc
    菜鸟教程新地址： www.runoob.com
    thwas was string example was ....wow!!!
    thwas was string example....wow!!!

    (2)去除字符串中的全部空白
    s.replace( ' ', '' )

7. split()     - 获得的是一个列表
    split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串；python split() 方法通过指定分隔符对字符串进行分割并返回一个列表，默认分隔符为所有空字符，包括空格/换行/制表符

    语法:str.split([sep=none][,count=s.count(sep)])
    -sep -- 可选参数，指定的分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
    -count -- 可选参数，分割次数，默认为分隔符在字符串中出现的总次数
    -返回分割后的字符串列表

    (1) 案例
    st0= '   song    huan     gong    '
    print(st0.split())    -> ['song', 'huan', 'gong']

    st0= 'ihelloiwordi' 
    解析:分隔符 i 在字符串中出现3次，ps:也就是i是刀切3次蛋糕，形成4个部分，左右没有字符以''表示
    print(st0.count('i'))    -> 3
    print(st0.split('i'))    -> ['', 'hello', 'word', '']

    s = '<a href="www.test.com">test</a>'
    s2 = s.split('"')[1] 
    解析:以"为分隔符取，形成的列表取出索引为1的值，就取出了'www.test.com'
    print(s2)    -> www.test.com

8. join()    - 拼接列表/元组可得到字符串
    join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
    
    语法:str.join(sequence)
    
    (1) 案例
    s1 = '-'
    lst = ['a','b']
    s_new = s1.join(lst)    ->a-b

    s1 = ''
    lst = ['a','b']
    s_new = s1.join(lst)    ->ab

4. 字符串格式化

1. format
    格式化输出，基本语法是通过 {} 和 : 来代替以前的 % ,format () 函数可以接受不限个参数,位置可以不按顺序
    (1)s ='我叫{}，今年{}，爱好{}，再说一下我叫{}'.format('太白',36,'女','太白')
    (2)s ='我叫{0}，今年{1}，爱好{2}，再说一下我叫{0}'.format('太白',36,'女') 
    (3)name = input("please input your name:")
       s ='我叫{name}，今年{age}，爱好{hobby}，再说一下我叫{name}'.format(name = name,age = 36,hobby = '女')

2. %    - %s,匹配一切类型
    s = 'hello'
    x = 5
    "the length of %s is %d" % (s,x)
    
    s = "i'm%s,i am %d"%{'name' = 'libai', 'age' = 19}

3. f'hello'
    name = python
    str_new = f"hello {python}"

5. 字符串编码

    在python2中，普通字符串是以8位ascii码进行存储的，而unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在python3中，所有的字符串都是unicode字符串。

1. bytes.decode()
    decode() 方法以指定的编码格式解码 bytes 对象.默认编码为 'utf-8'
    (1)语法
        bytes.decode(encoding="utf-8", errors="strict")
    (2)参数
        -encoding -- 要使用的编码,如"utf-8"
        -errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个unicodeerror。
        其他可能的值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
    (3)案例
    str = "菜鸟教程";
    str_utf8 = str.encode("utf-8")
    str_gbk = str.encode("gbk")
    print(str) -> 菜鸟教程
    print("utf-8 编码：", str_utf8) 
    >>>utf-8 编码： b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'
    print("gbk 编码：", str_gbk)
    >>>gbk 编码： b'\xb2\xcb\xc4\xf1\xbd\xcc\xb3\xcc'
    print("utf-8 解码：", str_utf8.decode('utf-8','strict')) 
    >>>utf-8 解码： 菜鸟教程
    print("gbk 解码：", str_gbk.decode('gbk','strict')) 
    >>>gbk 解码： 菜鸟教程


2.str.encode()
    encode() 方法以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案
    (1)语法
        str.encode(encoding='utf-8',errors='strict')
    (2)参数
        -encoding -- 要使用的编码,如: utf-8
    (3)案例
    str = "菜鸟教程";
    str_utf8 = str.encode("utf-8")
    str_gbk = str.encode("gbk")
    print(str) -> 菜鸟教程
    print("utf-8 编码：", str_utf8)
    >>>utf-8 编码： b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'
    print("gbk 编码：", str_gbk)
    >>>gbk 编码： b'\xb2\xcb\xc4\xf1\xbd\xcc\xb3\xcc'
    print("utf-8 解码：", str_utf8.decode('utf-8','strict'))
    >>>utf-8 解码： 菜鸟教程
    print("gbk 解码：", str_gbk.decode('gbk','strict')) 
    >>>gbk 解码： 菜鸟教程

6. 字符串进制转换

1. 进制转换
    >>> num=10
    >>> print('十六进制：%#x' % num)    #使用%x将十进制num格式化为十六进制
    十六进制：0xa
    >>> print('二进制:', bin(num))      #使用bin将十进制num格式化为二进制
    二进制: 0b1010
    >>> print('八进制：%#o' % num)      #使用%o将十进制num格式化为八进制
    八进制：0o12
    
2. 上面使用格式化符号进行进制转换中，多加入了一个#号，目的是在转换结果头部显示当前进制类型，如不需要，可将#号去除
    >>> print('八进制：%o' % num)
    八进制：12
    >>> print('十六进制：%x' % num)
    十六进制：a
    
3. 字符串分割 - partition()
    s1 = "i'm a good sutdent." # 以'good'为分割符，返回头、分割符、尾三部分
     ("i'm a ", 'good', ' sutdent.')
        
4. 统计个数,返回字典类型
    from collections import counter
    var2 = "1987262819009787718192084951"
    print (counter(var2))
    counter({'1': 5, '9': 5, '8': 5, '7': 4, '2': 3, '0': 3, '6': 1, '4': 1, '5': 1})
    
5. ip掩码换算
    b = '1'
    bs_len = len(b)
    while bs_len < 9:
        #global b
        b_b = b.ljust(8,'0')
        d = int(b_b,2)
        print('二进制 %s 相当于十进制 %s' %(b_b,d))
        b = b +"1"
        bs_len = len(b)
    二进制 10000000 相当于十进制 128
    ...
    
6. 字符串<->列表
    (1)字符串->列表
    var='菜鸟教程'
    list = []
    list = [i for i in var]
    
    (2)列表->字符串
    var1 = ' ,'.join(list)
    
    (3)字符串->元组
    tup = tuple(var)