python基本数据类型之,Python运算符及基本数据类

一、列表----list

1、算数运算符:

          列表是有序的,列表元素可以被修改

+   -  *  /   **    %  //  

=================list之灰魔法================

num=9%2

1、列表格式:

print(num)

  中括号括起来,

num=9%2
print(num)


num=9//2
print(num )

  逗号分隔每个元素,

2、成员运算

  列表中的元素可以是数字、字符串、列表、布尔值、等所有的都能放进去

name='苟陇辉'
 if '苟' in name:
    print('ok')
else:
    print('error')

 if '苟'not in name:
    print('ok')
else:
   print('error')

  “集合“,”内部可以放置任何东西

in             not in   判断某个东西是否在某个东西中包含。

  li=['alex', '小名', [12, 23, 45], 23, 23, '小花']

3、逻辑运算

2、列表中可以嵌套任何类型

布尔值:  结果 为‘真’  true   或者 结果为  ‘假’  false

3、可以通过索引取值,  或者切片取值(切片取值的结果也是列表)

# '' 空字符为假

  print(li[3])           print(li[3:-1])

# '   '  只要里面有东西 就为真

4、支持for循环,   while循环。

#  0    假

5、列表元素可以进行修改

# 其他  真

  索引修改: li [ 2 ] =120    print(li)

  ‘转换bool值     

  索引切片修改: li [1:3] = [27, 28]

a=123

6、删除

b=bool(a )’

  索引删除: del li [1]     print(li)

name='苟陇辉'
v= '苟' in name
print(v)

user='alex'
pwd=123
v=user=='alex' and pwd==124 or user=='ales'and pwd=='123' print(v)

  索引切片删除: del li [2,4]    print(li)

4、赋值运算

7、支持 in 操作

count=1

  v = 'alex' in li         print(li)

count=count+1  即  count+=1

8、嵌套列表查询方式

count=count%1 即 count%=1

  li=['小王',‘小宁’, [a, b, [d, e, f ],  c ], ‘小张’]

5、比较运算

  print(li[2][2][0])

a= 1>5

9、字符串转换成列表

print(a)

  s='abcdefg'

结果为 false

  li = list(s)

 

  print(li)

总结: 算数运算符 和 赋值运算符 得到的均为‘’真实‘’结果;比较运算符、 逻辑运算符、成员运算得到的结果均为“布尔值”

10、列表转换成字符串

基本数据类型

  如果列表中即有数字又有字符串,需要自己写一个for循环

 一、整形  int   

    li = [12,13,14,'xiaozhang', 'xiaowang']

注:在Python3中,无论数字多大,都属于int类型;在Python2中,数字变大,超过一定范围则称为long型;

    s=' '

魔法  

    for i in li :

1、转换功能

      s=s+str(i)

a='123'
print(type(a),a)     # type 查看类型 
b=int(a)             # 将字符串'123',转换为数字123
print(type(b),b)

    print(s)

365bet体育在线平台 1

  若列表中的元素只有字符串,直接用字符串join方法

a='0011'
v=int(a ,base=2)    # base=16/8/2  指代以16进制数,8进制数,2进制数表示a, 若是不写base=  则默认10进制数
print(v)

  li = ['xiaozhang', 'xiaowang']

365bet体育在线平台 2

   v = ' '.join(li)

2、

   print (v)

age=10
r=age.bit_length()    #表示当前数字的二进制,至少用多少位表示  10的二进制数为1010 即4位
print(r)

=====================list类中提供的方法===================

365bet体育在线平台 3

1、 append追加

    li = [11,22,33,44]

错误方法: v = li.append('alex')
          print(v)      打印出来为none,说明v中为空
因为字符串不能修改,而列表可以直接修改,所以:可以直接写

          li.append('alex')
          print(li)  打印结果为:[...'alex']
  或者: li.append(['alex'])
      print(li)  打印结果为: [...['alex']] 

2、clear清空列表

    li.clear()
    print(li)


3、copy拷贝
    浅拷贝:v=li.copy()
                print(v)


4、count 计算元素出现的次数

    v = li.count(22)
    print(v)


5、extend 扩展原列表
   参数必须是:iterable可迭代对象(能被for循环)

         li.extend([1992,'xiaowang'])
         print(li)
         打印结果为:[...,1992, 'xiaowang']
或者   li.extend('小王同学')
         print(li)
         打印结果为:['小',‘王‘,‘同’, ’学’]    

