; Python内置数据结构-list、tuple、string | Linux运维部落

Python内置数据结构-list、tuple、string

Python内置数据结构

分类

  • 数值型
    • int、float、complex、bool
  • 序列对象
    • 字符串 str
    • 列表 list
    • 元组 tuple
  • 键值对
    • 集 set
    • 字典 dict

数值型

  • 数值型
    • int、float、complex、bool都是类(class),1、5.0、1+2j都是对象即实例
    • int:在python3版本中表示长整型,没有大小限制,受限制于内存区域大小
    • float:浮点数由整数部分和小数部分组成,支持十进制和科学计数法表示,在python中只有双精度浮点数
    • complex:复数由实数和虚数部分组成,实数和虚数都是浮点数,例:3+4.2j
    • bool:int的子类,基友两个实例True和False,分别代表1和0,可以直接和整数计算
  • 类型转换
    • int(x) #返回一个整数
    • float(x) #返回一个浮点数
    • complex(x)/comples(x,y) #返回一个复数
    • bool(x) #返回布尔值,对应关系可查看真值表
  • 数字的处理函数
    • python中管与数学处理的模块math需要单独导入(import math),math.floor表示舍去小数部分的值取整,math.ceil表示只要小数位不是零则一律进1
    • int() #将括号内的浮点数小数点后的数值舍掉,只取整数部分
    • round() #这个函数去正式遵循四舍六入,当小数点后为5时,取离得最近的偶数值
    
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    可以测试下如下代码:
    -<span class="ruby"> print(math.ceil(<span class="hljs-number">2.1</span>))
    </span>-<span class="ruby"> print(math.floor(<span class="hljs-number">2.9</span>))
    </span>-<span class="ruby"> round(<span class="hljs-number">2.5</span>)
    </span>-<span class="ruby"> round(<span class="hljs-number">3.5</span>)
    </span>-<span class="ruby"> round(<span class="hljs-number">3.4</span>)
    </span>-<span class="ruby"> round(<span class="hljs-number">3.6</span>)
    </span>
    -<span class="ruby"> min() <span class="hljs-comment">#取括号内数字的最小值</span>
    </span>-<span class="ruby"> max() <span class="hljs-comment">#取括号内数字的最打值</span>
    </span>-<span class="ruby"> pow(x,y) <span class="hljs-comment">#取x的y次方</span>
    </span>-<span class="ruby"> math.sqrt(<span class="hljs-number">9</span>) <span class="hljs-comment">#取就得0.5次方,也就是√-3</span>
    </span>-<span class="ruby"> math.pi <span class="hljs-comment">#取π的值3.141592653589793</span>
    </span>-<span class="ruby"> math.e <span class="hljs-comment">#取自然常数的值2.718281828459045</span></span>
    • 转换进制
      • bin() #转换为二进制字符串
      • oct() #转换位八进制字符串
      • hex() #转换为十六进制字符串
  • 类型判断
    • type(object),返回类型,而不是字符串 例:type(a)、type(‘b’)、type(123) type(1+True+3.0)返回的类型是浮点型,这是应为因为在数学计算中包含一个隐式转换,由精度低的数项精度高的数转换
    • isinstance(obj,class_or_tuple),判断参数是不是后面其中一个的类型,返回布尔值 例:isinstance(6,str) isinstance(6,(str,bool,int,float))

