基础知识：数字、字符串、列表的类型及内置方法

系统管理员 2021-12-21 23:55 238阅读 0赞

今日学习内容：

一、基本数据类型及内置方法

1、数字类型

2、字符串类型

3、列表类型

今天学习的内容比较细比较杂，需要一点一点嚼烂慢慢消化，别急，加油！ヾ(◍°∇°◍)ﾉﾞ

=============================================================

一、可变不可变类型：

可变类型：值改变，id不变，也就是说在不改变id的情况下可以改变值，id地址不变。就是可变类型。

不可变类型：值改变，id也会随着改变，证明就是产生了新值，开辟了新的id空间存放新值。这种就是不可变类型，在id原值的基础上对应值不可改变，只能另辟新的id空间存放新值，而不能在原id地址上对对应值进行变更。

x = 1
    print(id(x))
    x = 2
    print(id(x))
    
    >>>>>>结果是2个值的对应id不同，发生了改变。
    
    x = [1, 2]          
    print(id(x))
    x[0] = 'A'  # 将列表索引0的数值改变替换为A，我们会发现列表的id值仍然不变
    print(id(x))

二、数字类型：

**1 int整型：int只能将纯数字的类型转成整型。**

age = 10  # age = int(10)
    a = '1234'  # int(a),会把字符串类型a转换成整型1234
    b = '1234  '  # int(b)会报错，int无法转换为整型
    c = '123abc'  # int(c)会报错，int无法转换为整型  
    #  int只能转换纯数字类型的字符串

**2  float浮点型：float只能将纯带小数的字符串类型数据转换成浮点型。**

**总结：int和float类型统称为数字类型，该类型数据为不可变类型，只能存一个值。**

**三、字符串类型：**

当我们定义一个字符串的时候其实是这样的

msg = ‘hello’  \# msg = str（'hello'）,也就是将hello数据变成字符串类型，然后关联给msg。

由于字符串属于一种记录描述性质状态的类型，所以，任何类型的变量都能转换成字符串类型。

a = 1
    b = 1.1
    c = ['a', 'b']
    d = {
        'c': 'sgt', 'd': 18, 'dd': 'tea'}
    A, B, C, D = [str(a), str(b), str(c), str(d)]
    print(A, B, C, D)
    print(type(A), type(B), type(C), type(D))
    
    1 1.1 ['a', 'b'] {
        'c': 'sgt', 'd': 18, 'dd': 'tea'}
    <class 'str'> <class 'str'> <class 'str'> <class 'str'>

常用操作+内置的方法（\*\*\*\*\*）：

3.1按索引取值（正向、反向取值）

# ---->正向： 0  1  2  3  4
    #            h  e  l  l  o
    #           -5 -4 -3 -2 -1  反向<-------
    msg = 'hello'
    print(msg[0],msg[4],msg[-1],msg[-4])
    
    结果是：h o o e

正向取值从索引0开始，反向取值从索引-1开始

注意：字符串取出的值，只能当做变量值，不可作为变量名。

3.2切片（顾头不顾尾，步长）

msg = 'hello world'
    print(msg[2:4:1])  # 起始索引位置2,结束索引位置，顾头不顾尾，步长1，所以结果：ll
    print(msg[0:5])    # 起始索引位置0，结束索引位置5，顾头不顾尾，步长没有默认为1，所以结果：hello
    print(msg[:])      # hello world
    print(msg[::2])    # hlowrd
    print(msg[::-1])   # 反向切片，dlrow olleh
    print(msg[-1::])   # 起始位置最右边d，默认步长为1，所以结果只有 d
    print(msg[-1::-1]) # dlrow olleh

3.3长度len（）

msg = 'hello world'
    print(len(msg))  # 结果11

计算字符串内索引总个数。

3.4成员运输in 、not in 判断小字符串是否存在于一串大字符串中。

msg = 'egon is my fantastic person'
    print('fan'in msg)
    print('rs' not in msg)
    print(not 'egon' not in msg)
    # True
    # False
    # True

3.5    .strip 移除空白

用来去除字符串左右两边的字符，不指定的话，默认移除空格。

print('  message    '.strip())
    print('   messa ge   '.strip())
    print('abc dmessage dxyz h'.strip('abcdxyzh '))
    # message
    # messa ge
    # message