6、index 获取当前值的索引位置(最左优先)
         v =  li.index(22)
         print(v)
     或者可以选取范围
         v=li.index('alex',1,3)

7、insert 指定索引位置插入元素
     li.insert(位置,插入的值)
     例如: li.insert(0,'alex')
                print(li)


》》》》》》》》》补充《》《》《》《》《》《》
源码中出现:    index索引,value值


8、pop 删除指定位置的值
    不指定索引时,默认删除最后一个值,并获取删除的值
        v = li.pop()
        print(li)
        print(v)
   指定索引时,删除指定位置的值,并获取删除的值
        v = li.pop(1)
        print(li)
        print(v)

9、remove 删除列表中的指定值,左边优先(括号内要填入删除的内容)
        li.remove(11)
        print(li)

10、reverse 反转,将当前列表进行反转
  li.reverse()
    print(li)

11、sort排序
   从小到大排序:
      li.sort()
   从大到小排序
      li.sort(reverse=True)
   欠两个参数:讲函数时补充 cmp, key

二、字符型

 二、元祖 tuple     

魔法 

  元素不可被修改,且元素不能被增加或者删除,但是可以被查看

1、

   tu = (11, 'alex',  ( 28, 29 ), 22, [33, 44 ], 55)

test='alex'
v=test.capitalize()         #表示首字母大写
print(v)

        按照惯例一般在末尾价格逗号来识别

365bet体育在线平台 4

  1、可通过索引取值,切片取值

2、

365bet体育在线平台,2、可以进行for循环(可迭代对象)

test='AleX'
v=test.casefold()          #表所有字母变小写
print(v)

3、因为是可迭代对象:字符串、列表、元祖可以相互转换

365bet体育在线平台 5

4、extend扩展,在元祖中同样适用

注意:

5、元祖是有序的

test='AleX'
v=test.lower()          #也表所有字母变小写,但是特殊字符表示不了。而capitalize()则对于很多未知的对应关系也可以表示
print(v)

5、元祖的一级元素不可被修改,元祖中嵌套的列表可以被修改

365bet体育在线平台 6

》》》》》》》》两个方法《》《》《》《》《》《
count 获取指定元素在元祖中出现的次数
index 获取某个指定元素的索引,可以设定起始位置查找

3、

三、字典 dict

test='aLex'
v=test.center(20,'*')       # 表示  设置宽度,并将内容居中,其中20代表总长度,'*'代表空白处的未知填充,只能有一个字符,可有可无
print(v)

  字典的value可以是任何值

365bet体育在线平台 7

 

标准为:test.center(width,fillchar=None)

info = {"k1": "v1", "k2": "v2"}        键值对

4、

  布尔值,列表、字典不能作为字典的key

test='alexalex'
v=test.count('ex')      # 去字符串里寻找子序列('ex')出现的次数
print(v)

1、查找字典内容

 365bet体育在线平台 8

v = info[key]    例如: v=info["k1"]

test='alexalex'
v=test.count('ex',5,8)      # 去字符串里寻找子序列('ex')出现的次数,指定寻找的起始 和 结束 位置  注意字符串第一位为0
print(v)

2、删除key :   del info["k1"]

365bet体育在线平台 9

3、for循环

5、

1、循环字典中所有的key
    for item in info.keys():
        print(item)


2、循环字典中的所有values(值)
    for item in info.values():
    prent(item)            


3、既要循环key又要循环字典中所有的值
     for item in info.keys():
        print(item,info[item])

     那么可以简写为:
    for k, v in info.items():
        print( k, v )

《》《》《》《》字典的方法《》《》《》《《》》
1、clear 清空

2、copy 浅拷贝

3、fromkeys  根据序列创建字典,并且制定统一的值
    用法: v= dict.fromkeys(['k1', 123, 'k2'], 22)

4、通过索引取key,如果字典中没有会直接报错
    get  用法:查找字典的key,key不存在时可以指定默认值

    方法一:
            dic = {"k1":23, "k2": 24}
            v= dic.get("k3")
            print(v)       如果k3不在字典中,则返回None
    方法二:
            dic = {"k1":23, "k2": 24}
            v= dic.get("k3",1111)
            print(v)       如果k3不在字典中,则返回1111      
5、items

6、 keys

7、 pop     删除。既可以指定所要删除的值,又可以拿到删除掉的值

        方法一:
        dic = {"k1":23, "k2": 24}
        v = dic.pop('k1') 
        print(dic,v)
       方法二:设定具体值,当要删除的key不存在时,返回到设置的值
         dic = {"k1":23, "k2": 24}
         v = dic.pop('k5',1111) 
         print(dic,v)   