列表(list)

  • 列表的特性
    • 一个队列,排列整齐的队伍
    • 列表里的个体称为元素(item),有若干元素组成
    • 元素可以式任意的数字、字符串、对象、列表等
    • 列表内元素有顺序,可以使用索引
    • 属于线性数据结构
    • 使用[]表示,[]空的中括号表示空列表
    • 列表是可以变化的,可以增、删、改、查和追加
  • 列表list、链表(linklist)、队列(queue)、栈(stack)的差异
    • 列表是有序地,一个接一个排列的集合,每一个元素占据一个单位,就像书本一样,一页内容对应一个页码,可以通过索引来查找
    • 链表是有连接的,一个连一个的,好比手拉手,通过前一个元素可以找到下一个元素
    • 队列可以是列表,也可以是链表,他可以项放行一样先进先出,也可以像解散一样后进先出
    • 栈 是以类似重叠的方式排列,就像摞盘子一样是典型的后进先出队列
  • 列表list定义、初始化
    • list() -> new empty list
    • list(iterable) -> new list initialized from iterable’s items(从可迭代的元素初始化列表)
    • 列表不能一开始就定义大小这是Python中的列表特性,它是可变化的
    • 列表的元素也可以是函数的结果
  • 列表索引访问
    • 索引(index),也叫下标
    • 正索引:从左到右,从0开始,是列表中每一个元素的编号
    • 负索引:从右到左,从-1开始
    • 正负索引不能超超界,超界后报错IndexError
    • 默认认为列表是从左往右排列的,左边头部右边尾部,左边下界右边上界
    • 列表可以通过索引来访问,格式为listname[index],index就是索引,是指某个元素在列表中的位置,默认从0开始
    
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    In <span class="hljs-string">[4]</span>: lst
    Out<span class="hljs-string">[4]</span>: <span class="hljs-string">[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]</span>

    In <span class="hljs-string">[5]</span>:

    In <span class="hljs-string">[5]</span>: lst<span class="hljs-string">[6]</span>
    Out<span class="hljs-string">[5]</span>: <span class="hljs-number">6</span>

    In <span class="hljs-string">[6]</span>:
  • 列表查询
    • index(valiue,[start,[stop]]) 1.通过值value,从指定区间查找列表的元素是否匹配 2.匹配第一个值就返回索引 3.匹配不到,显示valueError
    • count(value) 返回列表中匹配到的值得次数
    • 时间复杂度 1.index和count的方法复杂度是O(n),O(1)这个是表示效率最高,一步操作;count的时间复杂度是O(n)表示所有元素查看一遍或者叫遍历,有n个元素就做n次操作 2.随着数据规模的增大,效率会越来越低
    • 函数len() 查询项目中元素的个数,是公共的内建函数,可以查询类似集合的元素数量
  • 查询帮助
    • 查看帮助文档
    • 查看官方文档
    • 在ipython中通过help(keyword)
      • keyword可以是函数、类、对象、变量、方法名
  • 列表元素修改 当操作修改列表完成时若返回none值则没有新列表生成,是为就地修改
    • 索引访问修改 list[index]=value,索引不能超界,否则就提示异常 -列表增加,插入元素
      
      
      1
      2
      3
      4
      5
      <span class="hljs-number">1.</span> append(<span class="hljs-keyword">object</span>) <span class="hljs-meta">#尾部追加,不会生成新的列表,时间复杂度O(1)</span>
      <span class="hljs-number">2.</span> insert(index,<span class="hljs-keyword">object</span>) <span class="hljs-meta">#在指定索引处插入一个值,索引开始到最后的元素整体后移一个单位,索引超下界会在头部追加,超上界尾部追加。由于操作会硬气内存结构的变化,所以一般不使用</span>
      <span class="hljs-number">3.</span> extend(iteratable) <span class="hljs-meta">#列表扩展:将可迭代对象的元素追加进来,就地修改</span>
      <span class="hljs-number">4.</span> list1+list2 <span class="hljs-meta">#连接操作,将两个列表连接起来,产生新表,原列表不变</span>
      <span class="hljs-number">5.</span> list*num <span class="hljs-meta">#重复操作,将本列表元素重复n次,返回新的列表</span>
    • 列表删除元素
      
      
      1
      2
      3
      <span class="hljs-number">1.</span> <span class="hljs-comment">remove(value) #从左往右查找第一个匹配的值并移除,就地修改</span>
      <span class="hljs-number">2.</span> pop([index]) #不指定索引,从列表哦尾部弹出一个元素,或者制定索引,从指定索引出弹出元素
      <span class="hljs-number">3.</span> <span class="hljs-keyword">clear</span>() #清楚对象列表中的所有元素,剩下一个空列表
    • 列表其他操作
      
      
      1
      2
      3
      <span class="hljs-number">1.</span>reversed() #将列表中元素颠倒顺序,就地修改
      <span class="hljs-number">2.</span>sort(<span class="hljs-type">key</span>=None,reverse=False) #对列表惊醒排序,就地修改,默认升序;reverse=True,就是反转并按降序排列;<span class="hljs-type">key</span>可以制定一个函数,指定<span class="hljs-type">key</span>如何排序
      <span class="hljs-number">3.</span> in 查看一个元素在不在一个列表中;而for x in [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>]表示从列表中取出元素附给x
  • 列表复制
  • copy() #shadown cpoy(影子复制),也叫浅拷贝,遇到引用类型,只是复制了一个引用,如果引用的对象被修改,则两个列表所引用的元素都会改变,
  • 深拷贝,copy模块提供深拷贝,深copy会在内存中新建一个列表,并赋值