strip可用于用户交互输入数据时，如果数据中包含了无用的空格，这时就得进行去除空格处理

name = input('your username:').strip()
    pwd = input('your key:').strip()
    if name == 'sgt' and pwd == '123':
        print('登陆成功')
    else:
        print('登陆失败')

3.6切分     .split

按照某种分隔符，切分成列表。

info = 'a:b:c:d'
    print(info.split(':'))
    print(info.split(':',2))
    
    # ['a', 'b', 'c', 'd']
    # ['a', 'b', 'c:d']

#jion使用：':'.jion(msg1)    用冒号（冒号可替换字符）作为连接符，将纯字符串的列表拼接成一个新的字符串
    msg1 = ['my', 'age', 'is', '18']
    msg2 = ':'.join(msg1)
    print(msg2, type(msg2))
    
    # my:age:is:18 <class 'str'>

切分的列表必须是纯字符串列表

3.7循环（取值）

for x in 'hello'
        print(x)
    '''
    h
    e
    l
    l
    o
    '''

3.8以下是需要掌握的操作：

① .strip  .lstrip  .rstrip   两边去\*，左边去\*，右边去\*

print('*******login*******'.strip('*'))
    print('*******login*******'.lstrip('*'))
    print('*******login*******'.rstrip('*'))
    
    # login
    # login*******
    # *******login

② .lower  .upper 将字母全部变为小写，或者大写

print('Ab2cD'.lower())
    print('Ab2Cd'.upper())
    # ab2cd
    # AB2CD

③  .startswith  .endswith 判断是否以某种字符开头或者结尾。

info = 'egon alex sgt'
    print(info.startswith('egon'))
    print(info.startswith('e'))
    print(info.endswith('gt'))
    print(info.endswith('t'))
    # True
    # True
    # True
    # True

④  .format的玩法：

通常我们用到format会先说说以前学的格式化输出：

name = 'egon'
    age = '18'
    print('my name is %s,i am %s .' %(name,age))

然而这种输出有一种局限就是必须是按照前后循序依次对号入座，那么有没有一种不需要按顺序来，直接就能快速入座的输出呢？

format就可以做到：

print('my name is {name},i am {age} .'.format(name='egon',age='18'))

还有另外2种表达：

print('my name is {},i am {} .'.format('egon','18'))
    print('my name is {0}{1},i am {1}{1} .'.format('egon', '18'))
    
    # my name is egon,i am 18 .
    # my name is egon18,i am 1818 .

运用.format快速格式化输入：

name = input('请输入您的姓名：')
    age = input('请输入您的年龄：')
    job = input('请输入您的工作：')
    sex = input('请输入您的性别：')
    print('''
    ---------------info {a}---------------
    Name   : {a}
    Age    : {b}
    Sex    : {c}
    Job    : {d}
    ---------------end---------------''' .format(a=name, b=age, c=sex, d=job))

⑤  .split  . rsplit   切分成列表（0默认从左开始），右切分

info = 'a:b:c:d'
    print(info.rsplit(':'))
    print(info.rsplit(':',2))
    # ['a', 'b', 'c', 'd']
    # ['a:b', 'c', 'd']

⑥   .replace

