欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

1. 基本数据类型

程序员文章站 2022-06-17 11:08:37
一、整型 二、浮点型 三、布尔型 四、字符串 1. 字符串操作 2. 字符串切片 3. 字符串关键 4. 字符串格式化 5. 字符串编码 6. 字符串进制转换 ......

一、整型

    在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 = '123@163.com'
    addr1 = addr.strip('12') 
    解析:以上例子因为 1 在 123@163.com 的左边第一个,所以删除了继续判断,2 也存在,所以也删除。
    结果为:3@163.com

    addr = '123@163.com'
    addr1 = addr.strip('23') 
    解析:此时 2 不是第一个字符,所以无法继续
    结果为:123@163.com
    
    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

1. 基本数据类型

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)