• 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个深灰魔法
                字符串一旦创建,不可修改
                一旦修改或者拼接,都会造成重新生成字符
  • 相关阅读:
    ASP.NET 5 Web Api 集成测试
    EF 7.0 Beta8 实现简单Unit Of Work 模式
    C#与闭包(closure)学习笔记
    异步初探
    BUBI架构之旅【目录】
    【第2期】如何将NameNode和SecondaryNameNode分开不同节点
    【第1期】使用Docker虚拟化技术搭设Hadoop环境
    【第3期】Linux安装数据库oracle 11g
    【第2期】vsftpd的安装与使用
    【第1期】安装Linux服务器(DB主机与ETL主机)
  • 原文地址:https://www.cnblogs.com/joyceluyun/p/12470460.html
Copyright © 2020-2023  润新知