用法：info.replace('被替换的字符串’，‘替换成的字符串’，替换个数）

info = 'a fantastic man is sgt'
    print(info.replace('sgt','yl',1))
    
    # a fantastic man is yl

⑦   .isdigit判断

如果字符串由纯数字组成则返回True

print('12345'.isdigit())
    print('1234  5'.isdigit())
    print('12345 '.isdigit())
    print('12345abc'.isdigit())
    # True
    # False
    # False
    # False

while True:
        score = input('>>>>:').strip()
        if score.isdigit():
            score=int(score)
            if score > 90:
                print('great!')
            else:
                print('rubbish!')
            break
        else:
            print('请输入纯数字')

可以用于用户交互界面，首先将输入字符串取空白，然后转成数字类型，然后判断是否输入的是数字，如果是可进行下一步判断，如果不是，重新输入

⑧需要了解的操作：

\#1find rfind index rindex count

print('123 ke123ke'.find('ke'))           #4
    print('123 ke123ke'.rfind('ke'))           # 9          
    print('123 ke123ke'.index('ke'))           #4
    print('123 ke123ke'.rindex('ke'))           #9
    print('123 ke123ke'.count('ke',0,6))        #1
    
    find和index的区别是找不到的时候，find结果是-1，二index结果是报错
    print('123 ke123ke'.find('xxxx'))           #-1
    print('123 ke123ke'.index('xxxx'))        #报错
    
    
    print('123 ke123ke'.count('ke',0,6))       #1
    #计数，寻找计数字符串，从索引0开始到索引6如果找到一个ke就计1，如果找到2个就计2，以此类推。

\#2center ljust rjust zfill

print('egon'.center(11,'*'))     # 将egon放到总数为11个字符中间（50个字符包含egon的数量），其他用*号填充。****egon***
    print('egon'.ljust(11,'*'))      # 将egon放到总数为11个字符中，左对齐，其余字符用*号填充，egon*******
    print('egon'.rjust(11,'*'))      # 将egon放到总数为11个字符中，右对齐，其余字符用*号填充，*******egon
    
    print('egon'.rjust(11,'0'))      # 0000000egon
    print('egon'.zfill(11))          #总共11个字符，除egon以外其余从左边开始用0填充。0000000egon

\#3captalize swapcase title

print('abcdef dddddd'.capitalize())    #字符串的首字母大写Abcdef dddddd
    print('abcAef dddddd'.swapcase())      #字符串内字母大小写反转ABCaEF DDDDDD
    print('abcAef dddddd'.title())         #字符串内每个单词的首字母大写，其他都小写Abcaef Dddddd

\# is数字系列

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

nums1 = b'2'  # bytes
    nums2 = '2'   # 字符串数字
    nums3 = '四'  # 大写数字
    nums4 = 'Ⅵ'  # 罗马数字
    
    print(nums1.isdigit())
    print(nums2.isdigit())
    print(nums3.isdigit())
    print(nums4.isdigit())
    # True
    # True
    # False
    # False
    isdigit可以判断bytes和字符串数字为数字。
    
    # 阿拉伯数字组成的字符串
    # print(num2.isdecimal())
    # print(num3.isdecimal())
    # print(num4.isdecimal())
    
    # 阿拉伯数字\中文\罗马组成的字符串
    # print(num2.isnumeric())
    # print(num3.isnumeric())
    # print(num4.isnumeric())

字符串类型总结

存一个值，有序，不可变类型

**四、列表类型**

list数据类型转换：但凡能够被for循环遍历的数据类型都可以给list转换成列表类型

res = list('hello')
    print(res)
    #['h', 'e', 'l', 'l', 'o']
    
    
    res = list(123)    #数字类型不能被for i in 123
    #报错

常用操作+内置方法

优先掌握的操作：

4.1按索引取值（正向存取+反向存取）：

l = ['a', 'b', 'c', 'd', 'e']
    print(l[1])
    print(l[-2])
    print(id(l))
    l[4] = 'E'
    print(l, id(l))

Tip:对不存在的索引会报错！列表中的字符可以被替换，但是无法新增

但是字典可以新增：

dic = {
        'a':11}
    dic['b'] = 22
    print(dic)
    # {'a': 11, 'b': 22}

4.2切片（顾头不顾尾，步长）

#切片，顾名思义，将列表内的数据按照索引的特征，切取一部分形成新的列表
    #例：
    l = ['x', 'y', 'z', 'm', 'n']
    print(l[1:3])    #这里完整的应该是print(l[1:3:1]),最后那个1是步长，不写：1的话默认为1.从索引1开始到索引3的数据切出来组成新的列表
    print(l[::-1]    #这里是反向切片，前面两个冒号代表默认，从-1到-5全部切出来
    
    结果为：
    ['y', 'z', 'm']
    ['n', 'm', 'z', 'y', 'x']

4.3长度len

l=['a','b','c','d','e']
    print(len(l))
    #5

4.4成员运算in 和 not in, 判断数据在不在列表里。

l = ['x', 'y', 'z', 'm', 'n']
    print('z' in l)        #Ture
    print('a' not in l)   #Ture

4.5  \[\].append()追加，每次只能一个字符（多个的话会报错）。

\[\]insert(插入位置紧跟其后的索引值，插入的字符) 插入 ，每次只能插入一个字符

前面说过，列表按索引取值时候，只能替换，不能新增，现在我们用append和insert来对列表进行新增数据，

l = ['x', 'y', 'z', 'm', 'n']
    l.append('o')
    print(l)
    l.append('q')
    print(l)
    
    #['x', 'y', 'z', 'm', 'n', 'o']
    #['x', 'y', 'z', 'm', 'n', 'o', 'q']

这里的append只能在列表最后面添加数据，不能在任意位置添加。

而insert就可以：

l = ['x', 'y', 'z', 'm', 'n']
    l.insert(0，'xoxo')      # 在索引号为0的位置前添加数据。
    print(l)
    l.insert(6,'xxoo')       #l最大索引是4，如果要想在l最后插入数据，就得将起始索引设为大于最大索引的数。
    print(l)
    #['xoxo', 'x', 'y', 'z', 'm', 'n']

#['xoxo', 'x', 'y', 'z', 'm', 'n','xx00']

4.6 删除del和remove和pop

#del:
    l = ['x', 'y', 'z', 'm', 'n']
    del l[2]
    print(l)
    #['x', 'y', 'm', 'n']
    #del是一种删除通用的操作，没有返回值
    
    字典也可以删除
    dic = {
        'a':1}
    del dic['a']
    print(dic)
    
    #{}

#remove:
    l = ['x', 'y', 'z', 'm', 'n']
    res = l.remove('m')
    print(l)
    print(res)
    
    #['x', 'y', 'z', 'n']
    #None，        提示：remove删除的那个元素没有返回值。

#pop
    #指定要删除的那个元素的索引，返回刚删掉的元素。
    l=['a','bbb','c','d','e']
    l.pop(-1)    #删除‘e’
    res = l.pop(1)
    print(l)
    print(res)
    
    #['a', 'c', 'd']
    #bbb

小练习：队列：先进先出，后进先出的表达：（需要用到列表的新增append，然后用到列表的删除并得到返回值；pop）

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#先进先出：
    l = []
    l.append('first')
    l.append('second')
    l.append('third')
    print(l)
    print(l.pop(0))
    print(l.pop(0))
    print(l.pop(0))
    # ['first', 'second', 'third']
    # first
    # second
    # third
    
    # 后进先出
    l = []
    l.append('first')
    l.append('second')
    l.append('third')
    print(l)
    print(l.pop(-1))
    print(l.pop(-1))
    print(l.pop(-1))
    #['first', 'second', 'third']
    # third
    # second
    # first

排队，先进先出、后进先出

4.7 循环

l=['a','b','c','d','e']
    for item in l:
        print(item)
    
    结果是：
    a
    b
    c
    d
    e

4.8.一些需要了解的操作

extend clear reverse sort

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# extend
    l = []
    print(id(l))
    l.extend('a')
    print(l, type(l))
    print(id(l))
    
    # 1851073943240
    # ['a'] <class 'list'>
    # 1851073943240
    #extend主要是讲指定字符串、列表加到一个指定的列表当中形成一个更大的列表,extend不能直接添加数字类型，字符串可以。

extend

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# clear
    l = [12,123,'abc']
    l.clear()
    print(l)
    #[]

clear

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# clear
    l = [12,123,'abc']
    # l.clear()
    # print(l)
    # #[]
    l.reverse()
    print(l)
    # ['abc', 123, 12]
    
    m = [11,22,'cdf']
    print(m[::-1])     #reverse的功能和列表的反向切片类似。将列表发现排列
    #['cdf', 22, 11]

reverse

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

l = [12, 123, 2]
    l1 = ['a', 'b', 'z', 'n']
    l.sort()
    l1.sort()
    print(l)
    print(l1)
    
    # [2, 12, 123]
    # ['a', 'b', 'n', 'z']
    #注意：sort只能将全部是同总类型的列表进行排列，而且是升序排列。

sort

转载于:https://www.cnblogs.com/suguangti/p/10581873.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211220/6922b4e1380c44acbed3c7eb2c5b25e4.png