随机数

random模块 1.random.randint(a,b) #返回[a,b]之间的整数 2.random.choice(seq) #从非空序列中随机挑选一个元素 3.randrange([start,]stop[,step]) #从指定按制定奇数递增的集合中获取一个随机数,默认奇数为1 4.random.shuffle(list) #就地打乱列表元素

练习

1.求100内的素数


1
2
3
4
5
6
7
8
9
lst=[<span class="hljs-number">2</span>]
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">3</span>,<span class="hljs-number">100</span>,<span class="hljs-number">2</span>):
    <span class="hljs-keyword">for</span> n <span class="hljs-keyword">in</span> lst:
        <span class="hljs-keyword">if</span> i%n ==<span class="hljs-number">0</span>:
            <span class="hljs-built_in">break</span>
    <span class="hljs-keyword">else</span>:
        #<span class="hljs-built_in">print</span>(i)
        lst.<span class="hljs-built_in">append</span>(i)   #将计算出的素数追加到素数列表中
<span class="hljs-built_in">print</span>(lst)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
import math
pn=[]
<span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(3,1000,2):
    <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> pn:
        <span class="hljs-keyword">if</span> x%<span class="hljs-attribute">i</span>==0:
            <span class="hljs-attribute">sign</span>=<span class="hljs-literal">True</span>
            break
        <span class="hljs-keyword">if</span> i&gt;=math.ceil(x*<span class="hljs-number">*0</span>.5):
            <span class="hljs-attribute">sign</span>=<span class="hljs-literal">False</span>
            break
    <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> sign:   #只有是真值的时候,才会执行及里边的语句块,当flag为<span class="hljs-literal">False</span>,<span class="hljs-keyword">not</span> flag是<span class="hljs-literal">True</span>,程序才会进去<span class="hljs-keyword">if</span>内部语句块,否则就继续下面的语句
        #<span class="hljs-builtin-name">print</span>(x)
        pn.append(x)
<span class="hljs-builtin-name">print</span>(pn)

2.计算杨辉三角的前六行


1
2
3
4
5
6
7
8
9
triangle=[[<span class="hljs-number">1</span>],[<span class="hljs-number">1</span>,<span class="hljs-number">1</span>]]
<span class="hljs-keyword">for</span> <span class="hljs-selector-tag">i</span> <span class="hljs-keyword">in</span> range(<span class="hljs-number">2</span>,<span class="hljs-number">6</span>):
    <span class="hljs-selector-tag">p</span> = triangle[i-<span class="hljs-number">1</span>]
    cur=[<span class="hljs-number">1</span>]
    <span class="hljs-keyword">for</span> j <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>,i-<span class="hljs-number">1</span>):
        cur.append(<span class="hljs-selector-tag">p</span>[j]+<span class="hljs-selector-tag">p</span>[j+<span class="hljs-number">1</span>])
    cur.append(<span class="hljs-number">1</span>)
    triangle.append(cur)
<span class="hljs-function"><span class="hljs-title">print</span><span class="hljs-params">(triangle)</span></span>


1
2
3
4
5
6
7
8
9
10
11
12
13
<span class="hljs-built_in">triangle</span>=[]
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">6</span>):
    <span class="hljs-keyword">if</span> i==<span class="hljs-number">0</span>:
        lr=[<span class="hljs-number">1</span>]
        <span class="hljs-built_in">triangle</span>.<span class="hljs-built_in">append</span>(lr)
    <span class="hljs-keyword">else</span>:      
        p=<span class="hljs-built_in">triangle</span>[i-<span class="hljs-number">1</span>]
        cur=[<span class="hljs-number">1</span>]
        <span class="hljs-keyword">for</span> j <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">0</span>,i-<span class="hljs-number">1</span>):
            cur.<span class="hljs-built_in">append</span>(p[j]+p[j+<span class="hljs-number">1</span>])
        cur.<span class="hljs-built_in">append</span>(<span class="hljs-number">1</span>)
        <span class="hljs-built_in">triangle</span>.<span class="hljs-built_in">append</span>(cur)