8、  popitem随机删除,并返回删除的值

       dic = {"k1":23, "k2": 24}
        v,k = dic.popitem() 
        print(dic,v,k)   

9、setdefault设置值,如果值已经存在,并获取存在key对应的值
    如果key不存在,创建并获取新创建的key的值
   例如: dic = {"k1":23, "k2": 24}
             v = dic.setdefault("k111","alex") 
             print(dic,v)

10、update 更新

dic = {"k1":23, "k2": 24}
方法一:dic.update({'k1': 1111, 'k3',123})
            print(dic)
方法二: dic.update(k1=123, k3=345, k5='alex')
            print(dic)   
test='alex'
v=test.endswith('ex')      #  字符串以什么结尾 
print(v)                   #  v=test.startswith('a') 表示字符串以什么开头   

 

365bet体育在线平台 10

6、

test='alexalex'
v=test.find('ex',5,8)       # 从开始往后找,获取其位置 ,可指定其寻找的起始位置,注意,大于等于5,小于8
print(v)

365bet体育在线平台 11

注意:找不到时 结果为-1

7、

test='alexalex'
v=test.index('8')           #  从开始往后找,获取其位置 ,可指定其寻找的起始位置,找不到时程序报错,故一般使用find命令,找不到时 运行结果为-1
print(v)

365bet体育在线平台 12    程序报错

8、

test='i am {name},age{a}'
v=test.format(name='alex',a=19)     # 格式化,将一个字符串的占位符替换为指定的值。注意格式的准确性,括号必须为大括号
print(v)

365bet体育在线平台 13

test='i am {name},age{a}'
v=test.format_map({'name':'alex','a':19})     # 也是格式化,将一个字符串的占位符替换为指定的值。注意格式的准确性,冒号不能少
print(v)

365bet体育在线平台 14

9、

test='syeijc435_+'
v=test.isalnum()        # 判断字符串中是否只包含字母和数字,若有其他符号 ,则结果为false
print(v)

365bet体育在线平台 15

10、

test='tuys'
v=test.isalpha()        # 判断字符串是否只包含字母 汉字
print(v)

365bet体育在线平台 16

11、

test='124'
v=test.isdecimal()      # 判断字符串是否只包含数字
print(v)

365bet体育在线平台 17

test='12'
v=test.isdigit()         # 判断字符串是否只包含数字          
print(v)

365bet体育在线平台 18

 

 二者的区别为  若为 ② 则 .isdecimal 为false       . isdigit 为true   

test='二2②'
v=test.isnumeric()      # 判断是否全为数字  可识别汉字
print(v)

 365bet体育在线平台 19

 

.isnumeric 也可识别 汉字‘二’

12、

test='_123rt'
v=test.isidentifier()       # 判断 标识符 格式是否正确  注意:标识符同字符串规则一样,不能使用数字开头
print(v)

 365bet体育在线平台 20

13、

test='totijdn'
v=test.isprintable()        # 判断是否存在不可见的(如n、t) ,或运行结果不可显示的字符  
print(v)

365bet体育在线平台 21

14、

test='    '
v=test.isspace()        # 判断是否字符串全为空格
print(v)

365bet体育在线平台 22

15、

test='Gou long hui'
v=test.istitle()        # 判断是否为标题(标题中每一个首字母都需大写)
print(v)
v=test.title()      # 转换为标题
print(v)

365bet体育在线平台 23

16、

test='aeiou'
test1='12345'   #  获得对应关系
v='asidou'
v1=str.maketrans('aeiou','12345')       # 替换功能
new_v=v.translate(v1)
print(new_v)

365bet体育在线平台 24

17、

test='aLEx'
v=test.swapcase()       # 大小写转换
print(v)

365bet体育在线平台 25

17、

test='usernametemailtpasswordngoulonghuitglh020@qq.comt123nweiguoquantweiguoquan@qq.comt234'
v=test.expandtabs(20)       # 从开始往后找制表符't',20个一组,找到后用空格自动补齐20,可用于制作表格
print(v)

365bet体育在线平台 26

 

必背魔法:

1、

test='alexex'
v=test.find('ex')       # 从开始往后找,找到第一个之后,获取其位置
print(v)

 

365bet体育在线平台 27

