zoukankan      html  css  js  c++  java
  • Python笔记—基本数据类型—数字&字符串

    数字    int   # 整型 所有的功能,都在int里
            a = 123
            v = a.bit_length()   # 软件自带函数联想
            print(v)
    
            - int
                将字符串转换成数字
                a = '123'
                print(type(a),a)     # type 显示为类型
                b = int(a)     # 把字符串转换成数字
                b = b + 1000   # 转换成数字后可运算
                print(type(b),b)     # 即显示类型,又显示值
    
            - bit_length(self)       # 所有self都可以不输入
                当前数字的二进制数值的位数
                # 1  1
                # 2  10
                # 3  11
                # 4  100
                # 5  101
                # 当前数字的二进制至少用几位来表示
                r = age.bit_length()
    
        字符串  str
            - def capitalize(self)
                首字母变大写
                a = 'alex'
                v =  a.capitalize()
                print(v)
                # 返回结果  Alex
    
            - def center(self,  int, fillchar: unicode = ...) 
                在总长度为windth的范围内,居中显示self,fillchar空白处显示内容,需引用''
                a = 'alex'
                v = a.center(10,'*')
                print(v)
                #返回结果   ***alex***
    
            - def count(self, x: unicode)
                在字符串中,对于某个x出现的次数
                a = 'alexalex'
                v = a.count('ex')
                print(v)
                # 返回结果    2
    
            - def find(self, sub: unicode, start: int = ..., end: int = ...)
                在字符串中,在【x,y】的区间内,第一次找到v的位置,如果找不到,则反馈-1
                # 字符串位置顺序从0开始
                a = 'alex'
                v = a.find('l',3,4)
                print(v)
                # 返回结果    -1
                v = a.find('l',0,4)
                # 返回结果    1
    
            - def format(self, *args: object, **kwargs: object)
                在字符串中,针对某部分进行格式化替换{},{}
    
                1、按照默认顺序,不指定特定位置
                a = '{} {}'
                v = a.format('Hallo','World')
                print(v)
                # 或者直接print
                print("{} {}".format("hello","world") )
                # 返回结果    hello world
    
                2、设置指定位置,可以多次使用
                a = '{0} {1} {0}'
                v = a.format('Hallo','or')
                print(v)
                # 或者直接print
                print('{0} {1} {0}'.format('Hello','or'))
                # 返回结果    Hello or Hallo
    
                3、使用列表格式化
                person = {'name':'opcai','age':20}
                print('My name is {name} . I am {age} years old .'.format(**person))
                # 返回结果    My name is opcai . I am 20 years old .
    
                4、通过列表格式化
                stu = ['opcai','linux','MySQL','Python']
                print('My name is {0[0]} , I love {0[1]} !'.format(stu))
                # 返回结果    My name is opcai , I love linux !
    
            - def expandtabs(self, tabsize: int = ...)
                通过魔法,制作格式化文本或表格
                # 
      另起一行
                # 	  制表符
                # 	 和之前的加在一起等于输入的数字int
                s = 'username	email	password
    alex	alex@qq.com	123
    alex	alex@qq.com	123'
                v = s.expandtabs(20)
                print(v)
                # 返回结果
                username            email               password
                alex                alex@qq.com         123
                alex                alex@qq.com         123
                # username到email之间,正好是20个格子
    
            - def index(self, sub: unicode, start: int = ..., end: int = ...)
                在字符串中,在【x,y】的区间内,找到子序列的位置,如果找不到,则反馈error
                和 find 类似
                a = 'alex'
                v = a.index('l',3,4)
                print(v)
                # 返回结果    ValueError: substring not found
    
            - def isalnum(self)
                字符串中,是否包含  字母或数字
                text = '123abcd'
                v = text.isalnum()
                print(v)
                # 返回结果    True
    
            - def isalpha(self)
                字符串中,是否全是字母
                text = '123abcd'
                v = text.isalpha()
                print(v)
                # 返回结果    False
    
            - def isdecimal(self)    十进制数字
                当前输入是否是数字 十进制数字
    
            - def isdigit(self)      包含数字形式
                当前输入是否是数字 任何数字形式,是否包含十进制数字
    
            - def isnumeric(self)    形式全包含
                当前输入是否是数字 任何形式,包括中文(python3)
    
            - def isdecimal isdigit isnumeric 三者的区别
                test = '2'
                v1 = test.isdecimal()
                v2 = test.isdigit()
                v3 = test.isnumeric()
                print (v1,v2,v3)
                # 返回结果    True True True
                test = ''
                v1 = test.isdecimal()
                v2 = test.isdigit()
                v3 = test.isnumeric()
                print (v1,v2,v3)
                # 返回结果    False True True
                test = ''
                v1 = test.isdecimal()
                v2 = test.isdigit()
                v3 = test.isnumeric()
                print (v1,v2,v3)
                # 返回结果    False False True
    
            - def isidentifier(self)
                按照字母,数字,下划线顺序进行鉴别
                a = 'adb123_'
                v = a.isidentifier()
                print(v)
                # 返回结果    True
    
            - def islower(self)
                序列中是否全部是小写,只要有一个大写 就false
                a = 'Abcdefg'
                v = a.islower()
                print(v)
                # 返回结果    False
    
            - def isprintable(self)
                打印的时候都能看到的值就True,如果存在不可显示的,比如
    、	之类,则False
    
            - def isspace(self)
                判断序列里是否全部都是空格,只要有一个数字或文本,则False
                # 空字符串不含空格,False
    
            - def istitle(self)
                判断字符串是否全是以大写为开头的标题
                test = 'Tuple[unicode, unicode, unicode]'
                v1 = test.istitle()
                print(v1)
                # 返回结果    Fasle
                v2 = test.title()
                print(v2)
                # 返回结果    Tuple[Unicode, Unicode, Unicode]
                v3 = v2.istitle()
                print(v3)
                #返回结果    True
    
            - def isupper(self)
                判断字符串中所有的字符都是大写,只要有一个小写,就是False
                test = 'Tuple[unicode, unicode, unicode]'
                v1 = test.isupper()
                print(v1)
                # 返回结果    Fasle
                v2 = test.upper()
                print(v2)
                # 返回结果    TUPLE[UNICODE, UNICODE, UNICODE]
                v3 = v2.isupper()
                print(v3)
                #返回结果    True
    
            - def join(self, iterable: Iterable[unicode])
                在字符串中插入self,注意是把self插入引用,每一个字符之间
                test = '你是风儿我是沙'
                print(test)
                t = ' '
                v = t.join(test)   # 在序列test中插入t
                print(v)
                #返回结果    你 是 风 儿 我 是 沙
                or
                print(' '.join('你是风儿我是沙'))
                #返回结果    你 是 风 儿 我 是 沙
    
            - def ljust(self,  int, fillchar: unicode = ...)
                在引用的self右边,按照输入宽度要求,填充某标记
                test = 'alex'
                v = test.ljust(20,'*')
                print(v)
                #返回结果    alex****************
    
            - def rjust(self,  int, fillchar: unicode = ...)
                在引用的self左边,按照输入宽度要求,填充某标记
                test = 'alex'
                v = test.rjust(20,'*')
                print(v)
                #返回结果    ****************alex
    
            - def lower(self)
                把字符串中所有的字符变成小写
                # 验证码输入大小写都可以,这个时候后台执行lower,后台显示都是小写
    
            - def strip(self, chars: unicode = ...)
                在字符串中去除self  ()默认为空白
                移除指定字符串  有限最多匹配
                test = 'xalex'
                v1 = test.strip('x')
                v2 = test.lstrip('x')
                v3 = test.rstrip('x')
                print(v1,v2,v3)
                #返回结果    ale alex xale
    
            - def lstrip(self, chars: unicode = ...)
                在字符串中左边去除self
    
            - def rstrip(self, chars: unicode = ...)
                在字符串中右边去除self
    
            - def maketrans(self, *args, **kwargs)
                对于两组字符串进行对应顺序的替换
                结合 def translate 一起用
                v = '我爱你,你爱他,他爱她,她爱他'
                test = '你我他'
                test1 = '123'
                m = maketrans(test,test1)
                new_v = v.translate(m)
                print(new_v)
                #返回结果    2爱1,1爱3,3爱她,她爱3
    
            - def translate(self, table: Union[Dict[int, Any], unicode])
                把对应替换的关系,重新应用到str语句中
    
            - def partition(self, sep: unicode)
                在字符串中,以输入的x为切割符,从左到右找到第一个x并进行分割
                显示x
                Bug:只能分割成三段,且x在中间
                test = 'testabdeghrsoelt'
                v1 = test.partition('s')
                print(v1)
                v2 = test.rpartition('s')
                print(v2)
                #返回结果    ('te', 's', 'tabdeghrsoelt')
                #返回结果    ('testabdeghr', 's', 'oelt')
    
            - def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
                在字符串中,以输入的x为切割符,从右到左找到第一个x并进行分割
                Bug:只能分割成三段
    
            - def split
                在字符串中,以输入的x为切割符,从左到右找到x并进行分割
                不显示x
                可以根据x分成 n+1 段,n可以进行设置,不输入则为全部查找分割
                test = 'testabdesghrsoelt'
                v1 = test.split('s')
                v2 = test.split('s',1)
                v3 = test.rsplit('s',1)
                print(v1,v2,v3)
                #返回结果    ['te', 'tabde', 'ghr', 'oelt']
                #返回结果    ['te', 'tabdesghrsoelt']
                #返回结果    ['testabdesghr', 'oelt']
    
            - def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...)
                在字符串中,以输入的x为切割符,从右到座找到x并进行分割
                不显示x
                可以根据x分成 n+1 段,n可以进行设置,不输入则为全部查找分割
    
            - def splitlines(self, keepends: bool = ...)
                分割,只能根据 
    
                换行符进行分割,true。flase :是否保留换行符
    
                test = '124
    40869994
    8282292
    345'
                v = test.splitlines(True)
                print(v)
                v = test.splitlines()
                print(v)
                # 返回结果    
                # ['124
    ', '40869994
    ', '8282292
    ', '345']
                # ['124', '40869994', '8282292', '345']
    
            - def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = ...,
                           end: int = ...)
                判断是否以XXX开始
                test = 'backeit 1.1 1.1'
                v = test.startswith('ba')
                print(v)
                # 返回结果    True
                def endswith    判断是否以XXX结尾
    
            - def swapcase(self)
                字符串中所有大小写进行转换 all
                test = 'backeitFJEKEI'
                v = test.swapcase()
                print(v)
                # 返回结果    BACKEITfjekei
    
            - def zfill(self,  int)
                设置新字符串长度,引用原字符串右对齐,前面填充0
                test = 'backeitFJEKEI'
                v = test.zfill(20)
                print(v)
                # 返回结果    0000000backeitFJEKEI
    
            - def replace(self, old: unicode, new: unicode, count: int = ...) 
                替换
                test = '你是风儿我是沙'
                v = test.replace('','')
                print(v)
                # 返回结果    他是风儿我是沙
    
            - def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
            - def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...       
            
            - 7个基本魔法 join split find strip upper lower replace
    
            - 4个灰魔法 
                [int] 索引,获取字符串中某一个字符
                [int1:int2] 索引切片,获取两个区间之间的字符,>=int1,<int2
                len() 检测字符串的字符个数 or 列表中的元素个数
                for 循环
                    变量名 in 字符串: 循环接收器
                
                # 案例
                test = '你是风儿我是沙'
                index = 0
                while index < len(test):
                    v = test[index]
                    print(v)
                    index += 1
                print('====end====')
                # 返回结果
                你
                是
                风
                儿
                我
                是
                沙
                ====end====
                # 案例另一种表达方法
                test = '你是风儿我是沙'
                for A in test:
                    print(A)
    
            - 1个深灰魔法
                字符串一旦创建,不可修改
                一旦修改或者拼接,都会造成重新生成字符
  • 相关阅读:
    485串口接线
    mvc3 升级mvc5
    VB连接ACCESS数据库,使用 LIKE 通配符问题
    VB6 读写西门子PLC
    可用的 .net core 支持 RSA 私钥加密工具类
    解决 Win7 远程桌面 已停止工作的问题
    解决 WinForm 重写 CreateParams 隐藏窗口以后的显示问题
    解决安装 .net framework 发生 extracting files error 问题
    CentOS7 安装配置笔记
    通过特殊处理 Resize 事件解决 WinForm 加载时闪烁问题的一个方法
  • 原文地址:https://www.cnblogs.com/joyceluyun/p/12470460.html
Copyright © 2011-2022 走看看