<span class="hljs-built_in">print</span>(<span class="hljs-built_in">triangle</span>)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
triangle=[]
<span class="hljs-keyword">for</span> <span class="hljs-selector-tag">i</span> <span class="hljs-keyword">in</span> range(<span class="hljs-number">6</span>):
    <span class="hljs-keyword">if</span> i==<span class="hljs-number">0</span>:
        lr=[<span class="hljs-number">1</span>]
        triangle.append(lr)
    <span class="hljs-keyword">else</span>:
        p=[<span class="hljs-number">0</span>]
        <span class="hljs-selector-tag">p</span>.extend(triangle[i-<span class="hljs-number">1</span>])
        <span class="hljs-selector-tag">p</span>.append(<span class="hljs-number">0</span>)
        cur=[]
        <span class="hljs-keyword">for</span> j <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>,i+<span class="hljs-number">1</span>):
            cur.append(<span class="hljs-selector-tag">p</span>[j]+<span class="hljs-selector-tag">p</span>[j+<span class="hljs-number">1</span>])
        triangle.append(cur)
<span class="hljs-function"><span class="hljs-title">print</span><span class="hljs-params">(triangle)</span></span>


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<span class="hljs-built_in">triangle</span>=[]
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">6</span>):
    <span class="hljs-keyword">if</span> i==<span class="hljs-number">0</span>:
        lr=[<span class="hljs-number">1</span>]
        <span class="hljs-built_in">triangle</span>.<span class="hljs-built_in">append</span>(lr)
    elif i==<span class="hljs-number">1</span>:
        lr=[<span class="hljs-number">1</span>,<span class="hljs-number">1</span>]
        <span class="hljs-built_in">triangle</span>.<span class="hljs-built_in">append</span>(lr)        
    <span class="hljs-keyword">else</span>:      
        p=<span class="hljs-built_in">triangle</span>[i-<span class="hljs-number">1</span>]
        cur=[<span class="hljs-number">1</span>]
        x=<span class="hljs-number">1</span>
        <span class="hljs-keyword">while</span> x&lt;=(i-<span class="hljs-number">1</span>):
            cur.<span class="hljs-built_in">append</span>(p[x-<span class="hljs-number">1</span>]+p[x])
            x+=<span class="hljs-number">1</span>
        cur.<span class="hljs-built_in">append</span>(<span class="hljs-number">1</span>)
        <span class="hljs-built_in">triangle</span>.<span class="hljs-built_in">append</span>(cur)
<span class="hljs-built_in">print</span>(<span class="hljs-built_in">triangle</span>)

方法二


1
2
3
4
5
6
7
8
9
10
11
12
ol=[]
<span class="hljs-keyword">nl</span>=[1]
<span class="hljs-keyword">print</span>(<span class="hljs-keyword">nl</span>)
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-keyword">range</span>(1,6):
    ol=<span class="hljs-keyword">nl</span>.<span class="hljs-keyword">copy</span>()
    ol.<span class="hljs-keyword">append</span>(0)
    <span class="hljs-keyword">nl</span>.<span class="hljs-keyword">clear</span>()
    offset=0
    <span class="hljs-keyword">while</span> offset&lt;=i:
        <span class="hljs-keyword">nl</span>.<span class="hljs-keyword">append</span>(ol[offset-1]+ol[offset])
        offset+=1
    <span class="hljs-keyword">print</span>(<span class="hljs-keyword">nl</span>)

元组(tuple)