test='alexex'
v=test.rfind('ex',2,5)      # 从右往左找,规定范围在>=2,<5,之间,获取其位置, 注意:无论从左往右还是,从右往左数,都是左边第一个字符 索引为0
print(v)

365bet体育在线平台 28

 

2、

test='苟陇辉五六七八九'
v='_'.join(test)        # 将字符串中的每一个元素按照指定分隔符拼接。 注意    .join
print(v)

365bet体育在线平台 29

3和4 、

test='ALex'
v1=test.islower()       # 判断字符串是否全为小写
v2=test.lower()         # 将字符串全部转换为小写
v3=test.isupper()       # 判断字符串是否全为大写
v4=test.upper()         # 将字符串全部转换为大写
print(v1,v2,v3,v4)

365bet体育在线平台 30

5、

test='  xalex  '
test1='altetx'
# v1=test.lstrip()          # 去除左边空格
# v2=test1.lstrip()         # 去除‘t’‘n’
# v3=test.rstrip()          # 去除右边空格
# v4=test1.rstrip()         # 去除‘t’‘n’
# v5=test.strip()           # 去除所有空格
# v6=test1.strip()          # 去除‘t’‘n’
test2='xalex'
v7=test2.lstrip('xa')       # 去除指定字符
print(v7)


6、

test='testasdsddfg'
v1=test.partition('s')      # 以目标's'分割,找到第一个s后分,只能分割三块
v2=test.rpartition('s')     # 以目标's'分割,从右找 找到第一个s后分,只能分割三块
v3=test.split('s',)         # 以目标's'分割,找到第一个s后分,但是不显示分割字符s
v4=test.rsplit('s')         # 以目标's'分割,从右找到第一个s后分,但是不显示分割字符s
v5=test.split('s',2)        # 以目标's'分割,找到2个s后停止分割,且不显示分割字符s
print(v1)
print(v2)
print(v3)
print(v4)
print(v5)

365bet体育在线平台 31

特例:test.splitlines()  表示根据换行符‘n’分割      test.splitlines(True) 则显示换行符‘n’, test.splitlines(False),则不显示换行符‘n’。

7、

test='alexalexalex'
v=test.replace('al','bbb',2)        # 替换功能
print(v)

365bet体育在线平台 32

 

 

特殊用法:

1、

test='alex'
v=test[2]           # 据 索引 或 下标 获取字符串中的某个字符
print(v)
v2=test[0:2]        # 索引范围 左开右闭,顾头不顾尾
print(v2)
v3=len(test)        # 判断当前字符串有多少字符组成
print(v3)

365bet体育在线平台 33

2、for

test='苟陇辉苟'
index=0
while index<len(test):
    v=test[index]
    print(v)
    index+=1
print('====')

365bet体育在线平台 34

使用for语句时:

test='苟陇辉苟'     # for 循环格式   for 变量名 in 字符串:
for v in test:      #                    变量名
    print(v)

365bet体育在线平台 35     一个一个输出

 

字符串一旦创建,不可修改;

一旦修改或者拼接,都会造成重新生成字符串;

补充:

range的用法    帮助创建连续的数字,v=range(0,100,5)步长为5

                 v='alexalexalex'

replace      v=test.replace('ex','bbb',2)   2为替换前2个

 

练习题:将用户输入的文字及其对应的索引打印出来。

test=input('请输入:')
v=range(0,len(test))
for item in v:
    print(item,test[item])

365bet体育在线平台 36

 

 三、列表list

list 为类,li为通过list类创建的对象,列表里每一个元素通过, 隔开,中括号 括起来;可以修改,删除

方法

1、

 

li = [1,12,9,'age',['苟陇辉',[19,10],'你'],'alex',True]

 

li = [1,12,9,'age',['苟陇辉',[19,10],'你'],'alex',True]
print(li[3])            #
print(li[3:5])
li[1] = 120
print(li)
li[1] = [11,22,33,44]
print(li)
li[2:4] = [120,90]
print(li)
del li[1]
print(li)
del li[2:6]
print(li)           # 可通过索引、切片 取值,删除其中的元素

365bet体育在线平台 37

 

同样支持for循环,while 循环

2、in 操作

v = 12 in li

print(v)        True

 

3、

li = [1,12,9,'age',['苟陇辉',['19','10'],'你'],'alex',True]
v = li[4][1][0][1]      # 索引取值一直往里找
print(v)

结果为9
4、
(1)