元组是一个有序的元素组成的集合,使用()表示,元组是不可变对象,包括元祖的的长度和元素本身。如果元祖中的元素是一个引用对象,当引用对象本身发生变化是,元组中的元素才会发生变化。

  • 定义
    • tuplename=tuple() #定义一个空元组,括号里可以是可迭代对象、数字、字符串、列表等
    • tuplename=tuple(2,) #当定义一个元素的元组时,要在元素后加个逗号,否则会提示括号所在的类不是一个可迭代对象
    • tuple和list一样,可以使用‘+’连接两个不同的元组,创建一个新的元组打印出来,也可以通过‘*’创建一个被乘的元组重复几次的新元组打印出来。
    • 元祖也支持索引访问,包括正负索引,其访问的方式和列表一样,但是索引不能超界,否则引发异常
    • tuplename.index(9) #在tuplename这个元组中查看9的索引,会返回从左到右最近的匹配到的9的索引,匹配不到就返会valueerror。
    • tuplename.count(9) #在tuplename这个猿族中查询9这个值在元组中出现了几次
    • len(tuplename) #查询元祖的长度或者说是元组中元素的个数
    • 元组类似于只读权限的文件,这可以读取,不能增改删,只能删除整个元组
  • 命名元组namedtuple
    • namedtuple使用时需要执行命令“from collections import namedtuple”
    • namedtuple(typename,field_names(可以是空格或者逗号分隔的字段的字符串,也可以是字段的列表),verbose=FaLse,rename=False) #命名元组,返回元组的子类,并定义字段 例: “` In [2]: from collections import namedtuple
      
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      <span class="hljs-keyword">In</span> [<span class="hljs-number">3</span>]: <span class="hljs-keyword">Point</span>=namedtuple(<span class="hljs-string">'_Point'</span>,[<span class="hljs-string">'x'</span>,<span class="hljs-string">'y'</span>])

        <span class="hljs-keyword">In</span> [<span class="hljs-number">4</span>]: p=<span class="hljs-keyword">Point</span>(<span class="hljs-number">11</span>,<span class="hljs-number">22</span>)

        <span class="hljs-keyword">In</span> [<span class="hljs-number">5</span>]: p.x
        <span class="hljs-keyword">Out</span>[<span class="hljs-number">5</span>]: <span class="hljs-number">11</span>

        <span class="hljs-keyword">In</span> [<span class="hljs-number">6</span>]: p.y
        <span class="hljs-keyword">Out</span>[<span class="hljs-number">6</span>]: <span class="hljs-number">22</span>

        ```
  • 练习
    • 以此接收用户输入的3个数,排序后打印
      1. 转换int后,判断大小排序
      2. 使用max函数
      3. 使用列表的sort方法
      4. 冒泡法

字符串

字符串是有序的字符集合或者称字符序列,支持使用索引访问,是一个可迭代的对象

  • 字符串join连接 python种特殊字符需要转义后使用
    
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    例:
    In [<span class="hljs-number">15</span>]: lst
    Out[<span class="hljs-number">15</span>]: [<span class="hljs-string">'1'</span>, <span class="hljs-string">'2'</span>, <span class="hljs-string">'3'</span>]

    In [<span class="hljs-number">16</span>]: <span class="hljs-keyword">print</span>(<span class="hljs-string">'/'</span>.<span class="hljs-keyword">join</span>(lst))
    <span class="hljs-number">1</span><span class="hljs-regexp">/2/</span><span class="hljs-number">3</span>

    In [<span class="hljs-number">17</span>]: <span class="hljs-keyword">print</span>(<span class="hljs-string">'\'</span>.<span class="hljs-keyword">join</span>(lst))
    <span class="hljs-number">1</span>\<span class="hljs-number">2</span>\<span class="hljs-number">3</span>

    In [<span class="hljs-number">18</span>]: <span class="hljs-keyword">print</span>(<span class="hljs-string">'"'</span>.<span class="hljs-keyword">join</span>(lst))
    <span class="hljs-number">1</span><span class="hljs-string">"2"</span><span class="hljs-number">3</span>
    • 连接符 和列表的用法一样,在这里是将两个字符串连接到一起返回一个新字符串
  • 字符串分割 1.split系:将字符分割成若干字符串,并返回列表。
    
    
    1
    2
    3
    4
    5
    6
    7
    格式
    -<span class="ruby"> (string<span class="hljs-string">'s name).split(sep=None,maxsplit=-1)
    </span></span>分割时时从左向右sep制定分割字符串,默认时空白字符串作为分隔符;maxsplit制定分割次数,-1表示便利整个字符串。
    -<span class="ruby"><span class="hljs-string"> (string'</span>s name).rsplit(sep=None,maxsplit=-<span class="hljs-number">1</span>)
    </span>从右向左
    -<span class="ruby"> (string<span class="hljs-string">'s name).splitlines([keepends])
    </span></span>按照行来切分字符串,keepends指的是是否保留行分隔符(\n、\r\n、\r等)

    2.partittion系:将字符串按照分隔符分成两段,放回这两段和分割符的元组

    
    
    1
    2
    3
    4
    -<span class="ruby"> partition(sep(必须指定))
    </span>    从左到右,遇到分隔符就把字符串分成两部分,返回头(head)、分隔符、尾(tail)三部分的三元组;如果没有找到分隔符,就返回头、2个空元素的三元组
    -<span class="ruby"> rpartition(sep)
    </span>    从右到左,功能同上
  • 字符串大小写
    • upper() 全大写
    • lower() 全小写
    • swapcase() 交互大小写,就是大写变小写,小写变大写。
  • 字符串排版
    • title 标题的每个单词首字母大写
    • capitalize 第一个单词首字母大写
    • center(width[,fillchar]) 打印字符串时居中打印,用多少个字符的宽度如果字符串不够用某个字符填充,默认字符是空格
    • zfill(width) 右对齐打印,左边字符不够的用0填充
    • ljust/rjust(width[,fillchar]) 左/右对齐打印
  • 字符串修改
    
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    - <span class="hljs-keyword">replace</span>(<span class="hljs-keyword">old</span>,<span class="hljs-keyword">new</span>[,<span class="hljs-keyword">count</span>]) 替换
        在字符串中找到指定字符串,替换为新字符串,返回新字符串,<span class="hljs-keyword">count</span>表示替换几次
    - strip([chars]) 去除
        从字符串两端去除指定字符集chars中的所有字符串,如果chars没有指定则去除空白字符,同样有两种变体:lstrip/rstrip 从左/右开始去除
    - find(sub[,<span class="hljs-keyword">start</span>[,<span class="hljs-keyword">end</span>]]) 查找字符串
        在指定区间从左到右查找子串sub,找到则返回索引,没有就返回<span class="hljs-number">-1</span>
        变体rfind:从右到左查找
    - <span class="hljs-keyword">index</span>(sub[,<span class="hljs-keyword">start</span>[,<span class="hljs-keyword">end</span>]])  查找字符串
        在指定区间从左到右查找子串sub,找到则返回索引,没有就返回ValueError
        变体rindex:从右到左查找
    - <span class="hljs-keyword">count</span>(sub[,<span class="hljs-keyword">start</span>[,<span class="hljs-keyword">end</span>]]) 统计
        在指定区间从左到右统计子串sub出现的次数
    - endwith/startwith([<span class="hljs-built_in">char</span>,<span class="hljs-keyword">start</span>[,<span class="hljs-keyword">end</span>]]) 字符串判断
        在指定的区间中,字符串是否以指定的字符串开头或者结尾,返回bool值
    - ismetacharacters() 判断字符串有那些字符组成
        metacharacters可以时alpha、<span class="hljs-keyword">num</span>、<span class="hljs-built_in">decimal</span>、digit、dentifier、<span class="hljs-keyword">lower</span>、<span class="hljs-keyword">upper</span>、<span class="hljs-keyword">space</span>等
  • 字符串格式化 字符串格式化是指将字符串以特定的输出样式输出的书法
  1. join连接只能使用分隔符,但是连接的对象必须是可迭代对象
  2. ’+‘连接字符串比较方便,但是只能连接字符串
  • printf style
    
    
    1
    2
    3
    4
    5
    在python2<span class="hljs-number">.5</span>版本之前只能使用printf style(C语言风格)的方式来格式化
    格式要求
        占位符,使用%和格式字符组成
            <span class="hljs-number">1.</span>s掉用str()表示字符串;r调用repr(),表示对象通过repr函数转换为字符串;d调用int(),表示数字
            <span class="hljs-number">2.</span> 占位符中汗可以插入修饰字符,例如%<span class="hljs-number">03</span>d表示打印的字符站三个字符的位置,不够的前面用<span class="hljs-number">0</span>补齐
  • python自用的格式化字符串的语法
    
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    <span class="xml">'</span><span class="hljs-template-variable">{}</span><span class="hljs-template-variable">{xxx}</span><span class="xml">'.format(*args,*kwargs)
            1. args是位置参数,是个元组
            2. kwargs是关键字参数,是个字典
            3. 大括号表示占位符
            4. </span><span class="hljs-template-variable">{}</span><span class="xml">表示按照顺序匹配位置参数,</span><span class="hljs-template-variable">{n}</span><span class="xml">表示取位置参数索引n的值
            5. </span><span class="hljs-template-variable">{{}</span><span class="xml">}表示打印大括号
            6. </span><span class="hljs-template-variable">{xxx}</span><span class="xml">表示在关键字仲搜索名称一致的
            7. </span><span class="hljs-template-variable">{lst[0]}</span><span class="xml">表示访问对象元素
            8. </span><span class="hljs-template-variable">{p.x}</span><span class="xml">表示对象属性访问
        例:
        '</span><span class="hljs-template-variable">{}</span><span class="xml">:</span><span class="hljs-template-variable">{}</span><span class="xml">'.format('192.168.1.100',8888)  按位置参数匹配
        '</span><span class="hljs-template-variable">{server}</span><span class="hljs-template-variable">{1}</span><span class="xml">:</span><span class="hljs-template-variable">{0}</span><span class="xml">'.format(8888,'192.168.1.100',server='Webserver') 匹配关键字参数或命名参数
        对齐
        '</span><span class="hljs-template-variable">{0}</span><span class="xml">*</span><span class="hljs-template-variable">{1}</span><span class="xml">=</span><span class="hljs-template-variable">{2:&lt;2}</span><span class="xml">'.format(3,2,3*2)
        '</span><span class="hljs-template-variable">{0}</span><span class="xml">*</span><span class="hljs-template-variable">{1}</span><span class="xml">=</span><span class="hljs-template-variable">{2:&lt;02}</span><span class="xml">'.format(3,2,3*2)
        '</span><span class="hljs-template-variable">{0}</span><span class="xml">*</span><span class="hljs-template-variable">{1}</span><span class="xml">=</span><span class="hljs-template-variable">{2:&gt;02}</span><span class="xml">'.format(3,2,3*2)
        '</span><span class="hljs-template-variable">{:^30}</span><span class="xml">'.format('Internet Data Center') 表示占用30个字符居中对齐,不够的用空白字符填充
        '</span><span class="hljs-template-variable">{=:^30}</span><span class="xml">'.format('Internet Data Center')  表示占用30个字符居中对齐,不够的用=字符填充
        进制转换
        '</span><span class="hljs-template-variable">{0:d/x/o/b/X}</span><span class="xml">'.format(99)   d表示十进制,x/X表示十六进制小/大写,o表示八进制,b表示二进制</span>

练习

  • 用户输入一个数字
    • 判断是几位数
    • 打印每一位数重复次数
    • 按照个十百千万顺序打印每一位上的数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
num=<span class="hljs-string">''</span>
<span class="hljs-keyword">while</span> True:
    num=<span class="hljs-built_in">input</span>(<span class="hljs-string">'Enter:'</span>).strip()
    <span class="hljs-keyword">if</span> num.isdigit():
        <span class="hljs-keyword">break</span>
    <span class="hljs-keyword">else</span>:
        <span class="hljs-keyword">print</span>(<span class="hljs-string">'please Enter number'</span>)

<span class="hljs-built_in">count</span>=[<span class="hljs-number">0</span>]*<span class="hljs-number">10</span>

<span class="hljs-keyword">for</span> i in <span class="hljs-built_in">range</span>(<span class="hljs-number">10</span>):
    <span class="hljs-built_in">count</span>[i]=num.<span class="hljs-built_in">count</span>(str(i))
<span class="hljs-keyword">for</span> i in <span class="hljs-built_in">range</span>(<span class="hljs-number">10</span>):
    <span class="hljs-keyword">if</span> <span class="hljs-built_in">count</span>[i]:
        <span class="hljs-keyword">print</span>(i,<span class="hljs-built_in">count</span>[i])
lst=<span class="hljs-keyword">list</span>(num)
lst.<span class="hljs-built_in">reverse</span>()
<span class="hljs-keyword">print</span>(lst)
  • 输入五个数字,打印每个数字的位数,将这些数字按升序排列打印

1
2
3
4
5
6
7
8
9
10
11
12
13
列表排序
<span class="hljs-attribute">n</span>=<span class="hljs-string">''</span>
lst=[]
wsl=[]
<span class="hljs-attribute">c</span>=0
<span class="hljs-keyword">while</span> c&lt;=4:
    <span class="hljs-attribute">n</span>=input('Enter:')    
    lst.append(int(n))
    wsl.append(len(n))
    c+=1
<span class="hljs-builtin-name">print</span>(wsl)
lst.sort()
<span class="hljs-builtin-name">print</span>(lst)

本文来自投稿,不代表Linux运维部落立场,如若转载,请注明出处:/87482

发表评论

电子邮件地址不会被公开。 必填项已用*标注

联系我们

400-080-6560

在线咨询:点击这里给我发消息

邮件:1660809109@qq.com

工作时间:周一至周五,9:30-18:30,节假日同时也值班

友情链接:万达开户  guoqibee.com  万达主管  万达娱乐平台  万达开户  万达直属QQ  万达娱乐直属QQ  万达娱乐注册  万达注册