s = 'asdfghkl'
list(s)             # 转化功能   字符串转化为列表,内部使用的for循环,注意: 数字不可被转化,不可使用for循环
print(list(s))

365bet体育在线平台 38

(2)、列表转化字符串

①:列表中既有数字,又有字符串是 需要自己写一个for循环一个一个处理:

li=[1,2,3,'alex]

s=''

for item in li

  s=s+str(item)

print(s)

② 只有字符串

li=['123','alex']

v=''.join(li)

print(v)

一般方法:

1、

li = ['11','22','33','44']
li.append(5)            # 直接在原值后面追加一个
print(li)
li.append([99,'苟陇辉'])      # 只将一个整体以列表的形式加进去
print(li)
li.extend([99,'苟陇辉'])       # 将每一个元素都加进去
print(li)

365bet体育在线平台 39

2、

li = ['11', '22', '33', '44']
v = li.copy()                       # 浅拷贝   
print(v)

365bet体育在线平台 40

3、

li = ['11', '22', '33', '44','22']
v = li.count('22')                  #  计算‘22 ’出现的次数
print(v)

365bet体育在线平台 41

4、

li = [11,22,33,22,44]
v = li.index(22)                # 寻找当前元素的索引,找到第一个之后就不在找了
print(v)
v = li.index(22,2,4)            # 可加起始位置
print(v)
v = li.insert(0,99)             # 在指定位置0, 插入指定元素99
print(v)

5、

li = [11,22,33,22,44]
li.reverse()                        # 将当前列表进行反转
print(li)
li.sort()                           # 排序,从小到大排序
print(li)
li.sort(reverse=True)               # 从大到小排序
print(li)

365bet体育在线平台 42

6、删除

li = [11,22,33,22,44]
v = li.pop()                # 默认删除最后一个元素
print(li)                   # 获取删除后的列表
print(v)                    # 获取删除的值
li.pop(1)                   # 删除指定索引的元素
print(li)
print(li.pop(1))

li = [11,22,33,22,44]
li.remove(22)               # 删除指定的元素
print(li)

li.clear()                  # 清空列表
print(li)

365bet体育在线平台 43

 四、元祖  tuple

类:元祖   按照元祖类创建的对象 tu ;       #  元祖是对列表的二次加工;  小括号括起来,最后面加一个逗号“,”;

注:元祖(一级元素)不可被修改,不能被增加或者删除;   有序的;

tu = (111,'alex',(,),[()],True,33,44,)

 常用方法:

1、索引取值:v = tu[0]

2、切片取值:v = tu[0:2]

3、支持for循环

4、相互转换:s li tu

v = tuple(s)   v = tuple(li)

v = list(tu)     v = '_'.join(tu)( 只有字符串时)

一般方法:

count  : v = tu.count(33)    获取元素33  在 tu中出现的次数

index   :   v = tu.index(111)   获取元素 111  在tu中的索引    左边优先

 

五、字典 dict

对象   info = {'k1':'v1','k2':'v2'}

info = {'k1':18,

           'k2':true

           'k3':[11,22,33,{'kk1':'vv1','kk2':'vv2'},'kk3':(11,22,)]

           'k4':(11,22,33)}

注意: value  可是任意值

             key    列表,字典,不可为key ;bool值  True  默认=1   False  默认=0,若是重复是  则不显示

1、字典是无序的

2、取值:据K取值,即据索引取到指定元素 ,但不可使用切片(因为字典是无序的)。

3、删除:据K删除      del info ['k3']['kk1']

4、支持for循环 

for item in info         ==       for item in into.keys      默认循环‘k’

  print(item)   

for item in info.values        循环‘values’

  print(item)

for (k,v) in info.items()       循环K,V

  print(k,v)

5.v = dic.get('k1','111')    根据k获取值,key不存在时,可以可指定输入结果 111   不指定值时,默认结果为none

   print(v)

6 、v = dic.pop('k1',90)     找不到K值时,不报错,可指定 90  结果    注意:不写k时,默认删除最后一个

      print(dic,v)   其中v 为删除的值   

      dic.popitem  随机删除

7、v = dic.setdefault('k',123)   

   设置值,若key以存在,则不设置,获取当前k对应的值; 不存在时,设置并获取当前K对应的值

8、dic.uptade({'k1':'1234','k3':'3333'})    更新字典,若K以存在,则更新其V,若K不存在,加一个进去。

六、BOOL值

注意:转换为bool值  :  bool()

     假:  空字典,空列表,空元祖,空字符串,0

其余均为真。

   总结:

可变:列表,字典

不可变:字符串,数字,元祖                  验证方式:name = 'alex'  id(name)  可查看其储存ID

 

访问顺序:①:直接访问:数字

                  ②:顺序访问(即索引):字符串、列表、元祖

                  ③:映射:字典

存储元素个数:

                      容器类型:列表、元祖、字典

                       原子: 数字、字符串

七、集合:   s = {,,,}

定义:①:不同元素组成

           ②:无序

           ③:集合中的元素必须是不可变类型:数字、字符串、元祖

方法:

# 集合:
# s = set('hello')            # 定义一个集合
# print(s)

# s = {1,2,3,4,5,'6'}
# s.add('2')                  # 添加一个元素
# print(s)

# s = {1,2,3,4,5,'6'}
# s.clear()                   # 清空列表
# print(s)

# s = {1,2,3,4,5,'6'}
# s1 = s.copy()                 # 复制
# print(s1)

# s = {1,2,3,4,5,'6'}
# s.pop()                         # 随机删
# print(s)

# s = {1,2,3,4,5,'6'}
# s.remove('6')               # 指定元素删除,找不到时报错
# s1 = s.discard('6')         # 指定元素删除,找不到时不报错

# v = ['aaa','bbb','ccc']
# v1 = ['aaa','bbb','eee']
# s = set(v)
# s1 = set(v1)
# print(s,s1)
# print(s.intersection(s1))   # 交集
# print(s&s1)                 # 交集
#
# print(s.union(s1))          # 并集
# print(s|s1)                 # 并集
#
# print(s.difference(s1))     # 差集
# print(s1.difference(s))     # 差集
#
# print(s.symmetric_difference(s1))   # 交叉补集
# print(s^s1)                         # 交叉补集
#
# s.difference_update(s1)             # 差集之后 将得到的集合赋值给给s (即更新)
# print(s)

# s1 = {1, 2}
# s2 = {1, 2, 3, 4}
# print(s1.issubset(s2))   #    结果为 True   s1是s2的子集
# print(s2.issuperset(s1))  #   True   s2是s1的父集
# s1.update(s2)    # 更新多个值
# s1.add(5)  # 更新一个值
# s1.union(s2)     # 不更新
# print(s1)

# s = set( )        # 定义可变的集合
# s = frozenset()   # 定义不可变的集合

# names = ['alex','glh','alex','wc']          #  简单去重
# s = set(names)
# print(s)
# names = list(s)

八、字符串格式化

 

字符串格式化:
# 一:百分号方式
#  %s 均可接收    %d 只能接收数字类型   %f 浮点数(小数)
# msg = 'i am %s my hobby is %s' %('glh','alex')     # %.2s代表截取字符串的长度为2
# print(msg)

# tpl = 'percent%.2f' %(99.895652)        #2代表保留2位小数
# print(tpl)
# tpl = 'percent%.2f %%'%(99.895652)      # 打印百分比
# print(tpl)
# 
# tpl = 'i am %(pp).2f' %{'pp': 123.456}   #  后边为字典
# print(tpl)
# 
# msg = 'i am %(name)+60s %(age)d'%{'name': 'glh','age': 23}      # +号表示右对齐并补齐60位
# print(msg)
# msg = 'i am 33[46;1m%(name)+60s33[0m my hobby is alex ' %{'name': 'glh'}        # 加颜色
# print(msg)
# 
# print('root','x','x','o',sep=':')  # 分别得到结果 后拼接成一条记录    结果为  root:x:x:o
# 
# 二 format 字符串格式化

# tpl = 'i am {},age{},{}'.format('glh','23','alex')
# print(tpl)
# tpl = 'i am {2},age{1},{0}'.format('glh','23',['alex',23])      # 相当于按照后面后面元祖索引取值
# print(tpl)

# #  .format('seven',18) == .format(*['seven',18])
# #  .format('seven',18) == .format(**{'seven',18})

# tpl = 'numbers: {:b},{:o},{:d},{:x},{:X},{:%}'.format(15,15,15,15,15,15.89632)
# print(tpl)
# # 结果为numbers: 1111,17,15,f,F,1589.632000%   上述分别代表打印二进制 八进制 十进制 十六进制小写 十六进制大写 转换为百分数,默认保留6位

         

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

        

 

 

 

 

本文由365bet体育在线官网发布于操作系统,转载请注明出处:python基本数据类型之,Python运算符及基本数据类

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。